qyliang/CodeNanoFix huggingface dataset:
Buggy code:
ini=input().split()

N=int(ini[0])
K=int(ini[1])

mod=(N+K)%2
if mod==1:
    print("IMPOSSIBLE")
else:
    print((N+K)/2)

Fixed code:
ini=input().split()

N=int(ini[0])
K=int(ini[1])

mod=(N+K)%2
if mod==1:
    print("IMPOSSIBLE")
else:
    print(int((N+K)/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(str((a+b)/2))
else:
  print("IMPOSSIBLE")

Fixed code:
a,b=map(int, input().split())
if (a+b)%2==0:
  print(str((a+b)//2))
else:
  print("IMPOSSIBLE")
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 == 0:
    print((a+b)//2)
else :
    print("IMPOSSIBLE")
Buggy code:
A,B=input().split()

if (int(A)+int(B))%2 == 1:
    print(IMPOSSIBLE)
else:
    print(int((int(A)+int(B))/2))


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

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

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


Fixed code:
#A

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

flg=(A+B)%2
if (flg == 1):
    print("IMPOSSIBLE")
else:
    print(int((A+B)/2))
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 = list(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())
ans = a + b
if(ans%2 == 0):
  print(int(ans/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())

d = A+B

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

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

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

ans = "IMPOSSIBLE"
if ((a+b)%2 == 0):
    ans = round((a+b)/2)
print(ans)
Buggy code:
a,b=map(int,input().split())
if a%2==0 and 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:
# input process
inputData = input().split()
A, B = [int(x) for x in inputData]

K = (A + B) / 2
if K.is_integer():
    print(K)
else:
    print("IMPOSSIBLE ")

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

K = (A + B) / 2
if K.is_integer():
    print(int(K))
else:
    print("IMPOSSIBLE ")
Buggy code:
a,b=map(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:
  print(int((a + b)/2))
else :
  print("IMPOSSIBLE")
Buggy code:
a,b=int(input())
if (a+b)%2==0:
    print((a+b)/2)
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = input().split()
a, b = int(a), int(b)
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((a+b)/2)
else:
    print("IMPOSSIBLE")

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

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

if (x + y) % 2 == 0:
    print((x+y)/2)
else:
    print('IMPOSSIBLE')

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

if (x + y) % 2 == 0:
    print(round((x+y)/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())

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

if a+b % 2 == 0:
  print(int(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:
N,M=map(int,input().split())
if (N+M)%2==0:
  print((N+M)/2)
 else:
  print("IMPOSSIBLE")

Fixed code:
N,M=map(int,input().split())
if (N+M)%2==0:
  print((N+M)//2)
else:
  print("IMPOSSIBLE")
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 (a-b) % 2 == 0:
    print((a+b) // 2)
else:
    print("IMPOSSIBLE")
Buggy code:
#coding: UTF-8

i = list(map(int, input().split()))

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

print(A, B)
K = (A+B)/2

if(K.is_integer() == True):
    print(int(K))
else:
    print("IMPOSSIBLE")

Fixed code:
#coding: UTF-8

i = list(map(int, input().split()))

A = i[0]
B = i[1]
K = (A+B)/2

if(K.is_integer() == True):
    print(int(K))
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 (int((a+b)/2))
else:
	print('IMPOSSIBLE')
Buggy code:
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
a,b = ma()
k2 = abs(b-a)
if k%2==1:
    print(k2//2+min(b,a))
else:
    print("IMPOSSIBLE")


Fixed code:
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
a,b = ma()
k2 = abs(b-a)
if k2%2==0:
    print(k2//2+min(b,a))
else:
    print("IMPOSSIBLE")
Buggy code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())

a, b = map(int, input().split())

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


Fixed code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())

a, b = map(int, input().split())

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

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

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

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

Fixed code:
a,b=map(int, input().split())
k=(a+b)/2
if (a+b) % 2 != 0:
    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())

n = (a+b) % 2
if n == 0:
    print((a+b) // 2)
else:
    print('IMPOSSIBLE')
Buggy code:
# -*- coding: utf-8 -*-
a, b = map(iint, input().split())

x = a+b
if x%2 == 1:
  print('IMPOSSIBLE')
else:
  print('{}',x//2)

Fixed code:
# -*- coding: utf-8 -*-
a, b = map(int, input().split())
 
x = a+b
if x%2 == 1:
  print('IMPOSSIBLE')
else:
  print('{}'.format(x//2))
Buggy code:
# -*- coding: utf-8 -*-

def main():

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

    if (A + B) % 2 == 0:
        ans = (A + B) / 2

    else:
        ans = 'IMPOSSIBLE'

    print(ans)


if __name__ == "__main__":
    main()

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

def main():

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

    if (A + B) % 2 == 0:
        ans = (A + B) // 2

    else:
        ans = 'IMPOSSIBLE'

    print(ans)


if __name__ == "__main__":
    main()
Buggy code:
a, b = map(int, input().split())

s = (a+b)/2

if abs(a - s) == abs(b - s):
  print(s)
else:
  print('IMPOSSIBLE')

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

else:
  print("IMPOSSIBLE")

Fixed code:
a,b=map(int,input().split())
k=abs((a-b)/2)
if (a-b)%2==0:
  if (a<b):
    print(int(b-k))
  else:
    print(int(a-k))

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(int((A + B) / 2))
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = list(map(int, input().split()))

k = (a+b) / 2

if k == int(k):
    print(k)
else :
    print('IMPOSSIBLE')


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

k = (a+b) / 2

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

k = (a+b) / 2

if (a+b) % 2 == 0:
    print(k)
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())
k = int(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:
  K = (A+B)//2
  print(K)
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
if a-b//2:
    print(abs(a-b)//2+min(a, b))
else:
    print("IMPOSSIBLE")

Fixed code:
a, b = map(int, input().split())
if (a-b)%2 == 0:
    print(abs(a-b)//2+min(a, b))
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("IMPOSSIBLE")
else:
  print((a+b)//2)
Buggy code:
a,b=map(int,input.split())
ans=(a+b)/2
if ans%2==0:
  print(ans//1)
else:
  print("IMPOSSIBLE")


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

Fixed code:
a,b=map(int,input().split())
k=(a+b)/2
if k.is_integer():
  print(int(k))
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int,input().split())
if a == b:
  print(0)
else:
  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')

# print(ans)
Buggy code:
a,b = map(int,input().split())

if a % 2 == 0 and b % 2 != 0:
	print('IMPOSSIBLE')
	exit()
if a % 2 != 0 and b % 2 == 0:
  	print('IMPOSSIBLE')
	exit()
print((a + b) // 2)


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

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

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

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

if a % 2 == 0 and b % 2 == 1:
  print("IMPOSSIBLE")
elif a % 2 == 1 and b % 2 == 0:
  print("IMPOSSIBLE")
else:
  if a > b:
    k = b + (a-b)/2
    print(k)
  else:
    k = a + (b-a)/2
    print(k)

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

if a % 2 == 0 and b % 2 == 1:
  print("IMPOSSIBLE")
elif a % 2 == 1 and b % 2 == 0:
  print("IMPOSSIBLE")

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

if (a-b)%2 == 0:
    if a-b > b-a:
        print((a-b)/2)
    else:
        print((b-a)/2)

else:
    print("IMPOSSIBE")

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

if (a-b)%2 == 0:
    if a-b > b-a:
        print(int(a-((a-b)/2)))
    else:
        print(int(b-((b-a)/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(int((a+b)/2))
else:
  print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input())
print((a+b)//2 if not (a+b)%2 else "IMPOSSIBLE")

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

buf = a - b

if buf % 2 = 0:
	print(buf // 2)
else:
	print("IMPOSSIBLE")

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

buf = a + b

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

K = (A + B ) / 2

if K % 1 == 0:
  print(K)
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())
 if (a+b) % 2 == 0:
   print(a+b//2)
 else:
   print("IMPOSSIBLE")

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

Fixed code:
a,s=map(int,input().split())
if a%2==s%2:
  print((a+s)//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 = list(map(int, input().split()))

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

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

c = max(a,b)-min(a,b)
if c % 2 == 0:
  print("c // 2")
else:
  print("IMPOSSIBLE")

Fixed code:
a, b = map( int, input().split())
 
c = max(a,b)+min(a,b)
if c % 2 == 0:
  print(c // 2)
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
def kansu_return_flag(a,b):
    ans = 0
    flag = 0

    if abs(a-b)%2 != 0:
        flag = 0
        print('aaaa')
    else:
        ans = abs(a-b)/2 + a
        flag = 1
    return flag,ans

flag,ans = kansu_return_flag(a,b)

if flag == 1:
    print(ans)
else:
    print('IMPOSSIBLE')

Fixed code:
a, b = map(int, input().split())
def kansu_return_flag(a,b):
    ans = 0
    flag = 0

    if abs(a-b)%2 != 0:
        flag = 0
    else:
        ans = (a+b)/2
        flag = 1
    return flag,ans

flag,ans = kansu_return_flag(a,b)

if flag == 1:
    print(int(ans))
else:
    print('IMPOSSIBLE')
Buggy code:

ab = input().split()
A, B = int(ab[0]), int(ab[1])

if A == B:
    print(1)
    return
elif A % 2 != B % 2:
    print("IMPOSSIBLE")
    return
else:
    K = (A+B) // 2
    if abs(A-K) == abs(B-K):
        print(K)
        return
    else:
        print("IMPOSSIBLE")
        return


Fixed code:
ab = input().split()
A, B = int(ab[0]), int(ab[1])

if A == B:
    print(1)
elif A % 2 != B % 2:
    print("IMPOSSIBLE")
else:
    K = (A+B) // 2
    if abs(A-K) == abs(B-K):
        print(K)
    else:
        print("IMPOSSIBLE")
Buggy code:
a,b=map(int, input().split())
if a<b:
  a,b=b,a
#a>b is assured.
k=(a+b)/2
if k%1==0 and b<k<a:
    print(k)
else:
  print("IMPOSSIBLE")

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

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 == 1:
    print('INPOSSIBLE')
else:
    print((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())
ab = a + b
if ab % 2 == 0:
    print(ab//2)
else:
    print('IMPOSSIBLE2')


Fixed code:
a, b = map(int, input().split())
ab = a + b
if ab % 2 == 0:
    print(ab//2)
else:
    print('IMPOSSIBLE')
Buggy code:
import math
a, b = [int(i) for i in input().split()]
r = a - b
if r % 2 is 0:
  print(abs(int(r / 2)))
else:
  print("IMPOSSIBLE")
  


Fixed code:
import math
a, b = [int(i) for i in input().split()]
r = a - b if a > b else b - a
if r % 2 is 0:
  print(abs(int(r / 2)) + (a if a < b else b))
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())
ans = a+b

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


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

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

if (A-B)%2==0:
  print(answer)
else :
  print('imposible')

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

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

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

if (a - b) % 2 == 0:
  r = int(abs(a - b)/2 + min(a, b) )
else:
  r = 'IMPOSSIBLE'
print(r)

Fixed code:
a, b = map(int, input().split())
 
if (a - b) % 2 == 0:
  r = int(abs(a - b)/2 + min(a, b))
else:
  r = 'IMPOSSIBLE'
print(r)
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().strip().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:
inputA,B = input().split()
a = int(A)
b = int(B)
K = (a+b)/2
if K == int(K):
  print(int(K))
else:
  print('IMPOSSIBLE')

Fixed code:
A,B = input().split()
a = int(A)
b = int(B)
K = (a+b)/2
if K == int(K):
  print(int(K))
else:
  print('IMPOSSIBLE')
Buggy code:
a,b=int(input().split())
c=a+b
if c%2==0:
  print(c/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 = sorted(list(map(int,input().split())))
z = B-A

if z%2==0:
  print(z)
else:
  print("IMPOSSIBLE")

Fixed code:
A,B = sorted(list(map(int,input().split())))
z = B-A

if z%2==0:
  print(z//2+A)
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())
print('IMPOSSIBLE' if (A+B)%2!=0 else (A+B)//2)
Buggy code:
A, B = map(int, input().split())
K = (A + B)/2
if K == int(K):
  print(K)
else:
  print('IMPOSSIBLE')

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

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

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


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 != 0:
    print('IMPOSSIBLE')
else:
    print((a+b)/2)

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

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

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

Fixed code:
A, B = map(int, input().split())
if A == B:
    print(0)
else:
    if (A + B) % 2 == 0:
        print((A+B)//2)
    else:
        print("IMPOSSIBLE")
Buggy code:
A,B = map(int,input().split())
 
K=(A+B)/2
 
def is_integer_num(n):
    if isinstance(n, int):
        return True
    if isinstance(n, float):
        return n.is_integer()
    return False
 
if is_integer_num(K)==False:
  print(IMPOSSIBLE)
else:
  print(K)

Fixed code:
A,B = map(int,input().split())
 
K=(A+B)/2
 
def is_integer_num(n):
    if isinstance(n, int):
        return True
    if isinstance(n, float):
        return n.is_integer()
    return False
 
if is_integer_num(K)==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((a+b)//2)
else:
    print('IMPOSSIBLE')
Buggy code:
a, b = map(int, input().split())
sub = (a+b)/2
if sub % 1 != 0:
  print("IIMPOSSIBLE")
else:
  print(sub)

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

K = (A+B) / 2

if K%2 == 0:
    result = int(K)
else:
    result = "IMPOSSIBLE"
    
print(result)
        

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

K = (A+B)

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

Fixed code:
a,b=map(int,input().split())
val=(a+b)//2
if(val*2==a+b):
  print(val)
else:
  print("IMPOSSIBLE")
Buggy code:
a, b = [int(n) for n in input().split()]
print(a, b)

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


Fixed code:
a, b = [int(n) for n in input().split()]

if (a+b) % 2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")
Buggy code:
A,B=map(int,input().split())
print((A+B)/2) if (A+B)%2==0 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:
# coding: utf-8

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

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

Fixed code:
# coding: utf-8
 
A,B = map(int, input().split())
 
if (A+B)%2 == 0:
  print(int((A+B)/2))
else:
  print("IMPOSSIBLE")
Buggy code:
a,b=(int(x) for x in input().split())

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

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

print("IMPOSSIBLE" if (a+b)%2==1 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((b+a)%2==0):
	print((a+b)//2)
else:
	print("IMPOSSIBLE")
Buggy code:
A,B = map(int, input().split())

i = (A+B)/2 

if i % 1 ==0:
    print(i)
else:
    print('IMPOSSIBLE')

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

i = (A+B)/2 

if i % 1 ==0:
    print(int(i))
else:
    print('IMPOSSIBLE')