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

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

Solution (Python):
sentence = input()
ab = sentence.split()
A = int(ab[0])
B = int(ab[1])
if A == B:
    print(0)
    exit()
else:
    sum_ab = A + B
    if sum_ab % 2 == 0:
        print(sum_ab // 2)
        exit()
ans = "IMPOSSIBLE"
print(ans)

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

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

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

Solution (Python):

A,B=map(int,input().split())
if (A+B)/2==(A+B)//2:
    print(int((A+B)/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] = [int(i) for i in input().split()]

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

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

if A > B:
    A, B = B, A

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

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

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

Solution (Python):
import sys


def main():
    a, b = [int(s) for s in sys.stdin.readline().strip().split()]
    if (a + b) % 2:
        print('IMPOSSIBLE')
    else:
        print((a + b) // 2)


if __name__ == '__main__':
    main()

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):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    a, b = LI()
    c = (a + b) / 2
    if c % 1 == 0:
        print(int(c))
    else:
        print("IMPOSSIBLE")

if __name__ == '__main__':
    main()

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

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

Solution (Python):
inlist = input().split(' ')
a = int(inlist[0])
b = int(inlist[1])
if (a+b)%2 == 0:
	print((a+b)//2)
else:
	print('IMPOSSIBLE')

Solution (Python):

IMP = "IMPOSSIBLE"


def main():
    A, B = map(int, input().split())
    if A - B == 0:
        print(0)
    elif (A + B) % 2 == 0:
        print((A + B) // 2)
    else:
        print(IMP)


if __name__ == '__main__':
    main()

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

Solution (Python):
a,b=map(int,input().split())
x = (a+b)/2
if x%1 == 0:
  print(int(x))
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):
n=[int(n) for n in input().split()]
a=n[1]+n[0]
if a%2 == 1:
  print("IMPOSSIBLE")
else:
  print(int(a/2))

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

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

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

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

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

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

if(A>B):
    i=A
    j=B
else:
    i=B
    j=A

if((i-j)%2 == 1):
    print('IMPOSSIBLE')
else:
    print((i-j)//2 + j)

Solution (Python):
import sys, math, itertools, bisect, copy, re
from collections import Counter, deque, defaultdict






INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)








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

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

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

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

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

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

k = (a+b) / 2.0
if k == int(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())


ans = (A + B) / 2
if ans == int(ans):
    print(int(ans))
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):
import math
A,B = list(map(int,input().split()))

K = (A+B)/2

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B] = [long(input_raw[0]), long(input_raw[1])]
    if((A + B) % 2 == 1):
        print "IMPOSSIBLE"
    else:
        print (A + B)/2

if __name__ == '__main__':
    main()

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

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

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

c = max(a,b)
d = min(a,b)

if (c-d) % 2 == 1:
    print('IMPOSSIBLE')
else:
    print(int(d+(c-d)/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):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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)%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):
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((A + B) // 2)

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

suma=A+B
if suma%2==0:
    print(int(suma/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
input = sys.stdin.readline

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

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

A, B = map(int, ip().rstrip().split())
x = abs(A+B)
if x % 2 == 1:
    print('IMPOSSIBLE')
else:
    print(x//2)

Solution (Python):
import sys, math
from collections import deque

readline = sys.stdin.readline

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

K = (A + B) // 2

if 2 * K != A + B:
    print('IMPOSSIBLE')
else:
    print(K)

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

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

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

Solution (Python):

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

k = (a+b) // 2
r = (a+b) % 2

if r == 0:
    print(k)
else:
    print('IMPOSSIBLE')

Solution (Python):
def solve(a, b):
    d, m = divmod(a + b, 2)
    if m == 0:
        return d
    else:
        return None


def main():
    a, b = (int(z) for z in input().split())
    res = solve(a, b)
    print("IMPOSSIBLE" if res is None else res)


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

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


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

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

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

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

Solution (Python):
a,b=(int(x) for x in 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(abs(A+B)//2)
else :
    print('IMPOSSIBLE')

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(100000000)
def input():
    return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *

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

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

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

if A > B:
    tmp = A
    A = B
    B = tmp

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

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

Solution (Python):
import math

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

Solution (Python):
A, B = [int(i) for i in 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):
A, B = 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())

K = (max(A, B) - min(A, B))/2 + min(A, B)

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

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

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

Solution (Python):
import sys

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

if(a == b):
    print(0)
    sys.exit()
elif(abs(a+b) % 2 == 0):
    print(abs(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):
def li():
    return list(map(int, input().split()))


if __name__ == "__main__":
    [a, b] = li()
    if abs(a - b) % 2 == 0:
        print((a + b) // 2)
    else:
        print("IMPOSSIBLE")

Solution (Python):
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

def main():
    A, B = map(int, input().split())
    K = (A + B) / 2
    if math.ceil(K) != K:
        print("IMPOSSIBLE")
    else:
        print(int(K))

if __name__ == '__main__':
    main()

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 abs(A-B) % 2 == 1:
    print('IMPOSSIBLE')
else:
    print(int((A+B)/2))

Solution (Python):
def main():
    inp = input().split(' ')
    a = int(inp[0])
    b = int(inp[1])
    if ((a + b) / 2).is_integer():
        print(str((a + b) // 2))
    else:
        print('IMPOSSIBLE')


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
A,B = [int(i) for i in 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 == 1:
  print("IMPOSSIBLE")
else:
  print((A+B)//2)

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


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

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

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

Solution (Python):
N,M = map(int,input().split(' '))

if abs(N-M)%2==0:
    k = int(abs(N-M)/2)
    if N>M:
        print(M+k)
    else:
        print(N+k)
else:
    print('IMPOSSIBLE')

Solution (Python):
nums = list(map(int, input().split()))
A, B = nums[0], nums[1]
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:
    K = (A+B)//2
    print(K)
else:
    print('IMPOSSIBLE')

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

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

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

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

hoge = abs(A-B)

if hoge % 2 == 0:
    print(min(A, B) + hoge//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):
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
Mod = 1000000007



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




def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n < 2 is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))):
        if prime[i] == 1:
            for j in range(2*i,n):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n):
        if prime[i] == 1:
            res.append(i)
    return res

class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py

    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

Solution (Python):
A,B=map(int,input().split())
print(max(A,B)-int((max(A,B)-min(A,B))/2) if int((max(A,B)-min(A,B))/2) == (max(A,B)-min(A,B))/2 else 'IMPOSSIBLE'
)

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]


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


if __name__ == "__main__":
    main()

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

Solution (Python):
N, K = map(int, input().split())

if((N+K)%2!=0):
    print ("IMPOSSIBLE")
else:
    print ((N+K)//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 = input().split();

a = int(a)
b = int(b)

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

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

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

c = (a + b) /2 

if int(c) == c:
    print(int(c))

else:
    print("IMPOSSIBLE")

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

if float.is_integer((a+b)/2):
  print((a+b)//2)
else:
  print('IMPOSSIBLE')

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

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

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

Solution (Python):

import sys

NO = "IMPOSSIBLE"  

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



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):
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((A+B)//2)

Solution (Python):
a,b = map(int,input().split())
q,r = divmod(a+b,2)
if(r==1):
    print("IMPOSSIBLE")
else:
    print(q)

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

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

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

Solution (Python):
import math
A, B = map(int, input().split())
K = (A + B) / 2
if math.ceil(K) == math.floor(K):
    print(int(K))
else:
    print('IMPOSSIBLE')

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

Solution (Python):


def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    A, B = InputToInt()
    if (A-B)%2 == 1:
        print('IMPOSSIBLE')
    else:
        print(abs(int((A+B)/2)))

Solution (Python):
a, b = list(map(int, input().split()))
k = (abs(a) + abs(b)) / 2
_k = (abs(a) + abs(b)) // 2
if k == _k:
    print(_k)
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())

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

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

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

K2 = (A + B)

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

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

Solution (Python):

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

if (max(A,B) - min(A,B)) % 2 == 0:

    print (max(A,B) - (max(A,B) - min(A,B)) // 2)

else:

    print ("IMPOSSIBLE")

Solution (Python):
def INT_(n): return int(n)-1
def MI(): return map(int, input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_, input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n: int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split())) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')


def main():
    a, b = MI()
    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((A+B)//2)
else:
    print("IMPOSSIBLE")

Solution (Python):
def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





imp = "IMPOSSIBLE"
a, b = map(int, input().split())

hoge = (a + b)
ans = imp
if hoge % 2 == 0:
    ans = hoge // 2
print(ans)

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

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

    c = a + b

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

    return


if __name__ == '__main__':
    submit()

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

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

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

print(ans)

Solution (Python):
x,y=map(int,input().split())

k=x+y

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

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

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

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

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

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

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

Solution (Python):




def solve():
    A, B = list(map(int, input().split()))
    if A < B:
        A, B = B, A
    if (A - B) % 2 != 0:
        return 'IMPOSSIBLE'
    return (A - B) // 2 + B


def main():
    print(solve())


if __name__ == "__main__":
    main()

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

if a == b:
    print(0)
else:
    mid = (a + b) / 2
    if mid == round(mid):
        print(round(mid))
    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())

ab = a+b

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

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

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

Solution (Python):
a,b = map(int, input().split())
if abs(a - b) % 2 != 0:
  print('IMPOSSIBLE')
else:
  print(min(a, b) + abs(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 = [int(i) for i in input().split()]

ans = A + B

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

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

Solution (Python):
from sys import stdin
A,B = [int(x) for x in stdin.readline().rstrip().split()]
if (A + B) % 2 == 0:
    print((A+B)//2)
else:
    print("IMPOSSIBLE")

Solution (Python):

import sys
import math



tmp = input().split()
hoge = list(map(lambda a: int(a), tmp))
a = hoge[0]
b = hoge[1]

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

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

Solution (Python):
a,b = map(int,input().split())
if abs(a-b)%2 == 1:
    print('IMPOSSIBLE')
else:
    print(min(a,b)+abs(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())
K = (A + B) / 2

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

Solution (Python):
A,B = map(int,input().split())
s = A+B
if s%2==1:print('IMPOSSIBLE')
else:print(s//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())
ans = (a + b) / 2
if ans.is_integer():
    print(int(ans))
else:
    print("IMPOSSIBLE")

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


main()

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

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

Solution (Python):

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

if abs(a-b) % 2 == 1:
    print("IMPOSSIBLE")
else:
    c = abs(a-b) / 2
    print(int(max(a,b) - c))

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

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

Solution (Python):

import sys
def input(): return sys.stdin.readline().rstrip()
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
import heapq
INF = float("inf")
MOD = 10**9 + 7
sys.setrecursionlimit(10**7)

dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def mi(): return map(int, input().split())
def ii(): return int(input())


A, B = mi()

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

Solution (Python):


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

k = (A+B)//2

if (A-B)%2==0:
    print(k)

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

Solution (Python):


def main():
    a,b = map(int,input().split())
    if abs(a+b) % 2:
        print('IMPOSSIBLE')
    else:
        print((a+b)//2)






main()

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

Solution (Python):
import sys

a,b= [ int(x) for x in sys.stdin.readline().split() ]
k= a+b
if k%2==0: print( k//2 )
else: print( "IMPOSSIBLE" )

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

Solution (Python):
import sys

def debug(*args):
    print(*args, file=sys.stderr)


def solve(A, B):
    if A > B:
        A, B = B, A
    if (B - A) % 2 == 1:
        return "IMPOSSIBLE"
    return A + ((B-A)//2)

def main():
    A, B = [int(x) for x in input().split()]
    print(solve(A, B))

main()

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

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