CodeEff/ECCO huggingface dataset:
# Original solution
import itertools
n = int(eval(input()))
a = list(map(int,input().split()))
v = itertools.combinations(a,2)
for item in v:
    if item[0] == item[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
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(set(A))
print(('YES' if sorted(A) == sorted(B) else 'NO'))

# Optimized solution
N = int(eval(input()))
print(('YES' if N == len(set(input().split())) else 'NO'))
# Original solution
hoge = int(eval(input()))
n = list(map(int,input().split()))
ans = "YES"
count = 0

for i in n :
    
    for j in n :
        if i == j :
            count += 1
    
    if count >= 2 :
        ans = "NO"
    
    count = 0

print(ans)

# Optimized solution
hoge = int(eval(input()))
n = list(map(int,input().split()))

ans = "YES" if len(n) == len(set(n)) else "NO"
print(ans)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
for i in a:
    if a.count(i) >= 2:
        print("NO")
        exit()
print("YES")


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = set(a)
a.sort()
if len(a) != len(b):
    print("NO")
else:
    print("YES")
# Original solution
n=int(eval(input()))
a=list(map(int, input().split()))
is_yes = True
for i, a_i in enumerate(a):
  for j, a_j in enumerate(a[i+1:]):
    if a_i == a_j:
      is_yes = False
      break
if is_yes:
  print("YES")
else:
  print("NO")

# Optimized solution
n=int(eval(input()))
a=list(map(int, input().split()))
is_yes = True
a_m = {}
for a_i in a:
  if a_i in a_m:
    is_yes = False
    break
  a_m[a_i]=True
if is_yes:
  print("YES")
else:
  print("NO")
# Original solution
n = int(eval(input()))
num = list(map(int, input().split()))
ans = "YES"
lis = []
for i in num:
  if not i in lis:
    lis.append(i)
  else:
    ans="NO"
    break
    
print(ans)

# Optimized solution
n = int(eval(input()))
num = list(map(int, input().split()))
lenbef = len(num)
numset = set(num)
lenaft = len(numset)

if lenbef == lenaft:
  print("YES")
else:
  print("NO")
# Original solution
n = int(eval(input()))
num = list(map(int, input().split()))
lenbef = len(num)
numset = set(num)
lenaft = len(numset)

if lenbef == lenaft:
  print("YES")
else:
  print("NO")

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

count = 0
list00 = []
for i in range(0,n):
  if a[i] in list00:
    count = count
  else:
    count = count + 1
    list00.append(a[i])
if count == n:
  print('YES')
else:
  print('NO')
  

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

count = 0
list00 = sorted(a)
for i in range(1, n):
  if list00[i-1] == list00[i]:
    count = count*0
  else:
    count = count + 1

if count == n-1:
  print('YES')
else:
  print('NO')
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
b = set(a)
a = len(a)
b = len(b)


if a == b:
    print("YES")
else:
    print("NO")

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

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

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

mou = set([])
for i in range(n):
    if a[i] not in mou:
        mou.add(a[i])
    else:
        print('NO')
        exit()
print('YES')

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

if n == len(a):
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
m = []
for i in range(n):
  if a[i] in m:
    print('NO')
    exit(0)
  m.append(a[i])
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(0)
print('YES')
# Original solution
count = 0
flag = 0

def merge(a, left, mid, right):
    global count
    L = [0] * (mid - left + 1)
    R = [0] * (right - mid + 1)

    for i in range(len(L)):
        if i  == len(L) - 1:
            L[i] = float('inf')
        else:
            L[i] = a[left+i]
    
    for i in range(len(R)):
        if i == len(R) - 1:
            R[i] = float('inf')
        else:
            R[i] = a[mid+i]

    i = 0
    j = 0
    for k in range(left, right):
        if L[i] <= R[j]:
            a[k] = L[i]
            i += 1
        else:
            if i != len(L) - 1 and j != len(R) - 1:
                count += len(L) - i - 1
            a[k] = R[j]
            j += 1

def mergeSort(a, left, right):
    if left+1 < right:
        mid = int((left + right) / 2)
        mergeSort(a, left, mid)
        mergeSort(a, mid, right)
        merge(a, left, mid, right)

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

mergeSort(a, 0, n)

for i in range(len(a)-1):
    x = a[i]
    y = a[i+1]

    if x == y:
        flag = 1
        break

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

# Optimized solution
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()))
now = set([])
for i in a:
    if i in now:
        print('NO')
        exit()
    now.add(i)
print('YES')

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
now = set()
for i in a:
    now.add(i)
if len(now) == n:
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
now = set()
for i in a:
    now.add(i)
if len(now) == 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 = eval(input())
A = list(map(int,input().split( )))

for idx,i in enumerate(A):
    for j in A[idx+1:]:
        if i==j:
            print('NO')
            exit()
    
print('YES')

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

if len(set(A))==len(A):
    print('YES')
else:
    print('NO')
# Original solution
N=int(eval(input()))
A=[int(i) for i in input().split(" ")]
memo=[]
for a in A:
    if a in memo:
        print("NO")
        break
    else:
        memo+=[a]
else:
    print("YES")


# Optimized solution
N=int(eval(input()))
A=[int(i) for i in input().split(" ")]
memo={}
for a in A:
    if a in memo:
        print("NO")
        break
    else:
        memo[a]=1
else:
    print("YES")
# Original solution
def main():
    N = int(eval(input()))
    A = [int(i) for i in input().split()]
    s = set(A)
    if N == len(s):
        print("YES")
    else:
        print("NO")


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    N = int(input())
    A = [int(i) for i in input().split()]
    A.sort()
    for i in range(N-1):
        if A[i] == A[i+1]:
            return print("NO")
    print("YES")


if __name__ == '__main__':
    main()
# Original solution
N = int(eval(input()))
A = input().split()

cnt = 0

for i in range(1, N):
    x = A[0:i]
    y = A[i:N]
    
    for _x in x:
        if _x in y:
            cnt += 1
        
if cnt > 0:
    result = 'NO'
else:
    result = 'YES'
        
print(result)

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

A_set = set(A)

if len(A) == len(A_set):
    print('YES')
else:
    print('NO')
# Original solution
n = eval(input())
a = list(map(int, input().split()))
ans = 'YES'
b = []
for i in a:
    if i in b:
        ans = 'NO'
    else:
        b.append(i)
print(ans)

# Optimized solution
n = eval(input())
a = list(map(int, input().split()))
def has_duplicates(seq):
    return len(seq) != len(set(seq))
if has_duplicates(a):
    print('NO')
else:
    print('YES')
# Original solution
n = int(eval(input()))
numbers = list(map(int, input().split()))
for i in range(n):
  for j in range(i+1, n-i):
    if numbers[i] == numbers[j]:
      print("NO")
      exit()
else:
  print("YES")


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


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

if __name__ == '__main__':
    main()
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
sA = set(A)
print(("YES" if len(sA) == N else "NO"))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
print(("YES" if len(set(A)) == N else "NO"))
# Original solution
import sys
N = int(eval(input()))
A = list(map(int, input().split()))

for i in range(len(A)):
    for j in range(i+1, len(A)):
        if A[i] == A[j]:
            print('NO')
            sys.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
N=eval(input())
A=input().split()
if(sorted(set(A), key=A.index)==A):
  print("YES")
else:
  print("NO")


# Optimized solution
N=eval(input())
A=input().split()
def has_duplicates(seq):
    return len(seq) != len(set(seq))
if has_duplicates(A):
  print("NO")
else:
  print("YES")
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
B = "YES"
for i in range(1,N):
    if sorted(A)[i] == sorted(A)[i-1]:
        B ="NO"
        break
print(B)

# 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
i=int(eval(input()))
x=[int(x) for x in input().split()]
for i in x:
  if x.count(i)>1:
    c=0
    break
  else:
      c=1
if(c==1):
    print("YES")
elif(c==0):
    print("NO")      

# Optimized solution
i=int(eval(input()))
x=[int(x) for x in input().split()]
y=set(x)
if(len(y)==len(x)):
    print("YES")
else:
    print("NO")
# Original solution
N = int(eval(input()))
A = input().split()
flag = 1

for j in range(N):
	for i in range(N):
		if i+j+1<N:
			if A[j] == A[i+j+1]:
				flag = 0
				break
if flag==0:
	print('NO')
elif flag==1:
	print('YES')



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

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

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

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

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

if(has(A)):
    print('NO')
else:
    print('YES')
# Original solution
n = int(eval(input()))
a = [int(v) for v in input().split()]
a.sort()
a.append(-1)
d = 1
for i in range(0, n):
    if(a[i] == a[i + 1]):
        d = 0
        print("NO")
        break
if(d == 1):
    print("YES")


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


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

for p in range(n):
    i = p + 1
    while i < n:
        if a[p] == a[i]:
            y = False
            break
        i += 1
        
if y:
    print('YES')
else:
    print('NO')

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
list.sort(a)
y = True

for i in range(n - 1):
    if a[i] == a[i + 1]:
        y = False
        break
        
if y:
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
list.sort(a)
y = True

for i in range(n - 1):
    if a[i] == a[i + 1]:
        y = False
        break
        
if y:
    print('YES')
else:
    print('NO')

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = list(set(a))
m = len(b)
if n == m:
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
countalist = []
for i in a:
  countalist.append(a.count(i))
if max(countalist) >= 2:
  print('NO')
else:
  print('YES')

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
sorta = sorted(a)
sflag = False
for i in range(n - 1):
  if sorta[i] == sorta[i + 1]:
    sflag = True
    break
if sflag == True:
  print('NO')
else:
  print('YES')
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
d=0
for i in range(n):
    if a.count(a[i])>=1.5:
        d=1
        break
if d==0:
    print("YES")
else:
    print("NO")


# Optimized solution
n=int(eval(input()))
a=set(map(int,input().split()))
b=len(a)
if n==b:
    print("YES")
else:
    print("NO")
# Original solution
n = eval(input())
nums = list(input().split(' '))
if [x for x in set(nums) if nums.count(x) > 1]:
    print("NO")
else:
    print("YES")

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

flg = True

s = []



for i in a:
    if i in s:
        flg = False
        break

    s.append(i)


        
if flg:
    print('YES')
else:
    print('NO')

# Optimized solution
def has_duplicates(seq):
    return len(seq) != len(set(seq))


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

flg = has_duplicates(a)

if not flg:
    print('YES')
else:
    print('NO')
# Original solution
def distinct_or_not(a_list):
    tmp_list = []
    for a in a_list:
        if len(tmp_list) == 0:
            tmp_list.append(a)
        else:
            left = 0
            right = len(tmp_list) - 1
            while left <= right:
                mid = (left + right) // 2
                if tmp_list[mid] == a:
                    return 'NO'
                elif tmp_list[mid] > a:
                    right = mid - 1
                else:
                    left = mid + 1
            tmp_list.insert(right+1, a)
    return 'YES'

n = int(eval(input()))
a_list = [int(a) for a in input().split()]

print((distinct_or_not(a_list)))

# Optimized solution
def distinct_or_not_2(a_list):
    a_list.sort()
    for i in range(len(a_list)-1):
        if a_list[i] == a_list[i+1]:
            return 'NO'
    return 'YES'

n = int(eval(input()))
a_list = [int(a) for a in input().split()]

print((distinct_or_not_2(a_list)))
# Original solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32

YES = "YES"  # type: str
NO = "NO"  # type: str

def solve(N: int, A: "List[int]"):
    from collections import Counter
    c = Counter(A)
    if len([k for k,v in list(c.items()) if v != 1]) == 0:
        print(YES)
    else:
        print(NO)
    return



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
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)

if __name__ == '__main__':
    main()


# Optimized solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32

YES = "YES"  # type: str
NO = "NO"  # type: str

def solve(N: int, A: "List[int]"):
    if len(list(set(A))) == N:
        print(YES)
    else:
        print(NO)
    return



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
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)

if __name__ == '__main__':
    main()
# Original solution
n = int(eval(input()))
a = input().split()
ans = 'YES'

for i in range(n):
    if ans == 'NO':
        break;
    for j in range(i + 1, n):
        if a[i] == a[j]:
            ans = "NO"
            break;

print(ans)

# Optimized solution
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()))
s=0
for i in range(0,N):
    for j in range(i+1,N):
        if A[i]==A[j]:
            s=s+1
if s==0:
    print("YES")
else:
    print("NO")

# 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() ) )

exsit = []

ans = "YES"
for i in a:
  if i in exsit:
    ans = "NO"
    break
  else:
    exsit.append( i )

print( ans )

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

if n == len(a):
  ans = "YES"
else:
  ans = "NO"

print( ans )
# Original solution
n = int( eval(input()) )
a = set( map( int, input().split() ) )

if n == len(a):
  ans = "YES"
else:
  ans = "NO"

print( ans )

# 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()))
l = list(map(int, input().split()))

x = "YES"
k = 0
for i in l:
  k += 1
  for j in l[k:]:
    if i == j:
      x = "NO"
      break

print(x)

# Optimized solution
n = int(eval(input()))
l = list(map(int, input().split()))

A = len(l)
B = len(set(l))
if A == B:
  print("YES")
else:
  print("NO")
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in range(n):
  if a.count(a[i])>=2:
    ans=1
    break
if ans==1:
  print('NO')
else:
  print('YES')

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

    else:
        a.append(A[i])
        if i==N-1:print('YES')

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

        break
    elif i==N-2:print("YES")
# Original solution
N = (int)(eval(input()))
A = list(map(int, input().split()))

def hash(a):
    return a%100


def check(A):
    for i in range(len(A)):
        for j in range(i, len(A)):
            if(j+1 < len(A)):
                if(A[i] == A[j+1]):
                    # print("%d=%d"%(A[i], A[j]))
                    flag = True
                    return 'NO'

    return 'YES'

arr = [[] for i in range(100)]

for i in A:
    arr[hash(i)].append(i)

for i in arr:
    flag = False
    if(check(i) == "NO"):
        print("NO")
        flag = True
        break
if(not flag):
    print("YES")

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

A.sort()
# print(A)
flag = False
for i in range(len(A)):
    if(i+1 < len(A)):
        if(A[i] == A[i+1]):
            print("NO")
            flag = True
            break
if(not flag):
    print("YES")
# Original solution
N = int(eval(input()))
A_ls = list(map(int, input().split(' ')))
rst = set()
for i in A_ls:
    rst.add(i)
if len(rst) == N:
    print('YES')
else:
    print('NO')

# Optimized solution
N = int(eval(input()))
A_ls = list(input().split(' '))
A_set = { i for i in A_ls }
if len(A_set) == N:
    print('YES')
else:
    print('NO')
# Original solution
N = int(eval(input()))
A_ls = list(map(int, input().split(' ')))
rst = { i for i in A_ls }
if len(rst) == N:
    print('YES')
else:
    print('NO')

# Optimized solution
N = int(eval(input()))
A_ls = input().split(' ')
A_set = { i for i in A_ls }
if len(A_set) == N:
    print('YES')
else:
    print('NO')
# Original solution
N = int(eval(input()))
A_ls = input().split(' ')
A_set = { i for i in A_ls }
if len(A_set) == N:
    print('YES')
else:
    print('NO')

# Optimized solution
N = int(eval(input()))
ls = input().split(' ')
dic = { i for i in ls }
if len(dic) == N:
    print('YES')
else:
    print('NO')
# Original solution
n = int(eval(input()))
l = list(map(int,input().split()))
if len(l) == len(set(l)):
    print ("YES")
else:
    print ("NO")

# Optimized solution
n = int(input())
l = list(input().split())
print ("YES") if len(l) == len(set(l)) else print ("NO")
# Original solution
from collections import defaultdict
n = int(eval(input()))
d = defaultdict(int)
A = list(map(int,input().split()))

for a in A:
    if d[a] == 1:
        print('NO')
        exit()
    else:
        d[a] += 1

print('YES')


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

# Optimized solution
N = int(eval(input()))
s = list(map(int,input().split()))
count = 0
s.sort()

for i in range(N - 1):
  if s[i] == s[i + 1]:
    print("NO")
    count += 1
    break
    
if count == 0:
  print("YES")
# Original solution
n = eval(input())
lst = input().split()
isTrue = True

for i in lst:
  if lst.count(i) > 1:
    print('NO')
    isTrue = False
    break

if isTrue == True:
  print('YES')

# Optimized solution
n = eval(input())
lst = input().split()
sett = set(lst)

if len(lst) == len(sett):
  print('YES')
else:
  print('NO')
# Original solution
import sys
 
 
def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n = int(readline())
    a = list(map(int, readline().split()))
    a.sort()
    for i in range(1, n):
        if a[i] == a[i-1]:
            print("NO")
            exit()
    print("YES")
 
 
if __name__ == '__main__':
    solve()


# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
flg=0
if len(set(A))==N:
    flg=1
print(("YES" if flg else "NO"))
# 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()))

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 = list(map(int, input().split()))

for i in range(N-1):
    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()))

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

print('YES')