ZhenlongDai/ACPR huggingface dataset:
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())

if n >= 10:
    print(r)

else:
    in_r = 100 * (10-n)
    print(in_r)



Failing test case input:
9 319

Expected output:
419


Actual output:
100


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

if n >= 10:
    print(r)

else:
    in_r = r + 100*(10-n)
    print(in_r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int, input().split())

if n < 10:
    print(100 * (10-r))
else:
    print(r)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
-160500


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

if n < 10:
    print((100 * (10-n))+r)
else:
    print(r)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,r = map(int,input().split())
ans = 0

if n >= 10:
  ans = r
else:
  ans = 100 * (10 - n)
  
print(ans)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
1000


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
ans = 0

if n >= 10:
  ans = r
else:
  ans = r + (100 * (10 - n))
  
print(ans)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int,input().split())
if n<=10:
    print(r+100*(10-n))

Failing test case input:
76 1018

Expected output:
1018


Actual output:

Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n<=10:
    print(r+100*(10-n))
else:
    print(r)

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

print(b if a >= 10 else b-100*(10-a))

Failing test case input:
0 1885

Expected output:
2885


Actual output:
885


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

print(b if a >= 10 else b+100*(10-a))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = input().split()
N,R = int(N),int(R)
L = R
if N < 10:
    L = R - 100*(10-N)
else:
    L = R

print(L)


Failing test case input:
9 81

Expected output:
181


Actual output:
-19


Fixed submission (verdict: Accepted):
N,R = input().split()
N,R = int(N),int(R)
L = R
if N < 10:
    L=R + 100*(10-N)
else:
    L = R

print(L)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b = map(int, input().split())
if a < 10:
  ans = b + 100*(10 - a)
else:
  ans = b
print(b)
	


Failing test case input:
9 319

Expected output:
419


Actual output:
319


Fixed submission (verdict: Accepted):
a,b = map(int, input().split())
if a < 10:
  ans = b + 100*(10 - a)
else:
  ans = b
print(ans)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())
print(type(N), N, R)

if N<10:
    R=R+100*(10-N)
    print(R)
else:
    print(R)

Failing test case input:
76 6963

Expected output:
6963


Actual output:
<class 'int'> 76 6963
6963


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())


if N<10:
    R=R+100*(10-N)
    print(R)
else:
    print(R)
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, k = map(int, input().split())
if n < 10:
    print(k - (100 * (10 - n)))
else:
    print(k)

Failing test case input:
1 503

Expected output:
1403


Actual output:
-397


Fixed submission (verdict: Accepted):
n, k = map(int, input().split())
if n < 10:
    print(k + (100 * (10 - n)))
else:
    print(k)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int,input().split())
if n>=10:
  print(r)
else:
  print(r-100*(10-n))


Failing test case input:
6 206

Expected output:
606


Actual output:
-194


Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n>=10:
  print(r)
else:
  print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,r = [int(i) for i in readline().split()]

if n >= 10:
    print(r)
else:
    print(r-100*(10-n))

Failing test case input:
9 540

Expected output:
640


Actual output:
440


Fixed submission (verdict: Accepted):
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,r = [int(i) for i in readline().split()]

if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
sum,rate=map(int,input().split())
if sum>=10:
    print(rate)
else:
     ans=rate-100*(10-sum)
     print(ans)   

Failing test case input:
0 245

Expected output:
1245


Actual output:
-755


Fixed submission (verdict: Accepted):
sum,rate=map(int,input().split())
if sum>=10:
    print(rate)
else:
     ans=rate+100*(10-sum)
     print(ans)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())

if n<10:
  print(r-100*(10-n))
else:
  print(r)

Failing test case input:
1 503

Expected output:
1403


Actual output:
-397


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

if n<10:
  print(r+100*(10-n))
else:
  print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())

inside = 0
if N >= 10:
  inside = R
else:
  inside = R - 100*(10-N)

print(inside)
  

Failing test case input:
6 319

Expected output:
719


Actual output:
-81


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())

inside = 0
if N >= 10:
  inside = R
else:
  inside = R + 100*(10-N)

print(inside)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())

if N <= 10:
  print(R - (10-N)*100)
else:
  print(R)

Failing test case input:
1 139

Expected output:
1039


Actual output:
-761


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())

print( R if N >= 10 else R + 100*(10-N))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
n, r = map(int, input().split())
if n >= n:
    print(r)
else: 
    print(r - (10-n)*100)

Failing test case input:
0 245

Expected output:
1245


Actual output:
245


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r + (10-n)*100)
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int,input().split())
if r>=10:
  print(n)
else:
  print(r-(100*(10-n)))

Failing test case input:
1 139

Expected output:
1039


Actual output:
1


Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n>=10:
  print(r)
else:
  print(r+(100*(10-n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())
if n > 10:
  n = 10
print( r - 100 * (10 -n))

Failing test case input:
-1 -32

Expected output:
1068


Actual output:
-1132


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
if n > 10:
  n = 10
print(r + 100 * (10 -n))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, R = map(int, input().split())
if N>10:
    print(R)  
else:
    print(R - (100 * (10 - N)))

Failing test case input:
1 503

Expected output:
1403


Actual output:
-397


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
    print(R)  
else:
    print(R + (100 * (10 - N)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = [int(x) for x in input().split(' ')]

if N > 9:
  print(R)
else:
  print(R - 100 * (10 - N))


Failing test case input:
-1 -22

Expected output:
1078


Actual output:
-1122


Fixed submission (verdict: Accepted):
N, R = [int(x) for x in input().split(' ')]

if N > 9:
  print(R)
else:
  print(R + 100 * (10 - N))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N, R = map(int, input().split())
if N < 10:
  print(R - (100 * (10 - N)))
else:
  print(R)

Failing test case input:
-1 -28

Expected output:
1072


Actual output:
-1128


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N < 10:
  print(R + (100 * (10 - N)))
else:
  print(R)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

def main():
    n, r = map(int, input().split())
    if n >= 10:
        print(r)
    else:
        print(r - (100 * (10 - n)))


if __name__ == "__main__":
    main()


Failing test case input:
-1 2265

Expected output:
3365


Actual output:
1165


Fixed submission (verdict: Accepted):

def main():
    n, r = map(int, input().split())
    if n >= 10:
        print(r)
    else:
        print(r + (100 * (10 - n)))


if __name__ == "__main__":
    main()

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
print(R if 10>=N else R + 100*(10-N))

Failing test case input:
1 2265

Expected output:
3165


Actual output:
2265


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = list(map(int, input().split()))
if N >= 10:
    print(R)

Failing test case input:
6 206

Expected output:
606


Actual output:

Fixed submission (verdict: Accepted):
N,R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R+(100*(10-N)))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())
if N <= 10:
    print(R)
else:
    print(R + 1000 -10*N)

Failing test case input:
15 206

Expected output:
206


Actual output:
1056


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())
if N >= 10:
    print(R)
else:
    print(R + 1000 -100*N)

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

if a >= 10:
    print(b)
else:
    print(b-100*(10 - a))

Failing test case input:
-1 -28

Expected output:
1072


Actual output:
-1128


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

if a >= 10:
    print(b)
else:
    print(b + 100*(10 - a))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N < 10:
  O = N
else:
  O = R + 100*(10-N)
print(O)

Failing test case input:
0 503

Expected output:
1503


Actual output:
0


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
  O = R
else:
  O = R + 100*(10-N)
print(O)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
print(R if N >= 10 else R-100*(10-N))

Failing test case input:
1 1703

Expected output:
2603


Actual output:
803


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
print(R if N >= 10 else (R + 100*(10-N)))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N, R = map(int, input().split())

if N >= 10:
    print(N)
else:
    print(R + 100 * (10 - N))

Failing test case input:
22 3051

Expected output:
3051

Actual output:
22


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int,input().split())
ans=r

if n <10:
  ans= r - (100*(10-n))
  
print(ans)

Failing test case input:
0 -16

Expected output:
984


Actual output:
-1016


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

if n <10:
  ans= r + (100*(10-n))
  
print(ans)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())
if n<10:
	r = 100*(10-n)
print(r)


Failing test case input:
1 1703

Expected output:
2603


Actual output:
900


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
if n<10:
	r = 100*(10-n)+r
print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())
if N >= 10:
  rat = R
else:
  rat = R - 100*(10-N)
print(int(rat))

Failing test case input:
1 4162

Expected output:
5062


Actual output:
3262


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())
if N >= 10:
  rat = R
else:
  rat = R + 100*(10-N)
print(int(rat))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

def main():
    N,R = map(int,input().split())
    if N >= 10:
        print(R)
        return
    else:
        print(R-(100*(10-N)))

if __name__ == '__main__':
    main()

Failing test case input:
6 206

Expected output:
606


Actual output:
-194


Fixed submission (verdict: Accepted):

def main():
    N,R = map(int,input().split())
    if N >= 10:
        print(R)
        return
    else:
        print(R+(100*(10-N)))

if __name__ == '__main__':
    main()

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())

print(R if 10 <= N else (R - (100 * (10 - N))))

Failing test case input:
0 -16

Expected output:
984


Actual output:
-1016


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())

print(R if 10 <= N else (R + (100 * (10 - N))))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = input().split()
N,R = int(N),int(R)
L = R
if N < 10:
    L=100*(10-N)
else:
    L = R

print(L)


Failing test case input:
6 319

Expected output:
719


Actual output:
400


Fixed submission (verdict: Accepted):
N,R = input().split()
N,R = int(N),int(R)
L = R
if N < 10:
    L=R + 100*(10-N)
else:
    L = R

print(L)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int,input().split())
if n>=10:
    print(r)
else:
    r-=100*(10-n)
    print(r)
    

Failing test case input:
0 245

Expected output:
1245


Actual output:
-755


Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n>=10:
    print(r)
else:
    r+=100*(10-n)
    print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
L, R = map(int, input().split())
print(type(L), L, R)

if L < 10:
    print(R + (100*(10-L)))
else:
    print(R)


Failing test case input:
9 81

Expected output:
181


Actual output:
<class 'int'> 9 81
181


Fixed submission (verdict: Accepted):
L, R = map(int, input().split())

if L < 10:
    print(R + (100*(10-L)))
else:
    print(R)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def f():
  n, r = map(int,input().split())
  if n > 9:
    return r
  else:
    return 100 * (10 - n)


Failing test case input:
-1 2265

Expected output:
3365


Actual output:

Fixed submission (verdict: Accepted):
def main():
  n, r = map(int,input().split())
  if n > 9:
    print(r)
  else:
    print(r + 100 * (10 - n))

main()

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N, R = map(int, input().split())
if N >= 10:
  print(R)
else:
  print(100*(10-N))

Failing test case input:
1 81

Expected output:
981


Actual output:
900


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
  print(R)
else:
  print(R+100*(10-N))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

N,R = map(int, input().split())
if N < 10:
	R = R - 100 * (10 - N )
     
print(R)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
615


Fixed submission (verdict: Accepted):

N,R = map(int, input().split())
if N < 10:
	R = R + 100 * (10 - N )
     
print(R)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, r = map(int, input().split())

if n >= 10:
  print(r)
else:
  print(r - 100 * (10-n))

Failing test case input:
0 1885

Expected output:
2885


Actual output:
885


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

if n >= 10:
    print(r)
else:
    print(r + (100 * (10 - n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = list(map(int, input().split())) 
if a < 10:
  print(b-1000+100*a)
else:
  print(b)


Failing test case input:
9 206

Expected output:
306


Actual output:
106


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

if a >=10:
  c=int(b)
  print(c)
else:
  c=int(b+1000-100*a)
  print(c)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else 100 * (10 - N)
 
print(result)

Failing test case input:
6 319

Expected output:
719


Actual output:
400


Fixed submission (verdict: Accepted):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else R + 100 * (10 - N)
 
print(result)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
 
stdin = sys.stdin
inf = 2 << 60
mod = 1000000008
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

n, r = na()

if n >= 11:
    print(r)
else:
    print(r + 101 * (10 - n))

Failing test case input:
0 503

Expected output:
1503


Actual output:
1513


Fixed submission (verdict: Accepted):
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

n, r = na()

if n < 10:
    print(r + (100 * (10 - n)))
else:
    print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,K=map(int,input().split())
if N >=10:
    print(K)
else:
    print(K-100*(10-K))


Failing test case input:
1 81

Expected output:
981


Actual output:
7181


Fixed submission (verdict: Accepted):
N,K=map(int,input().split())
if N >=10:
    print(K)
else:
    print(K+100*(10-N))
Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
n,r=map(int,input().split())
if n>10:
	print(r)
else:
	print(r-1000+100*n)


Failing test case input:
0 1051

Expected output:
2051


Actual output:
51


Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n>10:
	print(r)
else:
	print(r+1000-100*n)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
if n < 10:
  ans = r - (100 * (10 - n))
  print(ans)
else:
  print(r)

Failing test case input:
9 206

Expected output:
306


Actual output:
106


Fixed submission (verdict: Accepted):
n, r  = map(int, input().split())
if n < 10:
    ans = r + (100 * (10 - n))
    print(ans)
else:
    print(r)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print(100*(10-n))


Failing test case input:
6 206

Expected output:
606


Actual output:
400


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

if n >= 10:
    print(r)
else:
    print(r + 100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r=map(int, input().split())
if n>=10:
  print(r)
else:
  print(r-100*(10-n))

Failing test case input:
1 1051

Expected output:
1951


Actual output:
151


Fixed submission (verdict: Accepted):
n,r=map(int, input().split())
if n>=10:
  print(r)
else:
  print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, r = map(int, input().split())
print(r - 100 * max(10 - n, 0))

Failing test case input:
1 4162

Expected output:
5062


Actual output:
3262


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
print(r + 100 * max(10 - n, 0))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int, input().split()) 
if N>=10:
  t=R
else :
  t=R+100*(10-N)
print(R)  

Failing test case input:
6 206

Expected output:
606


Actual output:
206


Fixed submission (verdict: Accepted):
N,R=map(int, input().split()) 
if N>=10:
  t=R
else :
  t=R+100*(10-N)
print(t)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())

if N >= 10:
    rate = R
else:
    rate = 100 * (10 - N)

print(rate)


Failing test case input:
9 319

Expected output:
419


Actual output:
100


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())

if N >= 10:
    rate = R
else:
    rate = R + (100 * (10 - N))

print(rate)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int, input().split())
print(R - 100 * (10 - max(10,N)))

Failing test case input:
17 3619

Expected output:
3619


Actual output:
4319


Fixed submission (verdict: Accepted):
N,R = map(int, input().split())
print(R + 100 * (10 - min(10,N)))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = [int(i) for i in input().split()]
print(r if n > 10 else r * (10 - n))

Failing test case input:
1 139

Expected output:
1039


Actual output:
1251


Fixed submission (verdict: Accepted):
n, r = [int(i) for i in input().split()]
print(r if n >= 10 else r + 100 * (10 - n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N < 10:
    print(N + R)
print(R)

Failing test case input:
0 245

Expected output:
1245


Actual output:
245
245


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
print(R + 100*(10 - min(10, N)))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,R = map(int,input().split())
if N <= 9:
  R -= 100*(10-N)
print(R)

Failing test case input:
0 -16

Expected output:
984


Actual output:
-1016


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())
if N <= 9:
  R += 100*(10-N)
print(R)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())

if N < 10:
    print(R - 100 * (10 - N))
else:
    print(R)

Failing test case input:
6 206

Expected output:
606


Actual output:
-194


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())

if N < 10:
    print(R + 100 * (10 - N))
else:
    print(R)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i = list(map(int, input().split()))
N = i[0]
R = i[1]

if N > 10:
  result = R
else:
  result = 100 * (10 - N)

print(result)

Failing test case input:
1 81

Expected output:
981


Actual output:
900


Fixed submission (verdict: Accepted):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else R + 100 * (10 - N)
 
print(result)

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N,R=map(int,input().split())
if N>=10:
  print('R')
else:
  print('R+100*(10-K)')
        

Failing test case input:
-1 503

Expected output:
1603


Actual output:
R+100*(10-K)


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if N>=10:
  print(R)
else:
  print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int,input().split())
if R>=10:
  a=N
else:
  a=100*(10-N)
print(a)

Failing test case input:
9 319

Expected output:
419


Actual output:
9


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if N>=10:
  a=R
else:
  a=100*(10-N)+R
print(a)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,k = map(int,input().split())

if n >= 10:
  print(k)
else:
  print(100*(100-k))

Failing test case input:
1 81

Expected output:
981


Actual output:
1900


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

if n >= 10:
  print(k)
else:
  print(k + 100*(10-n))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())

if n >= 10:
    print(r)
else:
    print(r - (100*(100-n)))
    


Failing test case input:
1 1051

Expected output:
1951


Actual output:
-8849


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

if n >= 10:
    print(r)
else:
    print(r + (100*(10-n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int,input().split())

if N>=10:
  print(R)
else:
  print(10-R/100)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
-6.149999999999999


Fixed submission (verdict: Accepted):
N, R = map(int,input().split())

if N>=10:
  print(R)
else:
  print(R+100*(10-N))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N,R=map(int,input().split())
print(R+100*(10-N))

Failing test case input:
22 3051

Expected output:
3051

Actual output:
1851


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if(N>=10):print(R)
else:print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())

if N >= 10 :
  print(R)
  
else :
  print(100*(10-N))

Failing test case input:
1 81

Expected output:
981


Actual output:
900


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())

if N >= 10 :
  print(R)
  
else :
  print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print( 100 * (10-n))

Failing test case input:
6 319

Expected output:
719


Actual output:
400


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

if n >= 10:
    print(r)
else:
    print( r + 100 * (10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
if n >= 10:
  print(r)
else:
  print(r + (100 * (10-r)))


Failing test case input:
1 139

Expected output:
1039


Actual output:
-12761


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
if n >= 10:
  print(r)
else:
  print(r + (100 * (10-n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = [int(i) for i in input().split()]
print(r if n >= 10 else r * (10 - n))

Failing test case input:
2 2919

Expected output:
3719

Actual output:
23352


Fixed submission (verdict: Accepted):
n, r = [int(i) for i in input().split()]
print(r if n >= 10 else r + 100 * (10 - n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())

if N < 10:
    print(R - (100*(10-N)))
else:
    print(R)

Failing test case input:
9 319

Expected output:
419


Actual output:
219


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())

if N < 10:
    print(R + (100*(10-N)))
else:
    print(R)
Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N,R=map(int,input().split())
print(R-100*(10-N))

Failing test case input:
1 139

Expected output:
1039


Actual output:
-761


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if(N>=10):print(R)
else:print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
from sys import stdin
N,R = [int(x) for x in stdin.readline().rstrip().split()]
print(R - (100*(10-N)))

Failing test case input:
0 245

Expected output:
1245


Actual output:
-755


Fixed submission (verdict: Accepted):
from sys import stdin
N,R = [int(x) for x in stdin.readline().rstrip().split()]
if N >= 10:
    print(R)
else:
    print(R + (100*(10-N)))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b=map(int,input().split())
c=0
if a >=10:
  print(b)
else:
  c = 100 * (10-a)
  print(c)

Failing test case input:
-1 -32

Expected output:
1068


Actual output:
1100


Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
c=0
res = 0
if a >=10:
  print(b)
else:
  c = 100 * (10-a)
  res = b+c
  print(res)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int, input().split())
if a < 10:
  print(b-100*(10-a))
else:
  print(b)


Failing test case input:
2 2919

Expected output:
3719

Actual output:
2119


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

if a >=10:
  c=int(b)
  print(c)
else:
  c=int(b+1000-100*a)
  print(c)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())
if n>10:
  print(r)
else:
  print(100*(10-n))

Failing test case input:
9 540

Expected output:
640


Actual output:
100


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
if n>10:
  print(r)
else:
  print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R*(10-N))


Failing test case input:
0 -28

Expected output:
972


Actual output:
-280


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R+(100*(10-N)))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
n, r = map(int,input().split())

if n>=10:
  print(r)
else:
  print(100*(10-n))

Failing test case input:
-1 -22

Expected output:
1078


Actual output:
1100


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

if n>10:
  print(r)
else:
  print(r+(100*(10-n)))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()


n,r = na()

print(r-max(0,100*(10-n)))

Failing test case input:
-1 -32

Expected output:
1068


Actual output:
-1132


Fixed submission (verdict: Accepted):
import sys
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()


n,r = na()

print(r+max(0,100*(10-n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
 
if n >= 10:
  print(r)
else:
  print(r - 100 * (10 - n))

Failing test case input:
9 319

Expected output:
419


Actual output:
219


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
 
if n >= 10:
  print(r)
else:
  print(r + 100 * (10 - n))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

def main():
    n, r = map(int, input().split())
    if n >= 10:
        print(r)
    else:
        print(100 * (10 - n))


if __name__ == "__main__":
    main()


Failing test case input:
9 81

Expected output:
181


Actual output:
100


Fixed submission (verdict: Accepted):

def main():
    n, r = map(int, input().split())
    if n >= 10:
        print(r)
    else:
        print(r + (100 * (10 - n)))


if __name__ == "__main__":
    main()

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
if  n >= 10:
  print(r)
else:
  print(r- 100*(10-n))

Failing test case input:
1 4162

Expected output:
5062


Actual output:
3262


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
if  n >= 10:
  print(r)
else:
  print(r+ 100*(10-n))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, R = map(int, input().split())
print(R if N>=10 else R-100*(10-N))


Failing test case input:
6 319

Expected output:
719


Actual output:
-81


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
print(R if N>=10 else R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = map(int,input().split())
if N < 10 :
    print( 100*(10 - N) )
else :
    print( R )


Failing test case input:
1 1703

Expected output:
2603


Actual output:
900


Fixed submission (verdict: Accepted):
N,R = map(int,input().split())
if N < 10 :
    print( R + 100*(10 - N) )
else :
    print( R )

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = [int(elem) for elem in input().split()]

if n < 10:
  print(r - 100 *(10-n))
else:
  print(r)

Failing test case input:
0 2265

Expected output:
3265


Actual output:
1265


Fixed submission (verdict: Accepted):
n, r = [int(elem) for elem in input().split()]
 
if n < 10:
  print(r + 100 *(10-n))
else:
  print(r)
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, m = map(int, input().split()) 
if a >=10:
  print(m)
else:
  out = m - 100 *(10-a)
  print(out)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
615


Fixed submission (verdict: Accepted):
a, m = map(int, input().split()) 
if a >=10:
  print(m)
else:
  out = m + 100 *(10-a)
  if out <= 1:
    print(1)
  else:
    print(out)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())

if n >= 10:
  print(r)
else:
  print(100 * (10 - n))

Failing test case input:
6 206

Expected output:
606


Actual output:
400


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
 
if n >= 10:
  print(r)
else:
  print(r + 100 * (10 - n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R = list(map(int,input().split()))  
if N >= 10:
    print("{}".format(100 - (10 - N)))
else:
    print(R)

Failing test case input:
9 81

Expected output:
181


Actual output:
81


Fixed submission (verdict: Accepted):
N, R = list(map(int,input().split()))
if N < 10:
    print("{}".format(R + (100 * (10 - N))))
else:
    print(R)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
print(n, r) 

ans = 0
if n >= 10:
  ans = r
else:
  ans = r + (100 * (10 - n))

print(ans)

Failing test case input:
1 1051

Expected output:
1951


Actual output:
1 1051
1951


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

ans = 0
if n >= 10:
  ans = r
else:
  ans = r + (100 * (10 - n))

print(ans)

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

n,r = map(int, input().split())
if n > 10:
    k = 100*(10-n)
    s = k + r
else:
    s = r
print(s)

Failing test case input:
2 2919

Expected output:
3719

Actual output:
2919


Fixed submission (verdict: Accepted):
n,r = map(int, input().split())
if n < 10:
    k = 100*(10-n)
    s = r + k
else:
    s = r
print(s)

Problem: p02765
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
n,r = map(int,input().split())
print(r-(100*(10-n)))


Failing test case input:
-1 -32

Expected output:
1068


Actual output:
-1132


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
print(r+(100*(max(10-n,0))))

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

if a >=10:
  c=int(b)
  print(c)
else:
  c=int(b-1000+100*a)
  print(c)


Failing test case input:
-1 -22

Expected output:
1078


Actual output:
-1122


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

if a >=10:
  c=int(b)
  print(c)
else:
  c=int(b+1000-100*a)
  print(c)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int, input().split())

if n < 10:
    print((100 * (10-r))+r)
else:
    print(r)

Failing test case input:
1 1051

Expected output:
1951


Actual output:
-103049


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

if n < 10:
    print((100 * (10-n))+r)
else:
    print(r)
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R= map(int,input().split())
if N > 9:
    print(R)
else:
    print(R-10*(10-N))

Failing test case input:
1 4162

Expected output:
5062


Actual output:
4072


Fixed submission (verdict: Accepted):
N,R= map(int,input().split())
if N > 9:
    print(R)
else:
    print(R+100*(10-N))

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

N,R = map(int, input().split())
if N <= 10:
	R = R - 100 * (10 - N )
     
print(R)

Failing test case input:
9 319

Expected output:
419


Actual output:
219


Fixed submission (verdict: Accepted):

N,R = map(int, input().split())
if N < 10:
	R = R + 100 * (10 - N )
     
print(R)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
l = list(map(int, input().split()))
if l[0] >= 10:
	print(l[1])
else:
  print(l[1]-(10-l[0])*100)

Failing test case input:
1 1703

Expected output:
2603


Actual output:
803


Fixed submission (verdict: Accepted):
l = list(map(int, input().split()))
if l[0] >= 10:
	print(l[1])
else:
  print(l[1]+(10-l[0])*100)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split())
 
if n < 10:
  print(r-(100*(10-n)))
else:
  print(r)


Failing test case input:
0 1051

Expected output:
2051


Actual output:
51


Fixed submission (verdict: Accepted):
n,r = map(int,input().split())
 
if n < 10:
  print(r+(100*(10-n)))
else:
  print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
print(r - 100 * max(0, 10 - n))

Failing test case input:
9 81

Expected output:
181


Actual output:
-19


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
print(r + 100 * max(0, 10 - n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
from sys import stdin
N,R = [int(x) for x in stdin.readline().rstrip().split()]
if N >= 10:
    print(R)
else:
    print(R - (100*(10-N)))

Failing test case input:
6 170

Expected output:
570


Actual output:
-230


Fixed submission (verdict: Accepted):
from sys import stdin
N,R = [int(x) for x in stdin.readline().rstrip().split()]
if N >= 10:
    print(R)
else:
    print(R + (100*(10-N)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int,input().split())

if N>=10:
    print(R)
else:
    print(100*(10-N))

Failing test case input:
-1 -22

Expected output:
1078


Actual output:
1100


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())

if N>=10:
    print(R)
else:
    print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int,input().split())
if N>=10:
    print(R)
else:
    print(R+100*(10-R))


Failing test case input:
0 503

Expected output:
1503


Actual output:
-48797


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if N>=10:
    print(R)
else:
    print(R+100*(10-N))
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())
if n < 10:
    print(r - 100 * (10 - n))
else:
    print(r)

Failing test case input:
0 1615

Expected output:
2615


Actual output:
615


Fixed submission (verdict: Accepted):
n, r = map(int, input().split())
if n < 10:
    print(r + 100 * (10 - n))
else:
    print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N < 10:
    ans = R - 100 * (10 - N)
else:
    ans = R
print(ans)

Failing test case input:
-1 -22

Expected output:
1078


Actual output:
-1122


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N < 10:
    ans = R + 100 * (10 - N)
else:
    ans = R
print(ans)

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N,R=map(int, input().split()) 

if N < 10:
  print(R)
else:
  print(R - 100*(10-N))

Failing test case input:
0 1885

Expected output:
2885


Actual output:
1885


Fixed submission (verdict: Accepted):
N,R=map(int, input().split()) 

if N >= 10:
  print(R)
else:
  print(R + 100*(10-N))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, r = map(int,input().split())
print(r-100*max(0,10-n))

Failing test case input:
9 319

Expected output:
419


Actual output:
219


Fixed submission (verdict: Accepted):
n, r = map(int,input().split())
print(r+100*max(0,10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int,input().split())
if n < 10:
    print(r-100*(10-n))
else:
    print(r)


Failing test case input:
9 81

Expected output:
181


Actual output:
-19


Fixed submission (verdict: Accepted):
n, r = map(int,input().split())
if n < 10:
    print(r+100*(10-n))
else:
    print(r)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,r=map(int,input().split())
if n>=10:print(r)
else:print(r-100*(10-n))

Failing test case input:
6 319

Expected output:
719


Actual output:
-81


Fixed submission (verdict: Accepted):
n,r=map(int,input().split())
if n>=10:print(r)
else:print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
print(R if 10>=N else R-100*(10-N))

Failing test case input:
1 81

Expected output:
981


Actual output:
81


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N<=2:
  print(R + (10-N)*100)
else:
  print(R)

Failing test case input:
6 206

Expected output:
606


Actual output:
206


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N<=10:
  print(R + (10-N)*100)
else:
  print(R)
Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())

if n == 0:
    print(0)
elif 0 < n >= 10:
    print(r)
else:
    print(r-(100*(10-n)))

Failing test case input:
1 1703

Expected output:
2603


Actual output:
803


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

if n >= 10:
    print(r)
else:
    print(r+(100*(10-n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int, input().split())

if N >= 10:
  print(R)
else:
  print(R-100*(10-N))

Failing test case input:
1 1703

Expected output:
2603


Actual output:
803


Fixed submission (verdict: Accepted):
N,R=map(int, input().split())

if N >= 10:
  print(R)
else:
  print(R+100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def resolve():
    N, R = map(int, input().split())  

    if N < 10:
        print(R)
    else:
        R = R - 100 * (10 - N)
        print(R)
 
if __name__ == "__main__":
    resolve()

Failing test case input:
-1 2265

Expected output:
3365


Actual output:
2265


Fixed submission (verdict: Accepted):
def resolve():
    N, R = map(int, input().split())  

    if N >= 10:
        print(R)
    else:
        R = R + 100 * (10 - N)
        print(R)
 
if __name__ == "__main__":
    resolve()

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N, R = map(int, input().split())
if N < 10:
    a = 100 * (10 - 2)
else:
    a = 0
print(R + a)

Failing test case input:
-1 -28

Expected output:
1072


Actual output:
772


Fixed submission (verdict: Accepted):
N, R = map(int, input().split())
if N < 10:
    a = 100 * (10 - N)
else:
    a = 0
print(R + a)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R=map(int,input().split())

if N<10:
  r=R-(100*(10-N))
else:
  r=R
print(r)

Failing test case input:
-1 -28

Expected output:
1072


Actual output:
-1128


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
 
if N<10:
  r=R+(100*(10-N))
else:
  r=R
print(r)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,ans = str(input()).split()
if int(n)<10:
    ans = int(ans) - (100*(10-int(n)))
print(int(ans))

Failing test case input:
2 4162

Expected output:
4962


Actual output:
3362


Fixed submission (verdict: Accepted):
n,ans = str(input()).split()
if int(n)<10:
    ans = int(ans) + (100*(10-int(n)))
print(int(ans))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else R - 100 * (10 - N)
 
print(result)

Failing test case input:
0 1885

Expected output:
2885


Actual output:
885


Fixed submission (verdict: Accepted):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else R + 100 * (10 - N)
 
print(result)

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

N,R=map(int,input().split())
print(R+100*(10-min(N, 9)))

Failing test case input:
76 835

Expected output:
835


Actual output:
935


Fixed submission (verdict: Accepted):

N,R=map(int,input().split())
print(R+100*(10-min(N, 10)))
Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
N,R=map(int, input().split()) 

if N >= 10:
  print(R)
else:
  print(R - 100*(10-N))


Failing test case input:
6 319

Expected output:
719


Actual output:
-81


Fixed submission (verdict: Accepted):
N,R=map(int, input().split()) 

if N >= 10:
  print(R)
else:
  print(R + 100*(10-N))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print(r - (100*(10 - n)))


Failing test case input:
6 319

Expected output:
719


Actual output:
-81


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

if n >= 10:
    print(r)
else:
    print(r + (100*(10 - n)))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
N,R =map(int,input().split())
if N>=10:
  print(R)
else:
  print(R-(100*(10-N)))

Failing test case input:
-1 -28

Expected output:
1072


Actual output:
-1128


Fixed submission (verdict: Accepted):
N,R =map(int,input().split())
if N>=10:
  print(R)
else:
  print(R+(100*(10-N)))

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,R=map(int,input().split())
if N>=10:
    print(R)
else:
    print(R-(100*(10-N)))


Failing test case input:
0 245

Expected output:
1245


Actual output:
-755


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
if N>=10:
    print(R)
else:
    print(R+(100*(10-N)))

Problem: p02765
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
n, r = map(int, input().split())

ans = r
if n < 9:
    ans = 100*(10 - n)

print(ans)



Failing test case input:
6 170

Expected output:
570


Actual output:
400


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

ans = r
if n < 10:
    ans += 100 * (10 - n)

print(ans)

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n,r = map(int,input().split()) 
if n>=10 :
    print(r)
else :
    print(r-100*(10-n)) 

Failing test case input:
1 503

Expected output:
1403


Actual output:
-397


Fixed submission (verdict: Accepted):
n,r = map(int,input().split()) 
if n>=10 :
    print(r)
else :
    print(r+100*(10-n))

Problem: p02765
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b = input().split()
if int(a) < 9:
  ans = int(b) - 100 * (10 - int(a))
  print(ans)
else:
  print(b)



Failing test case input:
0 -16

Expected output:
984


Actual output:
-1016


Fixed submission (verdict: Accepted):
a, b = input().split()
if int(a) <= 9:
  ans = int(b) + 100 * (10 - int(a))
  print(ans)
else:
  print(b)

Problem: p02765
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,R=map(int,input().split())
naibu=0
if(N>=10):
  naibu=R
else:
  naibu=R+100*(10-R)
print(naibu)

Failing test case input:
0 245

Expected output:
1245


Actual output:
-23255


Fixed submission (verdict: Accepted):
N,R=map(int,input().split())
naibu=0
if(N>=10):
  naibu=R
else:
  naibu=R+100*(10-N)
print(naibu)