CodeEff/ECCO huggingface dataset:
# Original solution
first_int = int(eval(input()))
secound_list = [int(k) for k in input().split()]

for k in range(first_int):
  if secound_list.count(secound_list[k]) >= 2:
    print('NO')
    break
  if k == first_int-1:
    print('YES')

# Optimized solution
first_int = int(eval(input()))
secound_list = [int(k) for k in input().split()]

def has_duplicates(seq):
    return len(seq) != len(set(seq))

if has_duplicates(secound_list) == False:
  print('YES')
else:
  print('NO')
# Original solution
n = int(eval(input()))
x = [int(x) for x in input().split()]
flag = 0
for i in range(len(x)):
    for j in range(len(x)):
        if i != j:
            if x[i] == x[j]:
                print("NO")
                flag = 1
                break
    if flag == 1:
        break
else:
    print("YES")

# Optimized solution
n = int(eval(input()))
x = [int(x) for x in input().split()]

s = set(x)

if len(s) != len(x):
    print("NO")
else:
    print("YES")
# Original solution
import sys

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

for i in range(N):
    x = A[i]
    for j in range(N-i-1):
        if x == A[i+j+1]:
            print('NO')
            sys.exit()

print('YES')

# Optimized solution
import sys

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

if len(A) == len(set(A)):
    print('YES')
else:
    print('NO')
# Original solution
# -*- coding: utf-8 -*-
n=int(eval(input()))  #数値入力 「N」だけの入力のとき
a=list(map(int, input().split()))  #リスト入力 「a1 a2 a3 ...」みたいな配列のような入力のとき
f = 0
for i in range(0,n):
    if a[i] in a[i+1:]:
        print("NO")
        f = 1
        break
if f ==0:
    print("YES")

# Optimized solution
# -*- coding: utf-8 -*-
n=int(eval(input()))  #数値入力 「N」だけの入力のとき
a=list(map(int, input().split()))  #リスト入力 「a1 a2 a3 ...」みたいな配列のような入力のとき
f = 0
if len(a) != len(set(a)):
    print("NO")
else:
    print("YES")
# Original solution
n = int(eval(input()))
lst = list(map(int,input().split()))
ans = 0
for i in range(len(lst)):
    if (lst.count(lst[i]) != 1):
        ans = 1

if (ans == 0):
    print("YES")
else:
    print("NO")


# Optimized solution
n = int(eval(input()))
lst = list(map(int,input().split()))
x = len(lst)
lst = list(set(lst))
y = len(lst)

if (x == y):
    print("YES")
else:
    print("NO")
# Original solution
from collections import Counter


n = int(eval(input()))
a = list(map(int, input().split()))
cnt = Counter(a)

if max(cnt.values()) == 1:
    print('YES')
else:
    print('NO')


# Optimized solution
n = int(eval(input()))
a = list(input().split())

if len(a) == len(set(a)):
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
d = [0]*(n-1)
for i in range(n-1):
    d[i]=l[i+1]-l[i]
p = 1
for j in d:
    p = p * j
if p == 0:
    print('NO')
else:
    print('YES')

# Optimized solution
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
s = 'YES'
for i in range(n-1):
    if l[i] == l[i+1]:
        s = 'NO'
print(s)
# Original solution
import collections

n = int(eval(input()))
a = list(map(int, input().split()))

c = collections.Counter(a)

if c.most_common()[0][1] == 1:
  print('YES')
else:
  print('NO')



# Optimized solution
from collections import Counter

n = int(eval(input()))
a = list(map(int,input().split()))

c = Counter(a)
if c.most_common()[0][1] == 1:
    print('YES')
else:
    print('NO')
# Original solution
N = eval(input())
A = list(map(int, input().split()))
ans = {}
b = True
for i in A:
  if i in ans:
    b = False
    break
  else:
    ans[i] = 0
    
if b:
  print("YES")
else:
  print("NO")
    


# Optimized solution
N = eval(input())
A = list(map(int, input().split()))
    
if len(A) == len(set(A)):
  print("YES")
else:
  print("NO")
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
C = {}
for i in range(N):
    a = A[i]
    if a not in C:
        C[a] = 0
    C[a] += 1
flag = 0
for a in C:
    if C[a]>1:
        flag = 1
        break
if flag==0:
    print("YES")
else:
    print("NO")

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
C = {}
for i in range(N):
    a = A[i]
    if a not in C:
        C[a] = 0
    C[a] += 1
if len(C)==N:
    print("YES")
else:
    print("NO")
# Original solution
n = int(eval(input()))
a = set(map(int, input().split()))
if len(a) == n:
    print('YES')
else:
    print('NO')


# Optimized solution
n = int(eval(input()))
a = set(map(int, input().split()))
print(('YES' if len(a) == n else 'NO'))
# Original solution
N = int(eval(input()))
all_list = input().split(' ')

before_list = []

for i in range(N):
  if before_list.count(all_list[i]) == 0:
    before_list.append(all_list[i])
  else:
    print('NO')
    exit()
if len(all_list) == len(before_list):
  print('YES')
  

# Optimized solution
N = int(eval(input()))

#listで囲むと良い
A = list(map(int, input().split()))

#setは重複する値が消される
if len(set(A)) == N:
    print('YES')
else:
    print('NO')
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

count = 0
for i in A:
    for j in A[count+1:]:
        if i == j:
            print("NO")
            break
    else:
        count += 1
        continue
    break
else:
    print("YES")


# Optimized solution
N = int(eval(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")
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
Ans = "YES"
List = []

for e in A:
    if e in List:
        Ans = "NO"
        break
    else:
        List.append(e)

print(Ans)

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
Ans = "YES"
List = []
before_n = 0
for e in A:
    if e == before_n:
        Ans = "NO"
        break
    else:
        before_n=e
print(Ans)
# Original solution
n=int(eval(input()))
a = list(map(int,input().split()))
for i in range (n):
  for j in range(n):
    if i != j:
      if a[i] == a[j]:
        print('NO')
        exit()
print('YES')

# Optimized solution
n=int(eval(input()))
a = list(map(int,input().split()))
a.sort()
for i in range (n-1):
  if a[i] == a[i+1]:
    print('NO')
    exit()
print('YES')
# Original solution
from  collections import Counter
n = int(input())
a = Counter([int(x) for x in input().split()])
print('NO') if a.most_common()[0][1]>1 else print('YES')


# Optimized solution
from  collections import Counter
n = int(input())
a = Counter([int(x) for x in input().split()])
print('NO') if len(a)!=n else print('YES')
# Original solution
n = int(eval(input()))
A = list(map(int, input().split()))
l = []
f = 0
for a in A:
  if a in l:
    f = 1
    print("NO")
    break
  else:
    l.append(a)
if f == 0:
  print("YES")

# Optimized solution
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(set(A))
if len(A) == len(B):
  print("YES")
else:
  print("NO")
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))
flag=0
for i in range(N):
    for j in range(i+1,N):
        if(A[i]==A[j]):
            flag=1
            break
    if(flag==1):
        break

if(flag==1):
    print("NO")
if(flag==0):
    print("YES")

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
ans={}
flag=0

for i in A:
    if(ans.get(i)!=None):
        flag=1
        break
    else:
        ans[i]=1
        
if(flag==0):
    print("YES")
else:
    print("NO")
# Original solution
import itertools
import math
import fractions
import functools
n = int(eval(input()))
a = list(map(int, input().split()))

s = set(a)
if len(s) == len(a):
    print("YES")
else: print("NO")

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
s = set()
for i in range(n):
    s.add(a[i])

if len(s) == len(a):
    print("YES")
else: print("NO")
# Original solution
n = int(eval(input()))
a_lst = list(map(int,input().split()))

for i in range(n):
    if a_lst.count(a_lst[i])!=1:
        print('NO')
        break
else:
    print('YES')

# Optimized solution
n = int(eval(input()))
a_lst = list(map(int,input().split()))
new_lst = list(set(a_lst))

if len(a_lst)==len(new_lst):
    print('YES')
else:
    print('NO')
# Original solution
N = int(eval(input()))
H = list(map(int,input().split()))
Ans = "YES"

for i in range(N):
    for j in range(N):
        if H[i] ==H[j] and i!=j:
            Ans = "NO"
    
print(Ans)

# Optimized solution
N = int(eval(input()))
H = list(map(int,input().split()))

Hlen = len(H)


Hsyugou = set(H)
Hhennkann = list(Hsyugou)
Hhennkannlen = len(Hhennkann)




if Hlen ==Hhennkannlen:
    print("YES")

else:
    print("NO")
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

for i in A:
  c = 0
  for j in A:
    if(j == i):
      c += 1
    if(c > 1):
      print("NO")
      exit()
print("YES")

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

if (len(A) == len(set(A))):
  print("YES")
else:
  print("NO")
# Original solution
import collections

n = int(eval(input()))
a = list(map(int, input().split()))

# リストaの要素の出現回数を計算
s = collections.Counter(a)

# 出現回数の最大値を取得
max_s = max(s.values())

if max_s == 1:
    print('YES')
else:
    print('NO')

# Optimized solution
n = int(eval(input()))

# 被りの要素が削除される
a = set(input().split())
print(('YES' if len(a) == n else 'NO'))
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))
list.sort(A)
for i in range(N-1):
    if A[i]-A[i+1]==0:
        print("NO")
        exit(0)
print("YES")

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
A.sort()
for i in range(N-1):
    if A[i+1]-A[i]==0:
        print("NO")
        exit(0)
print("YES")
# Original solution
N = int(eval(input()))

NumArr = [int(num) for num in input().split()]

ans = 'YES'
for num in NumArr:
    matchCount = NumArr.count(num)
    if matchCount > 1:
        ans = 'NO'
        break

print(ans)


# Optimized solution
N = int(eval(input()))

NumArr = [int(num) for num in input().split()]

flg = len(NumArr) == len(set(NumArr))

if flg:
    print('YES')
else:
    print('NO')
# Original solution
import collections
N = int(eval(input()))
number = list(map(int,input().split()))
number_count = collections.Counter(number)
for i,j in list(number_count.items()):
    if j >1:
        print("NO")
        exit(0)
print("YES")
    

# Optimized solution
N = int(eval(input()))
number = set(map(int,input().split()))
if len(number)==N:print("YES")
else:print("NO")
# Original solution
import math
import itertools
n = int(eval(input()))
#n, d = list(input().split())
A = list(map(int, input().split()))
check = [0]
for i in range(n):
    if A[i] in check:
        print("NO")
        exit()
    
    check.append(A[i])

print("YES")


# Optimized solution
import math
import itertools
n = int(eval(input()))
#n, d = list(input().split())
A = list(map(int, input().split()))
A.sort()
for i in range(n-1):
    if A[i]==A[i+1]:
        print("NO")
        exit()

print("YES")
# Original solution
N = int(eval(input()))
A = input().split()

flag = 0
for i in range(len(A)):
    for j in range(i+1,len(A)):
        if(A[i]==A[j]):
            flag = 1

if(flag == 0):
    print("YES")
else:
    print("NO")


# Optimized solution
N = int(eval(input()))
A = input().split()

if(len(A)) == len(set(A)):
    print("YES")
else:
    print("NO")
# Original solution
n=int(eval(input()))
if len(set(map(int,input().split())))==n:
  print('YES')
else:
  print('NO')

# Optimized solution
n = int(eval(input()))
A = list(map(int,input().split()))
B = set(A)
if len(A) == len(B):
  print('YES')
else:
  print('NO')
# Original solution
import sys
input = sys.stdin.readline

N = eval(input())
A = list(map(int,input().split()))
flag = False
while 1:
    a = A[0]
    A = A[1:]
    if a in A:
        flag = True
        break
    if len(A) == 0:
        break


if flag:
    print("NO")
else:
    print("YES")

# Optimized solution
import sys
input = sys.stdin.readline

N = int(eval(input()))
A = list(map(int,input().split()))
A = set(A)
if N == len(A):
    print("YES")
else:
    print("NO")
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(len(A)-1):
    if A[i+1:].count(A[i]) > 0:
        print ('NO')
        exit (0)
print ('YES')

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
S = set(A)
if len(A) == len(S):
    print ('YES')
else:
    print ('NO')
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
flag=0
for i in range(n):
  if a.count(a[i])!=1:
    flag=1
if flag==0:
  print("YES")
else:
  print("NO")

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
m=len(a)
a=set(a)
n=len(a)
if m==n:
  print("YES")
else:
  print("NO")
# Original solution
n = int(eval(input()))
a_n = [int(i) for i in input().split()]

def main():
    for i in range(len(a_n)):
        for j in range(i):
            if a_n[i] == a_n[j]:
                print('NO')
                return 0
    print('YES')
    return 0

main()

# Optimized solution
n = int(eval(input()))
a_n = [int(i) for i in input().split()]

def has_duplicates(seq):
    return len(seq) != len(set(seq))

if has_duplicates(a_n):
    print('NO')
else:
    print('YES')
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
  for j in range(i+1, N):
    if(A[i]==A[j]):
      print("NO")
      exit()
print("YES")

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
if len(A) == len(set(A)):
  print("YES")
else:
  print("NO")
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
res = True
p = 1
for n in range(N):
    for i in range(p, N):
        if A[n] == A[i]:
            res = False
    p += 1
if res:
    print('YES')
else:
    print('NO')

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
res = A[0]
cnt = True
for n in range(1, N):
    if A[n] == res:
        cnt= False
    res = A[n]
if cnt:
    print('YES')
else:
    print('NO')
# Original solution
from collections import Counter
N=int(eval(input()))
A=list(map(int,input().split()))

c = Counter(A).most_common()

for i in range(len(c)):
  if c[i][1]>1:
    print("NO")
    exit()

print("YES")
  

# Optimized solution
N = int(eval(input()))
A = [int(a) for a in input().split()]
B = set(A)

if len(A)==len(B):
  print("YES")
else:
  print("NO")
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
cnt = 0
for i in range(n):
	for j in range(n):
		if i != j and a[i] == a[j]:
			cnt += 1
			break
print((["NO","YES"][cnt==0]))

# Optimized solution
n=eval(input());a=list(map(int,input().split()))
print((["YES","NO"][len(set(a))!=len(a)]))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split(" ")))
deta = []
error = False

for i in range(n):
    if n == 0:
        pass
    elif error:
        break
    elif a[i] in deta:
        error = True
        break
    deta.append(a[i])
if error:
    print("NO")
else:
    print("YES")

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split(" ")))
deta = set()
error = False

for i in range(n):
    if n == 0:
        pass
    elif error:
        break
    elif a[i] in deta:
        error = True
        break
    deta.add(a[i])
if error:
    print("NO")
else:
    print("YES")
# Original solution
n = int(eval(input()))
nums = tuple(input().split())
judge = 0
for i in range(n):
  for j in range(i+1,n):
    if nums[i] == nums[j]:
      judge = 1
if judge == 0:
  print("YES")
else:
  print("NO")

# Optimized solution
n = int(eval(input()))
a = input().split()
a = sorted(list(map(int, a)))
def check(a):
    for i in range(n-1):
        if a[i] == a[i+1]:
            return 0
    return 1
if check(a) == 0:
    print("NO")
else:
    print("YES")
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(1,N):
  if A[i] in A[0:i]:
    print('NO')
    exit()
print('YES')

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
B = set(A)
if sorted(A) == sorted(B):
  print('YES')
else:
  print('NO')
# Original solution
N = int(eval(input()))
numb = input().split()

def answer(N, numb):
    for i in range(N):
        for j in range(N):
            if i <= j:
                continue

            if numb[i] == numb[j]:
                return "NO"

    return "YES"
 
print((answer(N,numb)))


# Optimized solution
N = int(eval(input()))
numb = input().split()

if len(set(numb)) == len(numb):
    print("YES")
else:
    print("NO")
# Original solution
import sys

def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


def main():
    N = II()
    A = LI()
    ans = 0

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


if __name__ == "__main__":
	main()

# Optimized solution
import sys

def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]


def main():
    N = II()
    A = LI()
    numa = len(set(A))
    #print(numa)
        
    if numa == N:
        print("YES")
    else:
        print("NO")


if __name__ == "__main__":
	main()
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

def distinct(arry):
  while True:
    if len(arry) == 1:
      return True
    x = arry.pop(0)
    if x in arry:
      return False

if distinct(A):
  print("YES")
else:
  print("NO")


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

def distinct(arry):
  x = set(arry)
  if len(A) != len(x):
    return False
  return True

if distinct(A):
  print("YES")
else:
  print("NO")
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
if len(a)==len(set(a)):
  print('YES')
else:
  print('NO')


# Optimized solution
def solve():
    N = int(eval(input()))
    A = set(input().split())
    
    a = len(A)
    if a == N:
        print("YES")
    elif a != N:
        print("NO")


if __name__ == '__main__':
    solve()
# Original solution
n=int(eval(input()))
l=list(map(int, input().split()))
tester=True
for i in range(n):
    for j in range(i+1,n):  
        if l[i]==l[j]:
            tester=False
            break

if tester==True:
    print('YES')
else:
    print('NO')




# Optimized solution
n=int(eval(input()))
l=list(map(int, input().split()))
s=set(l)
if len(l)==len(s):
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
a = sorted(list(map(int,input().split())))
for i in range(n-1):
    if a[i] == a[i+1]:
        print("NO")
        exit()
print("YES")

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
if len(set(a))==len(a):
    print("YES")
else:
    print("NO")
# Original solution
def func():
    return

n = int(eval(input()))
# s = input()
# a, b = map(int, input().split())
a = list(map(int, input().split()))
# a = input().split()

'''
for i in range(n-1):
    for j in range(i+1, n):
        if a[i] == a[j]:
            print("NO")
            exit()
'''
for i in range(n-1):
    if a[i] in a[i+1:]:
        print("NO")
        exit()

print("YES")

# Optimized solution
def func():
    return

n = int(eval(input()))
# s = input()
# a, b = map(int, input().split())
a = list(map(int, input().split()))
# a = input().split()

ascA = sorted(a)
for i in range(n-1):
    if ascA[i] == ascA[i+1]:
        print("NO")
        exit()

'''
for i in range(n-1):
    for j in range(i+1, n):
        if a[i] == a[j]:
            print("NO")
            exit()
'''
'''
ans = [0]*(max(a)+1)
for ida in a:
    if ans[ida] > 0:
        print("NO")
        exit()
    ans[ida] += 1
'''

print("YES")
# Original solution
import collections
import sys
N = eval(input())
A = input().split()
A1 = list(map(int,list(collections.Counter(A).values())))
for i in A1:
    if i >= 2:
        print('NO')
        sys.exit()
print('YES')

# Optimized solution
import sys
N = int(eval(input()))
A = input().split()
if N > len(set(A)):
    print('NO')
    sys.exit()
print('YES')
# Original solution
n = int(eval(input()))
a = input().split()
flag = False
for i in range(n):
    for j in range(i + 1, n):
        if a[i] == a[j]:
            flag = True
            break
    if flag:
        break

if flag:
    print("NO")
else:
    print("YES")


# Optimized solution
n = int(eval(input()))
a = [int(i) for i in input().split()]
if len(a) != len(set(a)):
    print("NO")
else:
    print("YES")
# Original solution
n = int(eval(input()))
A = list(map(int, input().split()))

r = 'YES'
for i in range(n-1):
    if A[i] in A[i+1:]:
        r = 'NO'
        break
print(r)

# Optimized solution
n = int(eval(input()))
A = list(map(int, input().split()))
print(('YES' if len(A)==len(set(A)) else 'NO'))
# Original solution
a = int(eval(input()))
b = list(map(int, input().split(" ")))
flag = True
for i in b:
  if (b.count(i) >= 2):
    flag = False

if (flag == True):
  print("YES")
else:
  print("NO")

# Optimized solution
a = int(eval(input()))
b = list(map(int, input().split(" ")))
t = set(b)
bb = list(t)

if (len(b) == len(bb)):
  print("YES")
else:
  print("NO")
# Original solution
a = int(eval(input()))
b = list(map(int, input().split(" ")))
t = set(b)
bb = list(t)

if (len(b) == len(bb)):
  print("YES")
else:
  print("NO")


# Optimized solution
N = int(eval(input()))
A = {i for i in input().split()}
print(("YES" if N==len(A) else "NO"))
# Original solution
import sys

N = int(eval(input()))
As = list(map(int, input().split()))

As.sort()
for i in range(N):
    for j in range(i + 1, N):
        if As[i] == As[j]:
            print('NO')
            sys.exit(0)
        if As[i] > As[j]:
            break

print('YES')

# Optimized solution
import sys

N = int(eval(input()))
As = list(map(int, input().split()))

As.sort()
for i in range(N):
    for j in range(i + 1, N):
        if As[i] == As[j]:
            print('NO')
            sys.exit(0)
        if As[j] > As[i]:
            break

print('YES')
# Original solution
import sys

N = int(eval(input()))
As = list(map(int, input().split()))

As.sort()
for i in range(N):
    for j in range(i + 1, N):
        if As[i] == As[j]:
            print('NO')
            sys.exit(0)
        if As[j] > As[i]:
            break

print('YES')

# Optimized solution
import sys

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

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

print('YES')
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
s = set(A)
print(('YES' if len(s)==len(A) else 'NO'))

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
s = set(A)
print(('YES' if len(A)==len(s) else 'NO'))
# Original solution
from collections import Counter

n = int(eval(input()))
a = list(map(int, input().split()))
re = 0

c = Counter(a)
new = list(c.values())

for i in new:
    if i > 1:
        re += 1

if re > 0:
    print("NO")
else:
    print("YES")


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
re = 0

from collections import Counter

c = Counter(a)

for i, v in list(c.items()):
    if v >= 2:
        re += 1

if re >= 1:
    print("NO")
else:
    print("YES")
# Original solution
N = int(eval(input()))

alist = list(map(int, input().split()))

checklist = {}

for item in alist:
    if alist.count(item) > 1:
        print('NO')
        exit(0)

print('YES')


# Optimized solution
N = int(eval(input()))

alist = input().split()

checklist = {}

for ite in alist:
    if checklist.get(ite) == '1':
        print('NO')
        exit(0)
    else:
        checklist[ite] = '1'

print('YES')
# Original solution
import itertools

n=int(eval(input()))
a=list(map(int,input().split()))

for i in itertools.combinations(a,2):
	if i[0]==i[1]:
		print("NO")
		exit()
		
print("YES")

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
s=set(a)

if n==len(s):
	print("YES")
else:
	print("NO")