Problem:
 Score: 100 points    Problem Statement We have two distinct integers A and B .  Print the integer K such that |A - K| = |B - K| .  If such an integer does not exist, print IMPOSSIBLE instead.      Constraints  All values in input are integers.  0 \leq A,\ B \leq 10^9  A and B are distinct.         Input Input is given from Standard Input in the following format:  A  B       Output Print the integer K satisfying the condition.  If such an integer does not exist, print IMPOSSIBLE instead.        Sample Input 1 2 16      Sample Output 1 9  |2 - 9| = 7 and |16 - 9| = 7 , so 9 satisfies the condition.       Sample Input 2 0 3      Sample Output 2 IMPOSSIBLE  No integer satisfies the condition.       Sample Input 3 998244353 99824435      Sample Output 3 549034394

Solution (Python):
import sys
input = sys.stdin.readline

A,B = [int(zz) for zz in input().split()]

K = (B**2-A**2)/(2*B-2*A)

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

Solution (Python):


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

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

Solution (Python):


n=input().split(" ")
n=sorted(n)
n[0]=int(n[0])
n[1]=int(n[1])
if (n[0]+n[1])%2==0:
    print(int((n[0]+n[1])/2))
else:
    print("IMPOSSIBLE")

Solution (Python):
a, b = [int(x) for x in input().split()]

k = (a + b) / 2
if k.is_integer():
    print(int(k))
else:
    k = (a - b) / 2
    if k.is_integer():
        print(int(k))
    else:
        print("IMPOSSIBLE")

Solution (Python):
A,B=map(int,input().split())
if A == B:
  K=0
elif (A+B)%2==0:
    K=(A+B)//2
else:
    K="IMPOSSIBLE"
print(K)

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

Solution (Python):
a, b = map(int, input().split())

t = abs(a + b) / 2

if t != int(t):
  print('IMPOSSIBLE')
else:
  print(int(t))

Solution (Python):
A, B = (int(x) for x in input().split())
tmp = abs(A) + abs(B)
if tmp % 2 == 0:
    print(tmp//2)
else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A, B = map(int, input().split(' '))

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

Solution (Python):
a,b = map(int,input().split())
if a%2==0 and b%2!=0:
    print("IMPOSSIBLE")
elif a%2!=0 and b%2==0:
    print("IMPOSSIBLE")
else:
    print(int(((a+b)/2)))

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):

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

Solution (Python):
a, b = map(int, input().split())
sum = a + b

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

Solution (Python):
A,B = map(int, input().split())

if A > B:
  n = (A-B) / 2
  r = (A-B) % 2
  if r == 0:
    print(int(B + n))
  else:
    print('IMPOSSIBLE')
    
else:
  n = (B-A) / 2
  r = (B-A) % 2
  if r == 0:
    print(int(A + n))
  else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = map(int, input().split())
if ((A+B) % 2) != 0:
    print("IMPOSSIBLE")
else:
    print(int((A+B)/2))

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




def main():
    a,b = map(int, input().split())
    t = a + b
    if t%2 != 0:
        print("IMPOSSIBLE")
    else:
        print(t//2)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
a, b = map(int, input().split())
abs = abs(a-b)
if abs%2==0:
    print(abs//2+min(a,b))
else:
    print('IMPOSSIBLE')

Solution (Python):
a, b = map(int, input().split())
if (a+b)%2==1:
	print('IMPOSSIBLE') 
else:
	print((a+b)//2)

Solution (Python):
A, B = map(int, input().split())

K = (A + B) / 2

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

Solution (Python):
a,b=map(int,input().split())

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

Solution (Python):
a,b=map(int,input().split())
answer=(a**2-b**2)/(2*(a-b))
if answer-int(answer)==0:print(int(answer))
else:print("IMPOSSIBLE")

Solution (Python):
A, B = map(int, input().split())

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

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

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

Solution (Python):
import sys
import numpy as np
from scipy.misc import comb
sys.setrecursionlimit(1000000)
 
a,b = map(int,input().split())

if abs(a-b) % 2 == 1:
    print("IMPOSSIBLE")
else:
    if a == b:
        print(0)
    elif a < b:
        print(int(abs(a-b) // 2 + a))
    else:
        print(int(abs(a-b) // 2 + b))

Solution (Python):
import sys

A,B= map(int, sys.stdin.readline().split())

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

Solution (Python):
A, B = map(int, input().split())
n = (A + B) / 2

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

Solution (Python):
a,b = (int(i) for i in input().split())
if (a+b)%2!=0:
    print("IMPOSSIBLE")
else:
    print((a+b)//2)

Solution (Python):


A, B = list(map(int, input().split()))
ans = (A+B) / 2
print(int(ans) if ans.is_integer() else "IMPOSSIBLE")

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    A, B = [int(x) for x in sys.stdin.readline().split()]

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



if __name__ == "__main__":
    resolve()

Solution (Python):
import io
import sys


def IN_S():
  return input()


def IN_I():
  return int(input())


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


def IN_L_S():
  return list(map(str, input().split()))


def STR_SPLIT(s, n):
  for l in range(0, len(s), n):
    yield s[0 + l:n + l]


def T_IN():
  global test_str
  sys.stdin = io.StringIO(test_str[1:-1])


test_str = '''
998244353 99824435
'''


def MAIN():
  
  A()


def A():
  a, b = IN_L_I()
  if (a + b) % 2 != 0:
    print("IMPOSSIBLE")
    exit()

  d = (a + b) // 2
  print(d)

  return None


def B():
  return None


def C():
  return None


MAIN()

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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

ans = (a + b) / 2
if (ans.is_integer()):
    print((a + b) // 2)
    exit()
print("IMPOSSIBLE")

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A,B = map(int, input().split())
if (((A-B)**2)**0.5)%2 == 1:
    print('IMPOSSIBLE')
else:
    print(int((A+B)/2))

Solution (Python):
a,b = map(int,input().split())

if a>b:
    i = a-b
    big =a
else:
    i = b-a
    big = b

if i % 2 == 0:
    print( big - int(i/2))
else:
    print('IMPOSSIBLE')

Solution (Python):
a,b = map(int, input().split())

if a > b:
  c = a
  a = b
  b = c

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

Solution (Python):
import numpy as np

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

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

Solution (Python):
a,b = map(int,input().split())
if (b-a) % 2 == 1:
    print("IMPOSSIBLE")
else:
    print(round((a+b)/2))

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

Solution (Python):
a, b = map(int, input().split())
s = abs(a + b)
print(s//2 if s % 2 == 0 else "IMPOSSIBLE")

Solution (Python):
a, b = map(int, input().split())

k = (a + b) / 2

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

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
a, b = (int(_) for _ in input().split())
if abs(a - b) % 2 != 0:
    print('IMPOSSIBLE')
else:
    dis = abs(a-b) // 2
    if a < b:
        print(a + dis)
    elif b < a:
        print(b + dis)

Solution (Python):

A, B = map(int, input().split())
if abs(A-B) % 2 == 0:
    tmp = abs(A-B) // 2
    if A > B:
        print(B + tmp)
    else:
        print(A + tmp)
else:
    print("IMPOSSIBLE")

Solution (Python):
W=list(map(int,input().split()))
 

A = W[0] + W[1]

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

Solution (Python):
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")

Solution (Python):
A, B = map(int, input().split())
print((A + B) // 2 if abs(A - B) % 2 == 0 else 'IMPOSSIBLE')

Solution (Python):

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

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

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

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
a, b = list(map(int, input().split()))

if a < b:
    a1 = a
    a2 = b
else:
    a1 = b
    a2 = a

K = (a1 + a2)/2.
if K.is_integer():
    print(int(K))
else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = (int(i) for i in input().split())
D = (A+B)%2

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

Solution (Python):
A,B = map(int, input().split())

K = (A+B)/2

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

Solution (Python):
S = input().split()
A = int(S[0])
B = int(S[1])

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

Solution (Python):
A, B = map(int, input().split())

K = (A + B) / 2

if A == B:
    print(0)
elif K.is_integer():
    print(int(K))
else:
    print('IMPOSSIBLE')

Solution (Python):
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")

Solution (Python):

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

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

Solution (Python):
parents = list(map(int,input().split(' ')))

A = parents[0]
B = parents[1]

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

Solution (Python):
a, b = [int(x) for x in input().split()]

if ((a+b) & 1) == 1:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)

Solution (Python):
a, b = map(int, input().split())
k = (a+b)/2
_k = int(k//1)
print(int(k)) if k == _k else print('IMPOSSIBLE')

Solution (Python):
a,b=map(int, input().split())

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

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

Solution (Python):
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
gi = lambda : list(map(int,input().strip().split()))
a, b = gi()
if (a + b)%2:
	print("IMPOSSIBLE")
	exit()
print((a + b)//2)

Solution (Python):
n,m=map(int,input().split())
if((n+m)%2):
    print('IMPOSSIBLE')
else:
    print((n+m)//2)

Solution (Python):
A, B = map(int, input().split())

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

K = (A + B) // 2

print(K)

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

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

Solution (Python):
import sys
a, b = [int(i) for i in sys.stdin.readline().split()]
n = (a + b) / 2
if n.is_integer():
    print(int(n))
else:
    print('IMPOSSIBLE')

Solution (Python):
a,b=map(int, input().split())  

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

Solution (Python):
a, b = map(int,input().split())

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

Solution (Python):
a,b=map(int,input().split())

res='IMPOSSIBLE'

if (b-a)%2==0:
	res=(a+b)//2

print(res)

Solution (Python):
A, B = list(map(int, input().split(' ')))

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

Solution (Python):
A, B = map(int,input().split()) 

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

Solution (Python):
def main():
    a,b=map(int,input().split(' '))
    if (a+b)%2==0:
        print(int((a+b)/2))
    else:
        print('IMPOSSIBLE')
if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(int, input().split())
if (a-b)%2 ==1:
    print('IMPOSSIBLE')
else:
    print((a+b)//2)

Solution (Python):
A, B = map(int, input().split())
if (A+B)%2 == 0:
  print((A+B)//2)
else:
  print("IMPOSSIBLE")

Solution (Python):

import decimal
a,b = list(map(int,input().split()))
if (a+b) % 2==0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")

Solution (Python):
a,b=map(int,input().split())
k=(a+b)/2
k1=(a+b)//2
if k==k1:
    print(k1)
else:
    print('IMPOSSIBLE')

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

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

Solution (Python):
A,B= map(int,input().split())
if (A + B)%2 == 0:
    print((A+B)//2)
else:
    print("IMPOSSIBLE")

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

Solution (Python):



def solv(a, b):
    k2 = a + b
    if k2 % 2:
        return 'IMPOSSIBLE'
    else:
        return k2 // 2


if __name__ == '__main__':

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

    ans = solv(a, b)

    print(ans)

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

Solution (Python):

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


if __name__ == "__main__":
    resolve()

Solution (Python):
a, b = map(int, input().split())
if (a+b)%2==0:
  ans = int((a+b)/2)
  print(ans)
else:
  print("IMPOSSIBLE")

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A,B=map(int,input().split()[:2])
k=A+B
if k%2==1:
    print('IMPOSSIBLE')
else:
    print(k//2)

Solution (Python):
A,B = map(int, input().split())

sum = A+B

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

Solution (Python):
A,B = map(int, input().split())

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

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

Solution (Python):
a,b = map(int,input().split())
f = (a+b)/2
if a==b:
	print(0)
elif f.is_integer():
	print(int(f))
else:
	print("IMPOSSIBLE")

Solution (Python):
a,b = map(int, input().split())

if (a % 2 == 0 and b%2 != 0) or (a % 2 != 0 and b%2 == 0):
    print("IMPOSSIBLE")
    exit()

print((a+b)//2)

Solution (Python):
I = input().split()
A = I[0]
B = I[1]

a = int(A)
b = int(B)

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

Solution (Python):
a,b = map(int, input().split())
if abs(a-b)%2: print("IMPOSSIBLE")
else:
        if a > b: a,b = b,a
        print((b-a)//2 + a)

Solution (Python):
A, B = map(int,input().split())

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

Solution (Python):
A, B = map(int,input().split())

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

Solution (Python):
a, b = map(int, input().split())

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

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

Solution (Python):
A, B = list(map(int, input().split()))
res = abs((A+B)/2)
if res == int(res):
    print(int(res))
else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = list(map(int, input().split()))
if (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print('IMPOSSIBLE')

Solution (Python):
a,b = list(map(int,input().split()))
if((a+b)//2 == (a+b)/2):
  print((a+b)//2)
else:
  print("IMPOSSIBLE")

Solution (Python):
a,b=map(int,input().split())
ans=(a+b)/2
if ans==int(ans):
  print(int(ans))
else:
  print("IMPOSSIBLE")

Solution (Python):
a, b = map(int, input().split())
sum = a + b
if sum%2 == 0:
    print(sum//2)
else:
    print("IMPOSSIBLE")

Solution (Python):
a,b=map(int,input().split())
k=(a+b)/2
if int(k)==k:
    print(int(k))
else:
    print('IMPOSSIBLE')

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

Solution (Python):
A,B = map(int, input().split())

C = abs(A - B)
if C % 2 == 1:
    print("IMPOSSIBLE")
else:
    ans = C//2
    if A < B:
        print(A + ans)
    else:
        print(B + ans)

Solution (Python):
a, b = map(int, raw_input().split(' '))
print (a + b) / 2 if (a + b) % 2 == 0 else 'IMPOSSIBLE'

Solution (Python):
a,b = map(int,input().split())

c = (a + b) / 2
d = (a + b) // 2
if c == d:
    print(int(c))
else:
    print("IMPOSSIBLE")

Solution (Python):


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

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

Solution (Python):
a, b = map(int, input().split())
k=(a+b)/2

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

Solution (Python):
A,B = map(int,input().split())
if A == B:
    print(0)
else:
    if (A+B) % 2 == 0:
        print((A+B)//2)
    else:
        print("IMPOSSIBLE")

Solution (Python):
from sys import stdin

def main():
    A, B = map(int, input().split())

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

input = lambda: stdin.readline()
main()

Solution (Python):
def resolve():
    a, b = map(int, input().split())

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

Solution (Python):
A,B = map(int,input().split())
if (A+B)%2 == 0:
    K = int((A+B)/2)
    print(K)
else:
    print("IMPOSSIBLE")

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

Solution (Python):
A,B = map(int,input().split())

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

Solution (Python):
A,B = map(int, input().split())
if abs(A-B)%2 == 0:
    print(max(A,B)-abs((A-B)//2))
else:
    print("IMPOSSIBLE")

Solution (Python):
a,b=map(int,input().split())
if (max(a,b)-min(a,b))%2==0:
    print(int((a+b)/2))
else:
    print('IMPOSSIBLE')

Solution (Python):
A,B = map(int,input().split())
C = A+B
if C%2 ==0:
    K = int(C/2)
elif A-B ==0:
    K = 0
else:
    K = "IMPOSSIBLE"
print(K)

Solution (Python):
a, b = map(int, input().split())
m = (a + b) / 2
if int(m) == m:
    print(int(m))
else:
    print('IMPOSSIBLE')

Solution (Python):
def resolve():
    a,b = map(int,input().split())
    if (a-b)%2!=0:
        print("IMPOSSIBLE")
        exit(0)
    print(b+(a-b)//2)


if __name__ == "__main__":
    resolve()

Solution (Python):
if __name__ == '__main__':
    a, b = map(int, input().split())
    k = (a+b)/2
    if k.is_integer():
        print(int(k))
    else:
        print("IMPOSSIBLE")

Solution (Python):
import sys,heapq,math,resource
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

def setrlim():
  sys.setrecursionlimit(250000)
  soft,hard = resource.getrlimit(RLIMIT_STACK)
  
  

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

Solution (Python):
A, B = map(int, input().split())
if abs(A - (A + B) / 2) == abs(B - (A + B) / 2) and (A+B)%2==0:
    print((A + B) // 2)
else:
    print('IMPOSSIBLE')

Solution (Python):
import sys

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

if a%2 == 0 and b%2 == 0:
    print(int((a+b)/2))
    sys.exit()

if a%2 != 0 and b%2 != 0:
    print(int((a+b)/2))
    sys.exit()

print("IMPOSSIBLE")

Solution (Python):
a, b = map(int, input().split())
if not abs(b - a) % 2:
    print((b + a) // 2)
else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
import sys
input = sys.stdin.readline

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

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

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a, b = list(map(int, input().split(" ")))

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

Solution (Python):
a,b=map(int,input().split())
if (a+b)%2==1:
  print('IMPOSSIBLE')
else:
  print((a+b)//2)

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A, B = [int(i) for i in input().split(' ')]
C = (B - A)/2
if int((B-A)/2)==(B-A)/2:
    print(int(A+C))
else:
    print('IMPOSSIBLE')

Solution (Python):

import sys

NO = "IMPOSSIBLE"  

def solve(A: int, B: int):
    if (A + B) % 2 :
        print(NO)
    else:
        print(int((A + B)/2))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(A, B)

if __name__ == '__main__':
    main()

Solution (Python):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

A, B = read_int()

def solve():
    if (A + B) % 2 == 0:
        return (A + B) // 2
    return 'IMPOSSIBLE'

if __name__ == "__main__":
    print(solve())

Solution (Python):
a, b = list(map(int, input().split()))
c = a + b
if c % 2 == 0:
    print(c // 2)
else:
    print('IMPOSSIBLE')

Solution (Python):
A, B = map(int, input().split())
if A == B or (A + B) % 2 == 0:
    print((A + B) // 2)
else:
    print("IMPOSSIBLE")

Solution (Python):
a,b = list(map(int, input().split()))

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

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
b,c = map(int, input().split())

if ((b+c)/2 - (b+c)//2) < 0.5:
  print((b+c)//2)
else:
  print("IMPOSSIBLE")

Solution (Python):
a,b = sorted(map(int,input().split()))
if (b - a) % 2 == 0:
    print(a + (b - a) // 2)
else:
    print("IMPOSSIBLE")

Solution (Python):
A,B=map(int,input().split())

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

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

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    input_line = list(map(int, input().split()))
    a = input_line[0]
    b = input_line[1]
    
    if((a + b) % 2 == 0):
    	print(int((a + b) / 2))
    else:
      print("IMPOSSIBLE")





if __name__ == '__main__':
  main()

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
A, B = map(int, input().split())

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

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

Solution (Python):
A, B = map(int,input().split())

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

Solution (Python):
A, B = list(map(int, input().split()))

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

Solution (Python):
A,B = map(int,input().split())
D=(A+B)
if D%2 == 0:
  	print(D//2)
else:
	print('IMPOSSIBLE')

Solution (Python):
A, B = (int(x) for x in input().split())
if (A+B) % 2 != 0:
    print('IMPOSSIBLE')
else:
    print((A+B)//2)

Solution (Python):
A, B = map(int, input().split())
if (A + B) % 2 != 0:
    print("IMPOSSIBLE")
else:
    print((A + B) // 2)

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A, B = map(int, input().split())

K = (A + B) / 2

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

Solution (Python):
from bisect import bisect_left, bisect_right; from collections import Counter, defaultdict, deque, OrderedDict; from copy import deepcopy; from fractions import gcd; from functools import lru_cache, reduce; from math import ceil, floor; from sys import stdin, setrecursionlimit
import heapq as hq; import itertools as its; import operator as op



inf = float('inf')
input = stdin.readline


def main():
    a, b = get_li()
    if abs(a - b) % 2 == 0:
        print((a + b) // 2)
    else:
        print('IMPOSSIBLE')
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def gets(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input().strip()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().strip().split(sep=sep))]
        for _ in range(n)
    )))


if __name__ == '__main__':
    setrecursionlimit(4100000)
    main()

Solution (Python):
a,b = map(int, input().split())

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

Solution (Python):

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

i = (B - A) / 2
if i.is_integer() :
    print(B - int(i))
else :
    print('IMPOSSIBLE')

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

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
import sys

sys.setrecursionlimit(10**9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def LIST(): return [int(x) for x in input().split()]
MOD = 10**9 + 7

A, B =LIST()

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

Solution (Python):
A,B = map(int,input().split())

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

Solution (Python):
a, b =map(int, input().split())  

diff = abs(a-b)

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

Solution (Python):
a, b = list(map(int, input().split(" ")))
k = a+b
if k%2 == 0:
    print(int(k/2))
else:
    print("IMPOSSIBLE")

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    A, B = LI()
    if (A+B)%2 != 0:
        print('IMPOSSIBLE')
    else:
        print((A+B)//2)

main()

Solution (Python):
A, B = map(int, input().split())
if A == B:
    print(0)
else:
    if (A + B) % 2 == 0:
        print((A+B)//2)
    else:
        print("IMPOSSIBLE")

Solution (Python):
A, B = [int(i) for i in input().split()]
K = (A**2 - B**2) / (2*A - 2*B) 

if K.is_integer():
  print(int(K))
else: 
  print('IMPOSSIBLE')

Solution (Python):
A,B = map(int,input().split())

d = A+B

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

Solution (Python):
a, b = (int(i) for i in input().split())

if abs(a-b) % 2 == 1:
    print("IMPOSSIBLE")
    exit()

diff = abs(a-b)
diff_2 = diff // 2

print(max(a,b) - diff_2)

Solution (Python):
A,B= list(map(int, input().split()))
if (A+B)%2==0:
    print(int((A+B)/2))
else:
    print("IMPOSSIBLE")

Solution (Python):
A, B = map(int, input().split())

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

Solution (Python):
A,B = map(int, input().split())

K = (A+B)/2.0
if (10*K)%10 != 0:
    answer = "IMPOSSIBLE"
else:
    answer = int(K)
print(answer)

Solution (Python):
a,b = map(int,input().split())

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

Solution (Python):
A,B = map(int,input().split())

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

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

if __name__ == "__main__":
  main()

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):

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

Solution (Python):
a=list(map(int,input().split()))
b = int(a[0])
c = int(a[1])
if((b+c)%2==0):
    print(int((b+c)/2))
else:
    print("IMPOSSIBLE")

Solution (Python):

a, b = [ int(v) for v in input().split() ]

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

Solution (Python):


import math
import sys
import itertools
import numpy as np


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

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

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

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

Solution (Python):
import numpy as np


a,b = map(int,input().split())
large = max(a,b)
small = min(a,b)
diff = large-small
if diff %2 == 1:
    print("IMPOSSIBLE")
else:
    print(small+diff//2)