#include <bits/stdc++.h>
using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, b, a) for (int i = (b) - 1; i >= (a); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const int P = 507;
const int H = 57;
const int INF = 1.1e9;

int a[P][H];
LL pref[P][H];

int p, h;

PII find_x(int i, int ii, int j, int jj)
{
	if(ii == h || jj == h)
		return {-1, -1};
		
	int xl = max(a[i][ii], a[j][jj]);
	int xr = min(a[i][ii + 1], a[j][jj + 1]);
	
	bool L = pref[i][ii] + (h - ii) * xl >= pref[j][jj] + (h - jj) * xl;
	bool R = pref[i][ii] + (h - ii) * xr >= pref[j][jj] + (h - jj) * xr;
	
	if(L == R)
		return {-1, -1};
	
	assert(ii != jj);
	if(R)
		return MP((pref[j][jj] - pref[i][ii] + jj - ii - 1) / (jj - ii), 1);
	else
		return MP((pref[j][ii] - pref[j][jj] + ii - jj) / (ii - jj), -1);
}
	
int ptr[P];
int solve(int i)
{
	fill(ptr, ptr + P, 0);
	int ans = p;
	
	FOR(k, 0, h - 1)
	{
		//k -> k + 1;
		ptr[i] = k;
		int bal = 0;
		FOR(j, 0, p)
		{
			LL scI = pref[i][k] + (h - k - 2) * a[i][k];
			LL scJ = pref[j][ptr[j]] + (h - ptr[j] - 2) * a[i][k];
			bal += scJ <= scI;
		}
		
		vector<PII> evs;
		FOR(j, 0, p)
		{
			if(j == i)
				continue;
			int nptr = ptr[j];
			while(nptr + 1 < h && a[j][nptr + 1] <= a[i][k + 1])
				nptr++;
			
			int oldsz = SZ(evs);
			FOR(kj, ptr[j], nptr + 1)
			{
				//kj -> kj + 1
				PII cur = find_x(i, k, j, kj);
				if(cur.F == -1)
					continue;
				evs.PB(cur);
			}		
			assert(SZ(evs) <= oldsz + 2);
			
			
			ptr[j] = nptr;
		}
		sort(ALL(evs));
		FOR(j, 0, SZ(evs))
		{
			if(j == 0 || evs[j - 1].F != evs[j].F)
				ans = min(ans, bal);
			
			bal += evs[j].S;
		}
		ans = min(ans, bal);
	}	
	return ans;
}


int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cin >> p >> h;
	FOR(i, 0, p)
	{
		FOR(j, 0, h)
			cin >> a[i][j];
		sort(a[i], a[i] + h);
		a[i][h] = INF;
		FOR(j, 0, h + 1)
		{
			pref[i][j] = a[i][j];
			if(j > 0)
				pref[i][j] += pref[i][j - 1];
		}
	}
	h++;
	
	FOR(i, 0, p)
	{
		cout << solve(i) << "\n";
	}
		
	return 0;
}