#include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

struct node {
	int lx, rx, ly, ry, v;
};

vector<node> T;
int new_node() {
	T.push_back({0, 0, 0, 0, 0});
	return (int)T.size() - 1;
}

void pull(int x) {
	T[x].v = 0;
	if (T[x].lx) T[x].v = max(T[x].v, T[T[x].lx].v);
	if (T[x].rx) T[x].v = max(T[x].v, T[T[x].rx].v);
	if (T[x].ly) T[x].v = max(T[x].v, T[T[x].ly].v);
	if (T[x].ry) T[x].v = max(T[x].v, T[T[x].ry].v);
}
void update_1d(int b, int v, int l, int r, int x) {
	T[x].v = max(T[x].v, v);
	if (l == r) {
		return;
	}
	int m = (l + r) / 2;
	if (b <= m) {
		if (!T[x].ly) {
			int nd = new_node();
			T[x].ly = nd;
		}
		update_1d(b, v, l, m, T[x].ly);
	}
	else {
		if (!T[x].ry) {
			int nd = new_node();
			T[x].ry = nd;
		}
		update_1d(b, v, m + 1, r, T[x].ry);
	}
}
void update_2d(int a, int b, int v, int lx, int rx, int ly, int ry, int x) {
	update_1d(b, v, ly, ry, x);
	if (lx == rx) {
		return;
	}
	int mx = (lx + rx) / 2;
	if (a <= mx) {
		if (!T[x].lx) {
			int nd = new_node();
			T[x].lx = nd;
		}
		update_2d(a, b, v, lx, mx, ly, ry, T[x].lx);
	}
	else {
		if (!T[x].rx) {
			int nd = new_node();
			T[x].rx = nd;
		}
		update_2d(a, b, v, mx + 1, rx, ly, ry, T[x].rx);
	}
}

int query_1d(int a, int b, int l, int r, int x) {
	if (b < l || a > r) return 0;
	if (a <= l && r <= b) return T[x].v;

	int m = (l + r) / 2;
	int ret = 0;
	if (T[x].ly) {
		ret = max(ret, query_1d(a, b, l, m, T[x].ly));
	}
	if (T[x].ry) {
		ret = max(ret, query_1d(a, b, m + 1, r, T[x].ry));
	}
	return ret;
}
int query_2d(int xs, int xe, int ys, int ye, int lx, int rx, int ly, int ry, int x) {
	if (xe < lx || xs > rx) return 0;
	if (xs <= lx && rx <= xe) {
		int ret = query_1d(ys, ye, ly, ry, x);
		return ret;
	}
	int mx = (lx + rx) / 2;
	int ret = 0;
	if (T[x].lx) {
		ret = max(ret, query_2d(xs, xe, ys, ye, lx, mx, ly, ry, T[x].lx));
	}
	if (T[x].rx) {
		ret = max(ret, query_2d(xs, xe, ys, ye, mx + 1, rx, ly, ry, T[x].rx));
	}
	return ret;
}
int main() {
	cin.tie(0); ios_base::sync_with_stdio(0);
	
	int n;
	cin >> n;

	vector<int> a(n);
	for (int i = 0; i < n; i++) cin >> a[i];

	for (int t = 0; t < 4; t++) {
		int x[n + 1], y[n + 1], z[n + 1];
		x[0] = y[0] = z[0] = 0;
		for (int i = 0; i < n; i++) {
			x[i + 1] = x[i];
			y[i + 1] = y[i];
			z[i + 1] = z[i];
			if (a[i] == t) {
				x[i + 1]++;
				y[i + 1]++;
				z[i + 1]++;
			}
			else if (a[i] == (t + 1) % 4) --x[i + 1];
			else if (a[i] == (t + 2) % 4) --y[i + 1];
			else if (a[i] == (t + 3) % 4) --z[i + 1];
		}

		for (int *p : {x, y, z}) {
			int b[n + 1];
			for (int i = 0; i <= n; i++) b[i] = p[i];
			sort(b, b + n + 1);
			int sz = unique(b, b + n + 1) - b;
			for (int i = 0; i <= n; i++) p[i] = lower_bound(b, b + sz, p[i]) - b;
		}

		int ord[n + 1];
		iota(ord, ord + n + 1, 0);
		sort(ord, ord + n + 1, [&](int i, int j) {
			if (z[i] != z[j]) return z[i] > z[j];
			if (y[i] != y[j]) return y[i] < y[j];
			if (x[i] != x[j]) return x[i] < x[j];
			return i > j;
		});

		T.clear();
		int nd = new_node();
		int ans = 0;

		for (int i = 0; i <= n; i++) {
			int pos = ord[i];

			ans = max(ans, query_2d(x[pos] + 1, n, y[pos] + 1, n, 0, n, 0, n, nd) - pos);
			update_2d(x[pos], y[pos], pos, 0, n, 0, n, nd);
		}
		cout << ans << ' ';
	}
	cout << '\n';
}