qyliang/CodeNanoFix huggingface dataset:
Buggy code:
# ABC135a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

a, b = map(int, input().split())
#print((a + b) / 2)
ans = (a + b) / 2
if (ans.is_integer()):
    print((a + b) // 2)
    exit()
print("impossible")

Fixed code:
# ABC135a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

a, b = map(int, input().split())
#print((a + b) / 2)
ans = (a + b) / 2
if (ans.is_integer()):
    print((a + b) // 2)
    exit()
print("IMPOSSIBLE")
Buggy code:
L,R = map(int,input().split())

ans = (L+R)/2

if ans.is_integer():
  return int(ans)
else:
  return "IMPOSSIBLE"

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

ans = (L+R)/2

if ans.is_integer():
  print(int(ans))
else:
  print("IMPOSSIBLE")
Buggy code:
, 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())
c = a + b
if c % 2 == 1:
    print("IMPOSSIBLE")
else:
    print(c / 2)


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

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

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


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

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

if __name__ == '__main__':
    main()

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

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

if __name__ == '__main__':
    main()
Buggy code:
A,B = [int(i) for i in input().split(' ')]

0<=A
B<=10**9

if int((A+B)/2):
  print((A+B)/2)
else:
  print('IMPOSSIBLE')

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

0<=A
B<=10**9

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



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

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

Fixed code:
a,b=map(int,input().split())
c=a%2
d=b%2
if (c-d)==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(int((a+b)/2))
else:
    print('IMPOSSIBLE')
Buggy code:
# Sol : (n1 + n2)/2
# Ex : 
# Q : 16 - x = 2 - x
# => 16 + x = 2 + x
# => 16 + 2 = 2x
# => 18/2 = x
# +> 9 = x
a = list(map(int, input().split()))
if ((a[0] + a[1]) // 2) * 2 != a[0] + a[1]:
    print("Impossible")
else:
    print(((a[0] + a[1]) // 2))

Fixed code:
# Sol : (n1 + n2)/2
# Ex : 
# Q : 16 - x = 2 - x
# => 16 + x = 2 + x
# => 16 + 2 = 2x
# => 18/2 = x
# => 9 = x
a = list(map(int, input().split()))
if ((a[0] + a[1]) // 2) * 2 != a[0] + a[1]:
    print("IMPOSSIBLE")
else:
    print(((a[0] + a[1]) // 2))
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 % 2 != b % 2:
	print('IMPOSSIBLE')
else:
	print((a + b) // 2)
Buggy code:
a,b = map(int, input().split())
sum = a + b
print(sum / 2 if sum % 2 == 0 else "IMPOSSIBLE")

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

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

if (a+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:
def resolve():
    a, b = map(int, input().split())

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

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

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

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


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

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

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

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

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

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

A = List[0]
B = List[1]

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

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

A = List[0]
B = List[1]

Flag = False
if (A + B) % 2 == 0:
    K = int((A + B)/2)
    Flag = True

if Flag == True:
    print(K)
else:
    print("IMPOSSIBLE")
Buggy code:
a, b = map(int, input().split())

if a < b:
    A = a
    B = b
else:
    A = b
    B = a

if (B - A) % 2 != 0:
	print("IMPOSSIBLE")

K = int(B - (B - A) / 2)
print(str(K))

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

if a < b:
    A = a
    B = b
else:
    A = b
    B = a

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

ans = 0

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

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

ans = 0

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

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

Fixed code:
#A
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())
c = abs(a - b) 
if c % 2 != 0:
    print("IMPOSSIBLE")
else:
    print(min(a, b) + c / 2)

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

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

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

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

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().split()))
a = l[0]
b = l[1]
if (a+b)%2 == 0:
  print((a+b)/2)
else:
  print('IMPOSSIBLE')

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

Fixed code:
A, B = map(int, input().split())
print(int((A+B)/2) if (A+B) % 2 == 0 else "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((A+B)//2)
Buggy code:
N,Y= [int(i) for i in input().split()]

if(N+Y)%2 == 0 :
	print((N+Y)//2)
else:
	print("impossible")

Fixed code:
N,Y= [int(i) for i in input().split()]

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

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

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

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:
    ans = (a + b) / 2
    print(ans)

Fixed code:
a,b = map(int,input().split())
if((a + b) % 2 == 1):
    print("IMPOSSIBLE")
else:
    ans = (a + b) // 2
    print(ans)
Buggy code:
from heapq import heappush, heappop
from collections import deque
import itertools
from itertools import permutations
import sys
import bisect
sys.setrecursionlimit(10**6)
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]
YN=['Yes','No']
YNeos='YNeos'
mo=10**9+7
imp='IMPOSSIBLE'


n,m=MI()
ans=(n+m)//2 if (n-m)%2==0 else imp
for n in range(n):
    0

print(ans)


Fixed code:
from heapq import heappush, heappop
from collections import deque
import itertools
from itertools import permutations
import sys
import bisect
sys.setrecursionlimit(10**6)
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]
YN=['Yes','No']
YNeos='YNeos'
mo=10**9+7
imp='IMPOSSIBLE'


n,m=MI()
ans=(n+m)//2 if (n-m)%2==0 else imp

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

I,m = divmod((A+B), 2)

if m != 0:
    res = msg
else:
    res = (A+B)/2

print(res)

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

I,m = divmod((A+B), 2)

if m != 0:
    res = msg
else:
    res = int((A+B)/2)

print(res)
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())
dif = abs(A - B)
print(dif//2 if dif%2==0 else 'IMPOSSIBLE')

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

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

ans = abs(a-b)
M = max(a,b)

if ans%2==0:
    ans/=2
    print(M-ans)
else:
    print("IMPOSSIBLE")

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

ans = abs(a-b)
M = max(a,b)

if ans%2==0:
    ans//=2
    print(M-ans)
else:
    print("IMPOSSIBLE")
Buggy code:
a,b = map(int, input().split())
sa = max(a,b)-min(a,b)
if sa % 2 != 0:
  print("IMPOSSIBLE")
else:
  print(min(a,b) + sa%2)

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

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

Fixed code:
A , B = (map(int , input().split()))
asn = (A + B) /2
if asn.is_integer() == True:
    print(int(asn))
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)%2 == 0:
	print((a+b)//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())
if (a+b)//2 == int((a+b)/2):
  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())
k = (A + B) / 2
if (A + B) % 2 == 0:    
    if A - k > 0 and B - k < 0:
        print('pat1')
        print(int(k))
    elif A - k < 0 and B - k > 0:
        print('pat2')
        print(int(k))    
    else:
        print('IMPOSSIBLE')
else:
    print('IMPOSSIBLE')

Fixed code:
A,B = map(int, input().split())
k = (A + B) / 2
if (A + B) % 2 == 0:    
    if A - k > 0 and B - k < 0:
        #print('pat1')
        print(int(k))
    elif A - k < 0 and B - k > 0:
        #print('pat2')
        print(int(k))    
    else:
        print('IMPOSSIBLE')
else:
    print('IMPOSSIBLE')
Buggy code:
A,B = 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())

flag = 0

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

answer = 0
if A/2 == abs(int(A/2)):
  answer = A/2
else:
  answer = "IMPOSSIBLE"
  
print(answer)

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

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

if abs(A-buf) == abs(B-buf) :
    print(int(buf))
else :
    print('IMPOSSIBLE')

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

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

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

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

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


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

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

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

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

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

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

k = (int(s[0]) + int(s[1])) / 2

if k % 2 == 0:
    print(int(k))
else:
    print('IMPOSSIBLE')


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

k = (int(s[0]) + int(s[1]))

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

k = (A+B)/2

if k.is_integer():
    print(int(k))
else:
    k = -(A+B)/2
    if k.is_integer():
        if k>0:
            print(int(k))
    else:
        print("IMPOSSOBLE")



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

k = (A+B)/2

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

up = (A**2-B**2)
down = (2 * ( A-B ))

if up % down == 0:
	print(up/down)
else:
	print("IMPOSSIBLE")

Fixed code:
# | A - K | = | B - K |
A, B = map(int, input().split())

up = (A**2-B**2)
down = (2 * ( A-B ))

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

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

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