ZhenlongDai/ACPR huggingface dataset:
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K , X = map(int,input().split())

ans=X-K+1

print(ans,end="")

for i in range(K*2-1):
  print(" ",end="")
  ans+=1
  print(ans)


Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-2 -1
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23


Fixed submission (verdict: Accepted):
K , X = map(int,input().split())

ans=X-K+1

print(ans,end="")

for i in range(K*2-2):
  print(" ",end="")
  ans+=1
  print(ans,end="")

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k, x = map(int, input().split())
L = []
for i in range(k):
    y = x + i
    z = x - i
    if y > 1000000:
        y = x
    L.append(y)
    if z < -1000000:
        z = x
    L.append(z)
print(set(L))


Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
{32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 27, 28, 29, 30, 31}


Fixed submission (verdict: Accepted):




k, x = map(int, input().split())
L = []
for i in range(k):
    y = x + i
    z = x - i
    if y > 1000000:
        y = x
    L.append(y)
    if z < -1000000:
        z = x
    L.append(z)
I = set(L)
L = list(sorted(I))
for s in L:
    print(s,end = " ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
a = range(x-k+1, x+k-1)
print(" ".join(map(str, a)))


Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
a = range(x-k+1, x+k)
print(" ".join(map(str, a)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())

l = list()

for i in range(X-K+1,X+K):
    l.append(i)
print(l)


Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())

for i in range(X-K+1,X+K):
    print(i, end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int,input().split())
for i in range(k-x+1,k+x):
    print(i,end=' ')

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 

Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
for i in range(x-k+1,x+k):
    print(i,end=' ')

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
for i in range(X - K, X + K + 1):
    print(i)


Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
for i in range(X - K + 1, X + K):
    print(i, end = ' ')
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=list(map(int,input().split( )))
list_=[x+i for i in range(-k+1,k)]
print(list_)


Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
k,x=list(map(int,input().split( )))
list_=[x+i for i in range(-k+1,k)]
print(*list_)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int,input().split())
if K == 1:
    print(X)
checkpoint = X
result = set()
start = checkpoint - K + 1
for i in range(K):
    for i in range(K):
        result.add(start + i)
    start = start + 1
L=[str(a) for a in result]
L=" ".join(L)
print(L)

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
64 65 66 67 68 69 53 54 55 56 57 58 59 60 61 62 63


Fixed submission (verdict: Accepted):
K,X = map(int,input().split())
if K == 1:
    print(X)
    exit()
checkpoint = X
result = set()
start = checkpoint - K + 1
for i in range(K):
    for i in range(K):
        result.add(start + i)
    start = start + 1
result = sorted(result)
L=[str(a) for a in result]
L=" ".join(L)
print(L)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int,input().split())
for i in range (K-X+1,K+X):
    if i < X + K -1:
        print(i,end=' ')
    else:
        print(i)

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Fixed submission (verdict: Accepted):
X,K = map(int,input().split())
for i in range (K-X+1,K+X):
    if i < X + K -1:
        print(i,end=' ')
    else:
        print(i)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
k = abs(k)
print(list(range(x-(k-1), x+k)))

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
[53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69]


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
k = abs(k)
print(' '.join(list(map(str, range(x-(k-1), x+k)))))

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k,x = map(int,input().split())
res = [i for i in range(x-k+1,x+k)]
print(res)

Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
res = [str(i) for i in range(x-k+1,x+k)]
print(" ".join(res))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,x=map(int,input().split())

kuro=[]
for i in range(x-n+1,x):
    kuro.append(i)
for i in range(x,n+x):
    kuro.append(i)
print(kuro)

Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]


Fixed submission (verdict: Accepted):
n,x=map(int,input().split())

kuro=[]
for i in range(x-n+1,x):
    kuro.append(i)
for i in range(x,n+x):
    kuro.append(i)
for i in range(len(kuro)):
    kuro[i]=str(kuro[i])
kuro=" ".join(kuro)
print(kuro)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = (int(i) for i in input().split())

result = list(range(x - k + 1, x + k))

print(result)

Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]


Fixed submission (verdict: Accepted):
k, x = (int(i) for i in input().split())
 
result = list(range(x - k + 1, x + k))

print(' '.join(map(str, result)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
min_x = X - K + 1
max_x = X + K - 1

print(list(range(min_x, max_x+1, 1)))

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
[-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
min_x = X - K + 1
max_x = X + K - 1
range_arr = list(range(min_x, max_x+1, 1))

print(' '.join(map(str, range_arr)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X=map(int,input().split())
a=[]
for i in range(K):
    a.append(X-i)
    a.append(X+i)

a.remove(X)
a.sort(reverse=False)
print(a)
    

Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
K,X=map(int,input().split())
a=[]
for i in range(K):
    a.append(X-i)
    a.append(X+i)


a.remove(X)
a.sort(reverse=False)

for j in range(2*K-1):
    x=a[j]
    print(x,end=' ')

Problem: p02946
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
k,x = map(int,input().split())
a=[]
for i in range(x-k+1,k+x-1):
    a.append(i)
print(*a)
    

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
4 5 6 7 8 9 10 11 12 13 14 15


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
a=[]
for i in range(x-k+1,k+x):
    a.append(i)
print(*a)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = [int(i) for i in input().split()]


for i in range(x-k+1, x+k-1):
    print(str(i)+" ", end="")
    
print()

Failing test case input:
5 35

Expected output:
31 32 33 34 35 36 37 38 39


Actual output:
31 32 33 34 35 36 37 38 


Fixed submission (verdict: Accepted):
k, x = [int(i) for i in input().split()]


for i in range(x-k+1, x+k):
    print(str(i)+" ", end="")
    
print()

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())
print([i for i in range(x-(k-1), x+(k-1)+1)])

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())
ans=[i for i in range(x-(k-1), x+(k-1)+1)]
print(*ans,sep=' ')

Problem: p02946
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
k, x = map(int, input().split())
ans = []
for i in range(x-k+1, x+k):
    ans.append(i)
print(*ans, sep=', ')

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
ans = []
for i in range(x-k+1, x+k):
    ans.append(i)
print(*ans, sep=' ')

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = [int(v) for v in input().split(" ")]

t=" ".join([str(v) for v in range(-k+1,k)])
print(t)


Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8


Fixed submission (verdict: Accepted):
k,x = [int(v) for v in input().split(" ")]

t=" ".join([str(v+x) for v in range(-k+1,k)])
print(t)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
l, r = 0, 2000001
l = max(X - K + 1, l)
r = min(X + K - 1, r)
lr = range(l, r)
print(*lr)

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
4 5 6 7 8 9 10 11 12 13 14 15


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
l = max(X - K + 1, -1000000)
r = min(X + K - 1, 1000000)
lr = range(l, r+1)
print(*lr)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int, input().split())
a = list()
 
b = x+k-1
c = x-k+1
 
for i in range(c,b+1):
  if  -1000000 <= i and i <= 1000000:
    a.append(i)
  
print(a)

Failing test case input:
11 63

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73


Actual output:
[53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73]


Fixed submission (verdict: Accepted):
k,x=map(int, input().split())
a = list()
 
b = x+k-1
c = x-k+1
 
for i in range(c,b+1):
  if  -1000000 <= i and i <= 1000000:
    a.append(i)
  
print(*a)
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
A,B = map(float, input().split())
K = (A**2-B**2)/(2*(A-B))
if K.is_integer():
    print(math.floor(0-K))
else:
    print("IMPOSSIBLE")


Failing test case input:
4 36

Expected output:
20


Actual output:
-20


Fixed submission (verdict: Accepted):
import math
A,B = map(int, input().split())
K = (A**2-B**2)/(2*(A-B))
if K.is_integer():
    print(math.floor(K))
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())

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

Failing test case input:
804043 1574255

Expected output:
1189149


Actual output:
1189149.0


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
if (a+b)%2 == 0:
    print(int((a+b)/2))


Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int, input().split())
print(int((a+b)/2) if (a+b)/2%2==0 else "IMPOSSIBLE")

Failing test case input:
142428602 25059880

Expected output:
83744241


Actual output:
IMPOSSIBLE


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if (A+B)/2%1==0:
    print((A+B)/2)
else:
    print("IMPOSSIBLE")

Failing test case input:
819805567 6544429

Expected output:
413174998


Actual output:
413174998.0


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

Problem: p02957
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(int,input().split())
if (b-a)%2==0:
  print(int((b-a)/2))
else:
  print('IMPOSSIBLE')

Failing test case input:
3240969 9769089

Expected output:
6505029


Actual output:
3264060


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
if (b-a)%2==0:
  print(int((b+a)/2))
else:
  print('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
if (A + B) % 2 != 0:
    print("IMPOSSIBLE")
else:
    print((A + B) / 2)


Failing test case input:
0 162

Expected output:
81


Actual output:
81.0


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
if (A + B) % 2 != 0:
    print("IMPOSSIBLE")
else:
    print((A + B)
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
q, r = divmod(sum(map(int, input().split())), 2)
print(q if r else 'IMPOSSIBLE')

Failing test case input:
101 23155

Expected output:
11628


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
q, r = divmod(sum(map(int, input().split())), 2)
print('IMPOSSIBLE' if r else q)

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
k=(a+b)/2
if k%1==0:
    print(k)
else:
    print('IMPOSSIBLE')


Failing test case input:
314794616 44782566

Expected output:
179788591


Actual output:
179788591.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a , b = map(int, input().split())
x = a-b
if x%2 == 1:
    print("IMPOSSIBLE")
else:
    print((a+b)/2)

Failing test case input:
1258 75698

Expected output:
38478


Actual output:
38478.0


Fixed submission (verdict: Accepted):
a , b = map(int, input().split())
x = a-b
if x%2 == 1:
    print("IMPOSSIBLE")
else:
    print(int((a+b)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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")

Failing test case input:
0 162

Expected output:
81


Actual output:
81.0


Fixed submission (verdict: Accepted):
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")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if ((a+b)%2) == 1:
    print ('IMPOSSIBLE')
else:
    print ((a+b)/2)

Failing test case input:
351241 1574255

Expected output:
962748


Actual output:
962748.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if ((a+b)%2) == 1:
    print ('IMPOSSIBLE')
else:
    print ((a+b)

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())


c  = abs((b-a)/2)

if c.is_integer() == True:
  print(int(c))


else:
  print("IMPOSSIBLE")

Failing test case input:
804043 1574255

Expected output:
1189149


Actual output:
385106


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())


c  = abs((b+a)/2)

if c.is_integer() == True:
  print(int(c))


else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int ,input().split())
c = (a + b)
if type(c) == int:
  print(c)
else :
  print("IMPOSSIBLE")

Failing test case input:
1764893 20404011

Expected output:
11084452


Actual output:
22168904


Fixed submission (verdict: Accepted):
a, b = map(int ,input().split())
if (a + b)%2 == 0:
  print(int((a + b)/2))
else :
  print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
k = a + b

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

Failing test case input:
0 162

Expected output:
81


Actual output:
81.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
k = a + b

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

Problem: p02957
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b = map(int, input().split())
k = (a + b) / 2

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

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
499791364


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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")

Failing test case input:
2563528379 9221341

Expected output:
1286374860


Actual output:
IMPOSSIBLE


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

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
K = (A+B)/2
if K % 2 == 0:
    print(int(K))
else:
    print("IMPOSSIBLE")

Failing test case input:
44913600 9480486

Expected output:
27197043


Actual output:
IMPOSSIBLE


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
K=(A+B)/2
if K%1==0:
  print(K)
else:
  print('IMPOSSIBLE')

Failing test case input:
1349313191 99824435

Expected output:
724568813


Actual output:
724568813.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if ((A+B)/2)%1==0:
    print((A+B)/2)
else:
    print("IMPOSSIBLE")

Failing test case input:
44913600 9480486

Expected output:
27197043


Actual output:
27197043.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int, input().split())
if a<b:
  a,b=b,a

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

Failing test case input:
2773903 1574255

Expected output:
2174079


Actual output:
2174079.0


Fixed submission (verdict: Accepted):
a,b=map(int, input().split())
if a<b:
  a,b=b,a

k=(a+b)/2
if k%1==0 and b<k<a:
  print(int(k))
else:
  print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if (A+B)%2==0:
  print((A+B)/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
819805567 6544429

Expected output:
413174998


Actual output:
413174998.0


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if (A+B)%2==0:
  print((A+B)
else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
K = (A+B)/2
judge = isinstance(K, float)
if judge:
  print("IMPOSSIBLE")
else:
  print(K)

Failing test case input:
314794616 44782566

Expected output:
179788591


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
if (A+B)%2 != 0:
  print("IMPOSSIBLE")
else:
  print((A+B)

Problem: p02957
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b=map(int,input().split())
if (a+b)%2!=0:
  print('IMPOSSIBLE')
else:
  h=(a+b)/2
  print(h)

Failing test case input:
5490045 24174675

Expected output:
14832360


Actual output:
14832360.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
if (A+B)%2==0:
  print((A+B)/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
108741947 17746947

Expected output:
63244447


Actual output:
63244447.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if (A+B)%2==0:
    print ((A+B)/2)
else:
    print ('IMPOSSIBLE')

Failing test case input:
2 94

Expected output:
48


Actual output:
48.0


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if (A+B)%2==0:
    print ((A+B)
else:
    print ('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x = input().split()

a = int(x[0])
b = int(x[1])

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

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
499791364


Fixed submission (verdict: Accepted):
x = input().split()

a = int(x[0])
b = int(x[1])

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
if (a + b) % 2 == 0:
  print((a+b)/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
1457 62403

Expected output:
31930


Actual output:
31930.0


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
if (a + b) % 2 == 0:
  print((a+b)
else:
  print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())
K2 = abs(A-B)
if K2%2 == 0:
    print(int(K2/2) )
else:
    print("IMPOSSIBLE")

Failing test case input:
111 12903

Expected output:
6507


Actual output:
6396


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())
K2 = abs(A-B)
if K2%2 == 0:
    print(int(max(A,B) - K2/2) )
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = list(map(int, input().split()))
if (a + b) % 2 == 0 :
  print((a + b) / 2)
else :
  print("IMPOSSIBLE")


Failing test case input:
1457 62403

Expected output:
31930


Actual output:
31930.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if (a + b) % 2 == 0 :
  print((a + b) 
else :
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())

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

Failing test case input:
155 18233

Expected output:
9194


Actual output:
9194.0


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

if (abs(A - B) % 2 == 0) :
	X = abs(A - B) % 2 + min([A, B])
else:
	X = "IMPOSSIBLE"


print("{0}".format(X))

Failing test case input:
1457 62403

Expected output:
31930


Actual output:
1457


Fixed submission (verdict: Accepted):

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

if (abs(A - B) % 2 == 0) :
	X = int(abs(A - B) / 2) + min([A, B])
else:
	X = "IMPOSSIBLE"


print("{0}".format(X))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if (a+b)/2 %2 == 0:
    print("IMPOSSIBLE")
else:
    print(str(int((a+b)/2)))


Failing test case input:
819805567 9274641

Expected output:
414540104


Actual output:
IMPOSSIBLE


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



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

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

Failing test case input:
107633744 9480486

Expected output:
58557115


Actual output:
112373987


Fixed submission (verdict: Accepted):



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

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

Problem: p02957
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b = map(int, input().split())
if (a + b) % 2 == 0:
    print(int((a + b) / 2))

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:

Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if (a + b) % 2 == 0:
    print(int((a + b) / 2))
else:
    print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(int,input().split())
if (a+b)%2==0:
    print((a+b)/2)
else:
    print("IMPOSSIBLE")


Failing test case input:
-2 24

Expected output:
11


Actual output:
11.0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if (a+b)%2==0:
    print((a+b)
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if (a+b)%2==0:
    print((a+b)/2)
else:
    print("IMPOSSIBLE")

Failing test case input:
9349 71369

Expected output:
40359


Actual output:
40359.0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if (a+b)%2==0:
    print((a+b)
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())

K = (A+B)/2
if isinstance(K,int):
    print(K)
else:
    print('IMPSSIBLE')

Failing test case input:
190939370 14450182

Expected output:
102694776


Actual output:
IMPSSIBLE


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
if A==B:
  K=1
  print(K)
else:
  if (A+B)%2==0:
    K=(A+B)/2
    print(K)
  else:
    print('IMPOSSIBLE')


Failing test case input:
4 24

Expected output:
14


Actual output:
14.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
if (A+B)%2==0:
  print((A+B)/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
-2 24

Expected output:
11


Actual output:
11.0


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if (A+B)%2==0:
  print((A+B)
else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if a+b % 2 == 0:
    print((a+b)/2)
else:
    print('IMPOSSIBLE')


Failing test case input:
44913600 9480486

Expected output:
27197043


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
c = a + b
if c % 2 == 0:
    print(int(c/2))
else:
    print('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a , b = map(int, input().split())
if (a + b)%2 == 0:
  print((a+b)/2)
else:
  print("impossible")

Failing test case input:
1457 62403

Expected output:
31930


Actual output:
31930.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if (a + b)%2 == 0:
  print((a+b)
else:
  print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x,y = map(int,input().split())
if x%2!=y%2:
  print('IMPOSSIBLE')
else:
  print((x+y)/2)

Failing test case input:
9349 184005

Expected output:
96677


Actual output:
96677.0


Fixed submission (verdict: Accepted):
x,y = map(int,input().split())
if x%2!=y%2:
  print('IMPOSSIBLE')
else:
  print(int((x+y)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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")

Failing test case input:
142428602 25059880

Expected output:
83744241


Actual output:
83744241.0


Fixed submission (verdict: Accepted):
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")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
sum=a+b
if sum%2==0:
  print(sum/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
160359946 44782566

Expected output:
102571256


Actual output:
102571256.0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
sum=a+b
if sum%2==0:
  print(int(sum/2))
else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
K = (A + B) / 2
ans = int(K) if K % 2 == 0 else "IMPOSSIBLE"
print(ans)

Failing test case input:
9349 71369

Expected output:
40359


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
K = (A + B) / 2
ans = int(K) if (A + B) % 2 == 0 else "IMPOSSIBLE"
print(ans)

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
if (abs(A-B)/2) % 1 != 0:
	print('IMPOSSIBLE')
else:
	print(int(abs(A-B)/2))

Failing test case input:
2261972 976314

Expected output:
1619143


Actual output:
642829


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
if (abs(A-B)/2) % 1 != 0:
	print('IMPOSSIBLE')
else:
	print(int(min(A,B)+abs(A-B)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())

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


Failing test case input:
2981809 20404011

Expected output:
11692910


Actual output:
0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
s = (a+b)/2

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

Failing test case input:
1665978 29045576

Expected output:
15355777


Actual output:
15355777.0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
s = int((a+b)/2)
u = (a+b)%2

if u == 0:
  print(s)
  
else: 
  print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int, input().split())

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

Failing test case input:
50 2

Expected output:
26


Actual output:
26.0


Fixed submission (verdict: Accepted):
a,b = map(int, input().split())
 
if (a+b)%2 == 1:
  print('IMPOSSIBLE')
else:
  print(int((a+b)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k = sum(list(map(int, input().split())))/2
if k % 1:
    print('IMPOSSIBLE')
    exit()
print(k)

Failing test case input:
2563528379 6197513

Expected output:
1284862946


Actual output:
1284862946.0


Fixed submission (verdict: Accepted):
k = sum(list(map(int, input().split())))/2
if k % 1:
    print('IMPOSSIBLE')
    exit()
print(int(k))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
ans=(A+B)/2

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

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
499791364


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

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if (a+b)%2==0:
    print((a+b)/2)
else:
    print('IMPOSSIBLE')

Failing test case input:
649873 24174675

Expected output:
12412274


Actual output:
12412274.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())
if (a+b)%2==0:
    print(int((a+b)/2))
else:
    print('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
input_ = input().split()
a = int(input_[0])
b = int(input_[1])

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

Failing test case input:
819805567 6544429

Expected output:
413174998


Actual output:
413174998.0


Fixed submission (verdict: Accepted):
input_ = input().split()
a = int(input_[0])
b = int(input_[1])

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A , B = (int(x) for x in input().split())
k = (B + A) / 2
K = (B + A) % 2
if K == 0:
    print(k)
else:
    print("IMPOSSIBLE")

Failing test case input:
2981809 20404011

Expected output:
11692910


Actual output:
11692910.0


Fixed submission (verdict: Accepted):
A , B = (int(x) for x in input().split())
k = (B + A) / 2
K = (B + A) % 2
if K == 0:
    print(int(k))
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
if (A + B) % 2 == 0:
    print(int((A + B) / 2))
else:
    print(-1)

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
-1


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
if (A + B) % 2 == 0:
    print(int((A + B) / 2))
else:
    print("IMPOSSIBLE")
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if a+b % 2 !=0:
  print("IMPOSSIBLE")
else:
  print((a+b)/2)

Failing test case input:
2770031 5298487

Expected output:
4034259


Actual output:
IMPOSSIBLE


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B=map(int,input().split())
print(abs(int((A-B)/2)) if (A-B)%2==0 else 'IMPOSSIBLE')

Failing test case input:
4 36

Expected output:
20


Actual output:
16


Fixed submission (verdict: Accepted):
A,B=map(int,input().split())
if (A+B)%2==0:
    print(int((A+B)/2))
else:
    print('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
a,b=map(int,input().split())
k=abs((a-b)/2)  
k1=math.trunc(k)
if (k-k1)==0 and k!=0:
    print(int(k))
else:
    print('IMPOSSIBLE')

Failing test case input:
108741947 17746947

Expected output:
63244447


Actual output:
45497500


Fixed submission (verdict: Accepted):
import math
a,b=map(int,input().split())
k=abs((a+b)/2)  
k1=math.trunc(k)
if (k-k1)==0 and k!=0:
    print(int(k))
else:
    print('IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int,input().split())
 
if (A+B) % 2 == 0:
  print((A+B)/2)
else :
  print("IMPOSSIBLE")

Failing test case input:
4373039 5298487

Expected output:
4835763


Actual output:
4835763.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())
C=(A+B)/2
D=A+B
if D %2 != 0:
    print('IMPOSSIBLE')
elif D %2 == 0:
    print(C)

Failing test case input:
0 34

Expected output:
17


Actual output:
17.0


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())
C=(A+B)/2
D=A+B
if D %2 > 0:
    print('IMPOSSIBLE')
elif D %2 == 0:
    print((A+B)

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int, input().split()))

b = a[0] + a[1]

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

Failing test case input:
3240969 9769089

Expected output:
6505029


Actual output:
6505029.0


Fixed submission (verdict: Accepted):
a = list(map(int, input().split()))

b = a[0] + a[1]

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

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

Failing test case input:
190939370 14450182

Expected output:
102694776


Actual output:
102694776.0


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())

if (A+B) % 2 == 1:
    print('IMPOSSIBLE')
else:
    print(int((A+B)/2))
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())

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

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
IMMPOSSIBLE


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B = map(int, input().split())
K = (A + B) / 2
ans = K if K % 2 == 0 else "IMPOSSIBLE"
print(ans)

Failing test case input:
804043 1574255

Expected output:
1189149


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
A, B = map(int, input().split())
K = (A + B) / 2
ans = int(K) if (A + B) % 2 == 0 else "IMPOSSIBLE"
print(ans)

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int, input().split()))
if (A[0] - A[1]) %2 != 0:
  print('impossible')
  exit()
print( int( abs(A[0]+ (A[1] - A[0])/2 ) ) )


Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
impossible


Fixed submission (verdict: Accepted):
A = list(map(int, input().split()))
if (A[0] - A[1]) %2 != 0:
  print('IMPOSSIBLE')
  exit()
print( int( abs(A[0]+ (A[1] - A[0])/2 ) ) )

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
A,B = map(float, input().split())
K = A+B/2
if K.is_integer():
    print(math.floor(K))
else:
    print("IMPOSSIBLE")


Failing test case input:
819805567 8560445

Expected output:
414183006


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
import math
A,B = map(int, input().split())
K = (A**2-B**2)/(2*(A-B))
if K.is_integer():
    print(math.floor(K))
else:
    print("IMPOSSIBLE")

Problem: p02957
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a, b = map(int, input().split())


if a > b or b > a and (a + b) % 2 == 0:

    k = (a+b) / 2
    print(int(k))

else:
    print('IMPOSSIBLE')

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
499791364


Fixed submission (verdict: Accepted):
a, b = map(int, input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int,input().split())
K = (A+B)/2
if type(K) is int:
  print(K)
else:
  print("Impossible")

Failing test case input:
1258 186122

Expected output:
93690


Actual output:
Impossible


Fixed submission (verdict: Accepted):
A,B = map(int,input().split())
K = (A+B)
if K%2 == 0 :
  print(K
else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int, input().split())
if a%2 != b%2:
  print("IMPOSSIBLE")
else:
  print((a+b)/2)

Failing test case input:
1349313191 99824435

Expected output:
724568813


Actual output:
724568813.0


Fixed submission (verdict: Accepted):
a,b=map(int, input().split())
if a%2 != b%2:
  print("IMPOSSIBLE")
else:
  print((a+b)
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)))
else:
  print("IMPOSSIBLE")

Failing test case input:
2978008 29045576

Expected output:
16011792


Actual output:
13033784


Fixed submission (verdict: Accepted):
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")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
if ((a+b)/2)%2 == 0:
    print(int((a+b)/2))
else:
    print("IMPOSSIBLE")


Failing test case input:
2981809 14428573

Expected output:
8705191


Actual output:
IMPOSSIBLE


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())

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


Failing test case input:
2978008 25356586

Expected output:
14167297


Actual output:
14167297.0


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, = map(int, input().split())
C = (A + B) / 2
print(int(C)) if (A + B) % 2 == 0 else print("impossible")

Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
impossible


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B = map(int, input().split())
print((A+B)/2 if (A+B)/2%2 == 0 else 'IMPOSSIBLE')

Failing test case input:
0 162

Expected output:
81


Actual output:
IMPOSSIBLE


Fixed submission (verdict: Accepted):
A,B = map(int, input().split())
print(int((A+B)/2) if (A+B)%2 == 0 else 'IMPOSSIBLE')

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if (a+b)%2 == 1 :
    print("IMPOSSIBLE")
else :
    print((a+b)/2)

Failing test case input:
89 11409

Expected output:
5749


Actual output:
5749.0


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
if (a+b)%2 == 1 :
    print("IMPOSSIBLE")
else :
    print(int((a+b)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
AB = input().split()
A = int(AB[0])
B = int(AB[1])

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


Failing test case input:
899758294 99824435

Expected output:
IMPOSSIBLE


Actual output:
499791364


Fixed submission (verdict: Accepted):
AB = input().split()
A = int(AB[0])
B = int(AB[1])

if (A + B) % 2 == 1:
    print("IMPOSSIBLE")
else:
    print(int( (A+B)/2 ) )
Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
if (a + b) % 2 != 0:
    print('IMPOSSIBLE')
else:
    print((a + b)/2)

Failing test case input:
1258 96120

Expected output:
48689


Actual output:
48689.0


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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input().split()

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

if k.is_integer():
    print(k)
else:
    print('impossible')


Failing test case input:
142428602 25059880

Expected output:
83744241


Actual output:
83744241.0


Fixed submission (verdict: Accepted):
s = input().split()

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

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = (int(x) for x in input().split())


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

else:
  print((a+b)/2)


Failing test case input:
1258 96120

Expected output:
48689


Actual output:
48689.0


Fixed submission (verdict: Accepted):
a,b = (int(x) for x in input().split())


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

else:
  print(int((a+b)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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")

Failing test case input:
969473 24174675

Expected output:
12572074


Actual output:
12572074.0


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

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

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split())
k = (a + b) / 2
l = (a + b) % 2
if l == 0:
    print(k)
else:
    print("IMPOSSIBLE")

Failing test case input:
4 42

Expected output:
23


Actual output:
23.0


Fixed submission (verdict: Accepted):


a_b_list = list(map(int,input().split()))
a = a_b_list[0]
b = a_b_list[1]

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

if l == 0:
  print(int(k))
else:
  print("IMPOSSIBLE")

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
if a+b%2 ==1:
    print("IMPOSSIBLE")
else:
    print((a+b)/2)

Failing test case input:
101 23155

Expected output:
11628


Actual output:
11628.0


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
if (a+b)%2 ==1:
    print("IMPOSSIBLE")
else:
    print(int((a+b)/2))

Problem: p02957
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = map(int, input().split(" "))
x = abs(a-b)
if x%2 == 0:
  print(x/2)
else:
  print("IMPOSSIBLE")

Failing test case input:
2981809 14428573

Expected output:
8705191


Actual output:
5723382.0


Fixed submission (verdict: Accepted):
a, b = map(int, input().split(" "))
x = abs(a+b)
if x%2 == 0:
  print(int(x/2))
else:
  print("IMPOSSIBLE")