Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
S = input()

r_list = []
g_list = []
b_list = []
for i, s in enumerate(S):
    if s == 'R':
        r_list.append(i)
    elif s == 'G':
        g_list.append(i)
    elif s == 'B':
        b_list.append(i)

count = 0
for a in r_list:
    for b in g_list:
        for c in b_list:
            i, j, k = sorted((a, b, c))
            if j - i != k - j:
                count += 1
print(count)

Fixed submission:
N = int(input())
S = input()

rs = set()
gs = set()
bs = set()
for i, s in enumerate(S):
    if s == 'R':
        rs.add(i+1)
    elif s == 'G':
        gs.add(i+1)
    elif s == 'B':
        bs.add(i+1)

count = 0
for i in rs:
    for j in gs:
        a = min(i, j)
        b = max(i, j)
        d = b - a
        e = 0
        if (a - d) in bs:
            e += 1
        if (b + d) in bs:
            e += 1
        if d % 2 == 0 and (b - (d // 2)) in bs:
            e += 1
        count += (len(bs) - e)
print(count)
Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

def get_d_min(a, b, X, Y):

    d = abs(a - b)
    if a == X and b == Y:
        d = 1
    elif a <= X and b > X and b <= Y:
        dd = (X - a) + (Y - b) + 1
        d = min(d, dd)
    elif a >= X and a < Y and b >= Y:
        dd = (a - X) + (b - Y) + 1
        d = min(d, dd)
    elif a > X and b < Y:
        dd = (a - X) + (Y - b) + 1
        d = min(d, dd)
    elif a < X and b > Y:
        dd = (X - a) + (b - Y) + 1
        d = min(d, dd)
    return d

N, X, Y = map(int, input().split())

comb = combinations(range(1, N + 1), 2)

counts = [0] * N
for a, b in comb:
    a, b = min(a, b), max(a, b)
    d_min = get_d_min(a, b, X, Y)
    counts[d_min] += 1

for count in counts[1:]:
    print(count)

Fixed submission:
from itertools import combinations

def get_d_min(a, b, X, Y):

    d = abs(a - b)
    if a == X and b == Y:
        d = 1
    elif a <= X and b > X and b <= Y:
        dd = (X - a) + (Y - b) + 1
        d = min(d, dd)
    elif a >= X and a < Y and b >= Y:
        dd = (a - X) + (b - Y) + 1
        d = min(d, dd)
    elif a > X and b < Y:
        dd = (a - X) + (Y - b) + 1
        d = min(d, dd)
    elif a < X and b > Y:
        dd = (X - a) + (b - Y) + 1
        d = min(d, dd)
    return d

N, X, Y = map(int, input().split())

comb = combinations(range(1, N + 1), 2)

counts = [0] * N
for a, b in comb:
    a, b = min(a, b), max(a, b)
    d_min = get_d_min(a, b, X, Y)
    counts[d_min] += 1

for count in counts[1:]:
    print(count)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
S = input()

count = 0
for i in range(1000):
    password = str(i).zfill(3)
    j = 0
    for s in S:
        if s == password[j]:
            j += 1
            if j == 3:
                count += 1
                break
print(count)

Fixed submission:
N = int(input())
S = input()

count = 0
for i in range(1000):
    password = str(i).zfill(3)
    j = 0
    for s in S:
        if s == password[j]:
            j += 1
            if j == 3:
                count += 1
                break
print(count)

Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

N = int(input())
S = input()

patterns = set(map(lambda c: ''.join(c), combinations(S, 3)))
print(len(patterns))

Fixed submission:
N = int(input())
S = input()

count = 0
for i in range(1000):
    password = str(i).zfill(3)
    j = 0
    for s in S:
        if s == password[j]:
            j += 1
            if j == 3:
                count += 1
                break
print(count)

Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

N = int(input())
S = input()

patterns = set([])
for c in combinations(S, 3):
    password = int(''.join(c))
    patterns.add(password)
print(len(patterns))

Fixed submission:
N = int(input())
S = input()

count = 0
for i in range(1000):
    password = str(i).zfill(3)
    j = 0
    for s in S:
        if s == password[j]:
            j += 1
            if j == 3:
                count += 1
                break
print(count)
Buggy python submission (verdict: Time Limit Exceeded):
S = input()

count = 0
for index, value in enumerate(S):
    if value == 'W':
        count += S[0:index].count('B')

print(count)


Fixed submission:
S = input()

count = 0
pre_index = 0
pre_count = 0
for index, value in enumerate(S):
    if value == 'W':
        n = S[pre_index:index].count('B')
        count += n + pre_count
        pre_count = n + pre_count
        pre_index = index

print(count)

Buggy python submission (verdict: Time Limit Exceeded):
S = input()

count = 0
while 'BW' in S:
    count += S.count('BW')
    S = S.replace('BW', 'WB')

print(count)


Fixed submission:
S = input()

count = 0
pre_index = 0
pre_count = 0
for index, value in enumerate(S):
    if value == 'W':
        n = S[pre_index:index].count('B')
        count += n + pre_count
        pre_count = n + pre_count
        pre_index = index

print(count)

Buggy python submission (verdict: Time Limit Exceeded):
S = input()

count = 0
while 'BW' in S:
    S = S.replace('BW', 'WB', 1)
    count += 1

print(count)

Fixed submission:
S = input()

count = 0
pre_index = 0
pre_count = 0
for index, value in enumerate(S):
    if value == 'W':
        n = S[pre_index:index].count('B')
        count += n + pre_count
        pre_count = n + pre_count
        pre_index = index

print(count)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = c = 0
i = j = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()

for i in set(s):
    for j in s:
        if i == j:
            b += 1
    c += int(b*(b-1)/2)
    b = 0

print(c)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = 1
c = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()
s.append('\0')

for i in range(1, len(s)):
    if s[i] == s[i-1]:
        b += 1
        continue
    c += int(b*(b-1)/2)
    b = 1
print(c)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = c = 0

for i in range(n):
    s.append(s[i] + a[i])

for i in set(s):
    b = s.count(i)
    if b > 1:
        c += int(b*(b-1)/2)
print(c)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = 1
c = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()
s.append('\0')

for i in range(1, len(s)):
    if s[i] == s[i-1]:
        b += 1
        continue
    c += int(b*(b-1)/2)
    b = 1
print(c)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = c = d = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()

for i in set(s):
    b = s.count(i)
    if b > 1:
        c += int(b*(b-1)/2)
print(c)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = 1
c = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()
s.append('\0')

for i in range(1, len(s)):
    if s[i] == s[i-1]:
        b += 1
        continue
    c += int(b*(b-1)/2)
    b = 1
print(c)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
count = 0
sum = 0

for i in range(0, n):
    for j in range(i, n):
        sum += a[j]
        if sum == 0:
            count += 1
    sum = 0
print(count)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = 1
c = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()
s.append('\0')

for i in range(1, len(s)):
    if s[i] == s[i-1]:
        b += 1
        continue
    c += int(b*(b-1)/2)
    b = 1
print(c)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
count = 0
sum = 0

for i in range(0, n):
    for j in range(i, n):
        sum += a[j]
        if sum == 0:
            count += 1
    sum = 0
print(count)


Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = [0]
b = 1
c = 0

for i in range(n):
    s.append(s[i] + a[i])
s.sort()
s.append('\0')

for i in range(1, len(s)):
    if s[i] == s[i-1]:
        b += 1
        continue
    c += int(b*(b-1)/2)
    b = 1
print(c)
Buggy python submission (verdict: Time Limit Exceeded):
from bisect import bisect_right


def main():
    n = int(input())
    A = sorted(list(map(int, input().split())))
    B = sorted(list(map(int, input().split())))
    C = sorted(list(map(int, input().split())))

    A_map = {}
    for a in A:
        i = bisect_right(B, a)
        B_ = B[i:]
        A_map[a] = B_
    
    B_map = {}
    for b in B:
        i = bisect_right(C, b)
        c_num = len(C) - i
        B_map[b] = c_num

    count = 0
    for a in A:
        for b in A_map[a]:
            count += B_map[b]
    print(count)


if __name__ == "__main__":
    main()


Fixed submission:
from bisect import bisect_right
from itertools import accumulate

def main():
    n = int(input())
    A = sorted(list(map(int, input().split())))
    B = sorted(list(map(int, input().split())))
    C = sorted(list(map(int, input().split())))

    B_counts = []
    for b in B:
        i = bisect_right(C, b)
        B_counts.append(len(C) - i)
    B_counts_cumsum = list(accumulate(B_counts))
    B_counts_cumsum.insert(0, 0)

    count = 0
    for a in A:
        i = bisect_right(B, a)
        if i == len(B):
            continue
        count += B_counts_cumsum[-1] - B_counts_cumsum[i]

    print(count)


if __name__ == "__main__":
    main()

Buggy python submission (verdict: Time Limit Exceeded):
from bisect import bisect_right


def main():
    n = int(input())
    A = sorted(list(map(int, input().split())))
    B = sorted(list(map(int, input().split())))
    C = sorted(list(map(int, input().split())))

    count = 0
    for a in A:
        i = bisect_right(B, a)
        B_ = B[i:]

        for b in B_:
            i = bisect_right(C, b)
            c_num = len(C) - i
            count += c_num

    print(count)


if __name__ == "__main__":
    main()


Fixed submission:
from bisect import bisect_right
from itertools import accumulate

def main():
    n = int(input())
    A = sorted(list(map(int, input().split())))
    B = sorted(list(map(int, input().split())))
    C = sorted(list(map(int, input().split())))

    B_counts = []
    for b in B:
        i = bisect_right(C, b)
        B_counts.append(len(C) - i)
    B_counts_cumsum = list(accumulate(B_counts))
    B_counts_cumsum.insert(0, 0)

    count = 0
    for a in A:
        i = bisect_right(B, a)
        if i == len(B):
            continue
        count += B_counts_cumsum[-1] - B_counts_cumsum[i]

    print(count)


if __name__ == "__main__":
    main()
Buggy python submission (verdict: Runtime Error):
n=int(input())
I=list(map(int,input().split()))
num=1000
for i in range(n-1):
    if I[i]<I[i+1]:
        p=num//I[i])
        num-=p*I[i]
        num+=p*I[i+1]

print(num)


Fixed submission:
n=int(input())
I=list(map(int,input().split()))
num=1000
for i in range(n-1):
    if I[i]<I[i+1]:
        p=num//I[i]
        num-=p*I[i]
        num+=p*I[i+1]

print(num)

Buggy python submission (verdict: Runtime Error):
n=int(input())
I=list(map(int,input().split()))
num=1000
if max(I)==I[0]:
    print("1000")
    exit()
for i in range(1,n+1):
    if I[i-1]<I[i]:
        num-=(num//I[i-1])*I[i-1]
        num+=(num//I[i-1])*I[i]

print(num)


Fixed submission:
n=int(input())
I=list(map(int,input().split()))
num=1000
for i in range(n-1):
    if I[i]<I[i+1]:
        p=num//I[i]
        num-=p*I[i]
        num+=p*I[i+1]

print(num)
Buggy python submission (verdict: Runtime Error):
N=int(input())

for h in range(1,N+1):
    num=0
    for i in range(1,N):
        for j in range(1,N):
            for k in range(1,N):
                if i**2+j**2+k**2+i*j+j*k+k*i==h:
                    num+=1
    print(num)


Fixed submission:
L,R,d=list(map(int,input().split()))
I=R-L+1
if L%d==0 and R%d==0:
    I=R-L
    print((I//d)+1)
else:
    print(I//d)

Buggy python submission (verdict: Runtime Error):
N=int(input())

for h in range(1,N+1):
    num=0
    for i in range(1,h):
        for j in range(1,h):
            for k in range(1,h):
                if i**2+j**2+k**2+i*j+j*k+k*i==h:
                    num+=1
    print(num)


Fixed submission:
L,R,d=list(map(int,input().split()))
I=R-L+1
if L%d==0 and R%d==0:
    I=R-L
    print((I//d)+1)
else:
    print(I//d)
Buggy python submission (verdict: Runtime Error):
N=int(input())
table=list(map(int,input().split()))
num=0
for i in table:
    if i%2==1 and (table[i])%2==1:
        num+=1
    print(num)


Fixed submission:
N=int(input())
table=list(map(int,input().split()))
num=0
for i in range(1,N+1):
    if i%2==1 and (table[i-1])%2==1:
        num+=1
print(num)
Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().split())
print(a*b)


Fixed submission:
S=list(map(int,input().split()))
for i in range(5):
    if S[i]==0:
        print(i+1)
Buggy python submission (verdict: Runtime Error):
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(1,101):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j-1])>abs(x-S[j]):
        T.clear()
        T.append(S[j])
print(min(T))


Fixed submission:
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(-200,200):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j-1])>abs(x-S[j]):
        T.clear()
        T.append(S[j])
print(min(T))

Buggy python submission (verdict: Runtime Error):
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(1,101):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)-1):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j])>abs(x-S[j+1]):
        T.clear()
        T.append(S[j+1])
print(min(T))


Fixed submission:
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(-200,200):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j-1])>abs(x-S[j]):
        T.clear()
        T.append(S[j])
print(min(T))

Buggy python submission (verdict: Runtime Error):
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(100):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)-1):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j])>abs(x-S[j+1]):
        T.clear()
        T.append(S[j+1])
print(min(T))


Fixed submission:
x,n=map(int,input().split())
I=list(map(int,input().split()))
S=[]
T=[]
ans=[]
for i in range(-200,200):
    S.append(i)
    if i in I:
        S.remove(i)
for j in range(len(S)):
    if j==0:
        T.append(S[0])
    elif abs(x-S[j-1])>abs(x-S[j]):
        T.clear()
        T.append(S[j])
print(min(T))
Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().input())
print(a*b)


Fixed submission:
a,b=map(int,input().split())
print(a*b)
Buggy python submission (verdict: Runtime Error):
import math
a,b,h,w=map(int,input().split())
deg_a=6*m
deg_b=30*h+m/2
deg_c=abs((deg_a)-(deg_b))
rad=math.radians(deg_c)
c**2=a**2+b**2-2*a*b*math.cos(rad)
print(c**0.5)


Fixed submission:
import math
a,b,h,m=map(int,input().split())
deg_a=6*m
deg_b=30*h+m/2
deg_c=abs((deg_a)-(deg_b))
rad=math.radians(deg_c)
c=a**2+b**2-2*a*b*math.cos(rad)
print(c**0.5)
Buggy python submission (verdict: Runtime Error):
S=str(input())
if S="ABC":
    print("ARC")
elif S="ARC":
    print("ABC")


Fixed submission:
S=str(input())
if S=="ABC":
    print("ARC")
elif S=="ARC":
    print("ABC")

Buggy python submission (verdict: Runtime Error):
S=input()
if S="ABC":
    print("ARC")
elif S="ARC":
    print("ABC")


Fixed submission:
S=str(input())
if S=="ABC":
    print("ARC")
elif S=="ARC":
    print("ABC")

Buggy python submission (verdict: Runtime Error):
S=input()
if S="ABC":
    print("ARC")
elif S="ARC":
    print("ABC")


Fixed submission:
S=str(input())
if S=="ABC":
    print("ARC")
elif S=="ARC":
    print("ABC")
Buggy python submission (verdict: Runtime Error):
N,M=map(int,input().split())
high=list(map(int,input().split()))
A=[0]*N
for i in range(M):
    a,b=map(int,input().split())
    A[a-1]=max(A[a-1],H[b-1])
    A[b-1]=max(A[b-1],H[a-1])
res=sum([H[i]>A[i] for i in range(N)])
print(res)


Fixed submission:
N,M=map(int,input().split())
H=list(map(int,input().split()))
A=[0]*N
for i in range(M):
    a,b=map(int,input().split())
    A[a-1]=max(A[a-1],H[b-1])
    A[b-1]=max(A[b-1],H[a-1])
res=sum([H[i]>A[i] for i in range(N)])
print(res)

Buggy python submission (verdict: Runtime Error):
N,M=map(int,input().split())
high=list(map(int,input().split()))
A=[0]*N
for i in range(M):
    a,b=map(int,input().split())
    A[a-1]=max(A[a-1],H[b-1])
    A[b-1]=max(A[b-1],H[a-1])
res=sum(H[i]>A[i] for i in range(N))
print(res)


Fixed submission:
N,M=map(int,input().split())
H=list(map(int,input().split()))
A=[0]*N
for i in range(M):
    a,b=map(int,input().split())
    A[a-1]=max(A[a-1],H[b-1])
    A[b-1]=max(A[b-1],H[a-1])
res=sum([H[i]>A[i] for i in range(N)])
print(res)
Buggy python submission (verdict: Time Limit Exceeded):
N=int(input())
l=[]
for h in range(N):
    s=input()
    if s not in l:
        l.append(s)
print(len(l))



Fixed submission:
N=int(input())
S=[input() for _ in range(N)]
print(len(set(S)))

Buggy python submission (verdict: Time Limit Exceeded):
N=int(input())
num=0
l=[]
for h in range(N):
    s=input()
    if s not in l:
        l.append(s)
print(len(l))


Fixed submission:
N=int(input())
S=[input() for _ in range(N)]
print(len(set(S)))
Buggy python submission (verdict: Time Limit Exceeded):
N=int(input())
A=list(map(int,input().split()))
for i in range(N):
    num=0
    for j in range(N-1):
        if i+1==A[j]:
            num+=1
    print(num)


Fixed submission:
N=int(input())
A=list(map(int,input().split()))
result=[0]*N
for a in A:
    result[a-1]+=1
print("\n".join(map(str,result)))

Buggy python submission (verdict: Time Limit Exceeded):
N=int(input())
A=list(map(int,input().split()))
for i in range(N):
    num=0
    for j in range(N-1):
        if i+1==A[j]:
            num+=1
    print(num)


Fixed submission:
N=int(input())
A=list(map(int,input().split()))
result=[0]*N
for a in A:
    result[a-1]+=1
print("\n".join(map(str,result)))
Buggy python submission (verdict: Runtime Error):
n=map(int,input().split())
num=0
for i in range(n):
    if (i%3!=0) and (i%5!=0):
        num+=i
print(num)


Fixed submission:
n=int(input())
num=0
for i in range(1,n+1):
    if (i%3!=0) and (i%5!=0):
        num+=i
print(num)

Buggy python submission (verdict: Runtime Error):
n=map(int,input().split())
for i in range(n):
    if (i%3==0) and (i%5==0):
        print("FizzBuzz")
    elif (i%3==0) and (i%5!=0):
        print("Fizz")
    elif (i%3!=0) and (i%5==0):
        print("Buzz")
    else:
        print(i)
    


Fixed submission:
n=int(input())
num=0
for i in range(1,n+1):
    if (i%3!=0) and (i%5!=0):
        num+=i
print(num)
Buggy python submission (verdict: Time Limit Exceeded):
N,K=map(int,input().split())
while True:
    num=abs(N-K)
    if num<N:
        N=num
    else:
        print(N)
        exit()


Fixed submission:
N,K=map(int,input().split())
print(min(N%K,-N%K))
Buggy python submission (verdict: Time Limit Exceeded):
n,a,b=map(int,input().split())
num=0
while n>0:
    if (n<a+b) and (n<a):
        num+=n
        break
    if (n<a+b) and (n>a):
        num+=a
        break
    n-=a+b
    num+=a
print(num)


Fixed submission:
n,a,b=map(int,input().split())
ans=n//(a+b)*a
rem=n%(a+b)
ans+=min(rem,a)
print(ans)
Buggy python submission (verdict: Runtime Error):
import math
a,b=map(int,input().split())
ans=[]
for i in range(1251):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        ans.append(i)
print(min(ans))


Fixed submission:
import math
a,b=map(int,input().split())
ans=[]
for i in range(1251):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        ans.append(i)
if len(ans)!=0:
    print(min(ans))
else:
    print("-1")

Buggy python submission (verdict: Runtime Error):
import math
a,b=map(int,input().split())
ans=[]
for i in range(1250):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        ans.append(i)
print(min(ans))


Fixed submission:
import math
a,b=map(int,input().split())
ans=[]
for i in range(1251):
    if math.floor(i*0.08)==a and math.floor(i*0.1)==b:
        ans.append(i)
if len(ans)!=0:
    print(min(ans))
else:
    print("-1")
Buggy python submission (verdict: Runtime Error):
a,b,c=map(int,input().split())
if (a==b!=c) or (a!=b==c) or (a==c!=b):
    print("Yes")
else:
    prnit("No")


Fixed submission:
a,b,c=map(int,input().split())
if (a==b!=c) or (a!=b==c) or (a==c!=b):
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
S,T=map(str,input().split())
A,B=map(str,input().split())
U=str(input())
if U==S:
    A-=1
elif U==T:
    B-=1
print(A, B)


Fixed submission:
S,T=map(str,input().split())
A,B=map(int,input().split())
U=str(input())
if U==S:
    A-=1
elif U==T:
    B-=1
print(A, B)
Buggy python submission (verdict: Runtime Error):
n=int(input())
table=sorted(list(map(int,input().split())))
for i in range(n):
    if table[i]==table[i+1]:
        print("NO")
        exit()
print("YES")


Fixed submission:
n=int(input())
table=sorted(list(map(int,input().split())))
for i in range(n-1):
    if table[i]==table[i+1]:
        print("NO")
        exit()
print("YES")

Buggy python submission (verdict: Time Limit Exceeded):
n=int(input())
table=sorted(list(map(int,input().split())))
for i in range(n):
    for j in range(n):
        if (table[i]==table[j]) and (i!=j) :
            print("NO")
            exit()
print("YES")


Fixed submission:
n=int(input())
table=sorted(list(map(int,input().split())))
for i in range(n-1):
    if table[i]==table[i+1]:
        print("NO")
        exit()
print("YES")

Buggy python submission (verdict: Time Limit Exceeded):
n=int(input())
table=list(map(int,input().split()))
for i in range(n):
    for j in range(n):
        if (table[i]==table[j]) and (i!=j) :
            print("NO")
            exit()
print("YES")


Fixed submission:
n=int(input())
table=sorted(list(map(int,input().split())))
for i in range(n-1):
    if table[i]==table[i+1]:
        print("NO")
        exit()
print("YES")
Buggy python submission (verdict: Runtime Error):
I="abcdefghijklmnopqrstuvwxyz"
for i in range(25):
    if I[i]==input():
        print(I[i+1])


Fixed submission:
S=input()
I="abcdefghijklmnopqrstuvwxyz"
for i in range(26):
    if S==I[i]:
        print(I[i+1])
        exit()