#include <bits/stdc++.h>

constexpr int INF = 1e9;

struct Point {
    int x, y, z;
    int w;
};

struct BIT {
    std::vector<int> tr;
    explicit BIT(int n) : tr(n + 1, INF) {}
    void update(int x, int k) {
        for (; x < tr.size(); x += x & -x) {
            tr[x] = std::min(tr[x], k);
        }
    }
    int query(int x) {
        int res = INF;
        for (; x; x -= x & -x) {
            res = std::min(res, tr[x]);
        }
        return res;
    }
    void clear(int x) {
        for (; x < tr.size(); x += x & -x) {
            tr[x] = INF;
        }
    }
};

int solve(std::vector<Point> p) {
    std::vector<int> tmp;
    for (auto p : p) {
        tmp.push_back(p.x);
        tmp.push_back(p.y);
        tmp.push_back(p.z);
    }
    std::sort(tmp.begin(), tmp.end());
    tmp.resize(std::unique(tmp.begin(), tmp.end()) - tmp.begin());
    for (auto &p : p) {
        int &x = p.x, &y = p.y, &z = p.z;
        x = std::lower_bound(tmp.begin(), tmp.end(), x) - tmp.begin() + 1;
        y = std::lower_bound(tmp.begin(), tmp.end(), y) - tmp.begin() + 1;
        z = std::lower_bound(tmp.begin(), tmp.end(), z) - tmp.begin() + 1;
        // std::cout << p.x << ' ' << p.y << ' ' << p.z << ' ' << p.w << '\n';
    }
    std::sort(p.begin(), p.end(), [](auto p, auto q) {
        return p.x < q.x;
    });

    BIT mt{tmp.size()}, mp{tmp.size()};

    int res = 0;
    std::vector<Point> buf(p.size());
    auto conquer = [&](auto &self, int L, int R) -> void {
        if (L == R) return;

        int mid = (L + R) / 2;
        self(self, L, mid);
        self(self, mid + 1, R);

        int min_x = p[mid + 1].x;
        for (int i = mid + 2; i <= R; ++i) {
            min_x = std::min(min_x, p[i].x);
        }

        int l = L, ptr = l;
        for (int i = mid + 1; i <= R; ++i) {
            while (l <= mid && p[l].y < p[i].y) {
                if (p[l].x < min_x) {
                    mt.update(p[l].z, p[l].w);
                } else {
                    mp.update(p[l].z, p[l].w);
                }
                buf[ptr++] = p[l];
                ++l;
            }
            res = std::max(res, p[i].w - mt.query(p[i].z - 1));
            if (p[i].x > min_x) {
                res = std::max(res, p[i].w - mp.query(p[i].z - 1));
            }
            buf[ptr++] = p[i];
        }
        while (l <= mid) {
            buf[ptr++] = p[l];
            ++l;
        }

        assert(ptr == R + 1);
        for (int i = L; i <= mid; ++i) {
            mt.clear(p[i].z);
            mp.clear(p[i].z);
        }

        std::copy(buf.begin() + L, buf.begin() + R + 1, p.begin() + L);
    };
    conquer(conquer, 0, p.size() - 1);

    return res;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;

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

    std::vector<std::array<int, 4>> s(n);
    for (int i = 0; i < n; ++i) {
        s[i][a[i]] += 1;
    }
    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < 4; ++j) {
            s[i][j] += s[i - 1][j];
        }
    }

    for (int t = 0; t < 4; ++t) {
        std::vector<Point> p;
        for (int i = 0; i < n; ++i) {
            std::array<int, 3> coord;
            for (int j = 0, k = 0; j < 3; ++j, ++k) {
                if (k == t) ++k;
                coord[j] = s[i][t] - s[i][k];
            }
            auto [x, y, z] = coord;
            int w = i;
            p.push_back(Point{x, y, z, w});
        }
        p.push_back(Point{0, 0, 0, -1});
        std::cout << solve(p) << ' ';
        // std::cout << "--------------\n";
    }
}