#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

const int MAX = 1000000000;

void solve(vector<int> &a, vector<int> &b, vector<pair<int, int>> &evs) {
	// for which range of compressed values are the sum of a strictly less than the sum of b?
	long long asum = accumulate(a.begin(), a.end(), 0LL);
	long long bsum = accumulate(b.begin(), b.end(), 0LL);

	int aslope = 0, bslope = 0;
	int ap = a.size() - 1, bp = b.size() - 1;
	
	if (asum < bsum) {
		int mx = max(a.back(), b.back());
		evs.emplace_back(mx+1, 1);
		evs.emplace_back(MAX+10, -1);
	}

	while (ap >= 0 || bp >= 0) {
		int mx = 1;
		if (ap >= 0) mx = max(mx, a[ap]);
		if (bp >= 0) mx = max(mx, b[bp]);

		while (ap >= 0 && a[ap] == mx) {
			asum -= a[ap];
			aslope++;
			ap--;
		}

		while (bp >= 0 && b[bp] == mx){
			bsum -= b[bp];
			bslope++;
			bp--;
		}

		int mx2 = 0;
		if (ap >= 0) mx2 = max(mx2, a[ap]);
		if (bp >= 0) mx2 = max(mx2, b[bp]);
		mx2++;

		long long L, R;
		if (asum < bsum) {
			// starts beating b from 0, at which point is b equal or smaller than a?
			L = 1;
			// bsum + bslope*x <= asum + aslope*x
			// bsum - asum <= (aslope - bslope)*x
			// x >= (bsum - asum)/(aslope - bslope)

			if (aslope <= bslope) {
				R = MAX + 10;
			} else {
				long long dif1 = bsum - asum;
				int sldif = aslope - bslope;
				R = (dif1 + sldif - 1) / sldif;
			}
		} else {
			// at what point does a start becoming lower
			R = MAX + 10;

			// bsum + bslope*x > asum + aslope*x
			// (bslope - aslope)*x > (asum - bsum)
			// x > (asum - bsum)/(bslope - aslope)

			if (aslope >= bslope) {
				L = MAX + 10;
			} else {
				long long dif1 = asum - bsum;
				int sldif = bslope - aslope;
				L = dif1 / sldif + 1;
			}
		}

		// compress L, R within [mx2, mx]
		R = min(R, (long long)mx + 1);
		L = max(L, (long long)mx2);

		if (L < R) {
			evs.emplace_back(L, 1);
			evs.emplace_back(R, -1);
		}
	}
}

signed main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n, m;
	cin >> n >> m;

	vector<vector<int>> s(n, vector<int>(m));
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cin >> s[i][j];
		}
		sort(s[i].begin(), s[i].end());
	}

	for (int i = 0; i < n; i++) {
		vector<pair<int, int>> evs;
		for (int j = 0; j < n; j++) {
			if (i == j) continue;
			solve(s[i], s[j], evs);
		}
		sort(evs.begin(), evs.end());

		int mx = 0, cur = 0;
		for (auto [u, v]: evs) {
			cur += v;
			mx = max(mx, cur);
		}
		cout << n - mx << '\n';
	}

	return 0;
}