#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define fo(i, n) rep(i, 0, n)
#define all(x) std::begin(x), std::end(x)
#define sz(x) int((x).size())
#define F first
#define S second
#define MP make_pair
#define PB push_back
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<double> vd;
typedef pair<double, double> pdd;
typedef vector<vd> vvd;
typedef vector<pdd> vpdd;

// #define MFFDEBUG 1

const int inf = 1e9;
const pii unit = {inf, -inf};
struct Node
{
	Node *l = 0, *r = 0;
	int lo, hi, madd = 0;
	pii val = unit;
	pii op(const pii &a, const pii &b)
	{
		return {min(a.F, b.F), max(a.S, b.S)};
	}
	Node(int lo, int hi) : lo(lo), hi(hi) {}
	Node(vi &v, int lo, int hi) : lo(lo), hi(hi)
	{
		if (lo + 1 < hi)
		{
			int mid = lo + (hi - lo) / 2;
			l = new Node(v, lo, mid);
			r = new Node(v, mid, hi);
			val = op(l->val, r->val);
		}
		else
		{
			val = {v[lo], v[lo]};
		}
	}
	pii query(int L, int R)
	{
		if (R <= lo || hi <= L)
			return unit;
		if (L <= lo && hi <= R)
			return val;
		push();
		return op(l->query(L, R), r->query(L, R));
	}
	void add(int L, int R, int x)
	{
		if (R <= lo || hi <= L)
			return;
		if (L <= lo && hi <= R)
		{
			madd += x;
			val.F += x;
			val.S += x;
		}
		else
		{
			push(), l->add(L, R, x), r->add(L, R, x);
			val = op(l->val, r->val);
		}
	}
	void push()
	{
		if (!l)
		{
			int mid = lo + (hi - lo) / 2;
			l = new Node(lo, mid);
			r = new Node(mid, hi);
		}
		if (madd)
		{
			l->add(lo, hi, madd), r->add(lo, hi, madd), madd = 0;
		}
	}
};

vi order;
vi values;
Node *tree;

void setsign(int pos, int val)
{
	ll delta = val - values[pos];
	tree->add(pos + 1, values.size() + 1, delta);
	values[pos] = val;
}

bool inv_overlaps(pii a, pii b)
{
	if (a.F > a.S)
		return false;
	if (b.F > b.S)
		return false;

	// b.F = -b.F;
	// b.S = -b.S;
	// swap(b.F, b.S);

	return !((a.S < b.F) || (b.S < a.F));
}

signed main()
{
	cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(cin.badbit | cin.failbit);

	int n;
	cin >> n;

	order = vi(n);
	values = vi(n, -1);

	{
		vi pref_sum(n + 1);
		fo(i, n + 1)
			pref_sum[i] = -i;
		tree = new Node(pref_sum, 0, n + 1);
	}

	fo(i, n)
	{
		ll v;
		cin >> v;
		v--;
		order[v] = i;
	}

	vector<bool> anses(n);

	fo(num, n)
	{
		int pos = order[num];
		setsign(pos, 0);

		pii self_ans = tree->query(pos, pos + 2);
		assert(self_ans.F == self_ans.S);
		int self = self_ans.F;

#if MFFDEBUG
		cerr << num << " at " << pos << endl;
#endif

		auto query_adjusted = [&](int L, int R)
		{
#if MFFDEBUG
			cerr << L << " to " << R << ": ";
#endif

			L = max(L, 0);
			R = min(R, n + 1);
			pii ans = tree->query(L, R);
			ans.F -= self;
			ans.S -= self;

#if MFFDEBUG
			cerr << ans.F << " to " << ans.S << endl;
#endif
			return ans;
		};

		bool ans = inv_overlaps(query_adjusted(0, pos + 1), query_adjusted(pos + 2, n + 1)) ||
				   inv_overlaps(query_adjusted(0, pos), query_adjusted(pos + 1, n + 1));

#if MFFDEBUG
		cerr << "Answer: " << ans << endl;
#endif

		anses[pos] = ans;

		setsign(pos, 1);
	}

	fo(i, n)
	{
		cout << (anses[i] ? "YES" : "NO");
		cout << (i == n - 1 ? '\n' : ' ');
	}
}