Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
import math
a,b,c=map(int,input().split())

if c==0:
    print("YES")
elif c%math.gcd(a,b)==0 and c!=0:
    print("YES")
else:
    print("NO")

Fixed submission:
a,b,c=map(int,input().split())
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
if c==0:
    print("YES")
elif c%gcd(a,b)==0 and c!=0:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a,b,c=map(int,input().split())
def gojo(x,y):
    if x%y==0:
        return y
    else:
        return gojo(y,x-y)

if c==0:
    print("YES")
elif c%gojo(a,b)==0 and c!=0:
    print("YES")
else:
    print("NO")

Fixed submission:
a,b,c=map(int,input().split())
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
if c==0:
    print("YES")
elif c%gcd(a,b)==0 and c!=0:
    print("YES")
else:
    print("NO")

Buggy python submission (verdict: Runtime Error):
a,b,c=map(int,input().split())
def gojo(x,y):
    if x%y==0:
        return y
    else:
        return gojo(y,x-y)

if c%gojo(a,b)!=0:
    print("NO")
else:
    print("YES")

Fixed submission:
a,b,c=map(int,input().split())
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
if c==0:
    print("YES")
elif c%gcd(a,b)==0 and c!=0:
    print("YES")
else:
    print("NO")
Buggy python submission (verdict: Time Limit Exceeded):
import math

n = int(input())
c = 0

for i in range(1, n):
    m = math.sqrt(i)
    for j in range(1, int(m)+1):
        if i%j == 0:
            c += 2
    if m.is_integer():
        c -= 1

print(c)

Fixed submission:
n = int(input())
c = 0

for i in range(1, n):
    c += (n-1) // i

print(c)
Buggy python submission (verdict: Runtime Error):
import numpy as np

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

s = 0

def step(a, s):
    am = np.argmax(a)
    s = s + np.max(a)*a[am+1:].shape[0] - np.sum(a[am+1:])

    if am == 0:
        return s
    else:
        return step(a[:am], s)

print(step(A, s))


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

s = 0

for i in range(1, N):
    if A[i-1] > A[i]:
        s += A[i-1] - A[i]
        A[i] = A[i-1]

print(s)

Buggy python submission (verdict: Runtime Error):
import numpy as np

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

s = 0

def step(a, s):
    am = np.argmax(a)
    s = s + np.max(a)*a[am+1:].shape[0] - np.sum(a[am+1:])

    if am == 0:
        return s
    else:
        return step(a[:am], s)

print(step(A, s))


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

s = 0

for i in range(1, N):
    if A[i-1] > A[i]:
        s += A[i-1] - A[i]
        A[i] = A[i-1]

print(s)

Buggy python submission (verdict: Runtime Error):
import numpy as np

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

s = 0

def step(a, s):
    am = np.argmax(a)
    s = s + np.max(a)*a[am+1:].shape[0] - np.sum(a[am+1:])
    
    if am == 0:
        return s
    return step(a[:am], s)

print(step(A, s))


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

s = 0

for i in range(1, N):
    if A[i-1] > A[i]:
        s += A[i-1] - A[i]
        A[i] = A[i-1]

print(s)

Buggy python submission (verdict: Runtime Error):
import numpy as np

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

s = 0

def step(a, s):
    am = np.argmax(a)
    s = s + np.max(a)*a[am+1:].shape[0] - np.sum(a[am+1:])
    
    if am == 0:
        return s
    return step(a[:am], s)

print(step(A, s))


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

s = 0

for i in range(1, N):
    if A[i-1] > A[i]:
        s += A[i-1] - A[i]
        A[i] = A[i-1]

print(s)

Buggy python submission (verdict: Runtime Error):
import numpy as np

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

s = 0

def step(a, s):
    am = np.argmax(a)
    s = s + np.max(a)*a[am+1:].shape[0] - np.sum(a[am+1:])
    
    if am == 0:
        return s
    return step(a[:am], s)

print(step(A, s))


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

s = 0

for i in range(1, N):
    if A[i-1] > A[i]:
        s += A[i-1] - A[i]
        A[i] = A[i-1]

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

if N<2:
	print(0)
elif N==2:
	print(2)
else:
	without=10**(N-2)
	each=N*(N-1)/2
	final=without*each

	considered=final%(1000000007)

	print(final)

Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)
elif N==2:
	print(2)
else:
	without=10**(N-2)
	each=N*(N-1)/2
	final=without*each

	considered=final%(1000000007)

	print(final)

Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)
ellif N==2:
	print(2)
else:
	without=10**(N-2)
	considered=(without+2)*(without+1)
	considered=considered%(1000000007)
	print(considered)
	


Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)

else:
	without=10*(N-2)
	considered=(without+2)*(without+1)
	consider%=10**9+7

Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)

else:
	without=10*(N-2)
	considered=(without+2)*(without+1)
	print(considered)


Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)
elif N==2:
	print(2)
else:
	without=10*(N-2)
	considered=(without+2)*(without+1)/2
	print(considered)

Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)

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

if N<2:
	print(0)
elif N==2:
	print(2)
else:
	without=10*(N-2)
	considered=without*(without-1)/2
	print(considered)

Fixed submission:
MOD=10**9+7
N=int(input())
 
all=pow(10,N,MOD)
sub9=pow(9,N,MOD)
sub8=pow(8,N,MOD)
print((all-2*sub9+sub8)%MOD)
Buggy python submission (verdict: Runtime Error):
N=input()
A=map(int,input().split(' '))
summed=0
for i in range(0,N):
	for j in range(i+1,N):
		sumed+=A[i]*A[j]
MOD=10**9+7
print(sumed%MOD)


Fixed submission:
D,T,S=map(int,input().split(' '))
if (D/S)<=T:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
S=input()
T=input()
result=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(ans,diff)

print(result)


Fixed submission:
S=input()
T=input()
result=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(result,diff)

print(result)

Buggy python submission (verdict: Runtime Error):
S=input()
T=input()
length=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(ans,diff)

print(result)


Fixed submission:
S=input()
T=input()
result=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(result,diff)

print(result)

Buggy python submission (verdict: Runtime Error):
S=input()
T=input()
length=len(T)
for i in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(ans,diff)

print(result)


Fixed submission:
S=input()
T=input()
result=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(result,diff)

print(result)

Buggy python submission (verdict: Runtime Error):
S=input()
T=input()
length=len(T)
for i in range(0,len(S)-len(T)+1):
	if S[i,i+length]==T:
		print(0)

Fixed submission:
S=input()
T=input()
result=len(T)
for s in range(0,len(S)-len(T)+1):
	diff=0
	for i in range(0,len(T)):
		if T[i]!=S[s+i]:
			diff+=1
	result=min(result,diff)

print(result)
Buggy python submission (verdict: Runtime Error):
def SumOfProduct(n, arrayA):
  ans = 0

  for i in range(0, len(arrayA)):
    for j in range(i + 1, len(arrayA)):
      ans += arrayA[i] * arrayA[j]

  print(ans)

n = int(input())
arrayA = list(map(int, input().split()))

SumOfProduct(n, arrayA)


Fixed submission:
requestMap = list(map(float, input().split()))

D = requestMap[0]
T = requestMap[1]
S = requestMap[2]

dist = S * T

if dist >= D:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
def main():
    n = int(input())
    list = list(map(int, input().split()))
    ans = 1

    for i in range(n):
        ans = ans * list[i]
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()


Fixed submission:
def main():
    n = int(input())
    A = list(map(int, input().split()))

    if 0 in A:
        print(0)
        return

    ans = 1
    for item in A:
        ans = ans * item
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()

Buggy python submission (verdict: Runtime Error):
def main():
    n = int(input())
    list = list(map(int, input().split()))
    ans = 1

    for i in range(n):
        ans = ans * list[i]
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()


Fixed submission:
def main():
    n = int(input())
    A = list(map(int, input().split()))

    if 0 in A:
        print(0)
        return

    ans = 1
    for item in A:
        ans = ans * item
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
list = list(map(int, input().split()))
ans = 1

for i in range(n):
    ans = ans * list[i]

if ans > 1000000000000000000:
    ans = -1
print(ans)


Fixed submission:
def main():
    n = int(input())
    A = list(map(int, input().split()))

    if 0 in A:
        print(0)
        return

    ans = 1
    for item in A:
        ans = ans * item
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
list = list(map(int, input().split()))
ans = 1

max = 10 ** 18

for i in range(n):
    ans = ans * list[i]

if ans > max:
    ans = -1
print(ans)


Fixed submission:
def main():
    n = int(input())
    A = list(map(int, input().split()))

    if 0 in A:
        print(0)
        return

    ans = 1
    for item in A:
        ans = ans * item
        if ans > 1000000000000000000:
            print(-1)
            return

    print(ans)


main()
Buggy python submission (verdict: Time Limit Exceeded):
import math

def comb(n, r, mod):
    return math.factorial(n + r - 1)//(math.factorial(n - 1)*math.factorial(r))%mod

def nCrModp(n, r, p): 
    if (r > n- r): 
        r = n - r   
  
    C = [0 for i in range(r + 1)] 
  
    C[0] = 1
  
    # One by constructs remaining rows of Pascal 
    # Triangle from top to bottom 
    for i in range(1, n + 1): 
  
        # Fill entries of current row  
        # using previous row values 
        for j in range(min(i, r), 0, -1): 
  
            # nCj = (n - 1)Cj + (n - 1)C(j - 1) 
            C[j] = (C[j] + C[j-1]) % p 
  
    return C[r]

s = int(input())
mod = 10**9 + 7
ans = 1

if s < 3:
    ans = 0

for i in range(2, 700): #分割数, 1の時は1通りなので除外
    if s < 3*i:
        break
    r = s - i*3
    ans = (ans + nCrModp(s - 2*i - 1, s - 3*i, mod))%mod

print(ans)


Fixed submission:
import math

def comb(n, r, mod):
    return math.factorial(n + r - 1)//(math.factorial(n - 1)*math.factorial(r))%mod

s = int(input())
mod = 10**9 + 7
ans = 1

if s < 3:
    ans = 0

for i in range(2, 700): #分割数, 1の時は1通りなので除外
    if s < 3*i:
        break
    r = s - i*3
    ans = (ans + comb(i, r, mod))%mod

print(ans)
Buggy python submission (verdict: Runtime Error):
a,b=raw.input().split(" ")
if b<a:
  print "Yes"
else :
  print "No"

Fixed submission:
a,b=input().split(" ")
a=int(a)
b=int(b)
if b<a:
  print ("No")
if b==a :
  print ("Yes")
Buggy python submission (verdict: Runtime Error):
n = int(input().rstrip())
edgeList = sorted([int(_) for _ in input().rstrip().split(" ")])n = int(input().rstrip())
edgeList = [int(_) for _ in input().rstrip().split(" ")]
cnt = 0
for i in range(n):
  for j in range(i+1, n):
    if edgeList[i] != edgeList[j]:
      for k in range(j+1, n):
        cnt += (edgeList[i] != edgeList[k] and 
                edgeList[j] != edgeList[k] and 
                edgeList[i] + edgeList[j] > edgeList[k] and 
                edgeList[j] + edgeList[k] > edgeList[i] and 
                edgeList[k] + edgeList[i] > edgeList[j])
print(cnt)

Fixed submission:
n = int(input().rstrip())
edgeList = [int(x) for x in input().rstrip().split(" ")]
cnt = 0
for i in range(n-2):
  for j in range(i+1, n-1):
    if edgeList[i] != edgeList[j]:
      for k in range(j+1, n):
        cnt += (edgeList[i] != edgeList[k] and 
                edgeList[j] != edgeList[k] and 
                edgeList[i] + edgeList[j] > edgeList[k] and 
                edgeList[j] + edgeList[k] > edgeList[i] and 
                edgeList[k] + edgeList[i] > edgeList[j])
print(cnt)
Buggy python submission (verdict: Runtime Error):
n, k = [int(x) for x in input().strip().split(" ")]
p = 10**9 + 7

num_list = [int(x) for x in input().strip().split(" ")]
num_list = sorted(num_list, reverse = True)
ans = 1
l_idx = 0
r_idx = -1

while True:
  if k >= 2:
    l_prod = num_list[l_idx] * num_list[l_idx+1]
    r_prod = num_list[r_idx] * num_list[r_idx-1]
    if l_prod >= r_prod:
      ans *= l_prod % p
      ans %= p
      l_idx +=2
      k -= 2
    else:
      ans *= r_prod % p
      ans %= p
      r_idx +=2
      k -= 2
  elif k == 1:
    ans *= num_list[l_idx] % p
    ans %= p
    break
  else:
    break
        
if num_list[0] < 0 and k % 2 == 1:
  ans = 1
  for i in range(k):
    ans *= num_list[i]
    ans %= p

print(ans)


Fixed submission:
n = int(input().rstrip())

print((1000-n)%1000)
Buggy python submission (verdict: Time Limit Exceeded):
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *					# ll = deepcopy(l)
from heapq import *					# heappush(hp,x)
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize				# minn = -maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *				# pre = [0] + list(accumulate(l))
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(adj):
	n = len(adj)
	dis = [maxsize]*n
	ans = [0]*n
	q = [0]
	dis[0] = 0
	while(q):
		src = q.pop(0)
		for nn in adj[src]:
			if(dis[nn] == maxsize):
				ans[nn] = src
				dis[nn] = dis[src] + 1
				q.append(nn)
			else:
				if(dis[nn] > dis[src] + 1):
					ans[nn] = src
					dis[nn] = dis[src] + 1
	for i in range(n):
		ans[i] += 1
	if(maxsize in dis[1:]):
		print('No')
	else:
		print('Yes')
		for i in range(1,n):
			print(ans[i])

N,M = list(map(int, stdin.readline().rstrip().split()))
adj = [[] for i in range(N)]
for _ in range(M):
	a,b = list(map(int, stdin.readline().rstrip().split()))
	a -= 1
	b -= 1
	adj[a].append(b)
	adj[b].append(a)
solve(adj)




Fixed submission:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *					# ll = deepcopy(l)
from heapq import *					# heappush(hp,x)
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize				# minn = -maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *				# pre = [0] + list(accumulate(l))
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
6 9
3 4
6 1
2 4
5 3
4 6
1 5
6 2
4 5
5 6
'''

def solve(adj):
	n = len(adj)
	dis = [maxsize]*n
	ans = [0]*n
	q = [0]
	dis[0] = 0
	while(q):
		src = q.pop(0)
		for nn in adj[src]:
			if(dis[nn] == maxsize):
				ans[nn] = src
				dis[nn] = dis[src] + 1
				q.append(nn)
	for i in range(n):
		ans[i] += 1
	if(maxsize in dis[1:]):
		print('No')
	else:
		print('Yes')
		for i in range(1,n):
			print(ans[i])

N,M = list(map(int, stdin.readline().rstrip().split()))
adj = [[] for i in range(N)]
for _ in range(M):
	a,b = list(map(int, stdin.readline().rstrip().split()))
	a -= 1
	b -= 1
	adj[a].append(b)
	adj[b].append(a)
solve(adj)
Buggy python submission (verdict: Time Limit Exceeded):
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 2 4
'''

def solve(n,x,y):
	adj = [[] for i in range(n+1)]
	adj[x].append(y)
	adj[y].append(x)
	for i in range(1,n):
		adj[i].append(i+1)
		adj[i+1].append(i)
	# print(adj)
	ans = []
	d = {}
	for i in range(1,n):
		d[i] = 0
	for k in range(1,n+1):
		q = [k]
		dis = [maxsize]*(n+1)
		dis[k] = 0
		while(q):
			src = q.pop()
			for nn in adj[src]:
				if(dis[nn] > dis[src]+1):
					dis[nn] = dis[src] + 1
					q.append(nn)
		curr = 0
		# print('k:',k,dis)
		for ii in range(k+1,n+1):
			d[dis[ii]] += 1
	return d

N,X,Y = list(map(int, stdin.readline().rstrip().split()))
ans = solve(N,X,Y)
for i in range(1,N):
	print(ans[i])



Fixed submission:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 2 4
'''

def solve(n,x,y):
	adj = [[] for i in range(n+1)]
	adj[x].append(y)
	adj[y].append(x)
	for i in range(1,n):
		adj[i].append(i+1)
		adj[i+1].append(i)
	# print(adj)
	ans = []
	d = {}
	for i in range(1,n):
		d[i] = 0
	for k in range(1,n+1):
		q = [k]
		dis = [maxsize]*(n+1)
		dis[k] = 0
		while(q):
			src = q.pop()
			for nn in adj[src]:
				# if(nn > k or nn == X or nn == Y):
				if(dis[nn] > dis[src]+1):
					# if(src == 4):
						# print('src:',src,'nn:',nn)
					dis[nn] = dis[src] + 1
					q.append(nn)
				# else:
				# 	dis[nn] = 
			# if(k == 3):
			# 	print('src:',src)
			# 	print('dis:',dis)
		curr = 0
		# if(k == 3):
		# print('k:',k,dis)
		for ii in range(k+1,n+1):
			d[dis[ii]] += 1
	return d

N,X,Y = list(map(int, stdin.readline().rstrip().split()))
ans = solve(N,X,Y)
for i in range(1,N):
	print(ans[i])
Buggy python submission (verdict: Runtime Error):
,

Fixed submission:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	n = len(l)
	

s,t = map(str, stdin.readline().rstrip().split())
a,b = map(int, stdin.readline().rstrip().split())
u = input()
if(u == s):
	a -= 1
else:
	b -= 1
print(a,b)
Buggy python submission (verdict: Time Limit Exceeded):
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 3
1 2 2 4 5
'''

def solve(l,k):
	n = len(l)
	subs = []
	for i in range(n-k+1):
		subs.append(l[i:i+k])
	maxx = -1
	sub = []
	for i in subs:
		summ = sum(i)
		if(summ > maxx):
			maxx = summ
			sub = i
	ans = 0
	for i in sub:
		curr = i*(i+1)/2
		ans += curr/i
	# print(subs)
	return ans
	

N,K = map(int, stdin.readline().rstrip().split())
l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l,K)
print("%.10f"%ans)


Fixed submission:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 3
1 2 2 4 5
'''

def solve(l,k):
	n = len(l)
	pre = [l[0]]
	for i in range(1,n):
		pre.append(pre[i-1] + l[i])
	maxx = 0
	index = -1
	for i in range(k-1,n):
		summ = 0
		if(i == k-1):
			summ = pre[i]
		else:
			summ = pre[i] - pre[i-k]
		if(maxx < summ):
			maxx = summ
			index = i
	startIndex = index - k + 1
	optimalSub = l[startIndex:index+1]
	# print(optimalSub)
	ans = 0
	for i in optimalSub:
		curr = i*(i+1)/2
		ans += curr/i
	return ans

N,K = map(int, stdin.readline().rstrip().split())
l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l,K)
print("%.10f"%ans)