Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
import numpy as np
n,d=map(int,input().split())
x=[]
for i in range(n):
  l=map(int,input().split())
  x.append(l)

x=np.array(x)

def dist(x,y):
  diff=x-y
  diff_sq=np.square(diff)
  return(np.sqrt(np.sum(diff_sq)))

ans=0
for N in range(n):
    for i in range(N,n):
        X = dist(x[N], x[i])
 
        if X.is_integer():
            ans += 1
 
print(ans)


Fixed submission:
import numpy as np
def is_square(n):
    for i in range(200):
        if i*i == n:
            return True
    return False
n,d = map(int, input().split())
x = []
for i in range(n):
    x.append(list(map(int,input().split())))

x = np.array(x)

count = 0
for i in range(n):
    for j in range(i+1,n):
        l = x[i] - x[j]
        l = np.square(l)
        l = np.sum(l)
        flag = is_square(l)
        if(flag) :
            count +=1

print(count)

Buggy python submission (verdict: Runtime Error):
import numpy as np
n,d=map(int,input().split())
x=[]

def dist(x,y):
  diff=x-y
  diff_sq=np.square(diff)
  return(np.sqrt(np.sum(diff_sq)))

ans=0
for N in range(n):
    for i in range(N,n):
        X = dist(x[N], x[i])
 
        if X.is_integer():
            ans += 1
 
print(ans)


Fixed submission:
import numpy as np
def is_square(n):
    for i in range(200):
        if i*i == n:
            return True
    return False
n,d = map(int, input().split())
x = []
for i in range(n):
    x.append(list(map(int,input().split())))

x = np.array(x)

count = 0
for i in range(n):
    for j in range(i+1,n):
        l = x[i] - x[j]
        l = np.square(l)
        l = np.sum(l)
        flag = is_square(l)
        if(flag) :
            count +=1

print(count)

Buggy python submission (verdict: Runtime Error):
import numpy as np
n,d=map(int,input().split())
x=[]

def dist(x,y):
  diff=x-y
  diff_sq=np.square(diff)
  return(np.sqrt(np.sum(diff_sq)))

ans=0
for N in range(n):
    for i in range(N,n):
        X = distance(x[N], x[i])
 
        if X.is_integer():
            ans += 1
 
print(ans)

Fixed submission:
import numpy as np
def is_square(n):
    for i in range(200):
        if i*i == n:
            return True
    return False
n,d = map(int, input().split())
x = []
for i in range(n):
    x.append(list(map(int,input().split())))

x = np.array(x)

count = 0
for i in range(n):
    for j in range(i+1,n):
        l = x[i] - x[j]
        l = np.square(l)
        l = np.sum(l)
        flag = is_square(l)
        if(flag) :
            count +=1

print(count)
Buggy python submission (verdict: Runtime Error):
import math 
from functools import reduce
 
def gcd(*numbers):
    return reduce(math.gcd, numbers)
a,b,c,d = map(int, input().split())

cd = gcd(c,d)
cd = c*d //cd
c_able = b//c - (a-1)//c
d_able = b//d - (a-1)//d
cd_able = b//(cd) - (a-1)//(cd)

print(b- a + 1 - (c_able + d_able - cd_able))

Fixed submission:
import fractions
 
def gcd(a,b):
    return fractions.gcd(a,b)
a,b,c,d = map(int, input().split())

cd = gcd(c,d)
cd = c*d //cd
c_able = b//c - (a-1)//c
d_able = b//d - (a-1)//d
cd_able = b//(cd) - (a-1)//(cd)

print(b- a + 1 - (c_able + d_able - cd_able))

Buggy python submission (verdict: Runtime Error):
import math 
from functools import reduce
 
def gcd(*numbers):
    return reduce(math.gcd, numbers)
a,b,c,d = map(int, input().split())

cd = gcd(c,d)
cd = c*d //cd
c_able = b//c - (a-1)//c
d_able = b//d - (a-1)//d
cd_able = b//(cd) - (a-1)//(cd)

print(b- a + 1 - (c_able + d_able - cd_able))

Fixed submission:
import fractions
 
def gcd(a,b):
    return fractions.gcd(a,b)
a,b,c,d = map(int, input().split())

cd = gcd(c,d)
cd = c*d //cd
c_able = b//c - (a-1)//c
d_able = b//d - (a-1)//d
cd_able = b//(cd) - (a-1)//(cd)

print(b- a + 1 - (c_able + d_able - cd_able))
Buggy python submission (verdict: Runtime Error):
p = list(map(int,input().split()))

mn = 200
for i in p[:-2]:
    for j in p[i+1:]
    if (i+j < mn):
        mn = i+j

print(mn)




Fixed submission:
p = list(map(int,input().split()))

mn = 200
for i in range(2):
    for j in range(i+1,3):
        if (p[i]+p[j] < mn):
            mn = p[i]+p[j]

print(mn)
Buggy python submission (verdict: Time Limit Exceeded):
n,m = map(int, input().split())
a = [int(input()) for _ in range(m)]

mod = 10**9+7
dp = [0]*(n+1)
dp[0]=1
if 1 not in a:
    dp[1]=1
for i in range(2,n+1):
    if i in a :
        continue
    else:
        dp[i]= dp[i-1] + dp[i-2]
        dp[i]%= mod


print(dp[n])

Fixed submission:
n,m = map(int, input().split())
a = set([int(input()) for _ in range(m)])

mod = 10**9+7
dp = [0]*(n+1)
dp[0]=1
if 1 not in a:
    dp[1]=1
for i in range(2,n+1):
    if i in a :
        continue
    else:
        dp[i]= dp[i-1] + dp[i-2]
        dp[i]%= mod


print(dp[n])

Buggy python submission (verdict: Runtime Error):
n,m = map(int, input().split())
a = [int(input()) for _ in range(m)]

large = 10**9 +7
count = [0]*(n+1)
itr = 0
count[0] = 1
if a[0] != 1 :
    count[1] = 1
else:
    count[1] = 0
    itr = 1

for i in range(2,n+1):
    if itr<len(a) and a[itr] == i:
        itr +=1
        continue
    else:
        count[i] = (count[i-1] + count[i-2])%large

print(count[n])




Fixed submission:
n,m = map(int, input().split())
a = set([int(input()) for _ in range(m)])

mod = 10**9+7
dp = [0]*(n+1)
dp[0]=1
if 1 not in a:
    dp[1]=1
for i in range(2,n+1):
    if i in a :
        continue
    else:
        dp[i]= dp[i-1] + dp[i-2]
        dp[i]%= mod


print(dp[n])
Buggy python submission (verdict: Runtime Error):
n = int(input())
spi = []
for i in range(n):
    s, p = map(input().split())
    spi.append((s,-int(p), i))
spi = sorted(spi)
for s, p, i in spi:
    print(i+1)

Fixed submission:
n = int(input())
spi = []
for i in range(n):
    s, p = input().split()
    spi.append((s,-int(p), i))
spi = sorted(spi)
for s, p, i in spi:
    print(i+1)
Buggy python submission (verdict: Runtime Error):
from collections import defaultdict
n,m= map(int, input().split())
a = list(map(int, input().split()))
d = []
for i in range(m):
    b,c = map(int, input().split())
    d.append([b,c])
d = sorted(d, key=lambda x:x[1], reverse=True)
a = sorted(a)
itr = 0
for i in range(len(d)):
    change = d[i]

    for j in range(change[0]):
        if a[itr] > change[1]:
            print(sum(a))
            exit()
        else:
            a[itr] = change[1]
        itr+=1
        if itr == n:
            break
print(sum(a))


Fixed submission:
n,m = map(int, input().split())
a = list(map(int, input().split()))

bc = []

for i in range(m):
    b,c=map(int,input().split())
    bc.append([b,c])

bc = sorted(bc, key=lambda x: x[1],reverse=True)
a = sorted(a)

itr = 0 
for i in bc:
    b, c = i[0], i[1]
    for j in range(b):
        if a[itr]>=c:
            print(sum(a))
            exit()
        else:
            a[itr]=c
            itr +=1
            if itr == n:
                print(sum(a))
                exit()
print(sum(a))

Buggy python submission (verdict: Runtime Error):
from collections import defaultdict
n,m= map(int, input().split())
a = list(map(int, input().split()))
d = []
for i in range(m):
    b,c = map(int, input().split())
    d.append([b,c])
d = sorted(d, key=lambda x:x[1], reverse=True)
a = sorted(a)
itr = 0
for i in range(len(d)):
    change = d[i]

    for j in range(change[0]):
        if a[itr] > change[1]:
            print(sum(a))
            exit()
        else:
            a[itr] = change[1]
        itr+=1
print(sum(a))


Fixed submission:
n,m = map(int, input().split())
a = list(map(int, input().split()))

bc = []

for i in range(m):
    b,c=map(int,input().split())
    bc.append([b,c])

bc = sorted(bc, key=lambda x: x[1],reverse=True)
a = sorted(a)

itr = 0 
for i in bc:
    b, c = i[0], i[1]
    for j in range(b):
        if a[itr]>=c:
            print(sum(a))
            exit()
        else:
            a[itr]=c
            itr +=1
            if itr == n:
                print(sum(a))
                exit()
print(sum(a))

Buggy python submission (verdict: Runtime Error):
n,m= map(int, input().split())
a = list(map(int, input().split()))
d = []
for i in range(m):
    b,c = map(int, input().split())
    d.extend([c]*b)
d = sorted(d,reverse=True)
k = max(len(d),n)
d = d[0:k]

a = sorted(a)

for i in range(n):
    if i >=k-1:
        break 
    if a[i] > d[i]:
        break
    else:
        a[i] = d[i]

print(sum(a))



Fixed submission:
n,m = map(int, input().split())
a = list(map(int, input().split()))

bc = []

for i in range(m):
    b,c=map(int,input().split())
    bc.append([b,c])

bc = sorted(bc, key=lambda x: x[1],reverse=True)
a = sorted(a)

itr = 0 
for i in bc:
    b, c = i[0], i[1]
    for j in range(b):
        if a[itr]>=c:
            print(sum(a))
            exit()
        else:
            a[itr]=c
            itr +=1
            if itr == n:
                print(sum(a))
                exit()
print(sum(a))
Buggy python submission (verdict: Runtime Error):
n = int(input())
h, w = map(int, input().split())

print((n-w+1)*(n-h+1))

Fixed submission:
n = int(input())
h = int(input())
w = int(input())

print((n-w+1)*(n-h+1))
Buggy python submission (verdict: Time Limit Exceeded):
import sys
input = sys.stdin.readline
N,W = map(int,input().split())
wv = [list(map(int,input().split())) for i in range(N)]
f_min = 0 
dp = [[f_min] * (W+1) for _ in range(N+1)]
def chmin(a, b):
    if a > b:
        return b
    else:
        return a
def chmax(a,b):
    if a < b:
        return b
    else:
        return a
def main():
    # 初期条件

    for i in range(1,N+1):
        w,v = wv[i-1][0], wv[i-1][1]

        for sum_w in range(W+1):
            if sum_w - w >= 0:
                dp[i][sum_w] = chmax(dp[i][sum_w], dp[i-1][sum_w-w]+ v)
            
            dp[i][sum_w] = chmax(dp[i][sum_w],dp[i-1][sum_w])
    
    ans = 0
    for i in range(W+1):
        ans = chmax(ans,dp[N][i])
    print(ans)
            

            
 

if __name__ == "__main__":
    main()

Fixed submission:
import sys
input = sys.stdin.readline
N,W = map(int,input().split())
wv = [list(map(int,input().split())) for i in range(N)]
f_min = 0 
dp = [[f_min] * (W+1) for _ in range(N+1)]
def chmin(a, b):
    if a > b:
        return b
    else:
        return a
def chmax(a,b):
    if a < b:
        return b
    else:
        return a
def main():
    # 初期条件

    for i in range(1,N+1):
        w,v = wv[i-1][0], wv[i-1][1]

        for sum_w in range(W+1):
            if sum_w - w >= 0:
                dp[i][sum_w] = chmax(dp[i][sum_w], dp[i-1][sum_w-w]+ v)
            
            dp[i][sum_w] = chmax(dp[i][sum_w],dp[i-1][sum_w])
    
    ans = 0
    for i in range(W+1):
        ans = chmax(ans,dp[N][i])
    print(ans)
            

            
 

if __name__ == "__main__":
    main()
Buggy python submission (verdict: Runtime Error):
import heapq
from sys import stdin
input = stdin.readline

#入力
# s = input()
# n = int(input())
x,y = map(int, input().split())
# a = list(map(int,input().split()))
# w = [int(input()) for i in range(n)]

# ab=[]
# for i in range(m):
#     a,b = map(int, input().split())
#     ab.append((a,b))

print(x)
     
def main():
    ans = 0
    val = x
    while val <=y:
        ans+=1
        x*=2
    print(ans)
        
    

    
    

if __name__ == '__main__':
    main()

Fixed submission:
import heapq
from sys import stdin
input = stdin.readline

#入力
# s = input()
# n = int(input())
# a,b = map(int, input().split())
# a = list(map(int,input().split()))
# w = [int(input()) for i in range(n)]

# ab=[]
# for i in range(m):
#     a,b = map(int, input().split())
#     ab.append((a,b))
     
def main():
    a,b = map(int, input().split())
    ans = 0
    while a <=b:
        ans+=1
        a*=2
    print(ans)
        
if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
import bisect
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a, b, c = sorted(a), sorted(b), sorted(c)

ans = 0
for i in b:
    up_index = bisect.bisect_left(a,i)
    down_index = bisect.bisect_right(c,i)
    ans += len(a[:up_index])*len(c[down_index:])

print(ans)


Fixed submission:
import bisect
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a, b, c = sorted(a), sorted(b), sorted(c)

ans = 0
for i in b:
    up_index = bisect.bisect_left(a,i)
    down_index = bisect.bisect_right(c,i)
    ans += up_index * (n-down_index)

print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
import bisect
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a, b, c = sorted(a), sorted(b), sorted(c)

ans = 0
for i in b:
    up_index = bisect.bisect_left(a,i)
    down_index = bisect.bisect_right(c,i)
    ans += len(a[:up_index])*len(c[down_index:])

print(ans)


Fixed submission:
import bisect
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a, b, c = sorted(a), sorted(b), sorted(c)

ans = 0
for i in b:
    up_index = bisect.bisect_left(a,i)
    down_index = bisect.bisect_right(c,i)
    ans += up_index * (n-down_index)

print(ans)
Buggy python submission (verdict: Runtime Error):
import re
s = input()
t = input()

for i in range(len(s) - len(t), -1, -1):
	if re.fullmatch(s[i:i + len(t)].replace("?", "."), t):
		print((s[:i] + t + s[i+len(t)]).replace("?","a"))
		break
else:
	print("UNRESTORABLE")

Fixed submission:
s = input()[::-1]
t = input()[::-1]
sl, tl = len(s), len(t)
for i in range(sl - tl + 1):
    for j in range(tl):
        if s[i + j] != "?" and s[i + j] != t[j]:
            break
    else:
        print((s[:i] + t + s[i + tl:]).replace("?", "a")[::-1])
        break
else:
    print("UNRESTORABLE")
Buggy python submission (verdict: Runtime Error):
n, p = map(int, input().split())
a = list(map(int, input().split()))

odd = 0
even = 0

for i in a:
    if a %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))

Fixed submission:
n, p = map(int, input().split())
a = list(map(int, input().split()))

odd = 0
even = 0

for i in a:
    if i %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))

Buggy python submission (verdict: Runtime Error):
n, p = map(int, input().split())
a = list(map(int, input().split())

odd = 0
even = 0

for i in a:
    if a %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))

Fixed submission:
n, p = map(int, input().split())
a = list(map(int, input().split()))

odd = 0
even = 0

for i in a:
    if i %2 ==0:
        even +=1
    else:
        odd+=1
if even == n:
    if p == 0:
        print(2**n)
    else:
        print(0)
else:
    print(2**(n-1))
Buggy python submission (verdict: Runtime Error):
a,b = input().split()
a = int(a)
b = int(b.replace('.','')
print(a*b//100)

Fixed submission:
a,b = input().split()
a = int(a)
b = int(b.replace('.',''))
print(a*b//100)
Buggy python submission (verdict: Time Limit Exceeded):
N,K = map(int,input().split())
A=  list(map(int,input().split()))
now = 0
if K <= N:
    for i in range(K):
        now = A[now]-1
    print(now+1)
else:
    alr = [0]
    now = 0
    for i in range(K):
        now = A[now]-1
        if now not in alr:
            alr.append(now)
        else:
            loop = alr[alr.index(now):]
            rem = K - i - 1
            break
    ans = loop[rem%len(loop)]+1
    print(ans)
    

Fixed submission:
N,K = map(int,input().split())
A=  list(map(int,input().split()))
now = 0
if K <= N:
    for i in range(K):
        now = A[now]-1
    print(now+1)
else:
    alr = [0]
    alr2 = [False for i in range(N)]
    alr2[0] = True
    now = 0
    for i in range(K):
        now = A[now]-1
        if alr2[now] == False:
            alr.append(now)
            alr2[now] = True
        else:
            loop = alr[alr.index(now):]
            rem = K - i - 1
            break
    ans = loop[rem%len(loop)]+1
    print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
N,K = map(int,input().split())
A=  list(map(int,input().split()))
now = 0
if K <= N:
    for i in range(K):
        now = A[now]-1
    print(now+1)
else:
    alr = [0]
    now = 0
    for i in range(K):
        now = A[now]-1
        if now not in alr:
            alr.append(now)
        else:
            loop = alr[alr.index(now):]
            rem = K - i - 1
            break
    ans = loop[rem%len(loop)]+1
    print(ans)
    

Fixed submission:
N,K = map(int,input().split())
A=  list(map(int,input().split()))
now = 0
if K <= N:
    for i in range(K):
        now = A[now]-1
    print(now+1)
else:
    alr = [0]
    alr2 = [False for i in range(N)]
    alr2[0] = True
    now = 0
    for i in range(K):
        now = A[now]-1
        if alr2[now] == False:
            alr.append(now)
            alr2[now] = True
        else:
            loop = alr[alr.index(now):]
            rem = K - i - 1
            break
    ans = loop[rem%len(loop)]+1
    print(ans)
Buggy python submission (verdict: Runtime Error):
X=int(input())
ans = []
for a in range(-100,101):
    for b in range(-100,101):
        if a**5-b**5 == X:
            ans = [a,b]
            break
print(ans[0],ans[1])

Fixed submission:
X=int(input())
ans = []
for a in range(1001):
    for b in range(-1000,1001):
        if a**5-b**5 == X:
            ans = [a,b]
            break
print(ans[0],ans[1])
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
A = list(map(int,input().split()))
diff = [(i+1)-A[i] for i in range(N)]
plus = [A[i]+(i+1) for i in range(N)]
ans = 0
for i in range(N-1):
    pnum = plus[i]
    ans += diff[i+1:].count(pnum)
print(ans)

Fixed submission:
from collections import defaultdict
import bisect
N = int(input())
A = list(map(int,input().split()))
plus = [A[i]+(i+1) for i in range(N)]
diff = [-A[i]+(i+1) for i in range(N)]

plusc = defaultdict(list)
for i in range(N):
    plusc[plus[i]].append(i)
ans = 0
for i in range(1,N):
    ans += bisect.bisect_left(plusc[diff[i]],i)
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
A = list(map(int,input().split()))
diff = [(i+1)-A[i] for i in range(N)]
plus = [A[i]+(i+1) for i in range(N)]
ans = 0
for i in range(N-1):
    pnum = plus[i]
    ans += diff[i+1:].count(pnum)
print(ans)

Fixed submission:
from collections import defaultdict
import bisect
N = int(input())
A = list(map(int,input().split()))
plus = [A[i]+(i+1) for i in range(N)]
diff = [-A[i]+(i+1) for i in range(N)]

plusc = defaultdict(list)
for i in range(N):
    plusc[plus[i]].append(i)
ans = 0
for i in range(1,N):
    ans += bisect.bisect_left(plusc[diff[i]],i)
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
def bfs(start):
    global count
    d = [float('inf') for i in range(N)]
    d[start] = 0
    que = deque()
    que.append(start)
    alr = [start]
    while que:
        q = que.popleft()
        c = d[q]
        for i in path[q]:
            if i not in alr:
                que.append(i)
                alr.append(i)
                d[i] = c+1
    for i in range(start+1,N):
        count[d[i]-1] += 1

N,X,Y = map(int,input().split())
path = [[] for i in range(N)]
path[0] = [1]
path[N-1] = [N-2]
for i in range(1,N-1):
    path[i] = [i-1,i+1]
path[X-1].append(Y-1)
path[Y-1].append(X-1)

count = [0 for i in range(N-1)]
for i in range(N-1):
    bfs(i)
for i in range(N-1):
    print(count[i])

Fixed submission:
N,X,Y = map(int,input().split())
ans = [0 for i in range(N-1)]
for i in range(1,N):
    for j in range(i+1,N+1):
        mina = min(j-i, abs(X-i)+1+abs(Y-j), abs(Y-i)+1+abs(X-j))
        ans[mina-1] += 1
for i in ans:
    print(i)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
def bfs(start):
    global count
    d = [float('inf') for i in range(N)]
    d[start] = 0
    que = deque()
    que.append(start)
    alr = [start]
    while que:
        q = que.popleft()
        for i in path[q]:
            if i not in alr:
                que.append(i)
                alr.append(i)
                d[i] = min(d[i],d[q]+1)
    for i in range(start+1,N):
        count[d[i]-1] += 1

N,X,Y = map(int,input().split())
path = [[] for i in range(N)]
path[0] = [1]
path[N-1] = [N-2]
for i in range(1,N-1):
    path[i] = [i-1,i+1]
path[X-1].append(Y-1)
path[Y-1].append(X-1)

count = [0 for i in range(N-1)]
for i in range(N-1):
    bfs(i)
for i in range(N-1):
    print(count[i])

Fixed submission:
N,X,Y = map(int,input().split())
ans = [0 for i in range(N-1)]
for i in range(1,N):
    for j in range(i+1,N+1):
        mina = min(j-i, abs(X-i)+1+abs(Y-j), abs(Y-i)+1+abs(X-j))
        ans[mina-1] += 1
for i in ans:
    print(i)
Buggy python submission (verdict: Runtime Error):
from collections import Counter
N = int(input())
A = list(map(int,input().split()))
ac = Counter(A)
comblist = [0 for i in range(max(ac.values())+1)]
comblist[2] = 1
for i in range(3,max(4,max(ac.values())+1)):
    comblist[i] = comblist[i-1]*i//(i-2)
ans = {}
anssum = 0
for k,v in ac.items():
    if v > 1:
        anssum += comblist[v]
    if k not in ans:
        if v == 2:
            ans[k] = -1
        elif v == 1:
            ans[k] = 0
        else:
            ans[k] = comblist[v-1] - comblist[v]
for i in A:
    print(anssum+ans[i])

Fixed submission:
from collections import Counter
N = int(input())
A = list(map(int,input().split()))
ac = Counter(A)
comblist = [0 for i in range(max(ac.values())+1)]
if max(ac.values()) == 1:
    for i in range(N):
        print(0)
else:
    comblist[2] = 1
    for i in range(3,max(4,max(ac.values())+1)):
        comblist[i] = comblist[i-1]*i//(i-2)
    ans = {}
    anssum = 0
    for k,v in ac.items():
        if v > 1:
            anssum += comblist[v]
        if k not in ans:
            if v == 2:
                ans[k] = -1
            elif v == 1:
                ans[k] = 0
            else:
                ans[k] = comblist[v-1] - comblist[v]
    for i in A:
        print(anssum+ans[i])
Buggy python submission (verdict: Runtime Error):
if a*b < ((c-a-b)/2)**2:
    print('Yes')
else:
    print('No')

Fixed submission:
a,b,c = map(int,input().split())

if a == 0 and b == 0:
    if c > 0:
        print('Yes')
    else:
        print('No')
elif c-a-b <= 0:
    print('No')
else:
    if 4*a*b < (c-a-b)**2:
        print('Yes')
    else:
        print('No')