#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#define int long long
#define ld long double
#define vec vector
#define all(m) (m).begin(), (m).end()
#define forn(i,n) for(int i=0;i<(n);i++)

// TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
using namespace std;

int inf = 1e17;
int mod = 1e9+7;

struct node {
    int mn,mx,prop;
};

void propagate(int v, vec<node> &tree) {
    tree[2*v].mn += tree[v].prop;
    tree[2*v].mx += tree[v].prop;
    tree[2*v].prop += tree[v].prop;
    tree[2*v+1].mn += tree[v].prop;
    tree[2*v+1].mx += tree[v].prop;
    tree[2*v+1].prop += tree[v].prop;
    tree[v].prop = 0;
}

void build(int v, int l, int r,vec<int> &a, vec<node> &tree) {
    if (l==r) {
        tree[v] = {a[l],a[l],0};
        return;
    }
    int m = (l+r)/2;
    build(v*2,l,m,a,tree);
    build(v*2+1,m+1,r,a,tree);
    tree[v] = {min(tree[2*v].mn,tree[2*v+1].mn),max(tree[2*v].mx,tree[2*v+1].mx),0};
}

void upd(int v, int l, int r, int lq, int rq, int dx, vec<node> &tree) {
    if (l>rq || r<lq)
        return;
    if (lq<=l && r<=rq) {
        tree[v].mn += dx;
        tree[v].mx += dx;
        tree[v].prop += dx;
        return;
    }
    propagate(v,tree);
    int m = (l+r)/2;
    upd(2*v,l,m,lq,rq,dx,tree);
    upd(2*v+1,m+1,r,lq,rq,dx,tree);
    tree[v].mn = min(tree[2*v].mn,tree[2*v+1].mn);
    tree[v].mx = max(tree[2*v].mx,tree[2*v+1].mx);
}

int get_max(int v, int l, int r, int lq, int rq, vec<node> &tree) {
    if (l>rq || r<lq)
        return -inf;
    if (lq<=l && r<=rq)
        return tree[v].mx;
    propagate(v,tree);
    int m = (l+r)/2;
    return max(get_max(2*v,l,m,lq,rq,tree),get_max(2*v+1,m+1,r,lq,rq,tree));
}

int get_min(int v, int l, int r, int lq, int rq, vec<node> &tree) {
    if (l>rq || r<lq)
        return inf;
    if (lq<=l && r<=rq)
        return tree[v].mn;
    propagate(v,tree);
    int m = (l+r)/2;
    return min(get_min(2*v,l,m,lq,rq,tree),get_min(2*v+1,m+1,r,lq,rq,tree));
}

void solve() {
    int n;
    cin >> n;
    vector<int> arr(n);
    vec<int> pos(n+1);
    forn(i,n) {
        cin >> arr[i];
        pos[arr[i]] = i;
    }
    vector<int> cur(n, -1);
    vec<int> pref(n+1, -1);
    vec<int> suff(n+1, -1);
    pref[0] = 0;
    suff[n] = 0;
    forn(i, n+1) {
        if (i == 0) {
            continue;
        }
        pref[i] += pref[i-1];
        suff[n-i] += suff[n-i+1];
    }
    vec<node> tr_suff(4*n+8);
    vec<bool> ans(n, false);
    build(1,0,n,suff,tr_suff);

    vec<node> tr_pref(4*n+8);
    build(1,0,n,pref,tr_pref);

    int sum = -n;

    for (int i = n; i >= 1; i--) {
        int ind = pos[i];
        upd(1, 0, n, ind+1, n, 1, tr_pref);
        upd(1, 0, n, 0, ind, 1, tr_suff);
        sum++;
        if (sum < 0) {
            int min_l = get_min(1, 0, n, 0, ind, tr_pref);
            int min_l_save = get_min(1, 0, n, 0, ind-1, tr_pref);
            int min_r = get_min(1,0, n, ind+1, n, tr_suff);
            int min_r_save = get_min(1,0, n, ind+2, n, tr_suff);
            if ((sum - min_l - min_r_save >= 0) || (sum - min_l_save - min_r >= 0)) {
                ans[ind] = true;
            }
        } else if (sum > 0) {
            int max_l = get_max(1, 0, n, 0, ind, tr_pref);
            int max_l_save = get_max(1, 0, n, 0, ind-1, tr_pref);
            int max_r = get_max(1,0, n, ind+1, n, tr_suff);
            int max_r_save = get_max(1,0, n, ind+2, n, tr_suff);
            if ((sum - max_l - max_r_save <= 0) || (sum - max_l_save - max_r <= 0)) {
                ans[ind] = true;
            }
        } else {
            ans[ind] = true;
        }
        upd(1, 0, n, ind+1, n, 1, tr_pref);
        upd(1, 0, n, 0, ind, 1, tr_suff);
        sum++;
    }

    forn(i, n) {
        if (ans[i]) {
            cout << "YES ";
        } else {
            cout << "NO ";
        }
    }
    cout << "\n";
}

signed main() {

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int tt = 1;
    // cin>>tt;
    while (tt--)
        solve();
    return 0;
}