There are $n$ pillars aligned in a row and numbered from $1$ to $n$.

Initially each pillar contains exactly one disk. The $i$-th pillar contains a disk having radius $a_i$.

You can move these disks from one pillar to another. You can take a disk from pillar $i$ and place it on top of pillar $j$ if all these conditions are met:

  there is no other pillar between pillars $i$ and $j$. Formally, it means that $|i - j| = 1$;  pillar $i$ contains exactly one disk;  either pillar $j$ contains no disks, or the topmost disk on pillar $j$ has radius strictly greater than the radius of the disk you move. 

When you place a disk on a pillar that already has some disks on it, you put the new disk on top of previously placed disks, so the new disk will be used to check the third condition if you try to place another disk on the same pillar.

You may take any disk and place it on other pillar any number of times, provided that every time you do it, all three aforementioned conditions are met. Now you wonder, is it possible to place all $n$ disks on the same pillar simultaneously?


-----Input-----

The first line contains one integer $n$ ($3 \le n \le 2 \cdot 10^5$) — the number of pillars.

The second line contains $n$ integers $a_1$, $a_2$, ..., $a_i$ ($1 \le a_i \le n$), where $a_i$ is the radius of the disk initially placed on the $i$-th pillar. All numbers $a_i$ are distinct.


-----Output-----

Print YES if it is possible to place all the disks on the same pillar simultaneously, and NO otherwise. You may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).


-----Examples-----
Input
4
1 3 4 2

Output
YES

Input
3
3 1 2

Output
NO



-----Note-----

In the first case it is possible to place all disks on pillar $3$ using the following sequence of actions:

  take the disk with radius $3$ from pillar $2$ and place it on top of pillar $3$;  take the disk with radius $1$ from pillar $1$ and place it on top of pillar $2$;  take the disk with radius $2$ from pillar $4$ and place it on top of pillar $3$;  take the disk with radius $1$ from pillar $2$ and place it on top of pillar $3$.

Difficulty: EASY

Solutions:
num = int(input())
disks = list(map(lambda num: int(num), input().split()))
maximum = max(disks)
for (index, num) in enumerate(disks):
	if num == maximum:
		maxindex = index
		break
flag = 0
for i in range(len(disks[:maxindex])):
	if disks[i] > disks[i + 1]:
		flag = 1
		print('NO')
		break
if flag == 0:
	for i in range(len(disks[maxindex:]) - 1):
		if disks[maxindex + i] < disks[maxindex + i + 1]:
			flag = 1
			print('NO')
			break
	if flag == 0:
		print('YES')


def main():
	import sys
	input = sys.stdin.readline
	n = int(input())
	arr = list(map(int, input().split()))
	idx = arr.index(n)
	ok = 1
	for i in range(1, idx):
		if arr[i] < arr[i - 1]:
			ok = 0
	for i in reversed(range(idx, n - 1)):
		if arr[i] < arr[i + 1]:
			ok = 0
	if ok:
		print('YES')
	else:
		print('NO')
	return 0
main()


def f(A):
	max_index = 0
	for i in range(1, len(A)):
		if A[i] > A[max_index]:
			max_index = i
	(i, j) = (max_index - 1, max_index + 1)
	cur = A[max_index]
	while i >= 0 or j < len(A):
		left = A[i] if i >= 0 else cur
		right = A[j] if j < len(A) else cur
		assert not (left == cur and right == cur)
		if left > cur or right > cur:
			return False
		if i < 0 or (j < len(A) and left < right):
			cur = right
			j += 1
		elif j >= len(A) or (i >= 0 and right < left):
			cur = left
			i -= 1
		else:
			assert False
	return True
n = int(input())
A = list(map(int, input().split()))
print('YES' if f(A) else 'NO')


n = int(input())
a = list(map(int, input().split()))
k = max(a)
tof = True
p = -10000000000000000000000
for i in range(n):
	if a[i] == k:
		tof = False
		p = a[i]
		continue
	if tof and a[i] < p:
		print('NO')
		exit()
	if not tof and a[i] > p:
		print('NO')
		exit()
	p = a[i]
print('YES')


n = int(input())
a = [int(x) for x in input().split()]
ind = max(range(n), key=lambda x: a[x])
fail = False
mn = a[ind]
for i in range(ind, n):
	if a[i] > mn:
		fail = True
		break
	mn = min(mn, a[i])
if not fail:
	mn = a[ind]
	for i in range(ind, -1, -1):
		if a[i] > mn:
			fail = True
			break
		mn = min(mn, a[i])
if fail:
	print('NO')
else:
	print('YES')


t = int(input())
s = input().split()
s = list(map(int, s))
mx = s.index(max(s))
flag = True
for i in range(mx):
	flag &= s[i] < s[i + 1]
for i in range(mx, t - 1):
	flag &= s[i] > s[i + 1]
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
flag = False
for i in range(n - 1):
	if a[i] < a[i + 1]:
		continue
	else:
		flag = True
if not flag:
	print('YES')
	exit()
flag = False
for i in range(n - 1):
	if a[i] > a[i + 1]:
		continue
	else:
		flag = True
if not flag:
	print('YES')
	exit()
cnt = 0
for i in range(1, n - 1):
	if a[i - 1] < a[i] < a[i + 1]:
		continue
	if a[i - 1] > a[i] > a[i + 1]:
		continue
	if a[i - 1] < a[i] and a[i] > a[i + 1]:
		cnt += 1
		continue
	else:
		print('NO')
		exit()
if cnt == 1:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
ileft = iright = imax = 0
ma = arr[0]
flag = 0
for i in range(1, n):
	if arr[i] > ma:
		ma = arr[i]
		imax = i
ileft = imax - 1
iright = imax + 1
while ileft >= 0 or iright < n:
	l = r = -1
	if ileft >= 0:
		l = arr[ileft]
	if iright < n:
		r = arr[iright]
	mlr = -1
	mlr = max(l, r)
	if mlr != -1:
		if mlr >= arr[imax]:
			print('NO')
			flag = 1
			break
		else:
			arr[imax] = mlr
			if ileft >= 0 and iright < n:
				if arr[ileft] >= arr[iright]:
					ileft -= 1
				else:
					iright += 1
			elif ileft >= 0:
				ileft -= 1
			elif iright < n:
				iright += 1
if flag == 0:
	print('YES')


n = int(input())
t = list(map(int, input().split()))
for j in range(n):
	if t[j] == n:
		if sorted(t[0:j]) == t[0:j] and sorted(t[j + 1:][::-1]) == t[j + 1:][::-1]:
			print('YES')
		else:
			print('NO')


n = int(input())
line = input()
lst = []
for (idx, num) in enumerate(line.split(' ')):
	lst.append((int(num), idx))
lst.sort(reverse=True)
(left, right) = (lst[0][1], lst[0][1])
ans = 'YES'
for i in range(1, n):
	if not left - 1 <= lst[i][1] <= right + 1:
		ans = 'NO'
		break
	left = min(left, lst[i][1])
	right = max(right, lst[i][1])
print(ans)


k = int(input())
m = 0
s = list(map(int, input().split()))
for i in range(k):
	if s[i] > s[m]:
		m = i
ans = 'YES'
for i in range(m - 1):
	if s[i] > s[i + 1]:
		ans = 'NO'
for i in range(m, k - 1):
	if s[i] < s[i + 1]:
		ans = 'NO'
print(ans)


n = int(input())
a = list(map(int, input().split()))
x = 1
mx = max(a)
for i in range(n):
	if a[i] == mx:
		indx = i
		break
for i in range(n - 1):
	if i < indx and a[i] >= a[i + 1] or (i > indx and a[i] <= a[i + 1]):
		x = 0
		break
if x:
	print('YES')
else:
	print('NO')


a = int(input())
b = list(map(int, input().split()))
d = set(b)
if len(d) != a:
	print('NO')
	return
ima = 0
for i in range(a):
	if b[ima] < b[i]:
		ima = i
for i in range(1, ima):
	if b[i] < b[i - 1]:
		print('NO')
		return
for i in range(ima, a - 1):
	if b[i] < b[i + 1]:
		print('NO')
		return
print('YES')


n = int(input())
a = list(map(int, input().split()))
if n == 3:
	if a[0] < a[1] < a[2] or a[0] > a[1] > a[2]:
		print('YES')
	else:
		print('NO')
elif n > 3:
	l = a.index(max(a))
	if l == 0 and all((a[item] > a[item + 1] for item in range(n - 1))) or (l == -1 and all((a[item] < a[item + 1] for item in range(n - 1)))):
		print('YES')
	elif all((a[item] < a[item + 1] for item in range(l))) and all((a[item] > a[item + 1] for item in range(l + 1, n - 1))) or (all((a[item] > a[item + 1] for item in range(l))) and all((a[item] < a[item + 1] for item in range(l + 1, n - 1)))):
		print('YES')
	else:
		print('NO')


n = int(input())
l = list(map(int, input().split()))
flg = 0
for i in range(1, n - 1):
	if l[i] <= l[i - 1] and l[i] <= l[i + 1]:
		print('NO')
		flg = 1
		break
if flg == 0:
	print('YES')


x = int(input())
y = list(map(int, input().split()))
t = y.index(max(y))
n = 0
q = t + 1
bool = True
while n + 1 < t:
	if y[n] < y[n + 1]:
		n += 1
	else:
		bool = False
		break
if bool == False:
	print('NO')
else:
	while q + 1 < x:
		if y[q] > y[q + 1]:
			q += 1
		else:
			bool = False
			break
	if bool == False:
		print('NO')
	else:
		print('YES')


class Read:

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def main():
	n = Read.int()
	a = Read.list_int()
	max_a = max(a)
	index = a.index(max_a)
	l_index = index - 1
	r_index = index + 1
	while True:
		if l_index >= 0 and r_index < n:
			if a[l_index] > a[r_index]:
				if a[l_index] >= max_a:
					print('NO')
					return
				max_a = a[l_index]
				l_index -= 1
			else:
				if a[r_index] >= max_a:
					print('NO')
					return
				max_a = a[r_index]
				r_index += 1
		elif l_index >= 0:
			if a[l_index] >= max_a:
				print('NO')
				return
			max_a = a[l_index]
			l_index -= 1
		elif r_index < n:
			if a[r_index] >= max_a:
				print('NO')
				return
			max_a = a[r_index]
			r_index += 1
		else:
			break
	print('YES')
t = 1
for j in range(t):
	main()


t = int(input())
g = list(map(int, input().split()))
k = max(g)
flag = True
i = 0
while g[i] != k:
	if i != 0 and g[i] < g[i - 1]:
		print('NO')
		return
	i += 1
i += 1
while i < t and g[i] != k:
	if i != 0 and g[i] > g[i - 1]:
		print('NO')
		return
	i += 1
print('YES')


def solve(b):
	m = len(b)
	d = False
	for i in range(1, m):
		if a[i] < a[i - 1]:
			d = True
		elif a[i] > a[i - 1] and d:
			return False
	return True
n = int(input())
a = [int(x) for x in input().split(' ')]
if solve(a):
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
l = arr[0]
li = 0
for i in range(n):
	if arr[i] > l:
		li = i
		l = arr[i]
arl = arr[0:li + 1]
arr = arr[li:]
a = sorted(arl)
b = sorted(arr, reverse=True)
if arl != a:
	print('NO')
elif arr != b:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
mx = max(a)
idex = a.index(mx)
i = idex - 1
j = idex + 1
while i > -1 or j < n:
	if i > -1 and j < n:
		if a[i] > a[j] and a[i] < a[idex]:
			idex = i
			i -= 1
		elif a[i] < a[j] and a[j] < a[idex]:
			idex = j
			j += 1
		elif a[i] == a[j] and a[j] < a[idex]:
			idex = j
			j += 1
		else:
			print('NO')
			exit()
	elif i > -1:
		if a[i] < a[idex]:
			idex = i
			i -= 1
		else:
			print('NO')
			exit()
	elif j < n:
		if a[j] < a[idex]:
			idex = j
			j += 1
		else:
			print('NO')
			exit()
print('YES')


n = int(input())
a = [*map(int, input().split())]
i = a.index(n)
a1 = a[:i]
a1.sort()
a2 = a[i + 1:]
a2.sort(reverse=True)
if a == a1 + [n] + a2:
	print('YES')
else:
	print('NO')


n = int(input())
inputs = input().split(' ')
arr = []
for x in inputs:
	arr.append(int(x))

def largest(arr, n):
	max = arr[0]
	maxindex = 0
	for i in range(1, n):
		if arr[i] > max:
			max = arr[i]
			maxindex = i
	return maxindex
index = largest(arr, n)
arr2 = arr[index + 1:]
arr1 = arr[:index]
flag1 = 0
flag2 = 0
if all((arr1[i] <= arr1[i + 1] for i in range(len(arr1) - 1))):
	flag1 = 1
if all((arr2[i] >= arr2[i + 1] for i in range(len(arr2) - 1))):
	flag2 = 1
if flag1 == 1 and flag2 == 1:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
maxa = max(arr)
maxi = arr.index(maxa)
flag = 0
for i in range(maxi):
	if arr[i] >= arr[i + 1]:
		flag = 1
		break
if flag == 1:
	print('NO')
else:
	flag = 0
	for i in range(maxi + 1, n):
		if arr[i] >= arr[i - 1]:
			flag = 1
			break
	if flag == 1:
		print('NO')
	else:
		print('YES')


from collections import defaultdict as dt
n = int(input())
a = list(map(int, input().split()))
x = 0
d = dt(lambda : 0)
for i in a:
	d[i] = d[i] + 1
	if d[i] > 1:
		print('NO')
		x = 1
		break
if x == 0:
	d = sorted(a)
	e = d[::-1]
	b = max(a)
	c = a.index(b)
	if c == 0:
		if e == a:
			print('YES')
		else:
			print('NO')
	elif c == n - 1:
		if d == a:
			print('YES')
		else:
			print('NO')
	else:
		d = sorted(a[:c + 1])
		e = sorted(a[c:])[::-1]
		if d == a[:c + 1] and e == a[c:]:
			print('YES')
		else:
			print('NO')


n = int(input())
l = list(map(int, input().split()))
m = l.index(n)
c = 0
p = 0
s = 0
for i in range(m):
	if l[i] <= l[i + 1]:
		c += 1
	else:
		s += 1
		break
for i in range(m, n - 1):
	if l[i] >= l[i + 1]:
		p += 1
	else:
		s += 1
		break
if s > 0:
	print('NO')
else:
	print('YES')


n = int(input())
discs = list(map(int, input().split()))
x = discs.index(max(discs))
first_list = discs[:x]
second_list = discs[x:]
second_list.reverse()
second_list.pop()
caseA = 0
caseB = 0
caseC = 0
if all((first_list[i] < first_list[i + 1] for i in range(len(first_list) - 1))):
	caseA = 1
if all((second_list[i] < second_list[i + 1] for i in range(len(second_list) - 1))):
	caseB = 1
discs.sort()
if all((discs[i] != discs[i + 1] for i in range(n - 1))):
	caseC = 1
if caseA and caseB and caseC:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
i = a.index(max(a))
f = True
j = i + 1
while j < n:
	if a[j] >= a[j - 1]:
		f = False
	j += 1
j = i - 1
while j >= 0:
	if a[j] >= a[j + 1]:
		f = False
	j -= 1
print('YES' if f else 'NO')


n = int(input())
l = list(map(int, input().split()))
k = l.index(n)
if l[:k] == sorted(l[:k]) and l[k + 1:] == sorted(l[k + 1:])[::-1]:
	print('YES')
else:
	print('NO')


import math
import os
import random
import re
import sys

def check(arr, n):
	flag = 0
	for i in range(n - 1):
		if arr[i] < arr[i + 1]:
			if flag == 0:
				flag += 1
			elif flag == -1:
				print('NO')
				return
		elif flag == 0 or flag == 1:
			flag = -1
	print('YES')
n = int(input())
arr = list(map(int, input().split()))
check(arr, n)


def sv():
	N = int(input())
	A = list(map(int, input().split()))
	dec = False
	for i in range(1, N):
		if dec:
			if A[i] > A[i - 1]:
				return False
		elif A[i] < A[i - 1]:
			dec = True
	return True
print('YES' if sv() else 'NO')


n = int(input())
A = [int(i) for i in input().split()]
x = max(A)
ind = A.index(x)
c = 0
arr1 = A[:ind]
if ind < n - 1:
	arr2 = A[ind + 1:]
	temp2 = sorted(arr2, reverse=True)
	if temp2 == arr2:
		c += 1
else:
	c += 1
if ind == 0:
	c += 1
else:
	temp1 = sorted(arr1)
	if temp1 == arr1:
		c += 1
if c == 2:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
big = l.index(n)
count = 0
lol = 0
for i in range(big):
	if l[i] > l[i + 1]:
		count += 1
		break
for i in range(big, n - 1):
	if l[i] < l[i + 1]:
		lol += 1
		break
if lol == 1 or count == 1:
	print('NO')
else:
	print('YES')


import sys
from collections import defaultdict
import math

def main():
	n = int(input())
	a = list(map(int, input().split()))
	pos = a.index(max(a))
	ok = True
	for i in range(pos):
		if a[i] > a[i + 1]:
			ok = False
			break
	if ok:
		for i in range(pos + 1, n):
			if a[i] > a[i - 1]:
				ok = False
				break
	print('YES' if ok else 'NO')
main()


from heapq import heappush, heappop
from collections import deque
import sys
sys.setrecursionlimit(10 ** 6)

def MI():
	return map(int, input().split())

def I():
	return int(input())

def LI():
	return [int(i) for i in input().split()]
YN = ['YES', 'NO']

def bisect(ls, x):
	(l, r) = (0, len(ls))
	while r - l > 1:
		mid = (l + r) // 2
		if ls[mid] >= x:
			r = mid
		else:
			l = mid
	return l
q = 1
for _ in range(q):
	n = I()
	a = LI()
	m = max(a)
	mi = a.index(m)
	if a[:mi] == sorted(a[:mi]):
		if mi == n - 1:
			ans = 0
		elif a[mi + 1:] == sorted(a[mi + 1:])[::-1]:
			ans = 0
		else:
			ans = 1
	else:
		ans = 1
	print(YN[ans])


n = int(input())
a = list(map(int, input().split()))
i = 0
max = 0
for x in range(n):
	if a[x] > max:
		max = a[x]
		i = x
cur = 1
ans = 1
while cur <= i:
	if a[cur] < a[cur - 1]:
		ans = -1
		break
	cur += 1
if ans == 1:
	while cur < n - 1:
		if a[cur] < a[cur + 1]:
			ans = -1
			break
		cur += 1
if ans == 1:
	print('YES')
else:
	print('NO')


nb_pillars = int(input())
wheels = [int(s) for s in input().split()]
maxi = wheels.index(max(wheels))
could_be = True
for i in range(maxi):
	could_be &= wheels[i] < wheels[i + 1]
for i in range(maxi, nb_pillars - 1):
	could_be &= wheels[i] > wheels[i + 1]
print(['NO', 'YES'][could_be])


n = int(input())
numbers = list(map(int, input().split()))
flag = 0
for i in range(1, len(numbers) - 1):
	if numbers[i] < numbers[i - 1] and numbers[i] < numbers[i + 1]:
		flag = 1
		print('NO')
		break
if flag == 0:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
for i in range(n):
	arr[i] = [arr[i], i]
arr.sort(reverse=True)
l = arr[0][1]
r = arr[0][1]
for i in range(1, n):
	a = arr[i][1]
	if abs(l - a) > 1 and abs(r - a) > 1:
		print('NO')
		break
	else:
		l = min(l, a)
		r = max(r, a)
else:
	print('YES')


n = int(input())
inp = input()
a = [int(ele) for ele in inp.split()]
b = a.copy()
b.sort()
b.reverse()
max = b[0]
single = [max]
top = 0
flag = 1
ind = a.index(max)
for i in range(ind - 1):
	if a[i] > a[i + 1]:
		print('NO')
		flag = 0
		break
if flag == 1:
	for i in range(ind + 1, len(a) - 1):
		if a[i] < a[i + 1]:
			print('NO')
			flag = 0
			break
if flag == 1:
	print('YES')


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
n = iinput()
a = linput()
ans = True
mx = max(a)
for i in range(n):
	if a[i] == mx:
		break
	if a[i] > a[i + 1]:
		ans = False
if ans:
	while i < n - 1:
		if a[i] < a[i + 1]:
			ans = False
		i += 1
print('YES' if ans else 'NO')


n = int(input())
A = list(map(int, input().split()))
idx = A.index(n)
flag = True
for i in range(idx, 0, -1):
	if A[i - 1] >= A[i]:
		flag = False
		break
for i in range(idx, n - 1):
	if A[i] <= A[i + 1]:
		flag = False
		break
print('YES' if flag else 'NO')


n = int(input())
arr = list(map(int, input().split()))
d = {}
for i in range(n):
	d[arr[i]] = i
index = arr.index(n)
(start, end) = (index, index)
flag = 0
for i in range(n - 1, 0, -1):
	if d[i] == start - 1:
		start -= 1
	elif d[i] == end + 1:
		end += 1
	else:
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


n = int(input())
data = list(map(int, input().split()))
k = data.index(max(data))
a1 = all((data[i] < data[i + 1] for i in range(k)))
a2 = all((data[i] > data[i + 1] for i in range(k)))
a3 = all((data[i] < data[i + 1] for i in range(k, n - 1)))
a4 = all((data[i] > data[i + 1] for i in range(k, n - 1)))
if a1 and a4 or (a2 and a3):
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(i) for i in input().split()]
m = 0
ind = -1
f1 = 0
f2 = 0
for i in range(n):
	if a[i] > m:
		ind = i
		m = a[i]
for i in range(ind):
	if a[i] >= a[i + 1]:
		f1 = 1
		break
for i in range(ind, n - 1):
	if a[i] <= a[i + 1]:
		f2 = 1
		break
if f1 == 1 or f2 == 1:
	print('NO')
else:
	print('YES')


import sys, math, queue
MOD = 998244353
sys.setrecursionlimit(1000000)
n = int(input())
a = list(map(int, input().split()))
indx = a.index(max(a))
ans = 'YES'
for i in range(indx + 1, n):
	if a[i] >= a[i - 1]:
		ans = 'NO'
		break
for i in reversed(range(indx - 1)):
	if a[i] >= a[i + 1]:
		ans = 'NO'
		break
print(ans)


def ans(a):
	for i in range(1, len(a) - 1):
		if a[i] < a[i - 1] and a[i] < a[i + 1]:
			return False
	return True
n = int(input())
l = list(map(int, input().split()))
print('YES' if ans(l) else 'NO')


n = int(input())
a = list((int(x) for x in input().split()))
m = max(a)
i = a.index(m)
b = a[:i]
c = a[i + 1:]
d = sorted(b)
e = sorted(c, reverse=True)
if b == d and c == e:
	print('YES')
else:
	print('NO')


n = input()
List = list(map(int, input().split()))
List2 = sorted(List)
out = 'YES'
I = List.index(List2[len(List2) - 1])
for i in range(I):
	if List[i] >= List[i + 1]:
		out = 'NO'
for i in range(I, len(List) - 1):
	if List[i] <= List[i + 1]:
		out = 'NO'
print(out)


n = int(input())
l = list(map(int, input().split()))
idx = -1
for i in range(len(l)):
	if l[i] == n:
		idx = i
flag = 1
for i in range(idx):
	if l[i] > l[i + 1]:
		flag = 0
for i in range(idx + 1, len(l) - 1):
	if l[i] < l[i + 1]:
		flag = 0
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
arr = input()
l = list(map(int, arr.split(' ')))
for i in range(1, len(l) - 1):
	if l[i] < l[i - 1] and l[i] < l[i + 1]:
		print('NO')
		exit(0)
print('YES')


import sys

def is_valid(ls):
	n = len(ls)
	k = ls.index(n)
	prev = 0
	for i in range(n):
		if i < k:
			if prev > ls[i]:
				return False
		if i > k:
			if prev < ls[i]:
				return False
		prev = ls[i]
	return True
n = int(sys.stdin.readline())
disk_ls = [int(i) for i in sys.stdin.readline().split()]
if is_valid(disk_ls):
	print('YES')
else:
	print('NO')


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
n = ii()
l = li()
m = l.index(n)
l2 = sorted(l[:m]) + [l[m]] + sorted(l[m + 1:], reverse=True)
if l == l2:
	print('YES')
else:
	print('NO')


def solve(nums):
	targetPiller = nums.index(max(nums))
	i = 0
	while i < targetPiller - 1:
		if nums[i] > nums[i + 1]:
			print('NO')
			return
		i += 1
	i = targetPiller + 1
	while i < len(nums) - 1:
		if nums[i] < nums[i + 1]:
			print('NO')
			return
		i += 1
	print('YES')
input()
nums = list(map(int, input().split()))
solve(nums)


n = int(input())
c = list(map(int, input().split()))
r = c.index(max(c))
l1 = c[:r]
l2 = c[r:]
l3 = sorted(l1)
l4 = sorted(l2)[::-1]
if l1 == l3 and l2 == l4:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
i = a.index(n)
print('YES') if a[:i] == sorted(a[:i]) and a[i + 1:] == sorted(a[i + 1:])[::-1] else print('NO')


n = int(input())
ar = list(map(int, input().split()))
m = max(ar)
ind = -1
for i in range(n):
	if ar[i] == m:
		ind = i
ans = 'YES'
a1 = []
a2 = []
for i in range(ind):
	a1.append(ar[i])
	a2.append(ar[i])
a2.sort()
for i in range(ind):
	if a1[i] != a2[i]:
		ans = 'NO'
a3 = []
a4 = []
for i in range(ind + 1, n):
	a3.append(ar[i])
	a4.append(ar[i])
a4.sort(reverse=True)
for i in range(len(a3)):
	if a3[i] != a4[i]:
		ans = 'NO'
print(ans)


n = int(input())
arr = list(map(int, input().split()))
prev = arr[0]
ind = len(arr)
for i in range(1, len(arr)):
	if prev < arr[i]:
		prev = arr[i]
	else:
		prev = arr[i]
		ind = i + 1
		break
for i in range(ind, len(arr)):
	if prev > arr[i]:
		prev = arr[i]
	else:
		print('NO')
		break
else:
	print('YES')


def solve():
	n = int(input())
	arr = [int(x) for x in input().split()]
	center = -1
	for (i, v) in enumerate(arr):
		if v == n:
			center = i
			break
	for i in range(0, center):
		if arr[i] > arr[i + 1]:
			return False
	for i in range(center, n - 1):
		if arr[i] < arr[i + 1]:
			return False
	return True
if solve():
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split()]
max = a[0]
maxp = 0
for i in range(n):
	if a[i] > max:
		maxp = i
		max = a[i]
i = maxp - 1
j = maxp + 1
flag = 0
current = max
while i >= 0 or j < n:
	if i >= 0 and j < n:
		if a[i] > a[j]:
			max = i
		else:
			max = j
		if a[max] >= current:
			flag = 1
			break
		elif max == i:
			current = a[i]
			i -= 1
		else:
			current = a[j]
			j += 1
	elif i >= 0:
		if a[i] >= current:
			flag = 1
			break
		else:
			current = a[i]
			i -= 1
	elif a[j] >= current:
		flag = 1
		break
	else:
		current = a[j]
		j += 1
if flag == 0:
	print('YES')
else:
	print('NO')


import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
R = lambda : map(int, input().split())
n = int(input())
l = list(R())
max_no = max(l)
index_max = l.index(max_no)
flag = False
for i in range(1, index_max):
	if l[i] < l[i - 1]:
		flag = True
		break
for j in range(index_max + 1, n):
	if l[j] > l[j - 1]:
		flag = True
		break
if flag:
	print('NO')
else:
	print('YES')


n = int(input().strip())
nums = list(map(int, input().strip().split()))
has_dups = len(nums) > len(set(nums))
mx = nums.index(max(nums))
if has_dups or nums[:mx + 1] != sorted(nums[:mx + 1]) or nums[mx:] != sorted(nums[mx:], reverse=True):
	print('NO')
else:
	print('YES')


a = int(input())
v = True
d = [int(i) for i in input().split()]
m = d.index(a)
(l, r) = (d[0:m], d[-1:m:-1])
while l or r:
	if len(r) and r[-1] == a - 1:
		r.pop()
	elif len(l) and l[-1] == a - 1:
		l.pop()
	else:
		print('NO')
		exit()
	a -= 1
print('YES')


from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
mod = 10 ** 9 + 7
eps = 10 ** (-7)

def inp():
	return int(input())

def inpl():
	return list(map(int, input().split()))

def inpl_str():
	return list(input().split())
N = inp()
aa = inpl()
maxi = aa.index(N)
for i in range(maxi, N - 1):
	if aa[i] < aa[i + 1]:
		print('NO')
		return
for i in reversed(list(range(0, maxi))):
	if aa[i] > aa[i + 1]:
		print('NO')
		return
print('YES')


n = int(input())
a = list(map(int, input().split()))
check = False
i = 0
while i < n - 1:
	if a[i] < a[i + 1]:
		i += 1
	else:
		break
while i < n - 1:
	if a[i] > a[i + 1]:
		i += 1
	else:
		break
if i < n - 1:
	check = True
if check:
	print('NO')
else:
	print('YES')


n = int(input(''))
a = input('')
p = []
for i in a.split(' '):
	p.append(int(i))
count = 0
for i in range(1, p.index(max(p))):
	if p[i - 1] > p[i]:
		count = 1
		break
for i in range(p.index(max(p)) + 1, len(p)):
	if p[i - 1] < p[i]:
		count = 1
		break
if count == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(i) for i in input().split()]
if n > len(set(a)):
	print('NO')
else:
	(curr, verdict) = (a[0], True)
	if a[1] > curr:
		up = True
		down = False
		mark = n - 1
		for i in range(1, n):
			if a[i] < curr:
				up = False
				down = True
				mark = i
				break
			curr = a[i]
		for i in range(mark, n):
			if a[i] > curr:
				verdict = False
				break
			curr = a[i]
	else:
		down = True
		for i in range(1, n):
			if a[i] > curr:
				verdict = False
				break
			curr = a[i]
	if verdict:
		print('YES')
	else:
		print('NO')


from collections import Counter, defaultdict
I = lambda : int(input())
M = lambda : map(int, input().split())
LI = lambda : list(map(int, input().split()))
n = I()
a = LI()
(f1, f2, f3) = (1, 1, 1)
for i in range(0, n - 1):
	if a[i] < a[i + 1]:
		f1 = 0
		break
for i in range(0, n - 1):
	if a[i] > a[i + 1] and f2 == 1:
		f2 = 2
	if f2 == 2 and a[i] < a[i + 1]:
		f2 = 0
		break
for i in range(0, n - 1):
	if a[i] > a[i + 1]:
		f3 = 0
		break
if f1 or (f2 == 1 or f2 == 2) or f3:
	print('YES')
else:
	print('NO')


n = int(input())
a = (*map(int, input().split()),)
x = i = 0
j = n - 1
while i < j:
	if x < a[i] < a[j]:
		x = a[i]
		i += 1
	elif x < a[j] < a[i]:
		x = a[j]
		j -= 1
	else:
		print('NO')
		exit()
print('YES')


input()
a = list(map(int, input().split()))
b = []
c = []
e = a.index(max(a))
b.append(a[:e])
c.append(a[e:len(a)])
d = sorted(b[0], reverse=False)
if b[0] == d and c[0] == sorted(c[0], reverse=True):
	print('YES')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
maximum = A[0]
idx = 0
for i in range(1, n):
	if A[i] > maximum:
		maximum = A[i]
		idx = i
l = idx - 1
r = idx + 1
ans = True
base = A[idx]
while l >= 0 and r < n:
	if A[l] > A[r]:
		if base < A[l]:
			ans = False
			break
		base = A[l]
		l -= 1
	else:
		if base < A[r]:
			ans = False
			break
		base = A[r]
		r += 1
if l >= 0:
	while l >= 0:
		if base < A[l]:
			ans = False
			break
		base = A[l]
		l -= 1
elif r < n:
	while r < n:
		if base < A[r]:
			ans = False
			break
		base = A[r]
		r += 1
if ans:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
max1 = l.index(n)
for i in range(1, n):
	if i <= max1:
		if l[i - 1] < l[i]:
			continue
		else:
			print('NO')
			exit()
	elif l[i] < l[i - 1]:
		continue
	else:
		print('NO')
		exit()
print('YES')


n = int(input())
array = list(map(int, input().split()))
ind = array.index(max(array))
(i, j) = (ind - 1, ind + 1)
now = array[ind]
while i != -1 or j != n:
	if i == -1:
		if array[j] < now:
			now = array[j]
			j += 1
		else:
			print('NO')
			exit(0)
	elif j == n:
		if array[i] < now:
			now = array[i]
			i -= 1
		else:
			print('NO')
			exit(0)
	elif array[i] > array[j]:
		if array[i] < now:
			now = array[i]
			i -= 1
		else:
			print('NO')
			exit(0)
	elif array[j] < now:
		now = array[j]
		j += 1
	else:
		print('NO')
		exit(0)
print('YES')


input()
X = list(map(int, input().split()))
Left = X[:X.index(max(X))]
Right = X[X.index(max(X)):]
print('YES' if sorted(Left) == Left and sorted(Right, reverse=True) == Right else 'NO')


n = int(input())
arr = [int(x) for x in input().split()]
temp = max(arr)
ind = arr.index(temp)
flag = 1
i = 0
arr2 = []
arr3 = []
for j in range(ind):
	arr2.append(arr[j])
for j in range(ind + 1, n):
	arr3.append(arr[j])
arr2.sort()
arr3.sort(reverse=True)
flag = 1
for j in range(ind):
	if arr2[j] != arr[j]:
		flag = 0
		break
if flag == 1:
	for j in range(ind + 1, n):
		if arr3[j - ind - 1] != arr[j]:
			flag = 0
			break
if flag == 1:
	print('YES\n')
else:
	print('NO\n')


n = int(input())
l = list(map(int, input().split()))
big = l[0]
ptr = 0
for i in range(1, len(l)):
	if l[i] > big:
		big = l[i]
		ptr = i
flag = 0
if ptr == len(l) - 1:
	if l[:ptr] == sorted(l[:ptr]):
		flag = 1
elif ptr == 0:
	if l[ptr + 1:] == sorted(l[ptr + 1:], reverse=True):
		flag = 1
elif l[:ptr] == sorted(l[:ptr]) and l[ptr + 1:] == sorted(l[ptr + 1:], reverse=True):
	flag = 1
if flag == 0:
	print('NO')
elif flag == 1:
	print('YES')


def main():
	n = int(input())
	a_list = list(map(int, input().split(' ')))
	max_a = max(a_list)
	max_a_i = a_list.index(max_a)
	ok = True
	before = a_list[0]
	for i in range(1, max_a_i):
		cur = a_list[i]
		if before >= cur:
			return 'NO'
		before = cur
	before = a_list[-1]
	for i in range(n - 2, max_a_i, -1):
		cur = a_list[i]
		if before >= cur:
			return 'NO'
		before = cur
	return 'YES'
out = main()
print(out)


import sys
import math
input = sys.stdin.readline
n = int(input())
arr = list(map(int, input().split()))
ind = arr.index(max(arr))
arr1 = list(arr[:ind])
arr2 = list(arr[ind + 1:])
arr2.sort(reverse=True)
arr1.sort()
if arr1 == arr[:ind] and arr2 == arr[ind + 1:]:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
if a == sorted(a) or a == sorted(a, reverse=True):
	print('YES')
else:
	out = True
	for i in range(n):
		if a[i] > a[i + 1]:
			break
	for j in range(i, n - 1):
		if a[j] < a[j + 1]:
			out = False
			break
	print('YES' if out else 'NO')


k = f = 0
n = int(input())
a = [int(x) for x in input().split()]
for i in range(1, n):
	if a[i] < a[i - 1]:
		f = 1
	if a[i] > a[i - 1] and f != 0:
		print('NO')
		k = 1
	if k == 1:
		break
if k == 0:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
ind = arr.index(max(arr))
(arr1, arr2) = (arr[:ind], arr[ind + 1:])
if arr1 == list(sorted(arr1)) and arr2 == list(reversed(sorted(arr2))):
	print('YES')
else:
	print('NO')


n = int(input())
x = list(map(int, input().split()))
flag = True
max_val = max(x)
max_pos = x.index(max_val)
for i in range(max_pos + 1):
	if i < max_pos - 1 and x[i + 1] < x[i]:
		flag = False
for i in range(max_pos, n + 1):
	if i < n - 1 and x[i + 1] > x[i]:
		flag = False
if flag:
	print('YES')
else:
	print('NO')


a = int(input())
b = list(map(int, input().split()))
i = 1
while i < a - 1:
	if b[i - 1] > b[i] and b[i] < b[i + 1]:
		exit(print('NO'))
	i += 1
print('YES')


def pd(a, mid):
	L = a[:mid][::-1]
	R = a[mid + 1:]
	k = a[mid]
	i = j = 0
	while i < len(L) and j < len(R):
		if L[i] < R[j]:
			if k > R[j]:
				k = R[j]
				j += 1
			else:
				return 0
		elif L[i] > R[j]:
			if k > L[i]:
				k = L[i]
				i += 1
			else:
				return 0
		else:
			return 0
	if i == len(L):
		if R[j:] == sorted(R[j:])[::-1]:
			return 1
	if j == len(R):
		if L[i:] == sorted(L[i:])[::-1]:
			return 1
	return 0
n = int(input())
l = list(map(int, input().split()))
k = l.index(max(l))
print('YNEOS'[not pd(l, k)::2])


import sys, collections
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().split()))
permu = [i for i in range(1, n + 1)]
if sorted(arr) != permu:
	print('NO')
else:
	idx = arr.index(max(arr))
	i = idx - 1
	j = idx + 1
	top = arr[idx]
	while i > -1 or j < n:
		if i < 0:
			if arr[j] == top - 1:
				top = arr[j]
				j += 1
			else:
				break
		elif j > n - 1:
			if arr[i] == top - 1:
				top = arr[i]
				i -= 1
			else:
				break
		elif arr[i] == top - 1:
			top = arr[i]
			i -= 1
		elif arr[j] == top - 1:
			top = arr[j]
			j += 1
		else:
			break
	if i <= -1 and j >= n:
		print('YES')
	else:
		print('NO')


n = int(input())
l1 = [int(x) for x in input().split()]
if len(set(l1)) != len(l1):
	print('NO')
else:
	i = 0
	while i < len(l1) - 1 and l1[i] < l1[i + 1]:
		i += 1
	while i < len(l1) - 1 and l1[i] > l1[i + 1]:
		i += 1
	if i != len(l1) - 1:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
i = a.index(n)
l = i - 1
r = i + 1
ans = 'YES'
for i in range(1, n):
	if l >= 0 and a[l] == n - i:
		l -= 1
	elif r < n and a[r] == n - i:
		r += 1
	else:
		ans = 'NO'
print(ans)


def check(l):
	for i in range(1, len(l)):
		if l[i] < l[i - 1]:
			return False
	return True
n = int(input())
a = [int(i) for i in input().split()]
max = max(a)
max_pos = a.index(max)
left = a[0:max_pos]
right = a[-1:max_pos:-1]
if check(left) and check(right):
	print('YES')
else:
	print('NO')


import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log, ceil
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
import itertools

def Int():
	return int(sys.stdin.readline())

def Mint():
	return map(int, sys.stdin.readline().split())

def Lstr():
	return list(sys.stdin.readline().strip())

def Str():
	return sys.stdin.readline().strip()

def Mstr():
	return map(str, sys.stdin.readline().strip().split())

def List():
	return list(map(int, sys.stdin.readline().split()))

def Hash():
	return dict()

def Mod():
	return 1000000007

def Ncr(n, r, p):
	return fact[n] * (ifact[r] * ifact[n - r] % p) % p

def Most_frequent(list):
	return max(set(list), key=list.count)

def Mat2x2(n):
	return [List() for _ in range(n)]

def Lcm(x, y):
	return x * y // gcd(x, y)

def dtob(n):
	return bin(n).replace('0b', '')

def btod(n):
	return int(n, 2)

def common(l1, l2):
	return set(l1).intersection(l2)

def solution():
	n = Int()
	a = List()
	s = 0
	for i in range(n - 2):
		if a[i] > a[i + 1] < a[i + 2]:
			s += 1
	if s == 0:
		print('YES')
	else:
		print('NO')
solution()


n = int(input())
a = list(map(int, input().split()))
f = 0
x = a.index(max(a))
i = x - 1
j = x + 1
while i >= 0 or j < n:
	if i >= 0:
		u = a[i]
	if j < n:
		v = a[j]
	if i >= 0 and a[x] - u == 1:
		x = i
		i -= 1
	elif j < n and a[x] - v == 1:
		x = j
		j += 1
	else:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


n = int(input())
A = list(map(int, input().split()))
M = max(A)
cnt = 0
j = -1
for (i, a) in enumerate(A):
	if a == M:
		cnt += 1
		j = i
if cnt >= 2:
	print('NO')
	exit()
for i in range(min(0, j - 1), j - 1):
	if A[i] >= A[i + 1]:
		print('NO')
		exit()
for i in range(j, n - 1):
	if A[i] <= A[i + 1]:
		print('NO')
		exit()
print('YES')


n = int(input())
a = list(map(int, input().split()))
largest_index = 0
largest_value = a[0]
for i in range(len(a)):
	if a[i] > largest_value:
		largest_value = a[i]
		largest_index = i
currPtr = 0
b = True
while currPtr < largest_index:
	if a[currPtr + 1] <= a[currPtr]:
		b = False
		break
	currPtr += 1
c = True
currPtr = largest_index
while currPtr < len(a) - 1:
	if a[currPtr + 1] >= a[currPtr]:
		c = False
		break
	currPtr += 1
if b and c:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
ind = a.index(max(a))
pos = True
for i in range(1, ind + 1):
	if a[i] < a[i - 1]:
		pos = False
		break
if pos:
	for i in range(ind + 1, n):
		if a[i] > a[i - 1]:
			pos = False
			break
	if pos:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
a = [(i, int(val)) for (i, val) in enumerate(input().split())]
a.sort(key=lambda x: -x[1])
leftmost_none = rightmost_none = a[0][0]
for i in range(1, n):
	if a[i][0] < a[0][0]:
		if leftmost_none - a[i][0] > 1:
			print('NO')
			exit()
		else:
			leftmost_none = a[i][0]
	elif a[i][0] > a[0][0]:
		if a[i][0] - rightmost_none > 1:
			print('NO')
			exit()
		else:
			rightmost_none = a[i][0]
print('YES')


n = int(input())
l = list(map(int, input().split()))
i = l.index(max(l))
l1 = l[0:i]
l2 = l[i + 1:n]
if sorted(l1) == l1:
	if sorted(l2, reverse=True) == l2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
m = 0
for i in range(n):
	if a[i] > m:
		m = a[i]
		mi = i
forw = a[mi:]
back = a[:mi]
flag = True
if forw:
	t1 = forw[0]
	for i in range(1, len(forw)):
		if forw[i] > t1:
			flag = False
		else:
			t1 = forw[i]
if back:
	t1 = back[-1]
	for i in range(len(back) - 1, -1, -1):
		if back[i] > t1:
			flag = False
		else:
			t1 = back[i]
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
arr = [int(x) for x in input().split()]
rev = sorted(arr, reverse=True)
ind = arr.index(rev[0])
i = ind - 1
j = ind + 1
t = 1
flag = True
while i > -1 or j < n:
	if i > -1 and arr[i] == rev[t]:
		t += 1
		i -= 1
	elif j < n and arr[j] == rev[t]:
		t += 1
		j += 1
	else:
		flag = False
		break
print('YES' if flag else 'NO')


w = int(input())
a = list(map(int, input().split()))
e = max(a)
t = 0
t1 = 0
if e == a[0]:
	t = 1
for j in range(1, w):
	if t == 0:
		if a[j] < a[j - 1]:
			t1 = 1
			break
	elif a[j] > a[j - 1]:
		t1 = 1
		break
	if a[j] == e:
		t = 1
if t1 == 0:
	print('YES')
else:
	print('NO')


import sys
import math
import itertools
import collections

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
n = ii()
a = li()
pos = a.index(n)
for i in range(pos):
	if a[i] >= a[i + 1]:
		exit(print('NO'))
for i in range(pos + 1, n, 1):
	if a[i - 1] <= a[i]:
		exit(print('NO'))
print('YES')


n = int(input())
l = [int(s) for s in input().split()]
re1 = 0
re2 = 0
for i in range(len(l)):
	if l[i] == n:
		re1 = i - 1
		re2 = i + 1
te = n - 1
fl = 0
while te != 0:
	if re1 >= 0:
		if l[re1] == te:
			te -= 1
			re1 -= 1
			continue
	if re2 < n:
		if l[re2] == te:
			te -= 1
			re2 += 1
			continue
	print('NO')
	fl = 1
	break
if fl == 0:
	print('YES')


ll = lambda : list(map(int, input().split()))
testcases = 1
for testcase in range(testcases):
	[n] = ll()
	a = ll()
	x = a.index(n)
	if a[0:x] == sorted(a[0:x]) and a[x + 1:n] == sorted(a[x + 1:n], reverse=True):
		print('YES')
	else:
		print('NO')


n = int(input())
a = [int(i) for i in input().split()]
idx = a.index(max(a))
if a[:idx] == sorted(a[:idx]) and a[idx + 1:] == sorted(a[idx + 1:], reverse=True):
	print('YES')
else:
	print('NO')


n = int(input(''))
arr = list(map(int, input().split()))
ind = arr.index(n)
flag = 0
for i in range(ind):
	if arr[i] > arr[i + 1]:
		flag = 1
		break
for i in range(ind + 1, n):
	if arr[i] > arr[i - 1]:
		flag = 1
		break
if flag:
	print('NO')
else:
	print('YES')


n = int(input())
A = list(map(int, input().split()))
x = A.index(n)
l = x - 1
r = x + 1
now = n - 1
ans = 'YES'
while l >= 0 or r < n:
	if l < 0:
		if A[r] == now:
			now -= 1
			r += 1
		else:
			ans = 'NO'
			break
	elif r >= n:
		if A[l] == now:
			l -= 1
			now -= 1
		else:
			ans = 'NO'
			break
	elif A[l] == now:
		l -= 1
		now -= 1
	elif A[r] == now:
		r += 1
		now -= 1
	else:
		ans = 'NO'
		break
print(ans)


from sys import stdin
n = int(stdin.readline().strip())
s = list(map(int, stdin.readline().strip().split()))
ind = -1
mx = -1
for i in range(n):
	if s[i] > mx:
		mx = s[i]
		ind = i
r = ind - 1
l = ind + 1
x = mx
while r > -1 or l < n:
	aux = x
	if r > -1 and l < n:
		if s[r] > s[l] and s[r] < x:
			x = s[r]
			r -= 1
		elif s[l] < x:
			x = s[l]
			l += 1
	elif r > -1:
		if s[r] < x:
			x = s[r]
			r -= 1
	elif l < n:
		if s[l] < x:
			x = s[l]
			l += 1
	if aux == x:
		break
if l == n and r == -1 and (x == min(s)):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
rev = [-1] * (n + 1)
for (i, j) in enumerate(a):
	rev[j] = i
mx = max(a)
l = a.index(mx)
r = l
for i in range(n - 1, 0, -1):
	idx = rev[i]
	if idx == l - 1:
		l -= 1
	elif idx == r + 1:
		r += 1
	else:
		print('NO')
		exit()
print('YES')


def solve():
	n = int(input())
	disks = list(map(int, input().split()))
	max_r = max(disks)
	met_r = False
	for i in range(n - 1):
		met_r |= disks[i] == max_r
		if not met_r:
			if disks[i] > disks[i + 1]:
				return 'NO'
		elif disks[i] < disks[i + 1]:
			return 'NO'
	return 'YES'
print(solve())


n = int(input())
x = list(map(int, input().split()))
flag = 0
if x[0] < x[1]:
	for i in range(2, n):
		if x[i] < x[i - 1] and flag == 0:
			flag = 1
		elif x[i] > x[i - 1] and flag == 1:
			flag += 1
			print('NO')
			break
		elif x[i] > x[i - 1] and i == n - 1:
			flag = 1
	if flag == 1:
		print('YES')
elif x[0] > x[1]:
	for i in range(2, n):
		if x[i] > x[i - 1]:
			print('NO')
			flag = 1
			break
	if flag == 0:
		print('YES')


F = lambda : int(input())
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
n = F()
l = L()
i = l.index(max(l))
if l[:i] == sorted(l[:i]) and l[i + 1:] == sorted(l[i + 1:], reverse=True):
	print('YES')
else:
	print('NO')


x = int(input())
y = list(map(int, input().split()))
for i in range(0, y.index(x)):
	if y[i] >= y[i + 1]:
		print('NO')
		exit()
for i in range(x - 1, y.index(x), -1):
	if y[i] >= y[i - 1]:
		print('NO')
		exit()
print('YES')


def main():
	n = int(input())
	a = [int(s) for s in input().split()]
	m = max(a)
	i = a.index(m)
	sol = 'YES'
	for (j, x) in enumerate(a):
		if j < i and x > a[j + 1]:
			sol = 'NO'
			break
		if j > i and x > a[j - 1]:
			sol = 'NO'
			break
	print(sol)
main()


n = int(input())
arr = list(map(int, input().split()))
ind = 0
mv = arr[0]
for i in range(n):
	if arr[i] > mv:
		mv = arr[i]
		ind = i
val = True
mv = arr[ind]
for i in range(ind - 1, -1, -1):
	if arr[i] >= mv:
		val = False
		break
	else:
		mv = arr[i]
mv = arr[ind]
for i in range(ind + 1, n):
	if arr[i] >= mv:
		val = False
		break
	else:
		mv = arr[i]
if val == False:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
Max = a.index(max(a))
if a[:Max] == sorted(a[:Max]) and a[Max:] == sorted(a[Max:], reverse=True):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
basic = 0
index = -1
for i in range(n):
	if a[i] > basic:
		basic = a[i]
		index = i
left = index
right = index
k = basic
t = True
for i in range(n):
	leftside = True
	rightside = True
	if left >= 1:
		if a[left - 1] == k - 1:
			left -= 1
		else:
			leftside = False
	else:
		leftside = False
	if right <= n - 2:
		if a[right + 1] == k - 1:
			right += 1
		else:
			rightside = False
	else:
		rightside = False
	if not leftside and (not rightside):
		t = False
		break
	k -= 1
if left == 0 and right == n - 1:
	t = True
if t:
	print('YES')
else:
	print('NO')


n = int(input())
ln = [int(i) for i in input().split(' ')]
m = ln.index(n)
wds = ['NO', 'YES']
f = True
for i in range(m - 1, -1, -1):
	if ln[i] > ln[i + 1]:
		f = False
for i in range(m + 1, len(ln)):
	if ln[i] > ln[i - 1]:
		f = False
print(wds[f])


n = int(input())
a = list(map(int, input().split()))
i = 1
while i < n and a[i] > a[i - 1]:
	i = i + 1
if i == n:
	print('YES')
	exit()
c = i - 1
i = i + 1
while i < n and a[i - 1] > a[i]:
	i = i + 1
if i == n:
	print('YES')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
print('NO' if any((A[i] > A[i + 1] < A[i + 2] for i in range(n - 2))) else 'YES')


h = int(input())
n = h
numbers = [int(i) for i in input().split()]
index1 = 0
for i in range(n):
	if numbers[i] == n:
		index1 = i
		break
index = index1
count2 = 1
count3 = 1
while True:
	if index + count2 >= n and index - count3 < 0:
		print('YES')
		break
	if index + count2 >= n:
		index2 = index - count3
		if numbers[index] < numbers[index2]:
			print('NO')
			exit()
		numbers[index] = numbers[index2]
		count3 += 1
		continue
	elif index - count3 < 0:
		index1 = index + count2
		if numbers[index] < numbers[index1]:
			print('NO')
			break
		numbers[index] = numbers[index1]
		count2 += 1
		continue
	index1 = index + count2
	index2 = index - count3
	maximal = max(numbers[index1], numbers[index2])
	if maximal > numbers[index]:
		print('NO')
		break
	numbers[index] = maximal
	if maximal == numbers[index1]:
		count2 += 1
	else:
		count3 += 1


n = int(input())
a = list(map(int, input().split()))
x = a.index(n)
f = 1
for i in range(1, x):
	if a[i] < a[i - 1]:
		f = 0
		break
if f:
	for i in range(x + 1, n):
		if a[i] > a[i - 1]:
			f = 0
			break
print(['NO', 'YES'][f])


t = int(input())
a = list(map(int, input().split()))
m = max(a)
b = True
for i in range(t - 1):
	if a[i] == m:
		break
	if a[i] < a[i + 1]:
		pass
	else:
		b = False
		break
ind = a.index(m)
for i in range(ind, t - 1):
	if a[i] > a[i + 1]:
		c = 1
	else:
		b = False
		break
if b:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
maxval = max(arr)
maxindex = -1
for i in range(n):
	if arr[i] == maxval:
		maxindex = i
		break
flag = 0
temp = maxval
for i in range(maxindex - 1, -1, -1):
	if temp <= arr[i]:
		flag = 1
		break
	else:
		temp = arr[i]
temp = maxval
for i in range(maxindex + 1, n):
	if arr[i] >= temp:
		flag = 1
		break
	else:
		temp = arr[i]
if flag == 0:
	print('YES')
else:
	print('NO')


IN = input
rint = lambda : int(IN())
rmint = lambda : map(int, IN().split())
rlist = lambda : list(rmint())
n = rint()
a = rlist()
l = 0
while l + 1 < n and a[l + 1] > a[l]:
	l += 1
r = n - 1
while r - 1 >= 0 and a[r - 1] > a[r]:
	r -= 1
if l + 1 >= r:
	print('YES')
else:
	print('NO')


n = int(input())
v = [int(i) for i in input().split()]
where = -1
for i in range(0, n):
	if v[i] == n:
		where = i
		break
if v[:where] == sorted(v[:where]) and v[where + 1:] == sorted(v[where + 1:], reverse=True):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
a1 = sorted(a)
flag = False
for i in range(n - 1):
	if a[i] == a[i + 1]:
		flag = True
if flag:
	print('NO')
else:
	j = 0
	g = 0
	while a[g] != a1[-j - 1]:
		g += 1
	r = g + 1
	l = g - 1
	j = 1
	flag = False
	while j < n:
		if r < n and a[r] == a1[-j - 1]:
			r += 1
			j += 1
		elif l > -1 and a[l] == a1[-j - 1]:
			l -= 1
			j += 1
		else:
			flag = True
			break
	if flag:
		print('NO')
	else:
		print('YES')


n = int(input())
arr = list(map(int, input().split()))
mid = arr.index(n)
i = mid - 1
while i >= 1:
	if arr[i - 1] > arr[i]:
		print('NO')
		exit()
	i -= 1
i = mid + 1
while i <= n - 2:
	if arr[i] < arr[i + 1]:
		print('NO')
		exit()
	i += 1
print('YES')


import sys
input = lambda : sys.stdin.readline().strip()
n = int(input())
left = {}
right = {}
ls = list(map(int, input().split()))
for i in range(1, n - 1):
	left[i] = i - 1
	right[i] = i + 1
left[0] = None
right[n - 1] = None
left[n - 1] = n - 2
right[0] = 1
index = {}
for i in range(n):
	index[ls[i]] = i
for i in range(n, 1, -1):
	if left[index[i]] == index[i - 1]:
		right[index[i - 1]] = right[index[i]]
		left[right[index[i]]] = index[i - 1]
	elif right[index[i]] == index[i - 1]:
		left[index[i - 1]] = left[index[i]]
		right[left[index[i]]] = index[i - 1]
	else:
		print('NO')
		break
else:
	print('YES')


n = int(input())
dat = list(map(int, input().split()))
m = max(dat)
res = True
asc = True
cur = 0
for i in range(n):
	if dat[i] == m:
		cur = dat[i]
		asc = False
		continue
	if asc:
		if cur >= dat[i]:
			res = False
		else:
			pass
	elif cur <= dat[i]:
		res = False
	else:
		pass
	cur = dat[i]
print('YES' if res else 'NO')


n = int(input())
a = list(map(int, input().split()))
kq = 1
t = a.index(n)
for i in range(t - 1):
	if a[i] > a[i + 1]:
		kq = 0
		break
if kq == 1:
	for i in range(t + 1, n - 1):
		if a[i] < a[i + 1]:
			kq = 0
			break
	if kq == 0:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


N = int(input())
A = [int(a) for a in input().split()]
ma = max(A)
mai = sum([i for i in range(N) if A[i] == ma])
print('NO' if sum([(A[i] > A[i + 1]) * (i < mai) + (A[i] < A[i + 1]) * (i > mai) for i in range(N - 1)]) else 'YES')


n = int(input())
a = list(map(int, input().split()))
j = a.index(max(a))
flag = True
for i in range(n - 1):
	if i == j:
		continue
	elif i < j:
		if a[i] >= a[i + 1]:
			flag = False
			break
	elif a[i] <= a[i + 1]:
		flag = False
		break
print('YES' if flag else 'NO')


t = 1
while t:
	t -= 1
	n = int(input())
	l = list(map(int, input().split()))
	flag = 1
	for i in range(1, len(l) - 1):
		if l[i - 1] > l[i] and l[i] < l[i + 1]:
			flag = 0
			break
	if flag:
		print('YES')
	else:
		print('NO')


n = int(input())
a = list(map(int, input().split()))
highestElement = max(a)
fwdHighElement = 0
bkHighElement = 0
highEleIndex = a.index(highestElement)
FlagFwd = 0
FlagBkwd = 0
if highEleIndex == len(a) - 1:
	for i in range(0, len(a) - 1):
		if a[i] < a[i + 1]:
			Flag = 1
		else:
			Flag = 0
			break
	if Flag == 1:
		print('YES')
		exit()
	else:
		print('NO')
		exit()
else:
	for i in range(highEleIndex, len(a) - 1):
		if a[i] > a[i + 1]:
			FlagFwd = 1
		else:
			FlagFwd = 0
			break
if highEleIndex == 0:
	for i in range(0, len(a) - 1):
		if a[i] > a[i + 1]:
			Flag = 1
		else:
			Flag = 0
			break
	if Flag == 1:
		print('YES')
		exit()
	else:
		print('NO')
		exit()
else:
	for i in range(0, highEleIndex - 1):
		if a[i] < a[i + 1]:
			FlagBkwd = 1
		else:
			FlagBkwd = 0
			break
if FlagFwd == 1 and FlagBkwd == 1:
	print('YES')
else:
	print('NO')


n = int(input())
u = list(map(int, input().split()))
if n < 3:
	print('YES')
	exit()
if u[0] != n and u[0] > u[1]:
	print('NO')
	exit()
if u[n - 1] != n and u[n - 1] > u[n - 2]:
	print('NO')
	exit()
for i in range(1, n - 1):
	if u[i] == n:
		continue
	if u[i] > max(u[i - 1], u[i + 1]):
		print('NO')
		exit()
print('YES')


n = int(input())
l = list(map(int, input().split()))
flag = 1
position = 1
for i in range(n - 1):
	if flag == 1:
		if l[i] >= l[i + 1]:
			flag = 0
	elif l[i] <= l[i + 1]:
		position = 0
if position == 1:
	print('YES')
else:
	print('NO')


for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	i = 0
	j = n - 1
	k = 1
	ok = True
	while i < j:
		if a[i] == k:
			i += 1
			k += 1
		elif a[j] == k:
			j -= 1
			k += 1
		else:
			ok = False
			break
	print(['NO', 'YES'][ok])


input()
a = list(map(int, input().split()))
ma = max(a)
ma_i = a.index(ma)
if a[:ma_i] == sorted(a[:ma_i]) and a[ma_i + 1:] == sorted(a[ma_i + 1:], reverse=True):
	print('YES')
else:
	print('NO')


n = int(input())
nums = list(map(int, input().split()))
ind_max = nums.index(n)
if ind_max == 0:
	for i in range(n - 1):
		if nums[i] < nums[i + 1]:
			print('NO')
			raise SystemExit
	print('YES')
	raise SystemExit
elif ind_max == n - 1:
	for i in range(n - 1):
		if nums[i] > nums[i + 1]:
			print('NO')
			raise SystemExit
	print('YES')
	raise SystemExit
else:
	for i in range(ind_max - 1):
		if nums[i] > nums[i + 1]:
			print('NO')
			raise SystemExit
	for i in range(ind_max, n - 1):
		if nums[i] < nums[i + 1]:
			print('NO')
			raise SystemExit
print('YES')


n = int(input())
l = list(map(int, input().split()))
max = l[0]
pos = 0
for i in range(1, n):
	if l[i] > max:
		max = l[i]
		pos = i
i = 0
f = 0
while i < pos:
	if l[i] > l[i + 1]:
		f = 1
		break
	i += 1
if f == 1:
	print('NO')
else:
	i = pos
	while i < n - 1:
		if l[i] < l[i + 1]:
			f = 1
			break
		i += 1
	if f == 1:
		print('NO')
	else:
		print('YES')


import sys
n = int(sys.stdin.readline())
p = list(map(int, sys.stdin.readline().split()))
mi = p.index(n)
t = n
prev = None if mi == 0 else mi - 1
next = None if mi == n - 1 else mi + 1
while t > 1:
	if prev is not None and next is not None:
		if p[prev] + 1 == t:
			mi = prev
			prev = None if mi == 0 else mi - 1
		elif p[next] + 1 == t:
			mi = next
			next = None if mi == n - 1 else mi + 1
		else:
			print('NO')
			exit()
	elif prev is None:
		if p[next] + 1 == t:
			mi = next
			next = None if mi == n - 1 else mi + 1
		else:
			print('NO')
			exit()
	elif p[prev] + 1 == t:
		mi = prev
		prev = None if mi == 0 else mi - 1
	else:
		print('NO')
		exit()
	t -= 1
print('YES')


n = int(input())
a = [int(i) for i in input().split()]
count = 0
maximum = a.index(max(a))
for i in range(0, maximum - 1):
	if a[i] > a[i + 1]:
		count += 1
for j in range(maximum, n - 1):
	if a[j] < a[j + 1]:
		count += 1
if count == 0:
	print('YES')
else:
	print('NO')


Input = lambda : map(int, input().split())
n = int(input())
l = list(Input())
MAX = max(l)
ind = l.index(MAX)
ind1 = ind - 1
ind2 = ind + 1
while ind1 != -1 or ind2 != n:
	if ind1 != -1 and ind2 != n:
		yy = max(l[ind1], l[ind2])
		if yy < MAX:
			MAX = yy
		else:
			print('NO')
			exit()
		if l[ind2] > l[ind1]:
			ind2 += 1
		elif l[ind2] < l[ind1]:
			ind1 -= 1
		else:
			print('NO')
			exit()
	elif ind1 != -1:
		yy = l[ind1]
		if yy < MAX:
			MAX = yy
		else:
			print('NO')
			exit()
		ind1 -= 1
	else:
		yy = l[ind2]
		if yy < MAX:
			MAX = yy
		else:
			print('NO')
			exit()
		ind2 += 1
print('YES')


n = int(input())
p = [int(i) for i in input().split()]
v = [-p[0]]
for i in range(1, n):
	v.append(p[i - 1] - p[i])
flag = False
for i in range(n):
	if v[i] > 0 and flag == False:
		flag = True
	elif v[i] < 0 and flag == True:
		print('NO')
		break
else:
	print('YES')


import sys, operator
n = int(input())
heights = list(map(int, input().split()))

def strictly_increasing(L):
	if not len(L):
		return True
	x = L[0]
	for i in L[1:]:
		if i > x:
			x = i
		else:
			return False
	return True

def strictly_decreasing(L):
	if not len(L):
		return True
	x = L[0]
	for i in L[1:]:
		if i < x:
			x = i
		else:
			return False
	return True
(max_index, value) = max(enumerate(heights), key=operator.itemgetter(1))
if strictly_increasing(heights[0:max_index]) and strictly_decreasing(heights[max_index + 1:]):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
s = 0
for i in range(2, n):
	if a[i - 2] > a[i - 1] < a[i]:
		s += 1
if s == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
t = a.copy()
t.sort()
t.pop()
ind = a.index(max(a))
i = ind - 1
j = ind + 1
while 1:
	if i == -1 and j == len(a):
		print('YES')
		break
	x = t.pop()
	if i >= 0 and x == a[i]:
		i = i - 1
	elif j < len(a) and x == a[j]:
		j += 1
	else:
		print('NO')
		break


(n, l) = (int(input()), list(map(int, input().split())))
(f, h) = (0, l.index(max(l)))
for i in range(n - 1):
	if i < h:
		if l[i + 1] < l[i]:
			f = 1
			break
	elif l[i + 1] > l[i]:
		f = 1
		break
print(['YES', 'NO'][f == 1])


n = int(input())
s = [int(i) for i in input().split()]
left = s[0:s.index(max(s))]
right = s[s.index(max(s)):]
if sorted(right, reverse=True) == right and sorted(left) == left:
	print('YES')
else:
	print('NO')


n = int(input())
l = [int(x) for x in input().split()]
if len(set(l)) < n:
	print('NO')
else:
	mx_idx = l.index(max(l))
	(l_bef, l_aft) = (l[:mx_idx], l[mx_idx + 1:])
	(flag1, flag2) = (0, 0)
	for i in range(len(l_bef)):
		if i > 0 and l_bef[i - 1] > l_bef[i]:
			flag1 += 1
			break
	for i in range(len(l_aft)):
		if i > 0 and l_aft[i - 1] < l_aft[i]:
			flag2 += 1
			break
	if flag1 or flag2:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
idx = a.index(max(a))
for i in range(1, n):
	if i > idx:
		if a[i - 1] < a[i]:
			print('NO')
			exit()
	elif a[i - 1] > a[i]:
		print('NO')
		exit()
print('YES')


class Pillar:

	def __init__(self, index, next_index):
		self.disk_count = 1
		self.index = index
		self.prev_index = index - 1 if index > 0 else index
		self.next_index = next_index

	def __repr__(self):
		return f'<i:{self.index} - dc:{self.disk_count}>'

	def is_empty(self):
		return self.disk_count == 0

class Disk:

	def __init__(self, radius, pillar):
		self.radius = radius
		self.pillar = pillar

	def __repr__(self):
		return f'<r:{self.radius} - pi:{self.pillar.index}>'

def can_place(moving_disk, target_disk, empty_pillars_between):
	first_condition = empty_pillars_between or abs(moving_disk.pillar.index - target_disk.pillar.index) == 1
	second_condition = moving_disk.pillar.disk_count == 1
	third_condition = moving_disk.radius < target_disk.radius
	return first_condition and second_condition and third_condition

def move_disk(disk, on_disk):
	disk.pillar.disk_count = 0
	unsorted_pillars[disk.pillar.prev_index].next_index = disk.pillar.next_index
	unsorted_pillars[disk.pillar.next_index].prev_index = disk.pillar.prev_index
	disk.pillar = on_disk.pillar

def are_pillars_between_empty(pillars, start_index, end_index):
	return pillars[start_index].next_index == end_index

def parse_input():
	for (j, value) in enumerate(input().split(' ')):
		unsorted_pillars.append(Pillar(j, j + 1 if j + 1 < pillar_count else j))
		unsorted_disks.append(Disk(int(value), unsorted_pillars[j]))
	return sorted(unsorted_disks, key=lambda d: d.radius, reverse=True)

def can_solve():
	for i in range(0, len(sorted_disks) - 1):
		start_pillar_index = sorted_disks[i].pillar.index if sorted_disks[i].pillar.index < sorted_disks[i + 1].pillar.index else sorted_disks[i + 1].pillar.index
		end_pillar_index = sorted_disks[i].pillar.index if sorted_disks[i].pillar.index > sorted_disks[i + 1].pillar.index else sorted_disks[i + 1].pillar.index
		empty_pillars = are_pillars_between_empty(unsorted_pillars, start_pillar_index, end_pillar_index)
		if not can_place(sorted_disks[i + 1], sorted_disks[i], empty_pillars):
			return False
		else:
			move_disk(sorted_disks[i + 1], sorted_disks[i])
	return True
pillar_count = int(input())
unsorted_pillars = []
unsorted_disks = []
sorted_disks = parse_input()
print('YES' if can_solve() else 'NO')


n = int(input())
ai = list(map(int, input().split()))
num = -1
for i in range(n):
	if ai[i] == n:
		num = i
		break
ans = 1
for i in range(num - 1, -1, -1):
	if ai[i + 1] < ai[i]:
		ans = 0
		break
for i in range(num + 1, n):
	if ai[i - 1] < ai[i]:
		ans = 0
		break
if ans == 1:
	print('YES')
else:
	print('NO')


n = int(input())
s = [int(x) for x in input().split()]
max_elem = s.index(max(s))
ans = True
for i in range(max_elem):
	if s[i] > s[i + 1]:
		ans = False
		break
for i in range(max_elem, n - 1):
	if s[i] < s[i + 1]:
		ans = False
		break
if ans:
	print('YES')
else:
	print('NO')


n = int(input())
s = list(map(int, input().split()))
k = s.index(max(s))
a = s[:k + 1]
b = s[k:]
if sorted(a) == a and sorted(b, reverse=True) == b:
	print('YES')
else:
	print('NO')


_ = int(input())
pillars = list(map(int, input().split()))
biggest = max(pillars)
bpi = pillars.index(biggest)
biggestSoFar = 0
for i in range(bpi):
	if biggestSoFar > pillars[i]:
		print('NO')
		quit()
	biggestSoFar = pillars[i]
biggestSoFar = 0
for i in reversed(range(bpi + 1, len(pillars))):
	if biggestSoFar > pillars[i]:
		print('NO')
		quit()
	biggestSoFar = pillars[i]
print('YES')


n = int(input())
a = map(int, input().split())
i = p = 0
for x in a:
	i += 1
	(x, p) = (p, x)
	if x > p:
		break
for x in a:
	if x > p:
		break
	p = x
	i += 1
print('YNEOS'[i < n::2])


n = int(input())
l = list(map(int, input().split()))
m = l.index(max(l))
p = 0
for t in range(m, 0, -1):
	if l[t] <= l[t - 1]:
		p = 1
		break
for tt in range(m, len(l) - 1):
	if l[tt] <= l[tt + 1]:
		p = 1
		break
if p == 0:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
up = 1
ind = 0
flag = True
while ind < n - 1:
	if up == 1:
		if l[ind] < l[ind + 1]:
			ind += 1
		else:
			ind += 1
			up = 2
	elif up == 2:
		if l[ind] > l[ind + 1]:
			ind += 1
		else:
			flag = False
			break
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
f = 0
for k in range(1, n):
	if a[k - 1] > a[k]:
		f = 1
	if f == 1 and a[k - 1] < a[k]:
		print('NO')
		exit()
print('YES')


n = int(input())
a = list(map(int, input().split()))
index = a.index(n)
start = a[0:index]
end = a[n - 1:index:-1]
if start == sorted(start) and end == sorted(end):
	print('YES')
else:
	print('NO')


n = int(input(''))
a = list(map(int, input().split()))
b = [i for i in range(1, n + 1)]
if b == a:
	print('YES')
	exit()
b = b[::-1]
if b == a:
	print('YES')
	exit()
f = 0
for i in range(1, n):
	if a[i] > a[i - 1]:
		continue
	else:
		f = i
		break
for i in range(f, n):
	if a[i] < a[i - 1]:
		continue
	else:
		print('NO')
		exit()
print('YES')


import sys
num = int(sys.stdin.readline())
t = sys.stdin.readline().split(' ')
for i in range(0, num):
	t[i] = int(t[i])
main_pillar = t.index(num)
invariant = 1
for i in range(1, num - 1):
	if t[i] < t[i + 1] and t[i] < t[i - 1]:
		invariant = 0
		break
for i in range(0, main_pillar - 1):
	if t[i] > t[i + 1]:
		invariant = 0
for i in range(main_pillar + 1, num - 1):
	if t[i] < t[i + 1]:
		invariant = 0
if invariant:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
p = 1
r = 1
e = 0
if r == 0:
	print('NO')
else:
	k = max(a)
	t = a.index(k)
	c = max(t, n - t - 1)
	for i in range(c):
		if i < t:
			if a[i] < a[i + 1]:
				pass
			else:
				e = 1
				break
		if i + t < n - 1:
			if a[i + t] > a[i + 1 + t]:
				pass
			else:
				e = 1
				break
	if e == 1:
		print('NO')
	else:
		print('YES')


def readn():
	return int(input())

def readlist():
	return list(map(int, input().split()))

def readnos():
	return map(int, input().split())
n = int(input())
a = readlist()
b = a.copy()
b.sort()
c = a.copy()
c.sort(reverse=True)
if b == a:
	print('YES')
elif c == a:
	print('YES')
else:
	ind = a.index(max(a))
	a1 = a[0:ind]
	a2 = a[ind:n]
	a11 = a1.copy()
	a22 = a2.copy()
	a11.sort()
	a22.sort(reverse=True)
	if a11 == a1 and a22 == a2:
		print('YES')
	else:
		print('NO')


n = int(input())
l = list(map(int, input().split()))
to = l.index(max(l))
ok = 1
for i in range(1, to):
	if l[i] <= l[i - 1]:
		ok = 0
		break
for i in range(to + 1, n):
	if l[i] >= l[i - 1]:
		ok = 0
		break
if ok:
	print('YES')
else:
	print('NO')


from sys import exit
n = int(input())
ls = list(map(int, input().split()))
x = ls.index(max(ls))
for i in range(x):
	if ls[i] >= ls[i + 1]:
		print('NO')
		exit()
for i in range(x, len(ls) - 1):
	if ls[i] <= ls[i + 1]:
		print('NO')
		exit()
print('YES')


input()
L = list(map(int, input().split()))
pos = L.index(max(L))
flag = True
for i in range(pos, 0, -1):
	if L[i] <= L[i - 1]:
		flag = False
		break
for i in range(pos, len(L) - 1):
	if L[i] <= L[i + 1]:
		flag = False
		break
if not flag:
	print('NO')
else:
	print('YES')


n = int(input())
A = list(map(int, input().split()))
i = A.index(max(A))
Bool = True
for x in range(1, i + 1):
	if A[x - 1] > A[x]:
		Bool = False
		break
if Bool == True:
	for x in range(i, n - 1):
		if A[x] < A[x + 1]:
			Bool = False
			break
if Bool == False:
	print('NO')
else:
	print('YES')


n = int(input())
a = [*map(int, input().split())]
i = a.index(n)
print('YNEOS'[a != [*sorted(a[:i]), n, *sorted(a[i + 1:])[::-1]]::2])


def gns():
	return list(map(int, input().split()))
n = int(input())
ns = gns()
mx = max(ns)
(l, r) = (-1, -1)
for i in range(n):
	if ns[i] == mx:
		(l, r) = (i, i)
		break
l -= 1
r += 1
while l >= 0 or r < n:
	if l >= 0 and ns[l] == mx - 1:
		mx -= 1
		l -= 1
		continue
	if r < n and ns[r] == mx - 1:
		mx -= 1
		r += 1
		continue
	print('NO')
	quit()
print('YES')


def main():
	n = int(input())
	f = 0
	ind = 0
	c = 0
	arr = [*map(int, input().split())]
	for i in range(0, n):
		if f < arr[i]:
			f = arr[i]
			ind = i
	for g in range(0, ind):
		if arr[g] < arr[g + 1]:
			c += 1
	for g in range(ind, n - 1):
		if arr[g] > arr[g + 1]:
			c += 1
	if c != n - 1:
		print('NO')
	else:
		print('YES')
main()


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
n = ii()
a = li()
i = a.index(n)
s = sorted
print('YNEOS'[a != s(a[:i]) + s(a[i:])[::-1]::2])


N = int(input())
s = [int(x) for x in input().split()]
pos = []
for i in range(0, N):
	pos.append(i)
dp = sorted(zip(s, pos))
dp = dp[::-1]
flag = 0
p1 = dp[0][1]
p2 = dp[0][1]
for i in range(1, len(dp)):
	if p1 - dp[i][1] == 1:
		p1 -= 1
	elif dp[i][1] - p2 == 1:
		p2 += 1
	else:
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


n = int(input())
disk = list(map(int, input().split(' ')))
start = disk.index(max(disk))
flag = True
for i in range(start, n - 1):
	if disk[i] <= disk[i + 1]:
		flag = False
		break
if flag:
	for i in range(0, start - 1):
		if disk[i] >= disk[i + 1]:
			flag = False
			break
if flag:
	print('YES')
else:
	print('NO')


import sys
cin = lambda : map(int, sys.stdin.readline().split())
n = int(input())
f = [*cin()]
for i in range(1, n - 1):
	if f[i - 1] > f[i] and f[i] < f[i + 1]:
		print('NO')
		exit(0)
print('YES')


n = int(input())
a = [int(x) for x in input().split()]
flag = 0
for i in range(1, len(a) - 1):
	if a[i] < a[i - 1] and a[i] < a[i + 1]:
		flag = 1
		break
	else:
		continue
if flag == 1:
	print('NO')
else:
	print('YES')


n = int(input())
sizes = list(map(int, input().split()))
larg = 0
pos = -1
for i in range(n):
	if sizes[i] > larg:
		larg = sizes[i]
		pos = i
inL = True
decR = True
i = 1
while i <= pos:
	if sizes[i] <= sizes[i - 1]:
		inL = False
	i += 1
i = pos + 1
while i < n:
	if sizes[i] >= sizes[i - 1]:
		decR = False
	i += 1
if inL and decR:
	print('YES')
else:
	print('NO')


n = int(input())
inp = list(map(int, input().split()))
k = inp.index(max(inp))
x = sorted(inp[k:])
x.reverse()
y = sorted(inp[:k])
if x == inp[k:] and y == inp[:k]:
	print('YES')
else:
	print('NO')


import sys
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
j = a.index(n)
for i in range(j):
	if a[i] > a[i + 1]:
		print('NO')
		exit()
for i in range(j, n - 1):
	if a[i] < a[i + 1]:
		print('NO')
		exit()
print('YES')


n = int(input())
disk = list(map(int, input().split()))
s = max(disk)
index = disk.index(s)
a = disk[:index]
b = disk[index + 1:]
c = a.copy()
d = b.copy()
c.sort()
d.sort(reverse=True)
if c == a:
	if d == b:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
i = 0
while a[i] != n:
	i += 1
j = i - 1
k = i + 1
x = n - 1
answer = True
while j >= 0 and k < n:
	if a[j] == x:
		x -= 1
		j -= 1
	elif a[k] == x:
		k += 1
		x -= 1
	else:
		answer = False
		break
while j >= 0:
	if a[j] == x:
		x -= 1
		j -= 1
	else:
		answer = False
		break
while k < n:
	if a[k] == x:
		k += 1
		x -= 1
	else:
		answer = False
		break
if answer:
	print('YES')
else:
	print('NO')


import sys
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().strip().split()))
i = a.index(max(a))
v = True
for j in range(0, i):
	if a[j] > a[j + 1]:
		v = False
for j in range(i, n - 1):
	if a[j] < a[j + 1]:
		v = False
if v == True:
	print('YES')
else:
	print('NO')


n = int(input())
array = list(map(int, input().split()))
i1 = 0
while i1 < n - 1 and array[i1] < array[i1 + 1]:
	i1 += 1
if i1 == n - 1:
	print('YES')
else:
	while i1 < n - 1 and array[i1] > array[i1 + 1]:
		i1 += 1
	if i1 == n - 1:
		print('YES')
	else:
		print('NO')


from sys import exit
n = int(input())
a = [int(x) for x in input().split()]
ind = a.index(max(a))
m = max(a)
l = ind - 1
r = ind + 1
while m > 1:
	if l > -1 and a[l] == m - 1:
		m -= 1
		l -= 1
	elif r < n and a[r] == m - 1:
		m -= 1
		r += 1
	else:
		print('NO')
		exit()
print('YES')


p = int(input())
a = list(map(int, input().split()))
mx = -1
for i in range(p):
	if a[i] > mx:
		ind = i
		mx = a[i]
a1 = a[:ind]
a2 = a[ind + 1:]
print('YES' if a1 == sorted(a1) and a2 == sorted(a2, reverse=True) else 'NO')


n = int(input())
a = [int(x) for x in input().split()]
flag = 0
for i in range(1, n - 1):
	if (a[i] > a[i - 1] and a[i] > a[i + 1] or (a[i] < a[i - 1] and a[i] < a[i + 1])) and a[i] != max(a):
		flag = 1
		break
if flag:
	print('NO')
else:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
max_val = temp = max(arr)
max_idx = i = arr.index(max_val)
tr = True
while tr and i >= 0:
	if arr[i] <= temp:
		temp = arr[i]
		i -= 1
	else:
		tr = False
if tr == False:
	print('NO')
else:
	i = max_idx
	temp = max_val
	while tr and i <= n - 1:
		if arr[i] <= temp:
			temp = arr[i]
			i += 1
		else:
			tr = False
	print('YES' if tr == True else 'NO')


n = int(input())
a = list(map(int, input().split()))
if n <= 2:
	print('YES')
else:
	mx = max(a)
	t = a.index(mx)
	l = 0
	r = 0
	if t > 0:
		for i in range(t - 1, -1, -1):
			if a[i] > mx:
				l = 1
				break
			else:
				mx = a[i]
	if t < n - 1:
		mx = max(a)
		for i in range(t + 1, n):
			if a[i] > mx:
				r = 1
				break
			else:
				mx = a[i]
	if l == 0 and r == 0:
		print('YES')
	else:
		print('NO')


n = int(input())
A = list(map(int, input().split()))
maks = A[0]
maksid = 0
for i in range(1, n):
	if A[i] > maks:
		maks = A[i]
		maksid = i
for i in range(1, maksid):
	if A[i - 1] > A[i]:
		print('NO')
		exit()
for i in range(maksid + 1, n):
	if A[i - 1] < A[i]:
		print('NO')
		exit()
print('YES')


import math
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
M = 10 ** 9 + 7

def isprime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def Freq(l):
	f = {}
	for i in l:
		if i in f:
			f[i] += 1
		else:
			f[i] = 1
	return f
inp = lambda : int(stdin.readline())
sip = lambda : stdin.readline()
mulip = lambda : map(int, stdin.readline().split())
lst = lambda : list(map(int, stdin.readline().split()))
slst = lambda : list(sip())
n = inp()
A = lst()
B = sorted(A)
if B == A or A == B[::-1]:
	print('YES')
else:
	cnt = 0
	if len(A) == 1 or len(A) == 2:
		print('YES')
	elif len(A) == 3:
		if max(A) == A[1] and A[0] != A[2]:
			print('YES')
		else:
			print('NO')
	else:
		mx = max(A)
		imx = A.index(mx)
		for i in range(imx, len(A) - 1):
			if A[i] > A[i + 1]:
				cnt += 1
		for i in range(1, imx + 1):
			if A[i - 1] < A[i]:
				cnt += 1
		if len(set(B)) == len(A) and cnt == len(A) - 1:
			print('YES')
		else:
			print('NO')


n = int(input())
aa = list(map(int, input().split()))
mx = max(aa)
if len(list(filter(lambda x: x == mx, aa))) > 1:
	print('NO')
imx = aa.index(mx)
up = aa[:imx]
down = aa[imx:]
if len(up) >= 2:
	for i in range(1, len(up)):
		if up[i - 1] >= up[i]:
			print('NO')
			exit(0)
if len(down) >= 2:
	for i in range(1, len(down)):
		if down[i - 1] <= down[i]:
			print('NO')
			exit(0)
print('YES')


n = int(input())
l = list(map(int, input().split()))
a = max(l)
z = l.index(a)
l1 = l[:z]
l2 = l[z:]
l2.reverse()
if l1 == sorted(l1) and l2 == sorted(l2):
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
x = arr.index(n)
if sorted(arr[:x]) == arr[:x] and sorted(arr[x + 1:])[::-1] == arr[x + 1:]:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
max_idx = 0
for i in range(1, len(arr)):
	if arr[max_idx] < arr[i]:
		max_idx = i
i = max_idx - 1
j = max_idx + 1
cur = arr[max_idx]
threshold = -1000000000.0
while i >= 0 or j <= n:
	left = threshold if i < 0 else arr[i]
	right = threshold if j >= n else arr[j]
	smallest = max(left, right)
	if smallest == threshold:
		print('YES')
		break
	elif smallest == right and smallest < cur:
		cur = smallest
		j += 1
	elif smallest == left and smallest < cur:
		cur = smallest
		i -= 1
	else:
		print('NO')
		break


n = int(input())
arr = list(map(int, input().split()))
maxi = arr.index(max(arr))

def possible():
	if maxi == n - 1:
		return arr == sorted(arr)
	if maxi == 0:
		return arr == list(reversed(sorted(arr)))
	return arr[:maxi + 1] == sorted(arr[:maxi + 1]) and arr[maxi:] == list(reversed(sorted(arr[maxi:])))
if possible():
	print('YES')
else:
	print('NO')


n = int(input())
l = []
l = input().split()
s = set(l)
if len(s) != n:
	print('NO')
	exit(0)
for i in range(1, n - 1):
	if int(l[i - 1]) > int(l[i]) and int(l[i]) < int(l[i + 1]):
		print('NO')
		exit(0)
print('YES')


import collections
n = int(input())
a = list(map(int, input().split()))
a = {i: j for (i, j) in enumerate(a)}
(m, idx) = (0, 0)
ans = 'YES'
for i in range(n):
	if a[i] > m:
		m = a[i]
		idx = i
for i in range(1, idx):
	if a[i] < a[i - 1]:
		ans = 'NO'
		break
for i in range(idx + 1, n):
	if a[i] > a[i - 1]:
		ans = 'NO'
		break
print(ans)


from collections import Counter as cr

def fn(r):
	if len(r) == 1 or len(r) == 0:
		return 1
	else:
		i = 1
		while i < len(r) and r[i] > r[i - 1]:
			i += 1
		if i == len(r):
			return 1
		else:
			return 0
n = int(input())
l = [int(e) for e in input().split()]
m = cr(l)
s = set(m.values())
if 1 in s and len(s) > 1 or (1 not in s and len(s) > 0):
	print('NO')
else:
	x = l.index(max(l))
	if fn(l[:x]) == 1 and fn(l[x + 1:][::-1]) == 1:
		print('YES')
	else:
		print('NO')


def printer(arr, m):
	prev = arr[m]
	for i in range(m, len(arr)):
		if prev < arr[i]:
			return 'NO'
		else:
			prev = arr[i]
	prev = arr[m]
	for i in range(m, -1, -1):
		if prev < arr[i]:
			return 'NO'
		else:
			prev = arr[i]
	return 'YES'
pillars = int(input())
arr = input().split(' ')
for i in range(len(arr)):
	arr[i] = int(arr[i])
m = max(arr)
index = arr.index(m)
print(printer(arr, index))


n = int(input())
a = [int(i) for i in input().split()]
c = a.index(max(a))
d = a[0:c]
e = a[c:]
flag = 0
if len(d) <= 1:
	pass
else:
	for i in range(0, len(d) - 1):
		if d[i + 1] > d[i]:
			pass
		else:
			flag = 1
			break
if len(e) <= 1:
	pass
else:
	for i in range(0, len(e) - 1):
		if e[i + 1] < e[i]:
			pass
		else:
			flag = 1
			break
if flag == 1:
	print('NO')
else:
	print('YES')


(n, a) = (int(input()), list(map(int, input().split())))
m = a.index(max(a))
if a[:m] != list(sorted(a[:m])) or a[m + 1:] != list(sorted(a[m + 1:], reverse=True)):
	print('NO')
else:
	print('YES')


def ladder():
	pillars = int(input())
	radii = []
	maxVal = 0
	idxMax = 0
	count = 0
	result1 = ''
	result2 = ''
	result3 = ''
	radii = input().split()
	for i in range(pillars):
		radii[i] = int(radii[i])
	idxMax = radii.index(max(radii))
	maxVal = radii[idxMax]
	if radii[:idxMax] == sorted(radii[:idxMax]) and radii[idxMax:] == sorted(radii[idxMax:], reverse=True):
		result1 = 'YES'
	else:
		result3 = 'NO'
	if result3 != 'NO':
		print(result1)
	else:
		print(result3)
ladder()


n = int(input())
L = [int(x) for x in input().split()]
mx = max(L)
ok = True
i = 0
if L[0] == mx:
	pass
else:
	i = 1
	while L[i] != mx:
		if L[i] < L[i - 1]:
			ok = False
		i += 1
i += 1
while i < n:
	if L[i] > L[i - 1]:
		ok = False
	i += 1
if ok == False:
	print('NO')
else:
	print('YES')


def f(l):
	for i in range(len(l) - 1):
		if l[i] > l[i + 1]:
			break
	if sorted(l[i + 1:], reverse=True) == l[i + 1:]:
		return 0
	return 1
M = 10 ** 9 + 7
R = lambda : map(int, input().split())
n = int(input())
L = list(R())
if len(set(L)) != n:
	print('NO')
else:
	print('YNEOS'[f(L)::2])


from sys import stdin, stdout
from collections import Counter
import math

def rsingle_int():
	return int(stdin.readline().rstrip())

def rmult_int():
	return [int(x) for x in stdin.readline().rstrip().split()]

def rmult_str():
	return stdin.readline().rstrip().split()

def r_str():
	return stdin.readline().rstrip()

def rsingle_char():
	return stdin.read(1)

def main():
	n = rsingle_int()
	a = rmult_int()
	max = 0
	for el in a:
		if el > max:
			max = el
	possible = True
	increasing = True
	st = 0
	for el in a:
		if el == max:
			increasing = False
		elif increasing:
			if el <= st:
				possible = False
				break
		elif el >= st:
			possible = False
			break
		st = el
	if possible:
		print('YES')
	else:
		print('NO')
main()


n = int(input())
a = list(map(int, input().split(' ')))
mx = a.index(n)
left = a[:mx]
right = a[mx + 1:]
if left == sorted(left) and right == sorted(right)[::-1]:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
p = 0
for i in range(1, n):
	if arr[p] < arr[i]:
		p = i
i = 0
while i < p:
	if arr[i] < arr[i + 1]:
		i += 1
	else:
		print('NO')
		break
else:
	i = p
	while i < n - 1:
		if arr[i] > arr[i + 1]:
			i += 1
		else:
			print('NO')
			break
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(1, n - 1):
	if a[i - 1] > a[i] and a[i] < a[i + 1]:
		ans = 'NO'
		break
	ans = 'YES'
print(ans)


n = int(input())
arrs = [int(x) for x in input().split()]
i = 0
while i < n - 1 and arrs[i] < arrs[i + 1]:
	i += 1
while i < n - 1 and arrs[i] > arrs[i + 1]:
	i += 1
print(['NO', 'YES'][i == n - 1])


for t in range(1):
	n = int(input())
	arr = list(map(int, input().split()))
	pos = arr.index(n)
	if sorted(arr[:pos]) == arr[:pos] and sorted(arr[pos:], reverse=True) == arr[pos:]:
		print('YES')
	else:
		print('NO')


def pro(arr):
	ind = 0
	maxi = 0
	for i in range(len(arr)):
		if arr[i] > maxi:
			maxi = arr[i]
			ind = i
	for i in range(ind - 1):
		if arr[i] > arr[i + 1]:
			print('NO')
			return
	for i in range(ind + 1, len(arr) - 1):
		if arr[i] < arr[i + 1]:
			print('NO')
			return
	print('YES')
n = int(input())
arr = list(map(int, input().split()))
pro(arr)


def check(arr, n):
	flag = 0
	for i in range(n - 1):
		if arr[i] < arr[i + 1]:
			if flag == -1:
				print('NO')
				return
		else:
			flag = -1
	print('YES')
n = int(input())
arr = list(map(int, input().split()))
check(arr, n)


n = int(input())
a = [int(x) for x in input().split()]
m = a.index(n)
for x in range(1, m):
	if a[x] < a[x - 1]:
		print('NO')
		exit()
for x in range(m + 1, n):
	if a[x] > a[x - 1]:
		print('NO')
		exit()
print('YES')


n = int(input())
arr = [int(i) for i in input().split()]
flag = True
t = 0
for i in range(n - 1):
	if arr[i] < arr[i + 1] and t == 0:
		continue
	elif arr[i] > arr[i + 1] and t == 0:
		t = 1
	elif arr[i] > arr[i + 1] and t == 1:
		continue
	else:
		flag = False
		break
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
m = l.index(max(l))
g = list()
g1 = l[0:m].copy()
g2 = l[m + 1:].copy()
g1.sort()
g2.sort(reverse=True)
if g1 == l[0:m] and g2 == l[m + 1:]:
	print('YES')
else:
	print('NO')


column_count = int(input())
columns = input().split()
for i in range(len(columns)):
	columns[i] = int(columns[i])
max_index = columns.index(max(columns))
risingA = False
for i in range(max_index, len(columns) - 1):
	if columns[i] < columns[i + 1]:
		risingA = True
risingB = False
for i in range(max_index, 0, -1):
	if columns[i - 1] > columns[i]:
		risingB = True
if not risingA and (not risingB):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
if len(set(a)) != n:
	print('NO')
	exit(0)
c = 0
for i in range(n - 1):
	if a[i] > a[i + 1]:
		c = i + 1
		break
if c == 0:
	print('YES')
	exit(0)
for i in range(c, n - 1):
	if a[i] < a[i + 1]:
		print('NO')
		exit(0)
print('YES')


n = int(input())
arr = list(map(int, input().split()))
flag = True
for i in range(0, n - 1):
	if flag == True:
		if arr[i] > arr[i + 1]:
			flag = False
	elif arr[i] < arr[i + 1]:
		print('NO')
		break
else:
	print('YES')


n = int(input())
lis = [int(x) for x in input().split()]
maxIndex = lis.index(n)
res = True
for i in range(1, maxIndex):
	if lis[i] < lis[i - 1]:
		res = False
		break
for i in range(maxIndex, n - 1):
	if lis[i] < lis[i + 1]:
		res = False
		break
print('YES' if res else 'NO')


import sys
input = sys.stdin.readline
from math import ceil, floor

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
n = int(input())
a = int_array()
asc = []
dsc = []
f = 0
for i in a:
	if f == 0:
		asc.append(i)
		if i == n:
			f = 1
	else:
		dsc.append(i)
if asc == sorted(asc) and dsc == sorted(dsc, reverse=1):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
j = a.index(max(a))
j += 1
(i, k) = (j - 1, j + 1)
a.insert(0, 0)
a.append(0)
while i > 0 or k < n + 1:
	if a[i] > a[k] and a[i] < a[j]:
		a[j] = a[i]
		i -= 1
	elif a[i] < a[k] and a[k] < a[j]:
		a[j] = a[k]
		k += 1
	else:
		print('NO')
		break
else:
	print('YES')


n = int(input())
pillars_str = input().split()
pillars = [int(pillar) for pillar in pillars_str]
possible = True
increasing = True
prev_pillar = 0
for pillar in pillars:
	if increasing:
		if prev_pillar < pillar:
			prev_pillar = pillar
		else:
			prev_pillar = pillar
			increasing = False
	elif prev_pillar > pillar:
		prev_pillar = pillar
	else:
		possible = False
		break
if possible:
	print('YES')
else:
	print('NO')


n = int(input())
arr = [int(s) for s in input().split()]
rec = max(arr)
l = r = 0
for i in range(n):
	if arr[i] == rec:
		l = r = i
find = n - 1
ans = 1
while find != 0:
	if l != 0 and arr[l - 1] == find:
		l -= 1
		find -= 1
	elif r != n - 1 and arr[r + 1] == find:
		r += 1
		find -= 1
	else:
		ans = 0
		break
print('YES' * ans + 'NO' * (1 - ans))


h = int(input())
list1 = list(map(int, input().split()))
for i in range(1, h - 1):
	if list1[i] < list1[i - 1] and list1[i + 1] > list1[i]:
		print('NO')
		exit(0)
else:
	print('YES')


n = int(input())
l = list(map(int, input().split()))
index = 0
mx = -1
f = True
for i in range(n):
	if mx < l[i]:
		index = i
		mx = l[i]
for i in range(index, n - 1):
	if l[i] < l[i + 1]:
		f = False
for i in range(index, 0, -1):
	if l[i] < l[i - 1]:
		f = False
if not f:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
flag = 1
ind = a.index(max(a))
for i in range(1, len(a) - 1):
	if a[i] < a[i + 1] and a[i] < a[i - 1]:
		print('NO')
		flag = 0
		break
if flag == 1:
	asc = a[:ind]
	temp1 = sorted(asc)
	if asc == temp1:
		dsc = a[ind + 1:]
		temp2 = sorted(dsc, reverse=True)
		if dsc == temp2:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


n = int(input())
L = list(map(int, input().split()))
s = set(L)
if len(s) != len(L):
	print('NO')
else:
	ind = L.index(max(L))
	nl = L[0:ind + 1]
	rnl = L[ind:]
	snl = list(set(nl))
	srnl = list(set(rnl))
	snl.sort()
	srnl.sort(reverse=True)
	if nl == snl and rnl == srnl:
		print('YES')
	else:
		print('NO')


n = int(input())
arr = [int(x) for x in input().split()]
x = arr.index(max(arr))
cur = max(arr)
l = x - 1
r = x + 1
ok = 1
for i in range(n - 1):
	if l < 0:
		ok *= arr[r] < cur
		cur = arr[r]
		r += 1
	elif r >= n:
		ok *= arr[l] < cur
		cur = arr[l]
		l -= 1
	elif arr[l] > arr[r]:
		ok *= arr[l] < cur
		cur = arr[l]
		l -= 1
	else:
		ok *= arr[r] < cur
		cur = arr[r]
		r += 1
print('YES' if ok else 'NO')


n = int(input())
a = input().split()
max = 0
flag = 1
for i in range(len(a)):
	if int(a[i]) > max:
		max = int(a[i])
		imax = i
for i in range(imax):
	if int(a[i]) > int(a[i + 1]):
		flag = 0
if imax != n - 1:
	for i in range(imax, n - 1):
		if int(a[i]) < int(a[i + 1]):
			flag = 0
if flag == 0:
	print('NO')
else:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
state = 0
for i in range(1, n):
	if arr[i] < arr[i - 1] and state == 0:
		state = 1
	if state == 1 and arr[i] > arr[i - 1]:
		state = 2
		break
if state == 2:
	print('NO')
else:
	print('YES')


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n,) = I()
a = [0] + I() + [0]
k = a.index(n)
x = k
y = k
for i in range(n - 1, 0, -1):
	if a[x - 1] == i:
		x -= 1
	elif a[x + 1] == i:
		x += 1
	elif a[y - 1] == i:
		y -= 1
	elif a[y + 1] == i:
		y += 1
	else:
		print('NO')
		exit()
print('YES')


n = int(input())
li = list(map(int, input().split()))
x = li.index(max(li))
if li[:x] == sorted(li[:x]) and li[x:] == sorted(li[x:])[::-1]:
	print('YES')
else:
	print('NO')


n = int(input())
arr = [int(x) for x in input().split(' ')]
bada = max(arr)
pos = arr.index(bada)
stack1 = arr[:pos]
stack2 = arr[pos + 1:]
stack2.reverse()
curr = bada - 1
flag = 0
while True:
	if len(stack1) and stack1[-1] == curr:
		stack1.pop()
		curr -= 1
	elif len(stack2) and stack2[-1] == curr:
		stack2.pop()
		curr -= 1
	else:
		if curr == 0:
			print('YES')
		else:
			print('NO')
		break


mod = 1000000007
eps = 10 ** (-9)

def main():
	import sys
	input = sys.stdin.buffer.readline
	N = int(input())
	A = list(map(int, input().split()))
	ii = -1
	for i in range(N):
		if A[i] == N:
			ii = i
			break
	ok = 1
	for i in range(ii):
		if A[i + 1] < A[i]:
			ok = 0
			break
	for i in range(ii + 1, N):
		if A[i] > A[i - 1]:
			ok = 0
			break
	if ok:
		print('YES')
	else:
		print('NO')
main()


n = int(input())
a = list(map(int, input().split()))
peak_reached = False
prev = a[0]
for i in range(1, n):
	if not peak_reached:
		if a[i] < prev:
			peak_reached = True
	elif a[i] > prev:
		print('NO')
		exit()
	prev = a[i]
print('YES')


n = int(input())
arr = list(map(int, input().split(' ')))
k = arr.index(max(arr))
k += 1
ok = True
for i in range(1, k - 1):
	ok &= arr[i - 1] < arr[i]
for i in range(k, n - 1):
	ok &= arr[i + 1] < arr[i]
if ok:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
flag = 0
flag2 = 0
i = 0
if a[0] < a[1]:
	while a[i] < a[i + 1]:
		i += 1
		if i >= n - 1:
			flag = 1
			break
	if flag == 0:
		for j in range(i, n - 1):
			if a[j] < a[j + 1]:
				flag2 = 1
				break
	if flag2 == 1:
		ans = 'NO'
	else:
		ans = 'YES'
else:
	for i in range(n - 1):
		if a[i] < a[i + 1]:
			flag2 = 1
			break
	if flag2 == 1:
		ans = 'NO'
	else:
		ans = 'YES'
print(ans)


n = int(input())
l = list(map(int, input().split()))
maks = -1000000000
ind = 0
for i in range(n):
	if l[i] > maks:
		ind = i
		maks = l[i]
odp = 1
for i in range(ind):
	if l[i + 1] < l[i]:
		odp = 0
		break
for i in range(ind, n - 1):
	if l[i + 1] > l[i]:
		odp = 0
		break
if odp == 0:
	print('NO')
else:
	print('YES')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		n = I()
		a = LI()
		l = 0
		r = n - 1
		for i in range(n - 1):
			if a[i] < a[i + 1]:
				l = i + 1
			else:
				break
		for i in range(n - 2, -1, -1):
			if a[i] > a[i + 1]:
				r = i
			else:
				break
		rr.append(YES(l == r))
	return JA(rr, '\n')
print(main())


def check_sorted(array, from_less=True):
	for i in range(len(array) - 1):
		if from_less:
			if array[i] > array[i + 1]:
				return False
		elif array[i] < array[i + 1]:
			return False
	return True
N = int(input())
arr = list(map(int, input().split()))
ind = arr.index(max(arr))
left_sorted = check_sorted(arr[:ind])
right_sorted = check_sorted(arr[ind:], from_less=False)
if left_sorted and right_sorted:
	print('YES')
else:
	print('NO')


n = int(input())
lis = list(map(int, input().split()))
acen = sorted(lis)
decen = sorted(lis, reverse=True)
if lis == acen or lis == decen:
	print('YES')
else:
	k = 0
	for i in range(2, n):
		if lis[i - 2] > lis[i - 1] < lis[i]:
			k = 1
			break
	if k == 0:
		print('YES')
	else:
		print('NO')


import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
mod = 10 ** 9 + 7

def lcm(x, y):
	return x * y / gcd(x, y)

def fact(x, mod=mod):
	ans = 1
	for i in range(1, x + 1):
		ans = ans * i % mod
	return ans

def arr2D(n, m, default=0):
	lst = []
	for i in range(n):
		temp = [default] * m
		lst.append(temp)
	return lst

def sortDictV(x):
	return {k: v for (k, v) in sorted(x.items(), key=lambda item: item[1])}

def solve(n, lst):
	ind = 0
	lst.append(-1)
	for i in range(n):
		if lst[i] >= lst[i + 1]:
			ind = i
			break
	for i in range(ind, n - 1):
		if lst[i] <= lst[i + 1]:
			return 'NO'
	return 'YES'
n = int(input())
lst = list(map(int, input().split()))
print(solve(n, lst))


import sys
n = int(input())
L = [int(x) for x in input().split()]
M = max(L)
i = L.index(M)
for j in range(i):
	if L[j] > L[j + 1]:
		print('NO')
		sys.exit(0)
for j in range(i, n - 1):
	if L[j] < L[j + 1]:
		print('NO')
		sys.exit(0)
print('YES')


n = int(input())
a = [int(i) for i in input().split()]
fail = 0
num_max = max(a)
index_max = a.index(num_max)
for i in range(index_max):
	if a[i] > a[i + 1]:
		fail = 1
		break
for i in range(index_max, n - 1):
	if a[i] < a[i + 1]:
		fail = 1
		break
if not fail:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(i) for i in input().split()]
k = a.index(max(a))
s = 0
for i in range(0, k):
	if a[i] < a[i + 1]:
		s += 1
for j in range(k, n - 1):
	if a[j] > a[j + 1]:
		s += 1
if s == n - 1:
	print('YES')
else:
	print('NO')


x = int(input())
a = list(map(int, input().split()))
b = max(a)
c = a.index(b)
d = c - 1
if c < x:
	c += 1
f = 0
while c < x:
	if a[c] > a[c - 1]:
		f = 1
		break
	c += 1
while d >= 0:
	if a[d] > a[d + 1]:
		f = 1
		break
	d -= 1
if f == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = [*map(int, input().split())]
m = max(a)
i = a.index(m)
(t1, t2) = ([], [])
for j in range(i):
	t1.append(m - a[j])
for j in range(i, n):
	t2.append(m - a[j])
if t1 == sorted(t1, reverse=True) and t2 == sorted(t2):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
k = 0
for i in range(n):
	if a[i] > a[k]:
		k = i
ch = 1
for i in range(k - 1):
	if a[i + 1] <= a[i]:
		ch = 0
for i in range(k, n - 1):
	if a[i + 1] >= a[i]:
		ch = 0
if ch == 0:
	print('NO')
else:
	print('YES')


n = int(input())
a = [int(w) for w in input().split()]
i = 0
while i < n - 1 and a[i] < a[i + 1]:
	i += 1
while i < n - 1 and a[i] > a[i + 1]:
	i += 1
print('YES' if i == n - 1 else 'NO')


n = int(input())
a = list(map(int, input().split()))
m = max(a)
ind = a.index(max(a))
i = ind - 1
j = ind + 1
while i >= 0 and j < n:
	if a[i] == m - 1:
		i -= 1
		m -= 1
	elif a[j] == m - 1:
		j += 1
		m -= 1
	else:
		exit(print('NO'))
while i >= 0:
	if a[i] == m - 1:
		i -= 1
		m -= 1
	else:
		exit(print('NO'))
while j < n:
	if a[j] == m - 1:
		j += 1
		m -= 1
	else:
		exit(print('NO'))
print('YES')


n = int(input())
arr = list(map(int, input().split()))
idx = arr.index(max(arr))
flag1 = True
flag2 = True
for i in range(0, idx):
	if arr[i] > arr[i + 1]:
		flag1 = False
for i in range(idx, n - 1):
	if arr[i] < arr[i + 1]:
		flag2 = False
if flag1 == True and flag2 == True:
	print('YES')
else:
	print('NO')


k = 0
b = 0
n = int(input())
a = input().split()
max = int(a[0])
for i in range(n):
	if max < int(a[i]):
		max = int(a[i])
		b = i
i = 0
while i >= 0 and i < b - 1:
	if int(a[i]) < int(a[i + 1]):
		k = 0
	else:
		k = 1
		break
	i = i + 1
i = b + 1
if k == 0:
	while i > b and i <= n - 2:
		if int(a[i]) > int(a[i + 1]):
			k = 0
		else:
			k = 1
			break
		i = i + 1
if k == 1:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
amax = max(a)
iamax = a.index(amax)
(aa, bb) = (a[:iamax], a[iamax:])
(sa, sb) = (sorted(aa), sorted(bb, reverse=True))
if aa == sa and bb == sb:
	print('YES')
else:
	print('NO')


N = int(input())
vals = [int(x) for x in input().split(' ') if len(x) > 0]
k = vals.index(max(vals))
if k == 0:
	bef = []
else:
	bef = vals[0:k]
if k == len(vals) - 1:
	aft = []
else:
	aft = vals[k + 1:]
if sorted(bef) == bef and sorted(aft, reverse=True) == aft:
	print('YES')
else:
	print('NO')


from sys import exit
input()
a = list(map(int, input().split()))
c = 0
if len(a) == 3:
	if a[0] < a[1] < a[2] or a[0] > a[1] > a[2]:
		print('YES')
	else:
		print('NO')
else:
	for i in range(1, len(a) - 1):
		if a[i - 1] > a[i] and a[i] < a[i + 1]:
			c = 4
			break
		if a[i - 1] < a[i] and a[i] > a[i + 1]:
			c += 1
	print('YES' if c < 2 else 'NO')


import sys
input = sys.stdin.readline
n = int(input())
b = list(map(int, input().split()))
if len(set(b)) != n:
	print('NO')
else:
	p = max(b)
	q = b.index(p)
	t = 0
	j = q - 1
	while j >= 1:
		if b[j] <= b[j - 1]:
			t = 1
			break
		j += -1
	for j in range(q + 1, n - 1):
		if b[j] <= b[j + 1]:
			t = 1
			break
	if t == 0:
		print('YES')
	else:
		print('NO')


n = int(input())
a = list(map(int, input().split()))
index = a.index(max(a))
left = a[:index]
right = a[index:]
l = left.copy()
left.sort()
right.reverse()
r = right.copy()
right.sort()
if r == right and left == l:
	print('YES')
else:
	print('NO')


n = int(input())
y = list(map(int, input().split()))
ind = y.index(max(y))
j = 1
f = 0
while j < ind:
	if y[j] < y[j - 1]:
		f = 1
		break
	j += 1
if f != 1:
	j = ind + 1
	f = 0
	while j < n:
		if y[j] > y[j - 1]:
			f = 2
			break
		j += 1
	if f == 2:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
ans = 1
ind = a.index(max(a))
for i in range(ind):
	ans *= a[i] < a[i + 1]
for i in range(ind, n - 1):
	ans *= a[i] > a[i + 1]
if ans:
	print('YES')
else:
	print('NO')


n = int(input())
flag = 0
decreasing = 0
radius = list(map(int, input().split()))
status = []
for i in range(n - 1):
	if radius[i] < radius[i + 1]:
		status.append('inc')
	else:
		status.append('dec')
if radius[i + 1] > radius[i]:
	status.append('inc')
else:
	status.append('dec')
for i in range(n - 1):
	if status[i] == 'inc' and status[i + 1] == 'dec':
		decreasing += 1
		if decreasing > 1:
			flag = 1
			break
	elif status[i] == 'dec' and status[i + 1] == 'inc':
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
flag = 0
if a[0] < a[1]:
	ascend = True
else:
	ascend = False
	flag = 1
ans = 'YES'
for i in range(n - 1):
	if ascend:
		if a[i] < a[i + 1]:
			continue
		else:
			if flag == 1:
				ans = 'NO'
				break
			flag = 1
			ascend = False
	elif a[i] > a[i + 1]:
		continue
	else:
		if flag == 1:
			ans = 'NO'
			break
		flag = 1
		ascend = True
print(ans)


n = int(input())
a = list(map(int, input().split()))
idx = sorted(range(n), key=lambda i: a[i], reverse=True)
left = 1
right = 1
ok = True
for cur in idx[1:]:
	if cur > idx[0]:
		if cur - idx[0] == right:
			right += 1
		else:
			ok = False
	if cur < idx[0]:
		if idx[0] - cur == left:
			left += 1
		else:
			ok = False
print('YES' if ok else 'NO')


n = int(input())
arr = list(map(int, input().strip().split()))
m = 0
argMax = -1
for i in range(n):
	if arr[i] > m:
		m = arr[i]
		argMax = i
res = 'YES'
for i in range(argMax - 1):
	if arr[i] > arr[i + 1]:
		res = 'NO'
		break
for i in range(argMax, n - 1):
	if arr[i] < arr[i + 1]:
		res = 'NO'
		break
print(res)


n = int(input())
dsk = [int(x) for x in input().split()]
lst = [x for x in dsk]
lst.sort(reverse=True)
max_idx = dsk.index(max(dsk))
r = max_idx + 1
l = max_idx - 1
flag = 0
for i in range(1, n):
	if l >= 0 and lst[i] == dsk[l]:
		l -= 1
	elif r < n and lst[i] == dsk[r]:
		r += 1
	else:
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


n = int(input().strip())
nums = [int(i) for i in input().strip().split()]
the_max = max(nums)
max_index = 0
for i in range(n):
	if nums[i] == the_max:
		max_index = i
		break
left_index = max_index
right_index = max_index
current_large = the_max
possible = True
while True:
	if right_index == n - 1:
		while left_index > 0:
			if nums[left_index - 1] < current_large:
				current_large = nums[left_index - 1]
				left_index -= 1
			else:
				possible = False
				break
		break
	if left_index == 0:
		while right_index < n - 1:
			if nums[right_index + 1] < current_large:
				current_large = nums[right_index + 1]
				right_index += 1
			else:
				possible = False
				break
		break
	if nums[left_index - 1] > nums[right_index + 1]:
		if nums[left_index - 1] < current_large:
			current_large = nums[left_index - 1]
			left_index -= 1
		else:
			possible = False
			break
	elif nums[left_index - 1] < nums[right_index + 1]:
		if nums[right_index + 1] < current_large:
			current_large = nums[right_index + 1]
			right_index += 1
		else:
			possible = False
			break
	else:
		possible = False
		break
print('YES' if possible else 'NO')


def main():
	n = int(input())
	line = input().split()
	v = [int(x) for x in line]
	pos = -1
	for i in range(n):
		if v[i] == n:
			pos = i
	(lo, hi) = (pos - 1, pos + 1)
	goal = n - 1
	ok = True
	while goal > 0 and ok:
		if lo >= 0:
			if v[lo] == goal:
				lo -= 1
				goal -= 1
				continue
		if hi < n:
			if v[hi] == goal:
				hi += 1
				goal -= 1
				continue
		ok = False
	if ok:
		print('YES')
	else:
		print('NO')
main()


n = int(input())
arr = list(map(int, input().split()))
max_idx = arr.index(max(arr))
is_possible = True
if len(set(arr)) != n:
	is_possible = False
if is_possible:
	for i in range(max_idx, 0, -1):
		if arr[i] <= arr[i - 1]:
			is_possible = False
			break
	for i in range(max_idx, n - 1):
		if arr[i] <= arr[i + 1]:
			is_possible = False
			break
print('YES' if is_possible else 'NO')


import io, sys
input = lambda f=io.StringIO(sys.stdin.buffer.read().decode()).readline: f().rstrip()
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
n = ii()
a = li()
p = a.index(max(a))
b = sorted(a)
b.pop()
ok = 1
(i, j) = (p - 1, p + 1)
while i >= 0 or j < n:
	if i >= 0 and a[i] == b[-1]:
		b.pop()
		i -= 1
	elif j < n and a[j] == b[-1]:
		b.pop()
		j += 1
	else:
		ok = 0
		break
print('YES' if ok else 'NO')


n = int(input())
a = list(map(int, input().split()))
x = a.index(max(a))
lis1 = a[0:x]
lis2 = a[x + 1:n]
t1 = sorted(lis1)
t2 = sorted(lis2, reverse=True)
c1 = 0
c2 = 0
s = 0
if len(t1) == 0:
	c1 = 1
if len(t2) == 0:
	c2 = 1
for i in range(len(t1)):
	if lis1[i] == t1[i]:
		s += 1
if len(t1) == s:
	c1 = 1
s = 0
for i in range(len(t2)):
	if lis2[i] == t2[i]:
		s += 1
if len(t2) == s:
	c2 = 1
if c1 == 1 and c2 == 1:
	print('YES')
else:
	print('NO')


n = int(input())
ls = list(map(int, input().split()))
k = ls.index(max(ls))
ls1 = ls[:k + 1]
ls2 = ls[k:]
if sorted(ls1) == ls1 and sorted(ls2, reverse=True) == ls2:
	print('YES')
else:
	print('NO')


n = int(input())
lst = list(map(int, input().strip().split()))
f = True
for i in range(1, n - 1):
	if lst[i - 1] > lst[i] and lst[i] < lst[i + 1]:
		f = False
		break
if f == True:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
flag = False
mx = arr.index(max(arr))
l1 = arr[:mx]
l2 = arr[mx + 1:]
if sorted(l1) == arr[:mx] and sorted(l2, reverse=True) == arr[mx + 1:]:
	flag = True
if flag == True:
	print('YES')
else:
	print('NO')


def mp():
	return map(int, input().split())
n = int(input())
a = list(mp())
max_i = a.index(max(a))
fail = False
for i in range(1, max_i):
	if a[i - 1] > a[i]:
		fail = True
for i in range(max_i, n - 1):
	if a[i] < a[i + 1]:
		fail = True
if fail:
	print('NO')
else:
	print('YES')


n = int(input())
l = list(map(int, input().split()))
ans = []
z = max(l)
ans.append(z)
index = 0
for i in range(len(l)):
	if l[i] == z:
		index = i
		break
i = index - 1
j = index + 1
while i >= 0 and j < n:
	if l[i] > l[j] and l[i] < ans[-1]:
		ans.append(l[i])
		i -= 1
	elif l[i] < l[j] and l[j] < ans[-1]:
		ans.append(l[j])
		j += 1
	else:
		break
while i >= 0:
	if l[i] < ans[-1]:
		ans.append(l[i])
		i -= 1
	else:
		break
while j < n:
	if l[j] < ans[-1]:
		ans.append(l[j])
		j += 1
	else:
		break
if sorted(ans) == sorted(l):
	print('YES')
else:
	print('NO')


import sys
n = int(input())
a = [int(x) for x in input().split()]
m = max(a)
mi = a.index(m)
le = mi - 1
ri = mi + 1
for i in range(n - 1, 0, -1):
	found = False
	if le >= 0 and a[le] == i:
		le -= 1
		found = True
	if ri < n and a[ri] == i:
		ri += 1
		found = True
	if not found:
		print('NO')
		sys.exit()
print('YES')


from sys import stdin
input = stdin.readline
n = int(input())
a = [int(i) for i in input().split()]
actual = 0
while actual < n - 1 and a[actual] < a[actual + 1]:
	actual += 1
while actual < n - 1 and a[actual] > a[actual + 1]:
	actual += 1
if actual == n - 1:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))[:n]
c = 0
d = 0
for i in range(n - 1):
	if a[i] > a[i + 1]:
		c = i
		break
if i + 2 != n:
	for i in range(c, n - 1):
		if a[i + 1] > a[i]:
			d += 1
			break
if d == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split(' ')]
isLower = False
last = -1
valid = True
for i in a:
	if not isLower:
		if i < last:
			isLower = True
	elif i > last:
		valid = False
		break
	last = i
print('YES' if valid else 'NO')


number = input()
lengths = list(map(int, input().split()))
max_index = lengths.index(max(lengths))
left_side = lengths[0:max_index]
if left_side == sorted(left_side):
	right_side = lengths[max_index + 1:]
	if right_side == sorted(right_side, reverse=True):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
l = input().split(' ')
l = list(map(int, l))
m = max(l)
pos = l.index(m)
l2 = []
l3 = []
for i in range(0, pos):
	l2.append(l[i])
for j in range(pos + 1, n):
	l3.append(l[j])
flag = 0
flag2 = 0
l4 = l2[:]
l4.sort()
if l4 == l2:
	flag = 1
l5 = l3[:]
l5.sort()
l5.reverse()
if l5 == l3:
	flag2 = 1
if flag == 1 and flag2 == 1:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout

def input():
	input.IT += 1
	return input.lines[input.IT - 1][:-1]
input.IT = 0
input.lines = stdin.readlines()

def print(*arg):
	print.out.append(' '.join((str(i) for i in arg)))
print.out = []
n = int(input())
a = list(map(int, input().split()))
m = a.index(max(a))
i = m - 1
j = m + 1
while i >= 0 and j < n and (a[m] > max(a[i], a[j])):
	if a[i] > a[j]:
		a[m] = a[i]
		i -= 1
	else:
		a[m] = a[j]
		j += 1
ans = True
while i >= 0:
	if a[m] < a[i]:
		ans = False
		break
	a[m] = a[i]
	i -= 1
while j < n:
	if a[m] < a[j]:
		ans = False
		break
	a[m] = a[j]
	j += 1
print('YES' if ans else 'NO')
stdout.write('\n'.join(print.out))


n = int(input())
a = list(map(int, input().split()))
pre = 0
is_down = False
for i in a:
	if i > pre and is_down is True:
		print('NO')
		exit(0)
	if i < pre:
		is_down = True
	pre = i
print('YES')


n = int(input())
A = [int(i) for i in input().split()]
incfirst = 1
decnext = 1
ok = 1
for i in range(n - 1):
	if A[i] < A[i + 1] and incfirst == 1:
		continue
	elif incfirst == 1:
		incfirst = 2
	elif incfirst == 2 and A[i] < A[i + 1]:
		decnext = 0
	elif incfirst == 2 and A[i] > A[i + 1]:
		continue
if incfirst >= 1 and decnext == 1 and ok:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
li = l.index(n)
ri = li
ind = [-1 for i in range(n)]
for (i, x) in enumerate(l):
	ind[x - 1] = i
ans = True
for i in range(n - 1, 0, -1):
	p = ind[i - 1]
	if p == li - 1:
		li -= 1
	elif p == ri + 1:
		ri += 1
	else:
		ans = False
		break
if ans:
	print('YES')
else:
	print('NO')


N = int(input())
if N == 0:
	print('NO')
else:
	A = input().split()
	A = map(int, A)
	A = list(A)
	mmm = -1
	I = -1
	for i in range(0, N):
		if mmm < A[i]:
			I = i
			mmm = A[i]
	b = True
	for i in range(0, I):
		if A[i] > A[i + 1]:
			b = False
	if N - 1 - I - 1 >= 1:
		for i in range(I + 1, N - 1):
			if A[i] < A[i + 1]:
				b = False
	if b:
		print('YES')
	else:
		print('NO')


from collections import deque

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
n = ii()
a = li()
f = 0
x = a.index(max(a))
for i in range(1, x):
	if a[i] < a[i - 1]:
		f = 1
		break
for i in range(n - 2, x, -1):
	if a[i] < a[i + 1]:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


x = int(input())
l = list(map(int, input().split()))
a = max(l)
b = l.index(a)
d = l[:b + 1]
p = l[b + 1:]
if sorted(d) == d and p == sorted(p)[::-1]:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
flag = True
for i in range(1, n - 1):
	if a[i] < a[i - 1] and a[i] < a[i + 1]:
		flag = False
		break
if flag:
	print('YES')
else:
	print('NO')


n = int(input())
list = [x for x in map(int, input().split())]
tmp_list = []
for i in range(1, len(list)):
	if list[i] > list[i - 1]:
		tmp_list.append(1)
	else:
		tmp_list.append(0)
flg = 0
for i in range(1, len(tmp_list)):
	if tmp_list[i] > tmp_list[i - 1]:
		flg = 2
		break
	if tmp_list[i] < tmp_list[i - 1]:
		flg += 1
if flg >= 2:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
i = a.index(max(a))
x = 1
for j in range(i, 0, -1):
	if a[j - 1] >= a[j]:
		x = 0
for j in range(i + 1, n):
	if a[j] >= a[j - 1]:
		x = 0
print('YES' if x else 'NO')


import sys

class BPillars:

	def solve(self):
		n = int(input())
		a = [int(_) for _ in input().split()]
		k = a.index(max(a))
		cur = n - 1
		(l, r) = (k - 1, k + 1)
		while l != -1 or r != n:
			if l != -1 and a[l] == cur:
				l -= 1
			elif r != n and a[r] == cur:
				r += 1
			else:
				print('NO')
				break
			cur -= 1
		else:
			print('YES')
solver = BPillars()
input = sys.stdin.readline
solver.solve()


n = int(input())
a = list(map(int, input().split()))
M = max(a)
i = a.index(M)
c = 0
test1 = all((x < y for (x, y) in zip(a[0:i], a[1:])))
test2 = all((x > y for (x, y) in zip(a[i:], a[i + 1:])))
if test1 == True and test2 == True:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
m = arr.index(max(arr))
i = m
ans = 'YES'
while i:
	if arr[i - 1] > arr[i]:
		ans = 'NO'
	i -= 1
i = m
while i < len(arr) - 1:
	if arr[i + 1] > arr[i]:
		ans = 'NO'
	i += 1
print(ans)


m = int(input())
l = list(map(int, input().split()))
ma = max(l)
for i in range(0, m):
	if l[i] == ma:
		p = i
		break
f = 0
for i in range(p, m - 1):
	if l[i] <= l[i + 1]:
		f = 1
		break
for j in range(1, p + 1):
	if l[j - 1] >= l[j]:
		f = 1
		break
if f == 1:
	print('NO')
else:
	print('YES')


n = int(input())
x = list(map(int, input().split()))
y = []
for i in range(1, n - 1):
	if x[i - 1] > x[i] and x[i + 1] > x[i]:
		y.append(1)
	else:
		y.append(0)
if sum(y) > 0:
	print('NO')
else:
	print('YES')


n = int(input())
ls = list(map(int, input().split()))
m = ls.index(max(ls))
l = ls[:m]
l2 = ls[m:]
if l == sorted(l) and l2 == sorted(l2, reverse=True):
	print('YES')
else:
	print('NO')


import math
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n - 1):
	if a[i - 1] > a[i] and a[i + 1] > a[i]:
		print('NO')
		exit(0)
print('YES')


n = int(input())
a = [int(i) for i in input().split()]
c = a.index(max(a))
count = 0
for i in range(1, c + 1):
	if a[i] > a[i - 1]:
		continue
	else:
		count = 1
		break
if count == 0:
	for i in range(c, n - 1):
		if a[i] > a[i + 1]:
			continue
		else:
			count = 1
print(('YES', 'NO')[count == 1])


n = int(input())
pillars = [int(item) for item in input().split(' ')]
max_ptr = -1
for i in range(n):
	if pillars[i] == n:
		max_ptr = i
		break
left = max_ptr - 1
right = max_ptr + 1
search = n - 1
ans = 'YES'
while left >= 0 or right < n:
	if left >= 0 and pillars[left] == search:
		left -= 1
	elif right < n and pillars[right] == search:
		right += 1
	else:
		ans = 'NO'
		break
	search -= 1
print(ans)


n = int(input())
a = list(map(int, input().split()))
b = a.copy()
c = a.copy()
k1 = sorted(b[:a.index(n)])
k2 = sorted(c[a.index(n):], reverse=True)
if a == k1 + k2:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
maxPosition = a.index(max(a))
flag = True
for i in range(maxPosition):
	if a[i] > a[i + 1]:
		flag = False
for i in range(maxPosition, n - 1):
	if a[i] < a[i + 1]:
		flag = False
print('YES') if flag == True else print('NO')


import sys
n = int(input())
a = list(map(int, sys.stdin.readline().split()))
rost = True
for i in range(1, n):
	if rost:
		if a[i] < a[i - 1]:
			rost = False
	elif a[i] > a[i - 1]:
		exit(print('NO'))
print('YES')


n = int(input())
a = list(map(int, input().split()))
m1 = max(a)
i = a.index(m1)
b = a[:i]
c = a[i + 1:]
b.sort()
c.sort()
if a[:i] == b and a[i + 1:] == c[::-1]:
	print('YES')
else:
	print('NO')


from sys import stdin
n = int(input())
a = list(map(int, stdin.readline().strip().split()))
max_elem = max(a)
left = a[:a.index(max_elem)]
right = a[a.index(max_elem):]
if left != sorted(left) or right != list(reversed(sorted(right))):
	print('NO')
else:
	print('YES')


n = int(input())
lis = [int(x) for x in input().split()]
for i in range(n):
	if lis[i] == n:
		p = i
ok = True
for i in range(1, p):
	if lis[i] < lis[i - 1]:
		ok = False
for i in range(p, n - 1):
	if lis[i] < lis[i + 1]:
		ok = False
if ok:
	print('YES')
else:
	print('NO')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
n = int(ri())
a = Ri()
(maxind, maxx) = (-1, -1)
for i in range(n):
	if a[i] > maxx:
		maxx = a[i]
		maxind = i
flag = True
for i in range(1, maxind + 1):
	if a[i] < a[i - 1]:
		flag = False
		break
for i in range(maxind + 1, n - 1):
	if a[i] < a[i + 1]:
		flag = False
		break
if not flag:
	NO()
else:
	YES()


def isdesc(a):
	b = a.copy()
	b.sort(reverse=True)
	if a == b:
		return True
	else:
		return False
n = int(input())
a = list(map(int, input().split()))
f = True
ind = a.index(max(a))
a1 = a[:ind][::-1]
a2 = a[ind + 1:]
if isdesc(a1) and isdesc(a2):
	print('YES')
else:
	print('NO')


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
N = int(input())
L = list(map(int, input().split()))
L_sorted = sorted(L, reverse=True)
max_ind = L.index(L_sorted[0])
left = max_ind - 1
right = max_ind + 1
ans = 'YES'
for l in L_sorted[1:]:
	if left >= 0 and L[left] == l:
		left -= 1
	elif right < N and L[right] == l:
		right += 1
	else:
		ans = 'NO'
		break
print(ans)


import sys
n = int(input())
a = list(map(int, input().rstrip().split()))
mx = max(a)
mx_index = a.index(mx)
for i in range(mx_index, n - 1):
	if a[i] > a[i + 1]:
		pass
	else:
		print('NO')
		sys.exit()
for i in range(mx_index, 0, -1):
	if a[i] > a[i - 1]:
		pass
	else:
		print('NO')
		sys.exit()
print('YES')


n = int(input())
radius = list(map(int, input().split()))
flag = 1
p = max(radius)
q = radius.index(p)
for i in range(q):
	if radius[i + 1] < radius[i]:
		flag = 0
for i in range(q, n - 1):
	if radius[i + 1] > radius[i]:
		flag = 0
if flag == 1:
	print('YES')
else:
	print('NO')


def find(A):
	O = A[:]
	A = sorted([(A[i], i) for i in range(len(A))])
	dic = {}
	for i in range(len(A)):
		if A[i][0] in dic:
			return 'NO'
		else:
			dic[A[i][0]] = i
	pos = []
	for i in range(len(O)):
		pos += [dic[O[i]]]
	rev_pos = {}
	for i in range(len(pos)):
		rev_pos[pos[i]] = i
	left = rev_pos[len(A) - 1]
	right = rev_pos[len(A) - 1]
	for i in range(len(A) - 2, -1, -1):
		now_pos = rev_pos[i]
		if now_pos == left - 1:
			left = now_pos
		elif now_pos == right + 1:
			right = right + 1
		else:
			return 'NO'
	return 'YES'
input()
print(find(list(map(int, input().strip().split(' ')))))


n = int(input())
a = list(map(int, input().split()))
a1 = max(a)
y1 = a.index(a1)
b = [a[j] for j in range(len(a[:y1]))]
b.sort()
c = [a[y1 + 1 + j] for j in range(len(a[y1 + 1:]))]
c.sort(reverse=True)
if a[:y1] == b and c == a[y1 + 1:]:
	print('YES')
else:
	print('NO')


pillars = int(input())
values = [int(x) for x in input().split()]
coorMax = values.index(max(values))
left = values[:coorMax]
right = values[coorMax + 1:]
leftSize = len(left)
rightSize = len(right)
first = True
if leftSize > 1:
	first = False
	for i in range(1, leftSize):
		if left[i] < left[i - 1]:
			break
		if i == leftSize - 1:
			first = True
second = True
if rightSize > 1:
	second = False
	for i in range(0, rightSize - 1):
		if right[i] < right[i + 1]:
			break
		if i == rightSize - 2:
			second = True
if first and second:
	print('YES')
else:
	print('NO')


mod = 1000000007
mod1 = 998244353
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n = ii()
l = il()
l2 = sorted(l)[::-1]
i = l.index(l2[0]) - 1
j = i + 2
for k in l2[1:]:
	if -1 < i < n and l[i] == k:
		i -= 1
	elif -1 < j < n and l[j] == k:
		j += 1
	else:
		exit(print('NO'))
print('YES')


def program():
	n = int(input())
	l = list(map(int, input().split()))
	state = 0
	for i in range(n - 1):
		if l[i] > l[i + 1] and state == 0:
			state = 1
		if l[i] < l[i + 1] and state == 1:
			state = 4
			break
	if state == 4:
		print('NO')
	else:
		print('YES')
program()


n = int(input())
p = input().rstrip().split(' ')
if len(list(set(p))) != len(p):
	print('NO')
else:
	l = []
	for i in range(0, len(p)):
		l.append(int(p[i]))
	T = max(l)
	G = 0
	A = l.index(T)
	for i in range(0, A - 1):
		if int(l[i]) < int(l[i + 1]):
			continue
		else:
			G = 1
			break
	if G == 1:
		print('NO')
	else:
		for i in range(A, len(l) - 1):
			if int(l[i]) > int(l[i + 1]):
				continue
			else:
				G = 1
				break
		if G == 1:
			print('NO')
		else:
			print('YES')


from collections import defaultdict
n = int(input())
a = [int(i) for i in input().split(' ')]
m = 0
m_i = None
c = defaultdict(int)
for i in range(len(a)):
	if m < a[i]:
		m = a[i]
		m_i = i
	c[a[i]] += 1
if len(set(c.values())) != 1:
	print('NO')
	exit()
if next(iter(c.values())) != 1:
	print('NO')
	exit()
for i in range(1, m_i):
	if a[i] <= a[i - 1]:
		print('NO')
		exit()
for i in range(m_i + 1, n - 1):
	if a[i] <= a[i + 1]:
		print('NO')
		exit()
print('YES')


n = int(input())
a = list(map(int, input().split()))
t = a.index(n)
res = True
for i in range(1, t):
	res &= a[i] > a[i - 1]
for i in range(t, n - 1):
	res &= a[i] > a[i + 1]
print('YNEOS'[not res::2])


n = int(input())
arr = list(map(int, input().split()))
lpos = arr.index(max(arr))
okay = True
for i in range(lpos):
	if not okay:
		break
	okay = okay & (arr[i] < arr[i + 1])
for i in range(lpos, n - 1):
	if not okay:
		break
	okay = okay & (arr[i] > arr[i + 1])
if okay:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(o) for o in input().split()]
mai = a.index(max(a))
a1 = a[:mai]
a2 = a[mai + 1:]
a1.sort()
a2.sort()
a2 = a2[::-1]
if a1 + [a[mai]] + a2 == a:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
x = max(a)
p = q = r = 0
c = 1
for i in range(n):
	if x == a[i]:
		p = i
q = p - 1
r = p + 1
y = z = -1
flag = True
while c < n:
	x = x - 1
	if q >= 0:
		y = a[q]
	else:
		y = -1
	if r < n:
		z = a[r]
	else:
		z = -1
	if y > 0 and y == x:
		c += 1
		q -= 1
	elif z > 0 and z == x:
		c += 1
		r += 1
	else:
		flag = False
		break
if flag == True:
	print('YES')
else:
	print('NO')


def main():
	n = int(input())
	a = list(map(int, input().split()))
	flag = True
	for i in range(n - 1):
		if a[i] == n:
			flag = False
			continue
		if flag == False and a[i] < a[i + 1]:
			print('NO')
			return
		elif flag == True and a[i] > a[i + 1]:
			print('NO')
			return
	print('YES')
	return
	return
main()


from collections import deque
n = int(input())
radius = list(map(int, input().split()))
for i in range(n):
	radius[i] = (radius[i], i, i)
radius.sort(reverse=True)
deque_of_radius = deque()
for i in radius:
	deque_of_radius.append((i[0], i[1], i[2]))
answer = False
for i in range(n - 1):
	(now, left, right) = deque_of_radius.popleft()
	(last, last_left, last_right) = deque_of_radius.popleft()
	if left - last_right == 1:
		deque_of_radius.appendleft((now, left - 1, right))
	elif last_left - right == 1:
		deque_of_radius.appendleft((now, left, right + 1))
	else:
		answer = True
		print('NO')
		break
if not answer:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
if len(set(a)) < n:
	print('NO')
else:
	m = a[0]
	mPosition = 0
	for i in range(1, n):
		if a[i] > m:
			m = a[i]
			mPosition = i
	a1 = a[:mPosition]
	a2 = a[mPosition + 1:]
	if sorted(a1) == a1 and sorted(a2, reverse=True) == a2:
		print('YES')
	else:
		print('NO')


import math
n = int(input())
list = [int(i) for i in input().split()]
val = max(list) - 1
ind = list.index(val + 1)
(l, r) = (ind - 1, ind + 1)
while val > 0:
	if l >= 0 and list[l] == val:
		l -= 1
		val -= 1
	elif r < n and list[r] == val:
		r += 1
		val -= 1
	else:
		print('NO')
		exit()
print('YES')


n = int(input())
arr = list(map(int, input().split()))
con = 0
stat = 1
for x in range(n - 1):
	if arr[x] > arr[x + 1]:
		con = 1
	if con == 1 and arr[x] < arr[x + 1]:
		stat = 0
		break
if stat:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)

def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
import math
n = getN()
nums = getList()
mx = max(nums)
up = True
ans = 'YES'
tmp = 0
for num in nums:
	if up:
		if num <= tmp:
			ans = 'NO'
		tmp = num
		if num == mx:
			up = False
	else:
		if num >= tmp:
			ans = 'NO'
		tmp = num
print(ans)


n = int(input())
arr = list(map(int, input().split()))
i = 0
j = len(arr) - 1
s = 0
while i < j:
	if arr[i] < arr[i + 1]:
		i += 1
		s = i
	else:
		s = i
		break
s1 = j
while j > 0:
	if arr[j] < arr[j - 1]:
		j -= 1
		s1 = j
	else:
		s1 = j
		break
if s == s1:
	print('YES')
else:
	print('NO')


n = int(input())
x = list(map(int, input().split()))
g = x.index(max(x))
flag = 0
for i in range(g - 1):
	if x[i] > x[i + 1]:
		flag = 1
		break
for i in range(g, n - 1):
	if x[i] < x[i + 1]:
		flag = 1
		break
if flag == 0:
	print('YES')
else:
	print('NO')


x = i = 0
j = int(input()) - 1
a = (*map(int, input().split()),)
while i < j and x < min(a[i], a[j]):
	if a[i] < a[j]:
		x = a[i]
		i += 1
	else:
		x = a[j]
		j -= 1
print('YNEOS'[i < j::2])


import sys
n = int(input())
A = list(map(int, input().split()))
max_idx = 0
for i in range(1, n):
	if A[i] > A[max_idx]:
		max_idx = i
for i in range(max_idx - 1, -1, -1):
	if A[i] > A[i + 1]:
		print('NO')
		sys.exit()
for i in range(max_idx + 1, n):
	if A[i] > A[i - 1]:
		print('NO')
		sys.exit()
print('YES')


n = int(input())
data = [int(i) for i in input().split()]
ind = [0] * (n + 1)
for i in range(n):
	ind[data[i]] = i
li = ind[n] - 1
ri = ind[n] + 1
good = True
for i in range(n - 1, 0, -1):
	if ind[i] == ri:
		ri += 1
		continue
	if ind[i] == li:
		li -= 1
		continue
	good = False
	break
if good:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
idx = 0
m = a[0]
for i in range(1, n):
	if a[i] > m:
		m = a[i]
		idx = i
ans = 'YES'
for i in range(idx):
	if a[i] > a[i + 1]:
		ans = 'NO'
		break
for i in range(idx, n - 1):
	if a[i] < a[i + 1]:
		ans = 'NO'
		break
print(ans)


n = int(input())
lis = list(map(int, input().split()))
m = max(lis)
k = lis.index(m)
m -= 1
if k == 0:
	j = 1
	while j < n and lis[j] == m:
		m -= 1
		j += 1
	if j == n:
		print('YES')
	else:
		print('NO')
	exit()
if k == n - 1:
	i = n - 2
	while i >= 0 and lis[i] == m:
		m -= 1
		i -= 1
	if i == -1:
		print('YES')
	else:
		print('NO')
	exit()
i = k - 1
j = k + 1
while i >= 0 or j < n:
	if i >= 0 and lis[i] == m:
		i -= 1
	elif j < n and lis[j] == m:
		j += 1
	else:
		print('NO')
		exit()
	m -= 1
print('YES')