Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
def main():
    k = int(input())
    k1 = k + 1

    sum = 0
    for i in range(1, k1):
        for j in range(1, k1):
            for m in range(1, k1):
                sum += math.gcd(math.gcd(i, j), m)
    print(sum)

main()

Fixed submission:
import math


def main():
    k = int(input())
    k1 = k + 1

    sum = 0
    for i in range(1, k1):
        for j in range(1, k1):
            for m in range(1, k1):
                sum += math.gcd(math.gcd(i, j), m)
    print(sum)

main()
Buggy python submission (verdict: Time Limit Exceeded):
x, k = [int(i) for i in input().split()]
for i in range(10000000000):
    if x <= abs(x-k):
        print(x)
        break
    else:
        x = abs(x-k)
        continue

Fixed submission:
x, k = [int(i) for i in input().split()]
ans = min(x%k, k - x%k)
print(ans)
Buggy python submission (verdict: Runtime Error):
from scipy.special import comb

n = int(input())
A = []
A = [int(i) for i in input().split()]

number_set = list(set(A))
#print("number set is :", number_set)    
    
for k in range(n):
    out = 0
    ans = []
    ans += A[0:k]
    ans += A[k+1:n]
    #print(ans)
    for i in range(len(number_set)):
        #print(ans.count(number_set[i]))
        out += comb(ans.count(number_set[i]), 2 ,exact = True)
        
    print(out)    
    

Fixed submission:
import collections
N = int(input())
li = list(map(int, input().split()))
cn = collections.Counter(li)
sumC = sum([n*(n-1)//2 for n in cn.values()])
for k in range(N):
    print(sumC - (cn[li[k]]-1))
Buggy python submission (verdict: Time Limit Exceeded):
k,n=map(int,input().split())
home = input()
home = home.split()
for i in range(len(home)):
    home[i] = int(home[i])

def search(i,home,l):
    d = 0
    leng = len(home)
    count=0
    while True:
        if count==leng-1:
            break
        j=i+1
        if j==leng:
            d+=home[0]+k-home[i]
            count+=1
            continue
        d += home[i+1]-home[i]
        count+=1
        i+=1
        if i == leng:
            i=0
    d2=0
    while True:
        if count==leng-1:
            break
        j=i-1
        if j==-1:
            d2+=home[leng-1]-home[0]+k
            count+=1
            continue
        d2 += home[i-1]-home[i]
        count+=1
        i+=1
        if i == -1:
            i=leng-1
    if d<=d2:
        l.append(d2)
    else:
        l.append(d)
    return
        


l=[]
for i in range(len(home)):
    search(i,home,l)
print(min(l))
    

Fixed submission:
k,n=map(int,input().split())
home = input()
home = home.split()
for i in range(len(home)):
    home[i] = int(home[i])
d=[]
for i in range(len(home)):
    if i == len(home)-1:
        d.append(home[0]+k-home[i])
        break
    d.append(home[i+1]-home[i])
Max = max(d)
leng=len(home)
count=0
for i in range(len(d)):
    if d[i] == Max:
        break
d=0
while True:
    
    if count==leng-1:
        break
    j=i-1
    if i==0:
        d+=abs(home[leng-1]-(home[0]+k))
        count+=1
    else:
        d += abs(home[i]-home[i-1])
        count+=1
    i-=1
    if i == -1:
        i=leng-1
print(d)
Buggy python submission (verdict: Runtime Error):
A,B,M=map(int,input().split())

al=[]
a=input().split()
for i in a:
    al.append(int(i))
bl = []
b=input().split()
for i in b:
    bl.append(int(i))
l=[]
cl=[]
for i in range(M):
    c = input().split()
    for i in c:
        l.append(int(i))
    cl.append(l)

l=[]
for cl in cl:
    a=0
    a=al[cl[0]]+bl[cl[1]]-cl[2]
    l.append(a)

print(min(a))
        
    

Fixed submission:
A,B,M=map(int,input().split())

al=[]
a=input().split()
for i in a:
    al.append(int(i))
bl = []
b=input().split()
for i in b:
    bl.append(int(i))

cl=[]
for i in range(M):
    l=[]
    c = input().split()
    for i in c:
        l.append(int(i))
    cl.append(l)
    
l=[]
for i in cl:
    a=0
    a=al[i[0]-1]+bl[i[1]-1]-i[2]
    l.append(a)

Min=min(al) + min(bl)
if min(l) < Min:
    print(min(l))
else:
    print(Min)

Buggy python submission (verdict: Runtime Error):
A,B,M=map(int,input().split())

al=[]
a=input().split()
for i in a:
    al.append(int(i))
bl = []
b=input().split()
for i in b:
    bl.append(int(i))
l=[]
cl=[]
for i in range(M):
    c = input().split()
    for i in c:
        l.append(int(i))
    cl.append(l)

l=[]
for cl in cl:
    a=0
    a=al[cl[0]]+bl[cl[1]]-cl[2]
    l.append(a)

print(a)
        
    

Fixed submission:
A,B,M=map(int,input().split())

al=[]
a=input().split()
for i in a:
    al.append(int(i))
bl = []
b=input().split()
for i in b:
    bl.append(int(i))

cl=[]
for i in range(M):
    l=[]
    c = input().split()
    for i in c:
        l.append(int(i))
    cl.append(l)
    
l=[]
for i in cl:
    a=0
    a=al[i[0]-1]+bl[i[1]-1]-i[2]
    l.append(a)

Min=min(al) + min(bl)
if min(l) < Min:
    print(min(l))
else:
    print(Min)
Buggy python submission (verdict: Runtime Error):
N,M= [int(x) for x in input().split()]

root = list(range(N))

for i in range(M):
    A,B = [int(x)-1 for x in input().split()]
    a = root[A]
    b = root[B]
    if a<b:
        root = [a if i == b else i for i in root]
    if b<a:
        root = [b if i == a else i for i in root]

print(len(set(root))-1)


Fixed submission:
N = int(input())

print("ACL"*N)
Buggy python submission (verdict: Runtime Error):
D,T,S =(int(x) for x in input().split(","))

if (D<=T*S):
    print("Yes")
else:
    print("No")


Fixed submission:
D,T,S =(int(x) for x in input().split())

if (D<=T*S):
    print("Yes")
else:
    print("No")

Buggy python submission (verdict: Runtime Error):
D,T,S =(int(x) for x in input().split(","));

if (D<=T*S):
    print("Yes");
else:
    print("No");


Fixed submission:
D,T,S =(int(x) for x in input().split())

if (D<=T*S):
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
a,b,c,d=map(int,input().split());print(max(0,min(c,d)-max(a,b))

Fixed submission:
a,b,c,d=map(int,input().split());print(max(0,min(b,d)-max(a,c)))
Buggy python submission (verdict: Runtime Error):
import math;n=int(input());g=int(input())
for i in range(n-1):t=int(input());g=g*t//math.gcd(g,t)
print(g)


Fixed submission:
import fractions;n=int(input());g=int(input())
for i in range(n-1):t=int(input());g=g*t//fractions.gcd(g,t)
print(g)
Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d=map(int,input().split())
c-=a
d-=b
g=math.gcd(max(c,d),min(c,d))
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)

Fixed submission:
def gcd(a,b):
	if b==0:return a
	return gcd(b,a%b)
a,b,c,d=map(int,input().split())
c=abs(c-a)
d=abs(d-b)
g=gcd(max(c,d),min(c,d))
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)

Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d=map(int,input().split())
c-=a
d-=b
g=math.gcd(c,d)
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)

Fixed submission:
def gcd(a,b):
	if b==0:return a
	return gcd(b,a%b)
a,b,c,d=map(int,input().split())
c=abs(c-a)
d=abs(d-b)
g=gcd(max(c,d),min(c,d))
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)

Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d=map(int,input().split())
c-=a
d-=b
g=math.gcd(c,d)
j=c//g
k=d//g
print((j+k-1)*g)

Fixed submission:
def gcd(a,b):
	if b==0:return a
	return gcd(b,a%b)
a,b,c,d=map(int,input().split())
c=abs(c-a)
d=abs(d-b)
g=gcd(max(c,d),min(c,d))
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)

Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d=map(int,input().split())
c-=a;d-=b;
g=math.gcd(c,d)
j=c//g;k=d//g
print((j+k-1)*g)

Fixed submission:
def gcd(a,b):
	if b==0:return a
	return gcd(b,a%b)
a,b,c,d=map(int,input().split())
c=abs(c-a)
d=abs(d-b)
g=gcd(max(c,d),min(c,d))
j=int(c/g)
k=int(d/g)
print((j+k-1)*g)
Buggy python submission (verdict: Runtime Error):
N = int(input())
A = int(input())
B = int(input())
num = []*3
for i in range(N):
    score = int(input())
    if (score <= A):
        num[0] += 1
    elif(score <= B):
        num[1] += 1
    else:
        num[2] +=1
max_value = 0
for i in range(3):
    if max_value < num[i]:
        max_value = num[i]
print(max_value)

Fixed submission:
N = int(input())
A,B=(int(x) for x in input().split())
scores = input().split()
num = [0,0,0]
for i in range(N):
    score = int(scores[i])
    if (score <= A):
        num[0] += 1
    elif(score <= B):
        num[1] += 1
    else:
        num[2] += 1
max_value = num[2]
for i in range(2):
    if max_value > num[i]:
        max_value = num[i]
print(max_value)

Buggy python submission (verdict: Runtime Error):
N = int(input())
A = int(input())
B = int(input())
num = []*3
for i in range(N):
    score = int(input())
    if (score <= A):
        num[0] += 1
    elif(score <= B):
        num[1] += 1
    else:
        num[2] +=1
print(min(num))


Fixed submission:
N = int(input())
A,B=(int(x) for x in input().split())
scores = input().split()
num = [0,0,0]
for i in range(N):
    score = int(scores[i])
    if (score <= A):
        num[0] += 1
    elif(score <= B):
        num[1] += 1
    else:
        num[2] += 1
max_value = num[2]
for i in range(2):
    if max_value > num[i]:
        max_value = num[i]
print(max_value)
Buggy python submission (verdict: Runtime Error):
N = int(input())
sum = int(N % 10) + (int(N/10))
if sum % 9 != 0:
    print("No")
else:
    print("Yes")

Fixed submission:
N = int(input())
x = N //1000
x1 = (N - x*1000)//100
x2 = (N - x*1000 - x1*100)//10
x3 = N - x*1000 - x1*100 - x2*10
sum = x+x1+x2+x3
if sum % 9 != 0:
    print("No")
else:
    print("Yes")

Buggy python submission (verdict: Runtime Error):
N = int(input())
sum = int(N % 10) + (int(N/10))
if sum % 9 == 0:
    print("Yes")
else:
    print("No")

Fixed submission:
N = int(input())
x = N //1000
x1 = (N - x*1000)//100
x2 = (N - x*1000 - x1*100)//10
x3 = N - x*1000 - x1*100 - x2*10
sum = x+x1+x2+x3
if sum % 9 != 0:
    print("No")
else:
    print("Yes")

Buggy python submission (verdict: Runtime Error):
N = int(input())
sum = 0
while (N != 0):
    sum = sum + int(N % 10)
    N = int(N / 10)
if sum%9 == 0:
    print("Yes")
else:
    print("No")

Fixed submission:
N = int(input())
x = N //1000
x1 = (N - x*1000)//100
x2 = (N - x*1000 - x1*100)//10
x3 = N - x*1000 - x1*100 - x2*10
sum = x+x1+x2+x3
if sum % 9 != 0:
    print("No")
else:
    print("Yes")
Buggy python submission (verdict: Runtime Error):
X, Y = map(int, input().split())
ans = 'No'
for a in range(X + 1):
    b = X - a
    if 2 * a + 4 * b == Y:
        ans = 'Yes'
        print(ans)


Fixed submission:
X = list(map(int, input().split()))
if X[0] == 0:
    print(1)
elif X[1] == 0:
    print(2)
elif X[2] == 0:
    print(3)
elif X[3] == 0:
    print(4)
else:
    print(5)
Buggy python submission (verdict: Runtime Error):
a,b,c,k = list(map(input(),split()))
if a+b >= k:
  print(min(a,k))
else:
  print(a-(k-a-b))

Fixed submission:
a,b,c,k = list(map(int,input().split()))
if a+b >= k:
  print(min(a,k))
else:
  print(a-(k-a-b))
Buggy python submission (verdict: Runtime Error):
h,n = map(int,input().split())
a = list(map(int,input().split()))
p = sum(a)
print("Yes" if h < =p else "No")

Fixed submission:
h,n = map(int,input().split())
a = list(map(int,input().split()))
p = sum(a)
print("Yes" if h <= p else "No")
Buggy python submission (verdict: Runtime Error):
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse = True)
for i in range(k):
    h[i] = 0
print(sum(h))

Fixed submission:
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse = True)
for i in range(min(n,k)):
    h[i] = 0
print(sum(h))

Buggy python submission (verdict: Runtime Error):
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort()
for i in range(k):
    h[i] = 0
print(sum(h))

Fixed submission:
n,k = map(int,input().split())
h = list(map(int,input().split()))
h.sort(reverse = True)
for i in range(min(n,k)):
    h[i] = 0
print(sum(h))
Buggy python submission (verdict: Runtime Error):
L,R = map(int,input().split())
def judge_distance(i,j):
    if j-i >= 2019:
        return True

def search_2019(i,j):
    res = False
    for p in range(j-i+1):
        if i+p % 2019 == 0:
            res = True
            exit()

if judge_distance(L,R) or search_2019(L,R):
    print(0)
else:
    mincount = float("inf")
    for i in range(L,R):
        for j in range(L+1,R+1):
            if i*j%2019 <= mincount:
                mincount = (i*j)%2019

print(mincount)

Fixed submission:
L,R = map(int,input().split())
def judge_distance(i,j):
    if j-i >= 2019:
        return True

def search_2019(i,j):
    res = False
    for p in range(j-i+1):
        if i+p % 2019 == 0:
            res = True
            exit()

if judge_distance(L,R) or search_2019(L,R):
    print(0)
else:
    mincount = float("inf")
    for i in range(L,R):
        for j in range(L+1,R+1):
            if i*j%2019 <= mincount:
                mincount = (i*j)%2019

    print(mincount)

Buggy python submission (verdict: Runtime Error):
L,R = map(int,input().split())
def judge_distance(i,j):
    if j-i >= 2019:
        return True

def search_2019(i,j):
    for p in range(j-i+1):
        if i+p % 2019 == 0:
            return True

if judge_distance(L,R) or search_2019(L,R):
    print(0)
else:
    mincount = float("inf")
    for i in range(L,R):
        for j in range(L+1,R+1):
            if i*j%2019 <= mincount:
                mincount = (i*j)%2019

print(mincount)

Fixed submission:
L,R = map(int,input().split())
def judge_distance(i,j):
    if j-i >= 2019:
        return True

def search_2019(i,j):
    res = False
    for p in range(j-i+1):
        if i+p % 2019 == 0:
            res = True
            exit()

if judge_distance(L,R) or search_2019(L,R):
    print(0)
else:
    mincount = float("inf")
    for i in range(L,R):
        for j in range(L+1,R+1):
            if i*j%2019 <= mincount:
                mincount = (i*j)%2019

    print(mincount)
Buggy python submission (verdict: Runtime Error):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
from fractions import gcd
from copy import deepcopy
import math
import queue
import numpy as np
#import sympy as syp(素因数分解とか)
Mod = 1000000007
import sys
sys.setrecursionlimit(1000000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




def main(): #startline--------------------------------------------
    n,m = map(int,input().split())
    s = list(map(int,input().split()))
    t = list(map(int,input().split()))
    dp = [[0]*(m+2) for i in range(n+2)]
    sdp = [[0]*(m+2) for i in range(n+2)]
    dp[0][0] = 1
    sdp[1][1] = 1
    for i in range(n+1):
        for j in range(m+1):
            if i == 0 and j == 0:continue
            if i>=1 and j >= 1 and s[i-1] == t[j-1]:
                dp[i][j] = sdp[i][j]%Mod
            sdp[i+1][j+1] = (sdp[i+1][j] + sdp[i][j+1] - sdp[i][j] + dp[i][j])%Mod

    print(sdp[n+1][m+1]%Mod)

if __name__ == "__main__":
    main() 
    
#endline===============================================
    

Fixed submission:
X,A = map(int,input().split())
print(0 if X < A else 10)
Buggy python submission (verdict: Runtime Error):
W,H,x,y = map(int,input().spilt())
print(W*H/2,1 if (x == W/2 and y == H/2) else W*H/2,0)

Fixed submission:
W,H,x,y = map(int,input().split())
if x == W/2 and y == H/2:
    print(W*H/2,1)
else:
    print(W*H/2,0)

Buggy python submission (verdict: Runtime Error):
W,H,x,y = map(int,input().spilt())
print(W*H/2,1 if x == W/2 and y == H/2 else W*H/2,0)

Fixed submission:
W,H,x,y = map(int,input().split())
if x == W/2 and y == H/2:
    print(W*H/2,1)
else:
    print(W*H/2,0)
Buggy python submission (verdict: Runtime Error):
N = int(input())
s = [input() for i in range(N)]
ABcount = 0
for i in s:
    ABcount += i.count("AB")
bvva = 0
bvvv = 0
vvva = 0
for i in s:
    if i[0] == "B" and i[-1] == "A":
        bvva += 1
    elif i[0] == "B":
        bvvv += 1
    elif i[-1] == "A":
        vvva += 1
if vvva != 0:
    if bvvv != 0:
        print(ABcount+bvva+1+(min(vvva-1,bvvv-1)))
    else:
        print(ABcount+bvva)
else:
    if bvvv != 0:
        print(ABcount+bvva)
    else:
        print(max(ABcount+bvva-1),0)

Fixed submission:
N,K = map(int,input().split())
print(N-K+1)
Buggy python submission (verdict: Time Limit Exceeded):
R,G,B,N = map(int,input().split())
ans = 0
for i in range(N+1):
    for j in range(N+1):
        if N >= G*i+B*j:
            if (N-(G*i+B*j))%R == 0:
               ans += 1

print(ans)

Fixed submission:
R,G,B,N = map(int,input().split())
ans = 0
for i in range(N+1):
    for j in range(N+1):
        if N >= G*i+B*j:
            if (N-(G*i+B*j))%R == 0:
               ans += 1
 
print(ans)
Buggy python submission (verdict: Runtime Error):
A,B = map(int,input().split())
print(max(A,B)+max(max(A-1,B),max(A,B-1))

Fixed submission:
A,B = map(int,input().split())
X = max(A,B)
Y = min(A,B)
if X+Y >= 2:
    print(max(A,B)+max(max(A,B)-1,min(A,B)))
else:
    print(X+Y)
Buggy python submission (verdict: Runtime Error):
a = [int(input()) for i in range(5)]
A = []
for i in range(5):
    if a[i]%10!=0:
        A.append(10-a[i]%10)
        a[i] += 10-a[i]%10

A.sort()
print(sum(a)-A[-1])
    

Fixed submission:
a = [int(input()) for i in range(5)]
A = []
for i in range(5):
    if a[i]%10!=0:
        A.append(10-a[i]%10)
        a[i] += 10-a[i]%10
 
A.sort()
print(sum(a)-A[-1] if len(A) != 0 else sum(a))
Buggy python submission (verdict: Runtime Error):
b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
else b == "G":
    print("C")
else:
    print("G")

Fixed submission:
b = input()
L = [["A","T"],["C","G"]]
for i in range(2):
    if b in L[i]:
        if L[i][0] == b:
            print(L[i][1])
        else:
            print(L[i][0])
Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
D = int(input())
print("Christmas"+"Eve"*(D-25).split())

Fixed submission:
# -*- coding: utf-8 -*-
D = int(input())
print("Christmas " + "Eve "*(25 - D))

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
N = int(input)
print("Christmas" + "Eve"*(25 - n))

Fixed submission:
# -*- coding: utf-8 -*-
D = int(input())
print("Christmas " + "Eve "*(25 - D))

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
N = int(input)
print("Christmas" + "Eve"*(25 - n).split())

Fixed submission:
# -*- coding: utf-8 -*-
D = int(input())
print("Christmas " + "Eve "*(25 - D))

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
N = int(input)
print("Christmas" + "Eve"*(25 - n).split)

Fixed submission:
# -*- coding: utf-8 -*-
D = int(input())
print("Christmas " + "Eve "*(25 - D))
Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
N = int(input())
a = [input() for i in range(N)]
s = int(max(a)) // 2
a.remove(max(a)) #aの最大の要素を消去
print(sum(a) + s) #処理後のリストaにSを加えて足す

Fixed submission:
# -*- coding: utf-8 -*-
N = int(input())
a = [int(input()) for i in range(N)]
s = int(max(a)) // 2
a.remove(max(a)) #aの最大の要素を消去
print(sum(a) + s) #処理後のリストaにSを加えて足す

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
N = int(input())
a = [input() for i in range(N)]
S = max(a) // 2
a.remove(max(a)) #aの最大の要素を消去
print(sum(a,S)) #処理後のリストaにSを加えて足す

Fixed submission:
# -*- coding: utf-8 -*-
N = int(input())
a = [int(input()) for i in range(N)]
s = int(max(a)) // 2
a.remove(max(a)) #aの最大の要素を消去
print(sum(a) + s) #処理後のリストaにSを加えて足す
Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
X = int(input())
def f(n):
  if n == 3,5,7:
    print("YES")
  else:
    print("NO")
    
print("{}".format(f(X)))

Fixed submission:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
X = int(input())
def f(n):
  if (n == 3)or(n == 5)or(n == 7):
    return "YES"
  else:
    return "NO"
    
print("{}".format(f(X)))

Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
X = int(input())
def f(n):
  if (n = 3) or (n = 5)or (n = 7):
    print("YES")
  else:
    print("NO")
    
print("{}".format(f(X)))

Fixed submission:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
X = int(input())
def f(n):
  if (n == 3)or(n == 5)or(n == 7):
    return "YES"
  else:
    return "NO"
    
print("{}".format(f(X)))
Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
X,Y= "int(input())","int(input())"
print("{}".format(X + 2 //Y))

Fixed submission:
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y= map(int,input().split())
print("{}".format(X + Y // 2))

Buggy python submission (verdict: Runtime Error):
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y= int(input()), int(input())
print("{}".format(X + Y // 2))

Fixed submission:
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y= map(int,input().split())
print("{}".format(X + Y // 2))

Buggy python submission (verdict: Runtime Error):
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y = int(input()), int(input())
print("{}".format(X+Y//2))

Fixed submission:
#!usr/bin/env python
# -*- coding: utf-8 -*-
X , Y= map(int,input().split())
print("{}".format(X + Y // 2))
Buggy python submission (verdict: Runtime Error):
# -*- coding utf-8 -*-
n = str(input())
S = n.replace(1,8)
T = S.replace(9,1)
U = T.replace(8,9)
print(U)

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
n = int(input())
S = n.replace(1,9).replace(9,1)
print(S)

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
n = str(input())
S = n.replace(1,9).replace(9,1)
print(S)

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
n = str(input())
S = n.replace(1,9).replace(9,1)

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
n = str(input())
m.replace(1,9:9,1)

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
n=int(input())
n.replace("1","9")and("9","1")

Fixed submission:
# -*- coding utf-8 -*-
n = str(input())
S = n.replace("1","8")
T = S.replace("9","1")
U = T.replace("8","9")
print(U)
Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
A,B,C=map(int,input().split())
print(max(A*10+B+C, B*10+C+A C*10+A+B))

Fixed submission:
# -*- coding: utf-8 -*-
A,B,C=map(int,input().split())
print(max(A*10+B+C, B*10+C+A,  C*10+A+B))