#include <bits/stdc++.h>
#ifdef LOCAL
#include "cp_debug.h"
#else
#define debug(...) 42
#endif
#define int long long
#define rep(i,a,b) for(int i = a; i < b; ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;

template<typename T> void read(T &x){
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
    read(first);
    read(args...);
}
template<typename T> void write(T x) {
    if(x > 9) write(x/10);
    putchar(x%10 + '0');
}

signed main() {
    int p, h;
    read(p, h);
    vector<vi> a(p, vi(h));
    rep(i,0,p) {
        rep(j,0,h) {
            read(a[i][j]);
        }
        a[i].emplace_back(2e9);
        sort(all(a[i]));
    }
    h++;
    vector<vector<pii>> ops(p);

    rep(i,0,p) rep(j,i+1,p) {
        int si = 0, sj = 0, cl = 0, pi = 0, pj = 0;
        while(pi < h || pj < h) {
            int nxt = -1, slope_i = h - pi, slope_j = h - pj;

            if(pj == h || (pi < h && a[i][pi] <= a[j][pj])) {
                nxt = a[i][pi];
            } else {
                nxt = a[j][pj]; 
            }
            while(pi < h && nxt==a[i][pi]) { pi++; }
            while(pj < h && nxt==a[j][pj]) { pj++; }

            // cl -> nxt
            assert(cl < nxt);
            int end_si = si + slope_i * (nxt - cl);
            int end_sj = sj + slope_j * (nxt - cl);
            if(si == sj) {
                if(end_si > end_sj) {
                    // [cl+1, nxt] j rank--
                    ops[j].emplace_back(cl+1, -1);
                    ops[j].emplace_back(nxt+1, 1);
                } else if(end_si < end_sj) {
                    // [cl+1, nxt] i rank--
                    ops[i].emplace_back(cl+1, -1);
                    ops[i].emplace_back(nxt+1, 1);
                }
            } else if(si < sj) {
                if(end_si < end_sj) {
                    // [cl+1, nxt] i rank--
                    ops[i].emplace_back(cl+1, -1);
                    ops[i].emplace_back(nxt+1, 1);
                } else {
                    assert(slope_i > slope_j);
                    int diff = sj - si, slope_df = slope_i-slope_j;
                    if(diff % slope_df == 0) {
                        int v = diff / slope_df;
                        // [cl+1, cl+v-1] i rank--
                        ops[i].emplace_back(cl+1, -1);
                        ops[i].emplace_back(cl+v, 1);
                        // [cl+v+1, nxt] j rank--
                        ops[j].emplace_back(cl+v+1, -1);
                        ops[j].emplace_back(nxt+1, 1);
                    } else {
                        int v = diff / slope_df;
                        // [cl+1, cl+v] i rank--
                        ops[i].emplace_back(cl+1, -1);
                        ops[i].emplace_back(cl+v+1, 1);
                        // [cl+v+1, nxt] j rank--
                        ops[j].emplace_back(cl+v+1, -1);
                        ops[j].emplace_back(nxt+1, 1);
                    }
                }
            } else {
                assert(si > sj);
                if(end_si > end_sj) {
                    // [cl+1, nxt] j rank--
                    ops[j].emplace_back(cl+1, -1);
                    ops[j].emplace_back(nxt+1, 1);
                } else {
                    assert(slope_i < slope_j);
                    int diff = si - sj, slope_df = slope_j-slope_i;
                    if(diff % slope_df == 0) {
                        int v = diff / slope_df;
                        // [cl+1, cl+v-1] j rank--
                        ops[j].emplace_back(cl+1, -1);
                        ops[j].emplace_back(cl+v, 1);
                        // [cl+v+1, nxt] i rank--
                        ops[i].emplace_back(cl+v+1, -1);
                        ops[i].emplace_back(nxt+1, 1);
                    } else {
                        int v = diff / slope_df;
                        // [cl+1, cl+v] j rank--
                        ops[j].emplace_back(cl+1, -1);
                        ops[j].emplace_back(cl+v+1, 1);
                        // [cl+v+1, nxt] i rank--
                        ops[i].emplace_back(cl+v+1, -1);
                        ops[i].emplace_back(nxt+1, 1);
                    }
                }
            }
            cl = nxt;
            si = end_si;
            sj = end_sj;
        }
    }

    rep(i,0,p) {
        int cv = 0, mn = 0, last_pos = -1;
        sort(all(ops[i]));
        for(auto [pos, diff]: ops[i]) {
            if(pos != last_pos) {
                if(last_pos != -1) {
                    mn = min(mn, cv);
                }
                last_pos = pos;
            }
            cv += diff;
        }
        if(last_pos != -1) mn = min(mn, cv);
        cout<<(p+mn)<<'\n';
    }
    return 0;
}