qyliang/CodeNanoFix huggingface dataset:
# Buggy code:
n,r = map(int,input().split())
if n >= 10:
    print(r)
else :
    print(r-100*(10-n))

# Fixed code:
n,r=map(int,input().split())
if n>=10:
    print(r)
else:print(r+100*(10-n))
# Buggy code:
N,R = map(int, input().split())

if N < 10:
    print(R)
else:
    print(100*(10-K))

# Fixed code:
N,R = map(int,input().split())
if N < 10:
    print(R+(10-N)*100)
else:
    print(R)
# Buggy code:
n, k = map(int, input().split())
res = 0
while n >= k:
  res += 1
  n //= k
  print(res+1)

# Fixed code:
n,k= map(int,input().split())
ans = 0
while n >= 1:
         n = n//k
         ans +=1
print(ans)
# Buggy code:
import numpy as np
N, K = map(int, input().split())

res = 0
M = N
while M > 1:
    M /= 3
    res += 1
print(res)

# Fixed code:
import numpy as np
N, K = map(int, input().split())

res = 0
M = N
while M >= 1:
    M /= K
    res += 1
print(res)
# Buggy code:
n,k=map(int,input().split())
i=0
while (n>0):
    n/=k
    i+=1
print(i)

# Fixed code:
n,k=map(int,input().split())
a=0
while n>=k:
  n=n//k
  a=a+1
print(a+1)
# Buggy code:
N,K = map(int,input().split())
for i in range(10**9):
  print(K**i)
  if K**i <= N < K**(i+1):
    print(i+1)
    break

# Fixed code:
N, K = map(int, input().split())
for i in range(10**9):
  if K**(i) <= N < K**(i+1):
    print(i+1)
    exit()
# Buggy code:
def Digits(N, K):
  if N:
    return 1
  digits = 0
  while N:
    N = N // K
    digits += 1
  return digits

N, K = map(int, input().split())
print (Digits(N, K))

# Fixed code:
def Digits(N, K):
  if not N:
    return 1
  digits = 0
  while N:
    N = N // K
    digits += 1
  return digits
 
N, K = map(int, input().split())
print (Digits(N, K))
# Buggy code:
n,k = map(int,input().split())
ans = 0
while int(n / k) != 0:
  ans += 1
  n = int(n / k)
print(ans)

# Fixed code:
n,k=map(int,input().split())
ans=0
while n>0:
  ans+=1
  n//=k
print(ans)
# Buggy code:
N,K=(int(x) for x in input().split())
b=1
a=1
while a=<N:
    b=b+1
    a=K**b
else:
     print(b)

# Fixed code:
N,K=(int(x) for x in input().split())
b=1
a=1
if N==1:
    print(1)
else:
     while a<=N:
          b=b+1
          a=K**b
     else:
          print(b)
# Buggy code:
N,K= map(int, input().split())
A = 0
cnt = -1
if N == 0:
    print(1)
else:
    while N >= A:
        cnt += 1
        A = K**(cnt+1)-1
        print(A)
    print(cnt+1)

# Fixed code:
N,K= map(int, input().split())
A = 0
cnt = -1
if N <= K-1:
    print(1)
else:
    while N > A:
        cnt += 1
        A = K**(cnt+1)-1
    print(cnt+1)
# Buggy code:
n, k = [int(i) for i in input().split()]
def decNbin(t, n):
  a = []
  while t!= 0:
    a.append(t % n)
    t  = t // n
  a.reverse()
  return a
"".join(map(str, decNbin(n, k)))

# Fixed code:
n, k = [int(i) for i in input().split()]
def decNbin(t, n):
  a = []
  while t!= 0:
    a.append(t % n)
    t  = t // n
  a.reverse()
  return a
print(len(str("".join(map(str, decNbin(n, k))))))
# Buggy code:
# -*- coding: utf-8 -*-

n, k = map(int, input().split())

res = 0
while n > 0:
    res += 1
    n //= k
    print(res, n, k)
print(res)

# Fixed code:
# -*- coding: utf-8 -*-

n, k = map(int, input().split())

res = 0
while n > 0:
    res += 1
    n //= k
print(res)
# Buggy code:
n,k=map(int,input().split())
ans=0
while n>=0:
    n//k
    ans+=1
print(ans)

# Fixed code:
n,k=map(int,input().split())
ans=0
while 0<n:
    ans+=1
    n=n//k
print(ans)
# Buggy code:
import itertools
N,K = map(int,input().split())
for i in itertools.count(1):
  if N//(K**i)<K:
    print(i)
    break


# Fixed code:
import itertools
N,K = map(int,input().split())

for i in itertools.count(0):
  if N//(K**i)<K:
    print(i+1)
    break
# Buggy code:
N,K=map(int,input().split())
X=0
cnt=0
i=0

while X<N:
    X=X+K**i
    print(X)
    i=i+1
    cnt=cnt+1

print(i)

# Fixed code:
N,K=map(int,input().split())
X=0
i=0
while X<N:
    X=X+(K-1)*K**i
    i=i+1
print(i)
# Buggy code:
n,k=map(int,input().split())
count=0
while (n/k)>=1:
  n/=k
  count+=1

print(count)

# Fixed code:
n,k=map(int,input().split())
ans=0
while n>0:
  n//=k
  ans+=1
print(ans)
# Buggy code:
 = map(int, input().split())

ans = 1
while(True):
    n = n//k
    if(n == 0):
        break
    ans += 1

print(ans)


# Fixed code:
n, k = map(int, input().split())

ans = 1
while(True):
    n = n//k
    if(n == 0):
        break
    ans += 1

print(ans)
# Buggy code:
n,k = [int(x) for x in input().split()]
res = 0
while n > 0:
  n // k
  c += 1
print(res)

# Fixed code:
n,k = [int(x) for x in input().split()]
res = 0
while n > 0:
  n //= k
  res += 1
print(res)
# Buggy code:
n,k = map(int,input().split())
c = 0
while n > 0:
  n = n//7
  c += 1
print(c)
  

# Fixed code:
n,k = map(int,input().split())
c = 0
while n > 0:
  n = n//k
  c += 1
print(c)
# Buggy code:
#!/usr/bin/env python3
import sys


def solve(N: int, K: int):
    count = 0
    while True:
        N = N // K
        if N >= 1:
            count += 1
        else:
            break
    print (cont)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    solve(N, K)

if __name__ == '__main__':
    main()


# Fixed code:
#!/usr/bin/env python3
import sys


def solve(N: int, K: int):
    count = 0
    while True:
        N = N // K
        if N >= 1:
            count += 1
        else:
            break
    print (count+1)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    solve(N, K)

if __name__ == '__main__':
    main()
# Buggy code:
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)

N, K = map(int, input().split())
if K!=10:
  N = Base_10_to_n(N, K)
print( N )

# Fixed code:
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
 
N, K = map(int, input().split())
if K!=10:
  N = Base_10_to_n(N, K)
print( len(str(N)) )
# Buggy code:
N, K = map(int, input().split())
cout = 1
for i in ranga(N):
    N = N//K
    cout += 1
    if N<K:
        break
print(cout)

# Fixed code:
N, K = map(int, input().split())
cout = 1
for i in range(N):
    if N<K:
        break
    N = N//K
    cout += 1

print(cout)
# Buggy code:
n,k=map(int,input().split())
ans=0
while n>k:
  n/=k
  n=int(n)
  ans+=1

print(ans+1)

# Fixed code:
n, k = map(int, input().split())
cnt = 0
while n >= k:
  n //= k
  cnt += 1
    
print(cnt + 1)
# Buggy code:
n,k=map(int,input().split())
ans=0
while n!=0:
  if n//k!=0:
    ans=ans+1
  elif n%k!=0:
    ans=ans+1
print(ans)


# Fixed code:
n,k=map(int,input().split())
ans=0
while n!=0:
  if n//k!=0:
    ans=ans+1
  elif n%k!=0:
    ans=ans+1
  n=n//k
print(ans)
# Buggy code:
def calculate_num(m, n):
  integer = m
  base = n
  result = ''
  while integer > 0:
    result += str(integer%base) + result
    integer = integer//base
    print(integer)
  return result

def main():
  num = input()
  num_list = num.split()
  number = int(num_list[0])
  base = int(num_list[1])
  result = calculate_num(number, base)
  print(int(result))
main()

# Fixed code:
def calculate_num(m, n):
  integer = m
  base = n
  result = ''
  digit = 0
  while integer > 0:
    result += str(integer%base)
    integer = integer//base
    digit = len(result)
  return digit

def main():
  num = input()
  num_list = num.split()
  number = int(num_list[0])
  base = int(num_list[1])
  result = calculate_num(number, base)
  print(result)
main()
# Buggy code:
input = input()

arr = input.split(" ")
N = int(arr[0])
K = int(arr[1])

def Base_10_to_n(X, n):
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = str(X_dumy%n)+out
        X_dumy = int(X_dumy/n)
    return out

R = Base_10_to_n(11, 2)

print(len(str(R)))

# Fixed code:
input = input()

arr = input.split(" ")
N = int(arr[0])
K = int(arr[1])

def Base_10_to_n(X, n):
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = str(X_dumy%n)+out
        X_dumy = int(X_dumy/n)
    return out

R = Base_10_to_n(N, K)

print(len(str(R)))
# Buggy code:
N, K = map(int, input().split())
def transform(X, n):
    print(int(X/n))
    if (int(X/n)):
        return transform(int(X/n), n)+str(X%n)
    return str(X%n)

print(len(transform(N, K)))


# Fixed code:
N, K = map(int, input().split())
def transform(X, n):
    if (int(X/n)):
        return transform(int(X/n), n)+str(X%n)
    return str(X%n)

print(len(transform(N, K)))
# Buggy code:
n,k = map(int,input().split())
n2 = k
count = 0
while n2 <= n:
  n2*=k
  count+=1
print(n2)
print(count+1)

# Fixed code:
n,k = map(int,input().split())
n2 = k
count = 0
while n2 <= n:
  n2*=k
  count+=1
print(count+1)
# Buggy code:
N,K = map(int,input().split())

ans = ""

while True:
  r = str(N % K)
  ans += r
  N = N // K
  if N < K:
    ans += str(N % K)
    ans = ans[::-1]
    if ans[0] == "0":
      ans = ans[1:]
      break
  
print(len(ans))

# Fixed code:
N,K = map(int,input().split())

ans = ""

while True:
  r = str(N % K)
  ans += r
  N = N // K
  if N < K:
    ans += str(N % K)
    break

ans = ans[::-1]
if ans[0] == "0":
  ans = ans[1:]  

print(len(ans))
# Buggy code:
N,K = map(int,input().split())
for i in range(N):
    if N >=2**i and N <2**(i+1):
        print(i+1)

# Fixed code:
N,K = map(int,input().split())
for i in range(N):
    if N >=K**i and N <K**(i+1):
        print(i+1)
        break
# Buggy code:
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
x2 = 0
x10, n = input().split()
print(int(x10), int(n))
x10 = int(x10)
n = int(n)
x2 = Base_10_to_n(x10, n)
print( len(x2) )

# Fixed code:
def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(X%n)
    return str(X%n)
x2 = 0
x10, n = input().split()
x10 = int(x10)
n = int(n)
x2 = Base_10_to_n(x10, n)
print(len(x2))
# Buggy code:
i = list(map(int, input().split()))
j=1
while i[0]<i[1]**j:
  j+=1
print(j)

# Fixed code:
i= list(map(int, input().split()))
j=1
while i[0]>=i[1]**j:
  j+=1
print(j)
# Buggy code:
s = input()
a = len(s)
print("x" * s)

# Fixed code:
s = input()
a = len(s)
print ("x"*a)
# Buggy code:
S = str(input())
result = []

for i in range(len(S)):
  result.append(x)

result = ''.join(result)
print(result)

# Fixed code:
S = str(input())
result = []
 
for i in range(len(S)):
  result.append('x')
 
result = ''.join(result)
print(result)
# Buggy code:
def main():
  S=input()
  nums = len(S)
  print(type(nums))
  xs = ''
  for num in range(nums):
    xs += "x"
  print(xs)
main()

# Fixed code:
def main():
  S=input()
  nums = len(S)
  xs = ''
  for num in range(nums):
    xs += "x"
  print(xs)
main()
# Buggy code:
s=input()
num=len(s)å
print("x"*(num))

# Fixed code:
s=input()
num=len(s)
print("x"*(num))
# Buggy code:
s=len(input())
2 print('x' * len(s))

# Fixed code:
s = input()
print("x"*(len(s)))
# Buggy code:
s=input()
S=''
for i in range(len(s))
    S+='x'
print(S)

# Fixed code:
s=input()
S=""
for i in range(len(s)):
    S+="x"
print(S)
# Buggy code:
S = input()

S_len = len(S)

print(x* S_len)

# Fixed code:
S = input()
 
S_len = len(S)
 
print("x" * S_len)
# Buggy code:
S = input()
S.replace()

ans = []

for i in range(len(s)):
    ans.append("x")

print("".join(ans))

# Fixed code:
S = input()
ans = []

for i in range(len(S)):
    ans.append("x")

print("".join(ans))
# Buggy code:
S = str(input())
print(len(S))
ans = ''
for i in range(len(S)):
    ans += 'x'


# Fixed code:
S = str(input())
ans = ''
for i in range(len(S)):
    ans += 'x'
print(ans)
# Buggy code:
S=input()
list_s = list(S)
for i in range(0, len(list_s)):
    list_s[i] = "x"
print(list_s)

# Fixed code:
S=input()
list_s = list(S)
for i in range(0, len(list_s)):
    list_s[i] = "x"

print(''.join(list_s))
# Buggy code:
S = input()
for i in len(S):
  print(x, end="")

# Fixed code:
S = input()
for i in range(len(S)):
  print('x', end="")
# Buggy code:
S=input()
a=[]
for i in range(len(S)):
    a.append('×')
print(''.join(a))

# Fixed code:
S=input()
a=[]
for i in range(len(S)):
    a.append('x')
print(''.join(a))
# Buggy code:
g=str(input())
print("x"*len(s))

# Fixed code:
g=str(input())
print("x"*len(g))
# Buggy code:
s = input()
n = len(s)
X = x*n
print(X)

# Fixed code:
s = input()
n = len(s)
X = "x" *n
print(X)
# Buggy code:
s = input()
l = len(input())
print('x'*l)

# Fixed code:
s = str(input())
l = len(s)
    
print("x"*l)
# Buggy code:
s=input()
for i in range(len(s)):
  t="x"
print(t)

# Fixed code:
s=input()
t=""
for i in range(len(s)):
  t+="x"
print(t)
# Buggy code:
a=input()
A=len(a)
b=x
for i in A-1:
  b=b+'x'
print(b)

# Fixed code:
a=input()
A=len(a)
b="x"
for i in range(A-1):
  b=b+"x"
print(b)
# Buggy code:
S = input()
print(S)
print("x"*len(S))



# Fixed code:
S = input()
print("x" *len(S))
# Buggy code:
S = input()
print(S[0])
s = []
for i in range(len(S)):
  s.append('x')
print(''.join(s))

# Fixed code:
S = input()

S = [i for i in S]

s = len(S)

for i in range(s):
  S[i] = 'x'

print(''.join(S))
# Buggy code:
s=input()

l=len(s)
a=""
for i in range(l):
  a+"x"
  
  
print(a)

# Fixed code:
s=input()
a=""

l=len(s)

for i in range (l):
  a=a+"x"
print(a)
# Buggy code:
from sys import stdin


def get_result(data):
    return 'x' * len(data[0])

if __name__ == '__main__':
    data = list(map(str, stdin.readline().split(' ')))
    # result = get_result(data)
    print('x' * len(data[0]))


# Fixed code:
from sys import stdin


def get_result(data):
#    return 'x' * len(data[0])
    return 'x' * len(data)


if __name__ == '__main__':
#     data = list(map(str, stdin.readline().split(' ')))
    data =  input()
    result = get_result(data)
    print(result)
# Buggy code:
S = input()
l = len(S)
ans = "*" * l
print(ans)

# Fixed code:
S = input()
l = len(S)
ans = "x" * l
print(ans)
# Buggy code:
n = input().strip()
for i in range(1, n+1):
    if i == n:
        print("x")
    else:
        print("x", end="")

# Fixed code:
A = input().strip()
n = len(A)
for i in range(1, n+1):
    if i == n:
        print("x")
    else:
        print("x", end="")
# Buggy code:
s = input()

a = x

print('x' * len(s))

# Fixed code:
s = len(input())

print('x' *s )
# Buggy code:
S = input()
for i in range(len(S)):
    print(x,end="")

# Fixed code:
S = input()
for i in range(len(S)):
  print('x', end='')
# Buggy code:
mozi = str(input())
s = str(x)
for i in range(len(mozi)):
  s += "x"
print(s)

# Fixed code:
mozi = str(input())
s = str()
for i in range(len(mozi)):
  s += str("x")
print(s)
# Buggy code:
s = input()
for i in len(s):
  print(x,end="")


# Fixed code:
s = input()
for i in range(len(s)):
  print("x",end="")
# Buggy code:
S = input()
S_list = list(S)

for i in range(len(S_list)):
  S_list[i] = "x"

print(*S_list)


# Fixed code:
S = input()
S_list = list(S)

for i in range(len(S_list)):
  S_list[i] = "x"

print(*S_list, sep="")
# Buggy code:
S = list(input())
print(x*len(S))

# Fixed code:
S = list(input())
print("x" * len(S))
# Buggy code:
S = input()

A = 'x'*(len(S))

# Fixed code:
S = input()
 
A = 'x'*(len(S))
print(A)
# Buggy code:
n = int(input())
s = list(map(int,input().split()))

def count(x):
    if len(s) != len(set(x)):
        return print("NO")
    else:
        return print("YES")

# Fixed code:
n = int(input())
s = list(map(int,input().split()))
 
def count(x):
    if len(s) != len(set(x)):
        return "NO"
    else:
        return "YES"
print(count(s))
# Buggy code:
N = int(input())
S = [int(i) for i in input().split()].sort()

flg = 0
for i in range(1,N):
  if S[i] = S[i-1]:
    flg = 1
    
if flg == 1:
  print("NO")
else:
  print("YES")  


# Fixed code:
N = int(input())
S = [int(i) for i in input().split()]
S.sort()

flg = 0
for i in range(1,N):
  if S[i] == S[i-1]:
    flg = 1
    
if flg == 1:
  print("NO")
else:
  print("YES")
# Buggy code:
N = int(input())
A = list(map(int, input().split()))
S = list(set(A))
if len(A) == len(S):
  return "YES"
else:
  return "NO"

# Fixed code:
N = int(input())
A = list(map(int, input().split()))
S = list(set(A))

if len(A) == len(S):
  print("YES")
else:
  print("NO")
# Buggy code:
input()
li = map(int,input().split())

print('NO' if len(li) > len(set(li)) else 'YES')

# Fixed code:
input()
li = list(map(int, input().split()))
print('NO' if len(li)>len(set(li)) else 'YES')
# Buggy code:
n=input()
l=list(map(int,input().split()))
d={}
flag=0

for i in range(n):
  if l[i] in d:
    flag=1
    break
    
if flag==0:
  print("YES")
else:
  print("NO")

# Fixed code:
n=int(input())
l=list(map(int,input().split()))
d={}
flag=0

for i in range(n):
  if l[i] in d:
    flag=1
    break
  else:
    d[l[i]]=1
    
if flag==0:
  print("YES")
else:
  print("NO")
# Buggy code:
import sys
N = int(input())
A = list(input().split())
def has(s):
    return len(s) != len(set(s))
B = has(A)

if B == False:
    print("NO")
    sys.stdout.flush
else:
    print("YES")
    sys.stdout.flush

# Fixed code:
import sys
N = int(input())
A = list(input().split())
def has(s):
    return len(s) != len(set(s))
B = A
B = has(A) 
if B == False:
    print("YES")
    sys.stdout.flush
else:
    print("NO")
    sys.stdout.flush
# Buggy code:
N = int(input())
A = list(map(int, input().split()))

A.sort()

for i in range(N - 1):
    if A[i] == A[i + 1]:
        print('NO')
        return

print('YES')


# Fixed code:
N = int(input())
A = list(map(int, input().split()))

A.sort()

for i in range(N - 1):
    if A[i] == A[i + 1]:
        print('NO')
        break
else:
    print('YES')
# Buggy code:
a = [int(i) for i in input().split(' ')]
b = list(set(a))

print( 'YES' if len(a)==len(b) else 'NO' ) 

# Fixed code:

input()
a = [int(i) for i in input().split(' ')]
b = list(set(a))

print( 'YES' if len(a)==len(b) else 'NO' )
# Buggy code:
import sys
input = sys.stdin.readline


def main():
  n = int(input())
  x = tuple(map(int, input().split()))
  length = len(x)
  if n == length:
    print('YES')
  else:
    print('NO')
  

if __name__ == '__main__':
  main()

# Fixed code:
import sys
input = sys.stdin.readline
 
 
def main():
  n = int(input())
  x = set(map(int, input().split()))
  length = len(x)
  if n == length:
    print('YES')
  else:
    print('NO')
  
 
if __name__ == '__main__':
  main()
# Buggy code:
n = int(input())
li = [int(x) for x in input().split()]

nozoki = list(set(li)).sort()
li.sort()
if (nozoki == li):
    print("YES")
else:
    print("NO")

# Fixed code:
n = int(input())
li = [int(x) for x in input().split()]

nozoki = list(set(li))
nozoki.sort()
li.sort()
if (nozoki == li):
    print("YES")
else:
    print("NO")
# Buggy code:
import collections
n=int(input())
a=list(map(int,input().split()))
b=len(a)
c=collections.Counter(a)
e=len(c.values())
print(e)
if b==e:
    print("YES")
else:
    print("NO")

# Fixed code:
import collections
n=int(input())
a=list(map(int,input().split()))
b=len(a)
c=collections.Counter(a)
e=len(c.values())
if b==e:
    print("YES")
else:
    print("NO")
# Buggy code:
from collections import Counter

# input
N = int(input())
A = list(map(int, input().split()))

if [1 ** N] == Counter(A).values():
    print("YES")
else:
    print("NO")

# Fixed code:
from collections import Counter

# input
N = int(input())
A = list(map(int, input().split()))

if [1] * N == list(Counter(A).values()):
    print("YES")
else:
    print("NO")
# Buggy code:
A=list(map(int, input().split()))
n=len(A)
A.sort()
for i in range(N-1):
  if A[i]==A[i+1]:
    print('NO')
    exit()
else:
  print('YES')

# Fixed code:
N=int(input())
A=list(map(int, input().split()))
A.sort()
if N==1:
  print('YES')
  exit()
for i in range(N-1):
  if A[i]==A[i+1]:
    print('NO')
    exit()
else:
  print('YES')
# Buggy code:
import sys
n = int(input())
a = sorted(list(map(lambda x: int(x),input().split())))
for i in range(n - 1):
    if a[i] == a[i+1] :
        print('NO')
        sys.exit()
print('Yes')


# Fixed code:
import sys
n = int(input())
a = sorted(list(map(lambda x: int(x),input().split())))
for i in range(n - 1):
    if a[i] == a[i+1] :
        print('NO')
        sys.exit()
print('YES')
# Buggy code:
N=(int)(input())
A=(input()).split()
A.sort()
 
for i in range(N-1):
  if A[i]==A[i+1]:
    print('NO')
  if i==N-2:
    print('YES')

# Fixed code:
N=(int)(input())
A=(input()).split()
A.sort()
 
for i in range(N-1):
    if A[i]==A[i+1]:
        print('NO')
        break
    elif i==N-2:
        print('YES')
# Buggy code:
N = int(input())
A = list(map(int,input().split()))
b = list(set(A))
if b == A: print ('YES')
else: print ('NO')

# Fixed code:
N=int(input())
A=list(map(int,input().split()))
if len(A)==len(set(A)):
  print("YES")
else:
  print("NO")
# Buggy code:
n = int(input())
a = input().split(' ')

if len(set(a)) == n:
  print('YES')
else
  print('NO')

# Fixed code:
n = int(input())
a = input().split()
if (len(a) == len(set(a))):
  print("YES")
else:
  print("NO")
# Buggy code:
from collections import Counter

n = int(input())
a = list(map(int, input().split()))
cnt = Counter(a)
flag = [i for i in cnt.values()]
if len(set(flag)) == 1:
    print("YES")
else:
    print("NO")

# Fixed code:
from collections import Counter

n = int(input())
a = list(map(int, input().split()))
cnt = Counter(a)
flag = [i for i in cnt.values()]
if len(set(flag)) == 1 and max(flag) == 1:
    print("YES")
else:
    print("NO")
# Buggy code:
N = int(input())
A = list(map(int,input().split()))
print(A)
if N==len(A):
    print('YES')
else:
    print('NO')

# Fixed code:
N = int(input())
A = set(list(map(int, input().split())))
print("YES" if len(A) == N else "NO")
# Buggy code:
n = int(input())
a_n = list(map(int, input().split()))

b_n = sorted(a_n)
flg = 0

for i in range(n - 1):
    if b_n[i] == b_n[i + 1]:
        flg = 1

if flg == 1:
    print("YES")
else:
    print("NO")

# Fixed code:
n = int(input())
a_n = list(map(int, input().split()))

b_n = sorted(a_n)
flg = 0

for i in range(n - 1):
    if b_n[i] == b_n[i + 1]:
        flg = 1

if flg == 1:
    print("NO")
else:
    print("YES")
# Buggy code:
n = int(input())
a = list(map(int,input().split()))
se = set(n)

if len(se) == len(a):
  print('YES')
else:
  print('NO')

# Fixed code:
n = int(input())
a = list(map(int, input().split()))
set_a = set(a)
if len(set_a) == len(a):
    print("YES")
else:
    print("NO")
# Buggy code:
N = int(input())
P = list(map(int,input().split()))
def has_duplicates(seq):
    return len(seq) != len(set(seq))
if has_duplicates(P) == 'False':
    print('YES')
elif has_duplicates(P) == 'True':
    print('NO')

# Fixed code:
N = int(input())
P = list(map(int,input().split()))
def has_duplicates(seq):
    return str(len(seq) != len(set(seq)))
if has_duplicates(P) == 'False':
  print('YES')
elif has_duplicates(P) == 'True':
  print('NO')
# Buggy code:
import sys
N = int(input())
cc = list(map(int,input().split()))
dic = set()
for i in cc:
  if i in dic:
    print('NO')
    sys.exit()
  else:
    dic.append(i)
print('YES')

    

# Fixed code:
import sys
N = int(input())
cc = list(map(int,input().split()))
dic = set()
for i in cc:
  if i in dic:
    print('NO')
    sys.exit()
  else:
    dic.add(i)
print('YES')
# Buggy code:
N=int(input())
A=sorted(list(map(int,input().split())))
for i in range(1,N):
  if A[i] == A[i-1]:
    print("YES")
  else:
    print("NO")

# Fixed code:
N=int(input())
A=sorted(list(map(int,input().split())))
flag = False
for i in range(1,N):
  if A[i] == A[i-1]:
    flag = True
if flag:
  print("NO")
else:
  print("YES")
# Buggy code:
N=int(input())
A=list(map(int, input().split()))

A.sort()
for i in range(N-1):
    if A[i]==A[i+1]:
        print("NO")

print("YES")

# Fixed code:
N = int(input())
A = list(map(int, input().split()))

A.sort()

ans = "YES"
for i in range(N-1):
  if A[i] == A[i+1]:
    ans = "NO"
    break
print(ans)