//
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define debug(...) fprintf (stderr, __VA_ARGS__)

#define lep(i, l, r) for (int i = (l), i##_end = (r); i <= i##_end; ++ i)
#define rep(i, r, l) for (int i = (r), i##_end = (l); i >= i##_end; -- i)

char _c; bool _f; template <class T> inline void IN (T & x) {
	_f = 0, x = 0; while (_c = getchar (), ! isdigit (_c)) if (_c == '-') _f = 1;
	while (isdigit (_c)) x = x * 10 + _c - '0', _c = getchar (); if (_f == 1) x = -x;
}

const int N = 5e5 + 5;
const int inf = 1e9;

int n, a[N], ans[N];

// rmq

int mi[20][N], mx[20][N];

inline void rmq_prework () {
	lep (i, 1, n) mi[0][i] = mx[0][i] = a[i];
	lep (j, 1, 19) lep (i, 1, n - (1 << j) + 1) {
		mi[j][i] = min (mi[j - 1][i], mi[j - 1][i + (1 << j - 1)]);
		mx[j][i] = max (mx[j - 1][i], mx[j - 1][i + (1 << j - 1)]);
	}
}
inline int qmin (int l, int r) {
	if (l > r) return inf;
	int ret = __lg (r - l + 1);
	return min (mi[ret][l], mi[ret][r - (1 << ret) + 1]);
}
inline int qmax (int l, int r) {
	if (l > r) return - inf;
	int ret = __lg (r - l + 1);
	return max (mx[ret][l], mx[ret][r - (1 << ret) + 1]);
}

//

inline bool test (int l, int r, int d) {
	if (l > r) return true;
	int a = qmin (l, r) - d;
	int b = qmax (l, r) - d;
	return a >= 0 && b <= r - l;
}
bool construct (int l, int r, int d) {
	if (l > r) return true;
	if (! test (l, r, d)) return false;
	rep (i, r, l) {
		vector <int> pt;
		bool ok = true;
		for (int j = i, p = r; ; ) {
			if (j == l) {
				if (a[j] - d == p - j) pt.emplace_back ( j );
				break ;
			} else {
				pt.emplace_back ( j );
				int nj = j - ((a[j] - d) - (p - j));
				if (nj >= j || nj < l) { ok = false; break ; }
				p = j, j = nj;
			}
		}
		if (! ok || ! pt.size ()) continue ;
		int x = pt.size ();
		for (int & j : pt) ans[j] = inf - d;
		lep (j, 0, x) {
			if (j == 0) {
				ok &= construct (pt[j] + 1, r, d + 1);
			} else if (j == x) {
				ok &= construct (l, pt[j - 1] - 1, d + 1);
			} else {
				ok &= construct (pt[j] + 1, pt[j - 1] - 1, d + 2);
			}
			if (! ok) break ;
		}
		if (ok) return true;
	}
	return false;
}

inline void simu () {
	stack <int> stk; stk.emplace ( 0 );
	vector <int> tot (n + 1, 0);
	lep (i, 1, n) {
		while (stk.size () > 1 && ans[stk.top ()] < ans[i]) stk.pop ();
		tot[i] += i - stk.top () - 1;
		tot[i] += stk.size () - 1;
		while (stk.size () > 1 && ans[stk.top ()] == ans[i]) stk.pop ();
		stk.emplace ( i );
	}
	while (! stk.empty ()) stk.pop ();
	stk.emplace ( n + 1 );
	rep (i, n, 1) {
		while (stk.size () > 1 && ans[stk.top ()] < ans[i]) stk.pop ();
		tot[i] += stk.top () - i - 1;
		tot[i] += stk.size () - 1;
		while (stk.size () > 1 && ans[stk.top ()] == ans[i]) stk.pop ();
		stk.emplace ( i );
	}
	lep (i, 1, n) assert (a[i] == tot[i]);
}
signed main () {
	IN (n);
	lep (i, 1, n) IN (a[i]);
	rmq_prework ();
	debug ("ok = %d\n", construct (1, n, 0));
	lep (i, 1, n) printf ("%d%c", ans[i], " \n"[i == n]);
	return simu (), 0;
}