qyliang/CodeNanoFix huggingface dataset:
Buggy code:
n=int(input())
arr=list(map(int,input().split()))
avg=sum(arr)/n
pos=0
diff=10**9
for i in range(n):
  if abs(arr[i]-avg)<diff:
    diff=abs(arr[i]-avg)
    pos=i

Fixed code:
n=int(input())
arr=list(map(int,input().split()))
avg=sum(arr)/n
pos=0
diff=10**9
for i in range(n):
  if abs(arr[i]-avg)<diff:
    diff=abs(arr[i]-avg)
    pos=i
print(pos)
Buggy code:
import numpy as np
n = int(input())
a = list(map(int, input().split()))
m = np.mean(a)
ans = 0
mx = 999999
for i in range(n):
  if abs(a[i] - m) < dist:
    dist = abs(a[i] - m)
    ans = i
print(ans)


Fixed code:
import numpy as np
n = int(input())
a = list(map(int, input().split()))
m = np.mean(a)
ans = 0
dist = abs(a[0] - m)

for i in range(n):
    if abs(a[i] - m) < dist:
        dist = abs(a[i] - m)
        ans = i

print(ans)
Buggy code:
n=int(input())
l=list(map(int,input().split()))
a=sum(l)/n
ans=0
b=100
for i in range(n):
  if b>abs(l[i]-a):
    b=abs(l[i]-a)
    ans=i
print(i)

Fixed code:
n=int(input())
l=list(map(int,input().split()))
a=sum(l)/n
ans=0
b=100
for i in range(n):
  if b>abs(l[i]-a):
    b=abs(l[i]-a)
    ans=i
print(ans)
Buggy code:
n=int(input());a=list(map(int,input().split()));ave=sum(a)//n;minn=0
for i in range(1,n):
  if abs(a[minn]-ave)>abs(a[i]-ave):minn=i
print(i)

Fixed code:
n=int(input());a=list(map(int,input().split()));ave=sum(a)/n;minn=0
for i in range(1,n):
  if abs(a[minn]-ave)>abs(a[i]-ave):minn=i
print(minn)
Buggy code:
n = int(input())
a = list(map(int, input().split()))
m = sum(a)/n
d = 100
c = 0
for i in range(n):
  a[i] = abs(a[i] - m)
  if a[i] < d:
    d = a[i]
    c = i+1
print(c)

Fixed code:
n = int(input())
a = list(map(int, input().split()))
m = sum(a)/n
d = 100
c = 0
for i in range(n):
  a[i] = abs(a[i] - m)
  if a[i] < d:
    d = a[i]
    c = i
print(c)
Buggy code:
N = int(input())
a = list(map(int,input().split()))

sum = 0

for i in a:
  sum += i
  
avg = sum/N
result = 0
tmp = 0

for i in range(len(a)):
  ans = avg - a[i]
  ans = ans if ans < 0 else ans * -1
  if i == 0:
    result = i
    tmp = ans
  elif tmp > ans:
    result = i

print(result)

Fixed code:
N = int(input())
a = list(map(int,input().split()))

sum = sum(a)
avg = sum/N

result = 0
tmp = 0

for i in range(len(a)):
  ans = avg - a[i]
  ans = ans if ans > 0 else ans * -1
  if i == 0:
    result = i
    tmp = ans
  elif tmp > ans:
    result = i
    tmp = ans

print(result)
Buggy code:
N = int(input())
at = input().split(" ")
a = []
for i in at:
    a.append(int(i))
avg = sum(a) / N
mdif, flag = abs(a[0]-avg), 0
for i in range(len(a)):
    if a[i]-avg < mdif:
        mdif = a[i] - avg
        flag = i
print(flag)


Fixed code:
N = int(input())
at = input().split(" ")
a = []
for i in at:
    a.append(int(i))
avg = sum(a) / N
mdif, flag = abs(a[0]-avg), 0
for i in range(len(a)):
    if abs(a[i]-avg) < mdif:
        mdif = abs(a[i]-avg)
        flag = i
print(flag)
Buggy code:
N = int(input())
a = list(map(int, input().split()))

ave = sum(a) / N

aa =[abs(a[i] - ave) for i in range(N)]

x = min(aa)

print(aa.find(x))

Fixed code:
N = int(input())
a = list(map(int, input().split()))

ave = sum(a) / N

aa =[abs(a[i] - ave) for i in range(N)]

x = min(aa)

print(aa.index(x))
Buggy code:
n=int(input())
s=input().split()
l=[int(s[i]) for i in range(n)]
su=sum(l)
best=10000000000000000
res=0
for i in range(n):
  if(su-n*l[i]<best):
    best=su-n*l[i]
    res=i
print(res)


Fixed code:
n=int(input())
s=input().split()
l=[int(s[i]) for i in range(n)]
su=sum(l)
best=10000000000000000
res=0
for i in range(n):
  if(abs(su-n*l[i])<best):
    best=abs(su-n*l[i])
    res=i
print(res)
Buggy code:
N = int(input())
a = list(map(int,input().split()))
Mean = sum(a)/N
a_norm = [a[i] - Mean for i in range(N)]
print(a_norm.index(min(a_norm)))

Fixed code:
N = int(input())
a = list(map(int,input().split()))
Mean = sum(a)/N
a_norm = [a[i] - Mean for i in range(N)]
a_norm_abs = list(map(abs,a_norm))
print(a_norm_abs.index(min(a_norm_abs)))
Buggy code:
N = int(sys.stdin.read().rstrip())
a = [int(x) in x for stdin.readline().rstrip().split(' ')]
d = [abs(sum(a)/float(N) - ai) for ai in a]

if len(set(d))==1:
	print(0)
else:
	 print(d.index(min(d)))

Fixed code:
import sys
N = int(sys.stdin.readline().rstrip())
a = [int(x) for x in sys.stdin.readline().rstrip().split(' ')]
d = [abs(sum(a)/float(N) - ai) for ai in a]

if len(set(d))==1:
  print(0)
else:
  print(d.index(min(d)))
Buggy code:
import numpy as np

n = int(input())
a = str(input())
array = [int(s) for s in a.split()]
sum = 0
difference = 0
index = 0

avarage = np.average(array)

for i, a in enumerate(array):
    tmp_diff = abs(a-avarage)
    if i == 0:
        difference = tmp_diff
        index = 0
    else:
        if difference > tmp_diff:
            difference = tmp_diff
            index = i

print(array[index])

Fixed code:
import numpy as np

n = int(input())
a = str(input())
array = [int(s) for s in a.split()]
sum = 0
difference = 0
index = 0

avarage = np.average(array)

for i, a in enumerate(array):
    tmp_diff = abs(a-avarage)
    if i == 0:
        difference = tmp_diff
        index = 0
    else:
        if difference > tmp_diff:
            difference = tmp_diff
            index = i

print(index)
Buggy code:
from statistics import mean
import math
n = int(input())
a = list(map(int, input().split()))

m = mean(a)
Min = math.fabs(a[0]-m)
ret = []

for i in range(1, len(a)):
    if math.fabs(a[i]-m) < Min:
        Min = math.fabs(a[i]-m)
        ret.append(i)
        print(math.fabs(a[i]-m))

print(ret)

if len(ret) > 0:
    print(ret[-1])
else:
    print(0)

Fixed code:
from statistics import mean
import math
n = int(input())
a = list(map(int, input().split()))

m = mean(a)
Min = math.fabs(a[0]-m)
ret = []

for i in range(1, len(a)):
    if math.fabs(a[i]-m) < Min:
        Min = math.fabs(a[i]-m)
        ret.append(i)


if len(ret) > 0:
    print(ret[-1])
else:
    print(0)
Buggy code:
P = int(input())
N = list(map(int,input().split()))
N.reverse()
#print(N)
s = sum(N)/P
minfr=9999
ans = 0
print(s)
for i ,n in enumerate(N):
    minfr = min(minfr,abs(n-s))
    print(minfr,i,n)
    if minfr == abs(n-s):
        ans = i
    # TODO: write code...
print(abs(ans-(P-1)))

Fixed code:
P = int(input())
N = list(map(int,input().split()))
N.reverse()
#print(N)
s = sum(N)/P
minfr=9999
ans = 0
#print(s)
for i ,n in enumerate(N):
    minfr = min(minfr,abs(n-s))
    #print(minfr,i,n)
    if minfr == abs(n-s):
        ans = i
    # TODO: write code...
print(abs(ans-(P-1)))
Buggy code:
n = int(input())
a = list(map(int, input().split()))
ave_a = sum(a) / n
sa = 101
min_ind = 0
for i in range(n):
    print(abs(a[i] - ave_a))
    if sa > abs(a[i] - ave_a):
        sa = abs(a[i] - ave_a)
        min_ind = i
print(min_ind)

Fixed code:
n = int(input())
a = list(map(int, input().split()))
ave_a = sum(a) / n
sa = 101
min_ind = 0
for i in range(n):
    if sa > abs(a[i] - ave_a):
        sa = abs(a[i] - ave_a)
        min_ind = i
print(min_ind)
Buggy code:
a=input().split()
a=[int(i) for i in a]
avg =sum(a)/len(a)
a=[abs(i -avg) for i in a]
print(a.index(min(a)))

Fixed code:
a=input()
a=input().split()
a=[int(i) for i in a]
avg =sum(a)/len(a)
a=[abs(i -avg) for i in a]
print(a.index(min(a)))
Buggy code:
n=int(input())
a=[int(i) for i in input().split()]
s=sum(a)
l=len(a)
x=s/l
ans=100
for cnt,i in enumerate(a):
    y=abs(i-x)
    if y<ans:
        ans=cnt
print(ans)

Fixed code:
n=int(input())
a=[int(i) for i in input().split()]
s=sum(a)
l=len(a)
x=s/l
z=100
for cnt,i in enumerate(a):
    y=abs(i-x)
    if y<z:
        ans=cnt
        z=y
print(ans)
Buggy code:
n = int(input())
a = list(map(int, input().split()))

su = sum(a) // n
mi = 1000
ans = 1000

for i, aa in enumerate(a):
	tmp = abs(aa - su)
	if tmp < mi:
		mi = tmp
		ans = min(i, ans)
		
print(ans)


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

su = sum(a) / n
mi = 1000
ans = 1000

for i, aa in enumerate(a):
	tmp = abs(aa - su)
	if tmp < mi:
		mi = tmp
		ans = i
		
print(ans)
Buggy code:
import numpy as np
N = int(input())
a = np.array([int(x) for x in input().split(" ")])
indices = np.abs(np.subtract.outer(a, a.mean())).argmin(0)
print(a[indices])

Fixed code:
import numpy as np
N = int(input())
a = np.array([int(x) for x in input().split(" ")])
indices = np.abs(np.subtract.outer(a, a.mean())).argmin(0)
print(indices)
Buggy code:
a = list(map(int,input().split()))

k = 0
ans = 0
for i in range(N):
    k += a[i]
find = k/N
now = 1000000
for i in range(N):
    if abs(a[i]-find) < now - 0.00001:
        ans = i
        now = abs(a[i]-find)
print(ans)

Fixed code:
N = int(input())
a = list(map(int,input().split()))

k = 0
ans = 0
for i in range(N):
    k += a[i]
find = k/N
now = 1000000
for i in range(N):
    if abs(a[i]-find) < now - 0.00001:
        ans = i
        now = abs(a[i]-find)
print(ans)
Buggy code:
n = int(input())
a = list(map(int, input().split()))
tmp = max(a)
ave = sum(a)/n
ans = 0
for i in range(n):
  if tmp < abs(ave - a[i]):
    ans = 1+i
    ave = abs(ave - a[i])
print(ans)

Fixed code:
n=int(input())
a=list(map(int,input().split()))
sum=0
for i in range(n):
  sum+=a[i]
ave=sum/n
min=abs(a[0]-ave)
ans=0
for i in range(1,n):
  if (abs(a[i]-ave)<min):
    min=abs(a[i]-ave)
    ans=i
print(ans)
Buggy code:
from statistics import mean
N = int(input())
a=list(map(int,input().split(' ')))

avg=mean(a)

b=[]
for i in range(N):
    b.append(abs(a[i]-avg) )

#print(min(b))
c=sorted(b)

for i in range(N):
    if c[i]==min(b):
        print(i)
        exit(0)


Fixed code:
from statistics import mean
N = int(input())
a=list(map(int,input().split(' ')))

avg=mean(a)

b=[]
for i in range(N):
    b.append(abs(a[i]-avg) )

#print(min(b))
#c=sorted(b)

for i in range(N):
    if b[i]==min(b):
        print(i)
        exit(0)
Buggy code:
n=int(input())
*a,=map(int,input().split())
m=sum(a)/n
print(m)
i=0
s=10**18
for j in range(n):
    if abs(a[j]-m)<s:
        i=j
        s=abs(a[j]-m)
print(i)

Fixed code:
n=int(input())
*a,=map(int,input().split())
m=sum(a)/n
i=0
s=10**18
for j in range(n):
    if abs(a[j]-m)<s:
        i=j
        s=abs(a[j]-m)
print(i)
Buggy code:
N = int(input())
A = list(map(int,input().split()))

p = sum(A)/N
q = 10**9+7
for i in range(N) :
	r = abs(p - A[i])
	if r < q :
		r = q
		ans = i
print(ans)


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

p = sum(A)/N

q = 10*9
for i in range(N) :
    r = abs(A[i] - p)
    if r < q :
        q = r
        ans = i
print(ans)
Buggy code:
x,y=map(int,input().split())
y = y/2
print(x+y)

Fixed code:
x,y=map(int,input().split())
y = y//2
print(x+y)
Buggy code:
def solve(X, Y):
	ans = []


	# append output array
    ans.append(str(X + Y // 2))

    # Output according to format
    ans = '\n'.join(ans)
    return ans

# receive inputs
X, Y = list(map(int, input().split()))

# print outputs
print(solve(X, Y))


Fixed code:
def solve(X, Y):
	ans = []
	
	ans.append(str(X + Y // 2))
	
    # Output according to format
	ans = '\n'.join(ans)
	return ans

# receive inputs
X, Y = list(map(int, input().split()))

# print outputs
print(solve(X, Y))
Buggy code:
x, y = map(int, input().split())
r = x + y / 2
print(r)

Fixed code:
x, y = map(int, input().split())

print(x + y // 2)
Buggy code:
def main():
    from sys import stdin
    r = stdin.readline()[:-1]
    #r = stdin.readlines()

    x, y = map(int, r.split())
    print(x*y//2)
   
if __name__ == '__main__':
    main()



Fixed code:
def main():
    from sys import stdin
    r = stdin.readline()[:-1]
    #r = stdin.readlines()

    x, y = map(int, r.split())
    print(x+y//2)
   
if __name__ == '__main__':
    main()
Buggy code:
    x, y = map(int, input().split())
    print(int(x + (y/2)))


Fixed code:
x, y = map(int,input().split())
#x = int(input())
print(x + y//2)
Buggy code:
# -*- coding: utf-8 -*-

X,Y= map(int,input().split())
print(X + Y/2)


Fixed code:
# -*- coding: utf-8 -*-

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

print(X + Y//2)
Buggy code:
X, Y = map(int, input().split())
print(int(X+Y/2)

Fixed code:
X,Y = map(int,input().split())
print(X + Y //2)
Buggy code:
#coding:utf-8
x, y = map(int, input().split())

print(x + y/2)

Fixed code:
#coding:utf-8
x, y = map(int, input().split())

print(x + y//2)
Buggy code:
X, y = map(int, input().split())

print(x + y // 2)

Fixed code:
x,y = map(int,input().split())
print((y//2)+x)
Buggy code:
a,b=map(int.input().split())
print(a + b//2)

Fixed code:
a,b=map(int,input().split())
print(a + b//2)
Buggy code:
a,b = map(int, open(0).read().split())
print(str(a + b/2))

Fixed code:
a,b = map(int, open(0).read().split())
print(str(a + b//2))
Buggy code:
x,y=map(int,input().split())

print(x+y/2)

Fixed code:
(x, y) = list(map(int, input().split()))
print(x + y // 2)
Buggy code:
x, y = input().split
print(int(x) + int(y) / 2)

Fixed code:
x,y=map(int,input().split())
print(x+(y//2))
Buggy code:
ab = list(map(int, input().split(' ')))
res = ab[0] + (ab[1] / 2)
print(res)

Fixed code:
ab = list(map(int, input().split(' ')))
res = ab[0] + (ab[1] // 2)
print(res)
Buggy code:
a, b = map(int, input().split())

print(a + b / 2)

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

print(a + b // 2)
Buggy code:
a,b=map(int,input().split());print(a+b/2)

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

print(a + b//2)
Buggy code:
X,Y=int(input().split())
C=X+Y/2
print(C)

Fixed code:
X,Y = input().split()

X = int(X)
Y = int(Y)

print(X + Y // 2)
Buggy code:
AB, BC = [int(s) for s in input().split(" ")]
print(AB + BC/2)

Fixed code:
AB, BC = [int(s) for s in input().split(" ")]
print(AB + BC//2)
Buggy code:
X,Y=map(int,(input().split()))
C=X+Y/2
print(C)

Fixed code:
X,Y = map(int,input().split())
 
print( X + (Y // 2))
Buggy code:
X,Y = map(int,input().split())
 
print( X + (Y / 2))

Fixed code:
X,Y=map(int,input().split(" "))
print(X+Y//2)
Buggy code:
x,y = map(int,input().split())

print(x+y/2)

Fixed code:
x,y=map(int,input().split())

print(x+int(y//2))
Buggy code:
X,Y = map(int,input().split())
x = X + (Y/2)
print(x)

Fixed code:

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

print(X + Y // 2)
Buggy code:
x,y=(int(i) for i in input().split())
print(x+y/2)

Fixed code:
x,y=(int(i) for i in input().split())
print(x+y//2)
Buggy code:
x, y = map(int, (input().split()))
print(x + (y / 2))

Fixed code:
x, y = map(int, input().split(' '))
print(x+y//2)
Buggy code:
X,Y = map(int, input().split())

print(X +(Y/2))

Fixed code:
X, Y = map(int, input().split())

Z = X + Y // 2
print(Z)
Buggy code:
x,y = list(map(int,input().split()))
print(x + (y/2))

Fixed code:
x,y = map(int, input().split())
print(x+y//2)
Buggy code:
x,y = map(int, sys.stdin.readline().rstrip("\n").split())
print(x+y/2)

Fixed code:
import sys
x,y = map(int, sys.stdin.readline().rstrip("\n").split())
print(x+y//2)
Buggy code:
x,y = map(int, input().split())
print(x+(y/2))

Fixed code:
x, y = map(int, input().split())
print(x + y//2 )
Buggy code:
X,Y=map(int ,input().split())
print(X+Y/2)

Fixed code:
X, Y = map(int, input().split())

print(X+(Y//2))
Buggy code:
X Y = map(int, input().split())
print(int(X + Y/2))

Fixed code:
X, Y = input().split()

print(int(X)+int(Y)//2)
Buggy code:
x,y = map(int,input().split())
z = x+y/2
print(z)

Fixed code:
x, y = map(int, input().split())
print((x+y//2))
Buggy code:
X,Y = map(int, input().split())
# N = int(input())
print(X + Y / 2)

Fixed code:
X,Y = map(int, input().split())
# N = int(input())
print(X + Y // 2)
Buggy code:
n = input()
x,y = map(int,input().split())
y = y/2
ans = x + y
print(ans)



Fixed code:
x,y = map(int, input().split())
ans = x + y // 2
print(ans)
Buggy code:
x, y = map(int, input().split())
z = y / 2
print(x + z)

Fixed code:
x,y = map(int,input().split())
print(x+(y//2))
Buggy code:
X, Y = map(int, input().split())
print(X+Y//2.0)

Fixed code:
X, Y = map(int, input().split())
print(X+(Y//2))
Buggy code:
a,b = map(int, input().split())
print(a + (b/2))

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

print(a+b//2)
Buggy code:
x, y = map(int,input().split())
y = y / 2
print(x + y)

Fixed code:
x, y = map(int,input().split())
y //= 2
print(x + y)
Buggy code:
x,y = map(int, input().split())
print(x+y/2)


Fixed code:
x,y=map(int,input().split())
print(x+(y)//2)
Buggy code:
X, Y = map(int,input().split())
print(X + Y/2)

Fixed code:
X,Y = list(map(int,input().split()))
print(X+Y//2)
Buggy code:
X, Y = map(int, input().split())

print(str(X+Y/2))

Fixed code:
X, Y = map(int, input().split())

print(str(X+Y//2))
Buggy code:
A,B = list(map(int,input().split()))
print(A+B/2)

Fixed code:
A, B = map(int, input().split())
print(A + B // 2)
Buggy code:
X,Y=map(int,input().split())
print(X+Y/2)


Fixed code:
X, Y = map(int, input().split(' '))

print(X + Y // 2)
Buggy code:
a, b = map(int, input().split())
print(a + b / 2)

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


print(a + b//2)
Buggy code:
a,b = map(int,input().split())
print(a + b/2)

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

ans = a + b // 2

print(ans)
Buggy code:
X,Y = map(int,input().split())

ans = X + Y/2

print(ans)


Fixed code:
X, Y=map(int, input().split())
print(X+Y//2)
Buggy code:
X, Y = list(map(int, input().split()))

ans = X + Y / 2
print(ans)

Fixed code:
X,Y = map(int,input().split())

ans = X + Y//2

print(ans)
Buggy code:
X,Y = list(map(int,input().split()))
print(X + Y / 2)

Fixed code:
X,Y = map(int,input().split())
print(X+(Y//2))
Buggy code:
X,Y=[int(i) for i in input().split()]
print(X+Y/2)

Fixed code:
X, Y = [int(i) for i in input().split()]
print(X + Y // 2)
Buggy code:
x, y = map(int(), input().split(' '))
print(x + y / 2)

Fixed code:
x,y=map(int,input().split())

print(x+y//2)
Buggy code:
X, Y = map(int, input().split())

print(X + Y / 2)

Fixed code:
X,Y = map(int,input().split())
ans = X + Y//2
print(ans)
Buggy code:
a,b = map(int(),input().split())
print(a+b/2)

Fixed code:
a,b = map(int,input().split())
print(a + b // 2)
Buggy code:
x,y = map(int, input().split())

print(x+y/2)

Fixed code:
x, y = map(int,input().split())

print(x+(y//2))
Buggy code:
X, Y = map(int, input().split())

print(X + Y / 2)


Fixed code:
X, Y = map(int,input().split())

print(X+Y//2)
Buggy code:
x,y=map(int,input().split(" "))
print(x+y/2)


Fixed code:
x,y=map(int,input().split(" "))
print(x+y//2)
Buggy code:
x,y=map(int,input().split())
print(x + y/2)

Fixed code:
x, y = map(int, input().split())
discount_y = y // 2
print(x + discount_y)
Buggy code:
x, y = list(map(input().split(), int))
print(x + y//2)

Fixed code:
x, y=map(int, input().split())
print(x+y//2)
Buggy code:
X, Y = map(int,input().split())
print(X+Y/2)

Fixed code:
X,Y = map(int,input().split())

s = X+Y//2

print(s)
Buggy code:
a,b=input().split()
a=int(a)
b=int(b)
print(a+b/2)

Fixed code:
a, b = input().split()

print(int(a) + int(b) // 2)
Buggy code:
x,y = map(int,input().split())
print(x + y /2)

Fixed code:
x, y = map(int, input().split())
print(x + (y//2))
Buggy code:
A,B=map(int, input().split())
print(A+B/2)

Fixed code:
A,B=map(int,input().split())
print(A+(B//2))
Buggy code:
print(eval(input().replace(" ", +) + "//2"))

Fixed code:
print(eval(input().replace(" ", "+") + "//2"))
Buggy code:
x,y = input().split()
print(int(x)+int(y)/2)

Fixed code:
x, y = map(int,input().split( ))
print(x + (y//2))
Buggy code:
X, Y = map(int, input().split())
Z = Y / 2
M = X + Z
print(M)

Fixed code:
X, Y = map(int, input().split())
Z = Y // 2
M = X + Z
print(M)
Buggy code:
x,y = map(int,input().split())
print((x+y)//2)

Fixed code:
x,y = map(int, input().split())
print(x + (y // 2))
Buggy code:
L = list(map(int,input().split()))

print(L[0]+l[1]//2)

Fixed code:
L = list(map(int,input().split()))

print(L[0]+L[1]//2)
Buggy code:
# -*- coding: <encoding name> -*-

X, Y = map(int, input())
print(X + Y // 2)

Fixed code:
# -*- coding: <encoding name> -*-

X, Y = map(int, input().split())
print(X + Y // 2)
Buggy code:
n,m=map(int,input().split())
print(n+m/2)

Fixed code:
n,m=map(int,input().split())
print(n+m//2)
Buggy code:
x, y = map(int, input().split(' '))
print(x + y / 2)

Fixed code:
x,y = map(int, input().split())

print( x + ( y //2))
Buggy code:
a,b = map(int,input().split())

print(a + b/2)

Fixed code:
a,b = map(int,input().split(" "))
print(a + b // 2)
Buggy code:
x,y = list(map(int,input().split())
print(x+y/2)

Fixed code:
x,y = map(int,input().split())

print(x+y//2)
Buggy code:
x, y = input().split(' ')

x = int(x)
y = int(y)

sum = x + y / 2
print(sum)

Fixed code:
x, y = input().split(' ')

x = int(x)
y = int(y)

sum = x + y // 2
print(sum)
Buggy code:
x , y = map(int,input().split())
print(x+y/2)

Fixed code:
x, y = list(map(int, input().split()))
print(x + y // 2)
Buggy code:
X,Y = map(int, input().split())
print(int(X+(Y/2))

Fixed code:
X,Y = list(map(int,input().split()))
print(X + Y // 2)
Buggy code:
x, y = tuple(map(int, input().split()))

print(x + y/2)

Fixed code:
x, y = map(int,input().split())
print(x+(y//2))
Buggy code:
x,y= map(int, input().split()) 
print(x+y/2)

Fixed code:
x,y= map(int, input().split()) 
ans=x+y//2
print(ans)
Buggy code:
a,b=map(int,input().split(" "))
print(a+b/2)

Fixed code:
a,b=map(int,input().split(" "))
print(a+b//2)
Buggy code:
X, Y = map(int, input().split())
print(X + Y/2)

Fixed code:
X,Y=list(map(int,input().split()))

print(X+(Y//2))
Buggy code:
A, B = map(int, input().split())
print(A+B/2)

Fixed code:
A, B = map(int, input().split())
print(A + B // 2)
Buggy code:
x, y = map(int, input().split())
print(x+y/2)

Fixed code:
x,y = map(int,input().split())
ans = x + y//2
print(ans)
Buggy code:
x,y = int(input().split())
print(int(x + y/2))

Fixed code:
x,y = map(int,input().split())
y//= 2
print(x+y)
Buggy code:
X,Y = map(int,input().split())
price = X + Y/2
print(price)


Fixed code:
X,Y = map(int,input().split())

print(X+Y//2)
Buggy code:
X,Y=map(int,input().split())
print((X+Y)//2)

Fixed code:
X, Y = map(int, input().split())
x = X + Y //2

print(x)
Buggy code:
n,m = map(int,input().split())
print(n+(m/2))

Fixed code:
n,m = map(int,input().split())
print(n+(m//2))
Buggy code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

X, Y = MAP()

print(X+Y//2)import sys, re


Fixed code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

X, Y = MAP()

print(X+Y//2)
Buggy code:

x,y=map(int, input().split())

print(x+y/2)

Fixed code:
x, y =map(int, input().split())
print(x + y // 2)
Buggy code:
x,y = map(int,input().split())
print(x+ y/2)

Fixed code:
x,y = map(int,input().split())
print(x+ y//2)
Buggy code:
a,b = map(int,input().split())

print(int((a + b) / 2))

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

print(a + b//2)
Buggy code:
X,Y = map(int,input().split())
print(X+Y/2)


Fixed code:
X, Y = map(int, input().split())

print (X + Y//2)
Buggy code:
X, Y = map(int, input().split())
print(X+Y/2) 

Fixed code:
X , Y = map(int , input().split())

charge = X + Y // 2

print(charge)
Buggy code:
x,y=map(int,input().split())
print(int(x+y/2)

Fixed code:
x,y = map(int, input().split())
print(x + y//2)
Buggy code:
a,b=map(int, input().split())
print(a + b / 2)

Fixed code:
a, b = map(int, input().split())
print(a + b // 2)
Buggy code:
a,b = map(int, input().split())

print((a)+b/2)


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

print(a+b//2)
Buggy code:
x,y = map(int,input().split())
print(x/2+y)

Fixed code:
x,y = map(int,input().split())
print(x + (y//2))