qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a = [int(s) for s in input().split()]
p = (a[0] + a[1]) / 2
if p == int(p):
  print(p)
else:
  print("IMPOSSIBLE")

Fixed code:
a = [int(s) for s in input().split()]
p = (a[0] + a[1]) / 2
if p == int(p):
  print(int(p))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())
if a+b % 2 !=0:
  print("IMPOSSIBLE")
else:
  print((a+b)/2)

Fixed code:
a,b = map(int,input().split())
if (a + b) % 2 == 0:
    print((a+b)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
l=list(map(int,input().rstrip().split()))
a=l[0]
b=l[1]
k=(a+b)/2
g=int(k)
if(k==g):
    print(k)
else:
    print("IMPOSSIBLE")

Fixed code:
l=list(map(int,input().rstrip().split()))
a=l[0]
b=l[1]
k=(a+b)/2
g=int(k)
if(k==g):
    print(g)
else:
    print("IMPOSSIBLE")
Buggy code:
A= list(map(int,input().split()))
if (A[0]+A[1])//2 == 0:
    print((A[0]+A[1])//2)
else:
    print('IMPOSSIBLE')

Fixed code:
A= list(map(int,input().split()))
if (A[0]+A[1])%2 == 0:
    print(int((A[0]+A[1])/2))
else:
    print('IMPOSSIBLE')
Buggy code:
a, x =map(int, input().split())
if (a+x)%2 ==0:
  print((a+x)/2)
else:
  print('IMPOSSIBLE')

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

if (a+b)%2 ==0:
  print(int((a+b)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b = map(int, input().split() )
 
if abs(b-a)%2==0:
    print(int(abs(b-a)/2))
else:
    print('IMPOSSIBLE')

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

if abs(a-b)%2 == 0:
    print(int((a+b)/2))
else:
    print('IMPOSSIBLE')
Buggy code:
A ,B = list(map(int,input().split()))
if (A+B)%2==0:
    print((A+B)/2)
else:
    print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().strip().split())
if (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
A,B = map(int, input().split())
C=(A+B)/2
D=A+B
if D %2 != 0:
    print('IMPOSSIBLE')
elif D %2 == 0:
    print(C)

Fixed code:
A,B = map(int, input().split())
C=(A+B)/2
D=A+B
if D %2 > 0:
    print('IMPOSSIBLE')
elif D %2 == 0:
    print((A+B)//2)
Buggy code:
a,b = map(int,input().split())
n=a+b
if n%2==0:print(n/2)
else:print("IMPOSSIBLE")

Fixed code:
a,b = map(int, input().split())
s = a+b
if s%2==0:
    print(int(s/2))
else:
    print('IMPOSSIBLE')
Buggy code:
A,B = map(int, input().split())
if A+B %2 == 1:
    print('IMPOSSIBLE)
else:
    print((A+B)/2)

Fixed code:
A, B = map(int, input().split())
if (A + B) % 2 == 0:
	print((A + B) // 2)
else:
	print('IMPOSSIBLE')
Buggy code:
# -*- coding:utf8 -*-

a[0],b[1] = sorted(list(map(int,input().split())))
ans = a + ((b - a) / 2) if (b - a) % 2 == 0 else 'IMPOSSIBLE'
print(ans)

Fixed code:
# -*- coding:utf8 -*-

l = sorted(list(map(int,input().split())))
a, b = l[0], l[1]
ans = int(a + ((b - a) / 2)) if (b - a) % 2 == 0 else 'IMPOSSIBLE'
print(ans)
Buggy code:
A,B = map(int, input().split())
K2 = abs(A-B)
if K2%2 == 0:
    print(int(K2/2) )
else:
    print("IMPOSSIBLE")

Fixed code:
A,B = map(int, input().split())
K2 = abs(A-B)
if K2%2 == 0:
    print(int(max(A,B) - K2/2) )
else:
    print("IMPOSSIBLE")
Buggy code:
a=[]
for x in input().split(" "):
    a.append(int(x))

if a[0]+a[1]%2==0:
    print((a[0]+a[1])/2)
else:
    print("IMPOSSIBLE")

Fixed code:
a=[]
for x in input().split(" "):
    a.append(int(x))

if (a[0]+a[1])%2==0:
    print((a[0]+a[1])//2)
else:
    print("IMPOSSIBLE")
Buggy code:
import sys
stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

a, b = li()

print((a+b) // 2 if (a+b) % 2 == 0 else "IMPOSSIBLE"

Fixed code:
import sys
stdin = sys.stdin

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

a, b = li()

print((a+b) // 2 if (a+b) % 2 == 0 else "IMPOSSIBLE")
Buggy code:
n=[int(i) for i in input().split()]
ans=n[0]+n[1]
if(ans%2==0):
  print(ans)
else:
  print("IMPOSSIBLE")

Fixed code:
n=[int(i) for i in input().split()]
ans=n[0]+n[1]
if(ans%2==0):
  print(int(ans/2))
else:
  print("IMPOSSIBLE")
Buggy code:
ab = list(map(int, input().split()))
a = ab[0]
b = ab[1]

mid2 = a + b

if mid2 % 2 == 0:
    mid = mid2 / 2
  else:
    mid = 'IMPOSSIBLE'
    
print(mid)

Fixed code:
ab = list(map(int, input().split()))
a = ab[0]
b = ab[1]

mid2 = a + b

if mid2 % 2 == 0:
    mid = int(mid2 / 2)
else:
    mid = 'IMPOSSIBLE'
    
print(mid)
Buggy code:
a, b = (int(x) for x in input().split())

if a % 2 == b % 2:
    print((a + b) / 2)
else:
    print("impossible"

Fixed code:
a, b = (int(x) for x in input().split())

if a % 2 == b % 2:
    print(int((a + b) / 2))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().splut());print((a+b)//2 if (a+b)%2==0 else "IMPOSSIBLE)
"

Fixed code:
a,b=map(int,input().split());print((a+b)//2 if (a+b)%2==0 else "IMPOSSIBLE")
Buggy code:
A,B = map(int, input().split())
a = min(A,B)
b = max(A,B)
if (a+b) % 2 == 0:
	print(int((b-a)/2))
else:
	print("IMPOSSIBLE")


Fixed code:
A,B = map(int, input().split())
a = min(A,B)
b = max(A,B)
if (a+b) % 2 == 0:
	print(int((b-a)/2 + a))
else:
	print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
c = a+b
if c % 2 == 0:
  c = abs(c)
  print(c/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int,input().split())
c = a+b
if c % 2 == 0:
  print(int(c/2))
else:
  print("IMPOSSIBLE")
Buggy code:
A,B = map(int, input().split())

print(abs(A-B)//2) if (A+B)%2 == 0 else print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split())
if abs(A-B) % 2 == 0:
  print((A+B)//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a = list(map(int, input().split()))

b = a[0] + a[1]

if b % 2 == 0:
  print(b/2)
else:
  print('IMPOSSIBLE')

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

b = a[0] + a[1]

if b % 2 == 0:
  print(b//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
if ((a + b)%2) == 0:
  print (a + b)//2
else:
  print ('IMPOSSIBLE')

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

if (a+b)%2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
print((lambda x:('IMPOSSIBLE' if (x[0]+x[1])%2==1 else (x[0]+x[1])/2))(list(map(int,input().split()))))

Fixed code:
print((lambda x:('IMPOSSIBLE' if (x[0]+x[1])%2==1 else (x[0]+x[1])//2))(list(map(int,input().split()))))
Buggy code:
A, B = list(map(int, input().split()))
result = (A+B)/2 if (A+B)%2 == 0 else "IMPOSSIBLE"
print(result)

Fixed code:
A, B = map(int, input().split())
print((A+B)//2 if (A+B)%2==0 else "IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())
if (a+b)%2==0:
    print((a+b)/2)
else:
    print("impossible")

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

if (a+b)%2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = list(map(int, input().split()))
resutl = (A+B)/2 if (A+B)%2 == 0 else "IMPOSSIBLE"
print(result)

Fixed code:
A, B = list(map(int, input().split()))
result = (A+B)//2 if (A+B)%2 == 0 else "IMPOSSIBLE"
print(result)
Buggy code:
A, B = map(int, input().split())
K = (A**2 - B**2) / (2*(A-B))

if round(K,0) == K:
  print(K)
else:
  print("IMPOSSIBLE")

Fixed code:
A, B = map(int, input().split())
K = (A**2 - B**2) / (2*(A-B))

if round(K,0) == K:
  print(int(K))
else:
  print("IMPOSSIBLE")
Buggy code:
import itertools

def getint(): return int(input())
def getints(): return list(map(int, input().split()))

a,b=list(sorted(getints()))


print((b-a)//2 if (b-a) % 2 == 0 else "IMPOSSIBLE")


Fixed code:
import itertools

def getint(): return int(input())
def getints(): return list(map(int, input().split()))

a,b=list(sorted(getints()))


print(a+(b-a)//2 if a%2==b%2 else "IMPOSSIBLE")
Buggy code:
a,b = map(int, input().split())

if (a+b)%2 == 0:
    print((a+b)/2)
else
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
if a % 2 != b % 2:
  print("IMPOSSIBLE")
else:
  print((a + b) // 2)
Buggy code:
a,b = map(int,input().split)
if((a + b) % 2 == 0):
    print((a + b) / 2)
else:
    print('IMPOSSIBLE')

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

if a%2 != b%2:
  print("IMPOSSIBLE")
else:
  print((a+b)//2)
Buggy code:
inp = input().split()
A = int(inp[0])
B = int(inp[1])
if ((A +B) /2) % 2== 0:
    print((A+B)/2)
else:
    print("IMPOSSIBLE")

Fixed code:
inp = input().split()
A = int(inp[0])
B = int(inp[1])
if (A + B) % 2== 0:
    print(int((A+B)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int, input().split())
if abs(a-b)%2==0:
  print(min(a,b)+(a-b)//2)
else:
  print("IMPOSSIBLE")


Fixed code:
a,b = map(int, input().split())
a,b = max(a,b),min(a,b)
if (a-b)%2==0:
  print(int(b+(a-b)//2))
else:
  print("IMPOSSIBLE")
Buggy code:
A,B = int(input().split())
C = A+B
if C % 2 == 0:
    K = int(C/2)
else:
    K = "IMPOSSIBLE"

Fixed code:
A,B = map(int,input().split())
C = A+B
if C % 2 == 0:
    K = int(C/2)
else:
    K = "IMPOSSIBLE"
print(K)
Buggy code:
A, B = map(int,input().split())
K = A+B
if K%2==0:
    print(K/2)
else:
    print("IMPOSSIBLE")

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

if (A+B) % 2 > 0:
  print("IMPOSSIBLE")
else:
  print ((A+B) // 2)
Buggy code:
S = input()

S = list(map(int, S.split()))

A = S[0]
B = S[1]

f = (A+B) / 2

if f.is_integer():
    print(int(f))
else:
    print(IMPOSSIBLE)


Fixed code:
S = input()

S = list(map(int, S.split()))

A = S[0]
B = S[1]

f = (A+B) / 2

if f.is_integer():
    print(int(f))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
if a % 2 == b % 2:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
if (a-b)%2==1:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)
Buggy code:
a,b = map(int,input().split())
if (a + b)%2 = 0:
    print((a+b)/2)
else:
    print("IMPOSSIBLE") 
    

Fixed code:
a,b = map(int,input().split())
if (a + b)%2 == 0 :
    print(round((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
if a+b%2 ==1:
    print("IMPOSSIBLE")
else:
    print((a+b)/2)

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

if (a + b) % 2 == 0:
  print (a + b) // 2
else:
  "IMPOSSIBLE"

Fixed code:
ab = input().split()
a = int(ab[0])
b = int(ab[1])
 
if (a + b) % 2 == 0:
    print((a + b) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())

if (A-B)%2==0:
    print(int((A+B)/2))
else :
    print('IMPSSIBLE')

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

if (A-B)%2==0:
    print(int((A+B)/2))
else :
    print('IMPOSSIBLE')
Buggy code:

A,B=map(int,input().split())

if (A+B)%2=1:
  print("IMPOSSIBLE")

else:
  print((A+B)/2)

Fixed code:

A,B=map(int,input().split())

if (A+B)%2==1:
  print("IMPOSSIBLE")

else:
  print(int((A+B)/2))
Buggy code:
A, B = map(int, input().split())
if A == B or (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print("No")

Fixed code:
A, B = map(int, input().split())
if A == B or (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int, input().split())

k=0
if (a+b )%2 == 0:
   print((a+b)/2  )
else:
   print("IMPOSSIBLE")


Fixed code:
a, b = map(int, input().split())
if (a - b) % 2 == 0:
    print((a + b) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
f=True
if a%2==0 and b%2==0:
  print((a+b)//2)
else:
  print("IMPOSSIBLE")


Fixed code:
a,b = map(int,input().split())
f=True
if a%2 == b%2:
  print((a+b)//2)
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=map(int, input().split())
if (a+b)%2==1:
  print('IMPOSSIBLE')
else:
  print(int(a+b)/2))

Fixed code:
a,b=map(int, input().split())
if (a+b)%2==1:
  print('IMPOSSIBLE')
else:
  k=int((a+b)/2)
  print(k)
Buggy code:
a,b = map(int,input().split())
if (a+b) % 2 ==0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int,input().split())
if (a+b)%2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
a,b=map(int,input().split())
if (a+b)%2 == 1 :
    print("IMPOSSIBLE")
else :
    print((a+b)/2)

Fixed code:
a,b=map(int,input().split())
if (a+b)%2 == 1 :
    print("IMPOSSIBLE")
else :
    print(int((a+b)/2))
Buggy code:
a, b = map(int,input().split())
c = a+b

if c%2==0:
  print(c/2)
else:
  print('IMPOSSIBLE')

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

if c%2==0:
  print(int(c/2))
else:
  print('IMPOSSIBLE')
Buggy code:
A,B = map(int,input().split())
k=(A**2-B**2)/(2*A-2*B)
if k == int(k):
  print(int(k))
else:
  print(IMPOSSIBLE)
    

Fixed code:
A,B = map(int,input().split())
k=(A**2-B**2)/(2*A-2*B)
if k == int(k):
  print(int(k))
else:
  print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input().split())
ans = (A+B)/2

if ans == (A+B)//2:
  print(ans)
else:
  print("IMPOSSIBLE")

Fixed code:
A, B = map(int, input().split())
ans = (A+B)//2

if ans == (A+B)/2:
  print(ans)
else:
  print("IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())
if　(A+B)%2 !=0:
  print('IMPOSSIBLE')
else:
  print((A+B)//2)

Fixed code:
A,B=map(int,input().split())
K=A+B
if K%2==0:
    K=int(K/2)
else:
    K='IMPOSSIBLE'

print(K)
Buggy code:
a,b=map(int,input().split())
if (a+b)%2==0:print((a+b)/2)
else:print("IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
if (a+b)%2==1:
    print("IMPOSSIBLE")
else:
    print((a+b)//2)
Buggy code:
x,y = map(int,input().split())
if (x + y) % 2 == 1:
  print("IMPOSSIBLE")
else:
  c = (x + y) /2
  print(c)

Fixed code:
x,y = map(int,input().split())
if (x + y) % 2 == 1:
  print("IMPOSSIBLE")
else:
  c = (x + y) /2
  print(int(c))
Buggy code:
A,B = (int(x) for x in input().split())

if (A+B) % 2 == 0:
    print(int((A+B)/2))
else:
    print('IMPOSSIBLIE')

    


Fixed code:
A,B = (int(x) for x in input().split())

if (A+B) % 2 == 0:
    print(int((A+B)/2))
else:
    print('IMPOSSIBLE')
Buggy code:
A, B = map(int, input().split())
if A==B:
  K=1
  print(K)
else:
  if (A+B)%2==0:
    K=(A+B)/2
    print(K)
  else:
    print('IMPOSSIBLE')


Fixed code:
A, B = map(int, input().split())
if (A+B) % 2 == 0:
    print(int((A+B) / 2))
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
if a+b%2==0:
    print((a+b)/2)
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
if (a+b)%2==0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input().split())
if A==B:
  K=1
  print(K)
else A!=B:
  if (A+B)%2==0:
    K=(A+B)/2
    print(K)
  else:
    print('IMPOSSIBLE')


Fixed code:
A, B = map(int, input().split())
if A==B:
  K=1
  print(K)
else:
  if (A+B)%2==0:
    K=(A+B)/2
    print(int(K))
  else:
    print('IMPOSSIBLE')
Buggy code:
A, B = map(int(input()))
if (A+B) % 2 == 0:
  print((A+B)//2)
else:
  print('IMPOSSIBLE')

Fixed code:
A, B = map(int,input().split())
if (A+B) % 2 == 0:
    print((A+B)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = [int(i) for i in input().split()]
if (a + b) / 2 % 1 == 0:
  print(int(a + b / 2))
else:
  print("IMPOSSIBLE")

Fixed code:
a, b = [int(i) for i in input().split()]
if (a + b) / 2 % 1 == 0:
  print(int((a + b) / 2))
else:
  print("IMPOSSIBLE")
Buggy code:
def main():
    s = input().split()
    if (int(s[0]) + int(s[1])) % 2 == 0:
        print(int((int(s[0]) + int(s[1])/2)))
    else:

        print('IMPOSSIBLE')


if __name__ == "__main__":
    main()



Fixed code:
def main():
    s = input().split()
    if (int(s[0]) + int(s[1])) % 2 == 0:
        print(int((int(s[0]) + int(s[1]))/2))
    else:
        print('IMPOSSIBLE')


if __name__ == "__main__":
    main()
Buggy code:
a,b=map(int,input().split())
if a+b/2:
  print("IMPOSSIBLE")
else:
  print(a+b/2)

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

if (a+b) / 2 != (a+b) // 2:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)
Buggy code:
a,b=map(int,input().split())
if abs(a-b)%2==0:
  print(abs(a-b)//2)
else:
  print("IMPOSSIBLE")

Fixed code:
a,b = map(int, input().split())
if abs(a-b)%2:
  print("IMPOSSIBLE")
else:
  print((a+b)//2)
Buggy code:
a, b = map(int, input().split())

if (a + b) % 2 == 1:
    print("IMPOSSIBLE")
else:
    print((a + b) / 2)



Fixed code:
a,b=map(int,input().split())
print((a+b)//2 if a%2==b%2 else 'IMPOSSIBLE')
Buggy code:
a, b = (int(i) for i in input().split())

if a % 2 != b % 2:
  print("IMPOSSIBLE")
else:
  print((a+b) / 2)

Fixed code:
a, b = (int(i) for i in input().split())
 
if a % 2 != b % 2:
  print("IMPOSSIBLE")
else:
  print(int((a+b) / 2))
Buggy code:
 a, b = map(int, input().split())
 if (abs(a)+abs(b))%2 == 0:
     print(int((abs(a) + abs(b))/2))
 else:
     print("IMPOSSIBLE")

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

if (a+b) %2 == 0:
  print((a+b)//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
print((a+b)//2 if (a+b)%2 == 0 else 'IMPSSIBLE')

Fixed code:
a,b=map(int,input().split())
print((a+b)//2 if (a+b)%2==0 else "IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())
K=(A+B)/2
print(K if K==int(K) else 'IMPOSSIBLE')

Fixed code:
A,B=map(int,input().split())
K=(A+B)/2
print(int(K) if K==int(K) else 'IMPOSSIBLE')
Buggy code:
A, B = map(int, input().split())
if (A+B)%2 != 0:
    print((A+B)//2)
else:
    print("IMPOSSIBLE)

Fixed code:
A, B = map(int, input().split())
if (A+B)%2 == 0:
  print((A+B)//2)
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
if ((a+b)/2)is_integer():
  print((a+b)//2)
  exit()
print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
if ((a+b)/2).is_integer():
  print((a+b)//2)
  exit()
print("IMPOSSIBLE")
Buggy code:
a,b = map(int,input().split())
d = abs(a+b)
if d %2 ==1:
  print('IMPOSSIBLE')
else:
  print(d/2)

Fixed code:
a,b = map(int,input().split())
d = a+b
if d %2 ==1:
  print('IMPOSSIBLE')
else:
  print(int(d/2))
Buggy code:
a,b = map(int,input().split())

if (a+b)%2 == 0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
if (a + b) % 2 == 0 :
  print(int((a+b)/2))
else :
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
if (a + b) % 2 == 0 :
  print((a + b) / 2)
else
  print("IMPOSSIBLE")


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

if ((a+b)%2==0):
  cnt = int((a+b)/2)
  print( cnt )
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().splid())
if (a + b) % 2 == 0 :
  print((a + b) / 2)
else
  print("IMPOSSIBLE")


Fixed code:
a, b = map(int, input().split())
if (a + b) % 2 == 0 :
  print((a + b) // 2)
else :
  print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input())
print((A + B) // 2 if abs(A - B) % 2 == 0 else 'IMPOSSIBLE')


Fixed code:
A, B = map(int, input().split())
print((A + B) // 2 if abs(A - B) % 2 == 0 else 'IMPOSSIBLE')
Buggy code:
a,b=map(int,input().split())
if((a+b)%2==1):
    print("INPOSSIBLE")
else:
    print((int((a+b)/2)))

Fixed code:
a,b=map(int,input().split())
if (a+b)%2==1:print("IMPOSSIBLE")
else:print((a+b)//2)
Buggy code:
A, B = map(int, input().split())
print((A+B)/2 if (A+B) % 2 == 0 else "IMPOSSIBLE")

Fixed code:
A,B = map(int, input().split())
print((A+B)//2) if (A+B)%2==0 else print("IMPOSSIBLE")
Buggy code:
#ABC135A - Harmony
A, B = list(map(int,input().split()))
if (max(A,B) - min(A,B)) % 2 == 1:
    print("IMPOSSIBLE")
else:a
    print((A+B)//2)

Fixed code:
#ABC135A - Harmony
A, B = list(map(int,input().split()))
if (max(A,B) - min(A,B)) % 2 == 1:
    print("IMPOSSIBLE")
else:
    print((A+B)//2)
Buggy code:
a, b = (int(x) for x in input().split())
if (a - b) % 2 == 0:
    print(int((a + b) / 2))
else:
    print("INPOSSIBLE")

Fixed code:
a, b = (int(x) for x in input().split())
if (a - b) % 2 == 0:
    print(int((a + b) / 2))
else:
    print("IMPOSSIBLE")
Buggy code:
import numpy as np

temp=list(map(int, input().split()))
temp=np.mean(temp)
if temp-int(temp)>0:
  output='IMPOSSIBLE'
else:
  output=temp
  
print(int(output))

Fixed code:
import numpy as np

temp=list(map(int, input().split()))
temp=np.mean(temp)
if temp-int(temp)>0:
  output='IMPOSSIBLE'
else:
  output=int(temp)
  
print(output)
Buggy code:
a = list(map(int, input().split()))
b = a[0] + a[1]
if b%2 == 0:
  print(b/2)
else:
  print('IMPOSSIBLE')

Fixed code:
a = list(map(int, input().split()))
b = a[0] + a[1]
if b%2 == 0:
  print(int(b/2))
else:
  print('IMPOSSIBLE')
Buggy code:
A,B=[int(x) for x in input().split()]
if A==B:
  print(0)
else:
  if (A+B)%2!=0:
    print('IMPOSSIBLE')
  else:
    print((A+B)/2)

Fixed code:
A,B=[int(x) for x in input().split()]
if A==B:
  print(0)
else:
  if (A+B)%2!=0:
    print('IMPOSSIBLE')
  else:
    print((A+B)//2)
Buggy code:
A,B = map(int,input().split())
K = 0
if (A+B)%2 == 0:
  K = (A+B) /2
else:
  K = 'IMPOSSIBLE'
  
print(int(K))


Fixed code:
A, B = map(int, input().split())
if (A + B) % 2 == 0:
	print((A + B) // 2)
else:
	print("IMPOSSIBLE")
Buggy code:
A, B= map(int, input().split())		#type int
if ((A+B)/2)%2 == 0:
	print(int((A+B)/2))
else:
	print("IMPOSSIBLE")

Fixed code:
A, B= map(int, input().split())		#type int
if (A+B)%2 == 0:
	print(int((A+B)/2))
else:
	print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
if (a+b)%2 == 0:
    print((a+b)/2)
else:
    print('IMPOSSIBLE')

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

k = (a + b) / 2

if k%1 == 0:
    print(int(k))
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
k = (a+b)/2
if abs(a-k) == abs(b-k):
    print(k)
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
k = int((a+b)/2)
if abs(a-k) == abs(b-k):
    print(int(k))
else:
    print("IMPOSSIBLE")
Buggy code:
A, B = map(int, input().split())
print('IMPOSSIBLE' if A%2 != B%2 else abs(B-A) // 2)

Fixed code:
A, B = map(int, input().split())
print('IMPOSSIBLE' if A%2 != B%2 else min(A, B) + abs(B-A) // 2)
Buggy code:
a,b=map(int, input().split())
print((a+b)/2 if (a+b)%2==0 else 'IMPOSSIBLE')


Fixed code:
a, b = map(int, input().split())
if (a + b)%2 == 0:
  k = (a + b)//2
  print(k)
else:
  print('IMPOSSIBLE')
Buggy code:
i = list(map(int, input().split()))

A = i[0]
B = i[1]

k = (A + B) / 2

if k.is_integer() == False:
	print(IMPOSSIBLE)
else:
	print(int(k))


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

A = i[0]
B = i[1]

k = (A + B) / 2

if k.is_integer() == False:
	print("IMPOSSIBLE")
else:
	print(int(k))
Buggy code:
A, B = map(int, input().split(' '))

if (A + B) % 2 == 0:
  print((A+B)/2)
else:
  print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split(' '))

if (A + B) % 2 == 0:
  print(int((A+B)/2))
else:
  print('IMPOSSIBLE')
Buggy code:
p,q=map(int,input().split())
if (p-q)%2==1:
  print("IMPOSSIBLE")
else:
  print(abs((p-q)//2))

Fixed code:
p,q=map(int,input().split())
if (p-q)%2==1:
  print("IMPOSSIBLE")
else:
  print((p+q)//2)
Buggy code:
A,B=input().sprit(" ")
A,B=int(A),int(B)

K=A+B
if K%2==0:
  print(K/2)
else:
  print("IMPOSSIBLE")

Fixed code:
A,B=input().split(" ")
A,B=int(A),int(B)

K=A+B
if K%2==0:
  print(int(K/2))
else:
  print("IMPOSSIBLE")
Buggy code:
_l=input().split()
_s=sum([int(i) for i in s])
if _s % 2 != 0:
  print('IMPOSSIBLE')
else:
  print(s/2)

Fixed code:
_l = input().split()
_s = sum([int(i) for i in _l])
if _s % 2 != 0:
    print('IMPOSSIBLE')
else:
    print(int(_s / 2))
Buggy code:
a, b = map(int, input().split())
if (a+b)/2 %2 == 0:
    print("IMPOSSIBLE")
else:
    print(str(int((a+b)/2)))


Fixed code:
a, b = map(int, input().split())
if ((a+b))%2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
if ((a+b)/2)%2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")


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

print("IMPOSSIBLE" if (a + b) % 2 else (a + b)//2)
Buggy code:
A, B = map(int, input().split())

if (A+B)%2 == 0:
    print( (A+B)/2 )
else:
    print('IMPOSSIBLE')

Fixed code:
A, B = map(int, input().split())
if (A+B)%2 == 1:
    print('IMPOSSIBLE')
else:
    print((A+B)//2)
Buggy code:
a,b=map(int,input().split())
if a%2==b%2:
    print((a+b)/2)
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
x = a + b
if x % 2:
    print('IMPOSSIBLE')
else:
    print(x // 2)