#include<bits/stdc++.h>
#include<atcoder/all>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using namespace atcoder;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<vector<int>> vvi;
typedef vector<vector<long long>> vvl;
typedef long double ld;
typedef pair<int, int> P;

template <int m> ostream& operator<<(ostream& os, const static_modint<m>& a) {os << a.val(); return os;}
template <int m> ostream& operator<<(ostream& os, const dynamic_modint<m>& a) {os << a.val(); return os;}
template <int m> istream& operator>>(istream& is, static_modint<m>& a) {long long x; is >> x; a = x; return is;}
template <int m> istream& operator>>(istream& is, dynamic_modint<m>& a) {long long x; is >> x; a = x; return is;}
template<typename T> istream& operator>>(istream& is, vector<T>& v){int n = v.size(); assert(n > 0); rep(i, n) is >> v[i]; return is;}
template<typename U, typename T> ostream& operator<<(ostream& os, const pair<U, T>& p){os << p.first << ' ' << p.second; return os;}
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v){int n = v.size(); rep(i, n) os << v[i] << (i == n - 1 ? "\n" : " "); return os;}
template<typename T> ostream& operator<<(ostream& os, const vector<vector<T>>& v){int n = v.size(); rep(i, n) os << v[i] << (i == n - 1 ? "\n" : ""); return os;}
template<typename T> ostream& operator<<(ostream& os, const set<T>& se){for(T x : se) os << x << " "; os << "\n"; return os;}
template<typename T> ostream& operator<<(ostream& os, const unordered_set<T>& se){for(T x : se) os << x << " "; os << "\n"; return os;}
template<typename S, auto op, auto e> ostream& operator<<(ostream& os, const atcoder::segtree<S, op, e>& seg){int n = seg.max_right(0, [](S){return true;}); rep(i, n) os << seg.get(i) << (i == n - 1 ? "\n" : " "); return os;}
template<typename S, auto op, auto e, typename F, auto mapping, auto composition, auto id> ostream& operator<<(ostream& os, const atcoder::lazy_segtree<S, op, e, F, mapping, composition, id>& seg){int n = seg.max_right(0, [](S){return true;}); rep(i, n) os << seg.get(i) << (i == n - 1 ? "\n" : " "); return os;}

template<typename T> void chmin(T& a, T b){a = min(a, b);}
template<typename T> void chmax(T& a, T b){a = max(a, b);}

const int MOD = 100000000;
const int K = 700;


random_device seed;
mt19937 mt(seed());

int main(){
	int n;
	cin >> n;
	
	vector<vector<int>> a(n);
	rep(i, n){
		a[i].resize(i + 1);
		cin >> a[i];
	}
	
	auto diff = [&](int x, int y){
		return min(abs(x - y), MOD - abs(x - y));
	};
	
	auto calc = [&](vector<int> c) -> int{
		int x = 0;
		for(int i = n - 1; i >= 0; i--){
			rep(j, (i + 1)){
				chmax(x, diff(c[j], a[i][j]));
			}
			vector<int> c_new(i);
			rep(j, i){
				c_new[j] = (c[j] + c[j + 1]) % MOD;
			}
			swap(c, c_new);
		}
		return MOD / 2 - x;
	};
	
	
	
	uniform_int_distribution<> distN(0, n - 1);
	uniform_int_distribution<> distA(0, MOD - 1);
	
	vector<vector<int>> val(n, vector<int>(K));
	vector<vector<int>> score(n, vector<int>(K, MOD));
	vector<vector<vector<int>>> cond(n, vector<vector<int>>(K));
	vector<vector<int>> retro(n, vector<int>(K, -1));
	
	rep(i, n) rep(k, K) val[i][k] = distA(mt);
	
	rep(i, n){
		if(i == 0){
			rep(k, K){
				score[0][k] = diff(a[n - 1][0], val[i][k]);
				cond[0][k] = {val[i][k]};
			}
		}else
		{
			rep(k1, K){
				rep(k2, K){
					int score_new = score[i - 1][k1];
					vector<int> cond_new = cond[i - 1][k1];
					
					int need = score[i][k2];
					if(score_new >= need) continue;
					
					{
						cond_new.push_back(val[i][k2]);
						chmax(score_new, diff(cond_new[i], a[n - 1][i]));
						
						if(score_new >= need) continue;
					}
					for(int j = i; j >= 0; j--){
						cond_new[j] += cond_new[j + 1];
						if(cond_new[j] > MOD) cond_new[j] -= MOD;
						
						chmax(score_new, diff(cond_new[j], a[(n - 1) - i + j][j]));
						if(score_new >= need) break;
					}
					if(score_new < score[i][k2]){
						score[i][k2] = score_new;
						cond[i][k2] = cond_new;
						retro[i][k2] = k1;
					}
				}
			}
		}
	}
	
	vector<int> ans(n);
	int score_ans = MOD / 2;
	
	rep(k, K){
		if(score[n - 1][k] < score_ans){
			score_ans = score[n - 1][k];
			
			int idx = k;
			for(int i = n - 1; i >= 0; i--){
				ans[i] = val[i][idx];
				idx = retro[i][idx];
			}
		}
	}
	cout << ans;
	
	return 0;
}