#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using vi = vector<int>;
using pi = pair <int, int>;

// struct psgt{
//     using rec = int;
//     static constexpr rec er = 0;
//     static rec cr(const rec& a, cost rec& b) { return a + b;}
//     struct node {
//         rec v;
//         int l, r;
//     };

//     vector<node> T;
//     vi RT;
//     int N;

//     psgt(const vector<rec>& a) : N(a.size()) {
//         T.reserve(2 * N);
//         RT.push_back(_build(0, N - 1, a));
//     }

//     psgt(int n, const rec& v = er) : psgt(vector<rec>(n , v)) {} // n times v
//     int _nn() {return T.emplace_back(), (int)T.size() - 1;}
//     int _build(int b, int e, const vector<rec>& a) {
//         int p = _nn();
//         if (b == e) return T[p].v = a[b], p;
//         int m = (b + e) / 2;
//         T[p].l = _build(b, m, a);
//         T[p].r = _build(m + 1, e, a);
//         T[p].v = cr(T[T[p].l].v, T[T[p].r].v);
//         return p;
//     }

//     int _upd(int i, int b, int e, int p, auto&& f) {
//         if (b > p || e < p) return i;
//         int q =  _nn();
//         T[q] = T[i];
//         if (b == e) return f(T[q].v), q;
//         int m = (b + e) / 2;
//         T[p].l = _upd(T[i].l, b, m, p, f);
//         T[p].r = _upd(T[i].r, m + 1, e, p, f);
//         T[p].v = cr(T[T[q].l].v, T[T[q].r].v);
//         return q;
//     }
//     int upd(int r, int p, auto&& f) {

//     }

#define L (i * 2 + 1)
#define R (i * 2 + 2)

constexpr int inf = 1e9+5;

struct rec
{
    int sum = 0;
    int len = 0;
    int pmin[4] = {0, inf, inf, inf};
    int smin[4] = {0, inf, inf, inf};
    int pmax[4] = {0, -inf, -inf, -inf};
    int smax[4] = {0, -inf, -inf, -inf};

    constexpr rec() = default;
    constexpr rec(int x) : sum(x), len(1)
    {
        sum = x;
        len = 1;
        pmin[1] = smin[1] = pmax[1] = smax[1] = x;
        pmin[0] = min(pmin[0], pmin[1]);
        smin[0] = min(smin[0], smin[1]);
        pmax[0] = max(pmax[0], pmax[1]);
        smax[0] = max(smax[0], smax[1]);
    }
};

ostream& operator<<(ostream& ostr, const rec& rec)
{
    ostr << rec.sum << ' ' << rec.len << '\n';
    for (auto x : rec.pmin)
        ostr << x << ' ';
    ostr << '\n';
    for (auto x : rec.smin)
        ostr << x << ' ';
    ostr << '\n';
    for (auto x : rec.pmax)
        ostr << x << ' ';
    ostr << '\n';
    for (auto x : rec.smax)
        ostr << x << ' ';
    ostr << '\n';
    return ostr;
}

struct sgt
{
    static constexpr rec er{};
    static rec cr(const rec& a, const rec& b) 
    {
        rec r;
        r.sum = a.sum + b.sum;
        r.len = a.len + b.len;
        for (int i = 0; i < 4; ++i)
            r.pmin[i] = min(a.pmin[i], a.sum + b.pmin[max(0, i - a.len)]);
        for (int i = 0; i < 4; ++i)
            r.pmax[i] = max(a.pmax[i], a.sum + b.pmax[max(0, i - a.len)]);
        for (int i = 0; i < 4; ++i)
            r.smin[i] = min(b.smin[i], b.sum + a.smin[max(0, i - b.len)]);
        for (int i = 0; i < 4; ++i)
            r.smax[i] = max(b.smax[i], b.sum + a.smax[max(0, i - b.len)]);
        return r;
    }
    vector<rec> T, A;
    int N;
    sgt(const vector<rec>& a) : T(4 * a.size()), A(a), N(a.size()){
        rebuild(0, N - 1);
    }
    sgt(int n, const rec& v = er) : sgt(vector<rec>(n, v)){}
    void _rebuild(int i, int b, int e, int f, int t){
        if (b > t || e < f) return;
        if (b==e) return void(T[i] = A[b]);
        int m = (b + e) / 2;
        _rebuild(L, b, m, f, t);
        _rebuild(R, m + 1, e, f, t);
        T[i] = cr(T[L], T[R]);
    }

    void rebuild(int f, int t) {
        if (f <= t) _rebuild(0, 0, N - 1, f , t);
    }
    rec _query(int i, int b, int e, int f, int t)
    {
        if (b > t || e < f) return er;
        if (b >= f && e <= t) return T[i];
        int m = (b + e) / 2;
        return cr(_query(L, b, m, f, t), _query(R, m + 1, e, f, t));
    }
    rec query(int f, int t) { return f <=t ? _query(0, 0, N - 1, f, t) : er;}
};

void solve ()
{
    int n;
    cin >> n;
    vi a(n);
    for (auto& x : a)
        cin >> x;
    vi p(n + 1);
    for (int i = 0; i < n; ++i)
        p[a[i]] = i;

    sgt sg(n, 1);

    vi result(n);
    
    for (int i = 1; i <= n; ++i)
    {
        sg.A[p[i]] = rec(0);
        sg.rebuild(p[i], p[i]);
        auto a = sg.query(0, p[i]);
        auto b = sg.query(p[i], n - 1);
        //cout << i << '\n';
        //cout << a << b;

        for (int j = 1; j < 4; ++j)
        {
            int mn = a.smin[j] + b.pmin[4 - j];
            int mx = a.smax[j] + b.pmax[4 - j];
            //cout << i << ' ' << j << ' ' << mn << ' ' << mx << '\n';
            result[p[i]] = (result[p[i]] || (mn <= 0 && mx >= 0));
        }
        sg.A[p[i]] = rec(-1);
        sg.rebuild(p[i], p[i]);
    }

    for (int i = 0; i < n; ++i)
    {
        cout << (result[i] ? "YES" : "NO");
        if (i + 1 < n)
            cout << ' ';
    }
    cout << '\n';
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    solve();
    return 0;
}