from math import ceil, floor

def line_ints(): return list(map(int, input().split()))

def compute():
    n, d = line_ints()

    points = []

    for _ in range(n):
        points.append( line_ints() )

    if len(points) == 1:
        print(0)
        return

    smallest = None
    top_dim = -1
    for dim in range(d):
        hi = None
        lo = None
        for p in points:
            if hi is None or p[dim] > hi:
                hi = p[dim]
            
            if lo is None or p[dim] < lo:
                lo = p[dim]

        if smallest is None or hi - lo > smallest:
            smallest = hi - lo
            top_dim = dim

    points = list(sorted(points, key=lambda x: x[top_dim]))

    neigh_dist = []
    for i in range(n - 1):
        p1 = points[i]
        p2 = points[i + 1]

        dist = 0
        for dim in range(d):
            dist += abs(p1[dim] - p2[dim])
        
        neigh_dist.append(dist)


    dim_avgs = []
    for dim in range(d):
        if dim == top_dim:
            dim_avgs.append(None)
            continue

        avg_dim = 0
        for p in points:
            avg_dim += p[dim]
        
        avg_dim /= len(points)

        above = 0
        below = 0

        for p in points:
            if p[dim] > avg_dim:
                above += 1
            elif p[dim] < avg_dim:
                below += 1
        
        if above >= below:
            dim_avgs.append(ceil(avg_dim))
        else:
            dim_avgs.append(floor(avg_dim))


    closest_i = None
    closest_dist = None

    for i, p in enumerate(points):

        dist = 0
        for dim in range(d):
            if dim_avgs[dim] is None:
                continue

            dist += abs(dim_avgs[dim] - p[dim])
        
        if closest_dist is None or dist < closest_dist:
            closest_i = i
            closest_dist = dist


    total_steps = closest_dist

    target_x = points[closest_i][top_dim]
    for i in range(closest_i, n - 1):
        n_dits = neigh_dist[i]
        target_x = target_x + n_dits

        steps = 0
        for dim in range(d):
            if dim == top_dim:
                steps += abs(points[i + 1][dim] - target_x)
            else:
                steps += abs(points[i + 1][dim] - dim_avgs[dim])


        total_steps += steps

    target_x = points[closest_i][top_dim]
    for i in range(closest_i - 1, -1, -1):
        n_dits = neigh_dist[i]
        target_x = target_x - n_dits

        steps = 0
        for dim in range(d):
            if dim == top_dim:
                steps += abs(points[i][dim] - target_x)
            else:
                steps += abs(points[i][dim] - dim_avgs[dim])
        
        total_steps += steps

    print(total_steps)

compute()