#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define SZ(a) ((int)a.size())
#define pb push_back
#define ALL(v) v.begin(), v.end()

const int INF = 1e9;

int n;
int arr[100005], bit[100005];
int tmp[100005][4], state[100005][3], idx[100005];
vector<int> val;
vector<pair<int*, int>> stk;

void modify(int x, int v, bool mem) {
    for (; x <= SZ(val); x += x & -x) {
        if (mem) stk.pb(make_pair(&bit[x], bit[x]));
        bit[x] = min(bit[x], v);
    }
}

int query(int x) {
    int rt = INF;
    for (; x; x -= x & -x)
        rt = min(rt, bit[x]);
    return rt;
}

int solve(int l, int r) {
    if (l == r) return 0;
    int mid = (l + r) >> 1;
    int ans = max(solve(l, mid), solve(mid + 1, r));
    
    queue<int> q;
    for (int a = l, b = mid + 1; a <= mid || b <= r;)
        if (b > r || (a <= mid && state[idx[a]][1] < state[idx[b]][1])) {
            modify(state[idx[a]][2], idx[a], true);
            q.push(idx[a++]);
        }
        else {
            ans = max(ans, idx[b] - query(state[idx[b]][2] - 1));
            q.push(idx[b++]);
        }
    while (!stk.empty())
        *stk.back().X = stk.back().Y, stk.pop_back();
    for (int i = l; i <= r; ++i)
        idx[i] = q.front(), q.pop();
    return ans;
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int vis[4] = {};
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cin >> arr[i], vis[arr[i]] = 1;
    int ans[4] = {};
    for (int i = 0; i < 4; ++i) {
        if (!vis[i]) continue;
        for (int j = 1; j <= n; ++j)
            if (arr[j] == 0) {
                arr[j] = i;
            }
            else if (arr[j] == i) {
                arr[j] = 0;
            }
        val.clear();
        val.pb(state[0][2] = 0);
        for (int j = 1; j <= n; ++j) {
            for (int k = 0; k < 4; ++k)
                tmp[j][k] = tmp[j - 1][k];
            ++tmp[j][arr[j]];
            for (int k = 0; k < 3; ++k)
                state[j][k] = tmp[j][0] - tmp[j][k + 1];
            val.pb(state[j][2]);
        }
        iota(idx, idx + n + 1, 0);
        sort(idx, idx + n + 1, [&](int a, int b) {
            if (state[a][0] != state[b][0]) return state[a][0] < state[b][0];
            if (state[a][1] != state[b][1]) return state[a][1] > state[b][1];
            return state[a][2] > state[b][2];
        });
        sort(ALL(val)), val.resize(unique(ALL(val)) - val.begin());
        for (int j = 0; j <= n; ++j)
            state[j][2] = upper_bound(ALL(val), state[j][2]) - val.begin();
        fill(bit, bit + SZ(val) + 1, INF);
        ans[i] = solve(0, n);
        for (int j = 1; j <= n; ++j)
            if (arr[j] == 0) {
                arr[j] = i;
            }
            else if (arr[j] == i) {
                arr[j] = 0;
            }
    }
    for (int i = 0; i < 4; ++i)
        cout << ans[i] << " \n"[i == 3];
}