Problem:
 Score : 100 points    Problem Statement Takahashi is a member of a programming competition site, ButCoder .  Each member of ButCoder is assigned two values: Inner Rating and Displayed Rating .  The Displayed Rating of a member is equal to their Inner Rating if the member has participated in 10 or more contests. Otherwise, the Displayed Rating will be their Inner Rating minus 100 \times (10 - K) when the member has participated in K contests.  Takahashi has participated in N contests, and his Displayed Rating is R . Find his Inner Rating.      Constraints  All values in input are integers.  1 \leq N \leq 100  0 \leq R \leq 4111         Input Input is given from Standard Input in the following format:  N  R       Output Print his Inner Rating.        Sample Input 1 2 2919      Sample Output 1 3719  Takahashi has participated in 2 contests, which is less than 10 , so his Displayed Rating is his Inner Rating minus 100 \times (10 - 2) = 800 .  Thus, Takahashi's Inner Rating is 2919 + 800 = 3719 .       Sample Input 2 22 3051      Sample Output 2 3051

Solution (Python):
tmp = list(input().split(" "))

N = int(tmp[0])
R = int(tmp[1])

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

Solution (Python):
a = list(map(int, input().split()))
if a[0] >9:
    print(a[1])
else:
    print(a[1] + 100 * (10 - a[0]))

Solution (Python):
n, r = map(int, input().split())

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

Solution (Python):
N, R =input().split()

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

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

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

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

Solution (Python):
n,r = map(int,input().split())

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

Solution (Python):
n,r = map(int,input().split())

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

Solution (Python):
N,R=list(map(int,input().split()))
print(R if N>=10 else 100*(10-N)+R)

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

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

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

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

Solution (Python):
i = list(map(int,input().split()))
ans = 0
if i[0] >=10:
    ans = i[1]
else:
    ans = i[1] + 100 * (10 - i[0])

print(ans)

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

Solution (Python):
n, r = map(int, input().split())

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
n, r = map(int, input().split())

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

Solution (Python):
a, b = map(int, input().split())
if a >= 10:
  print(b)
else:
  print(b + 100 * (10 - a))

Solution (Python):
N,R = map(int,input().split())
if N >= 10:
    print(R)
else:
    K = N
    print(100 * ( 10 - K) + R)

Solution (Python):
N, R = [int(_) for _ in input().split()]

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

Solution (Python):
import math

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

Solution (Python):
m,n = map(int,input().split())
if m>=10:
    print(n)
else:
    print(n+(100*(10-m)))

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

Solution (Python):
N,R=map(int,input().split())
minus=100*(10-N)

if N>=10:
  print(R)
elif N<10:
  print(R+minus)

Solution (Python):
n, r = map(int,input().split())
if n < 10:
    print(r+100*(10-n))
else:
    print(r)

Solution (Python):
l = list(map(int, input().split()))
N = l[0]
R = l[1]
if N >= 10:
    print(R)

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

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

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

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

Solution (Python):
str = input().split()
if int(str[0]) >= 10:
  print(int(str[1]))
else:
  print(int(str[1]) + 100*(10-int(str[0])))

Solution (Python):
n, r = map(int, input().split())
if n < 10:
    print(r + (100 * (10 - n)))
else:
    print(r)

Solution (Python):
N, R = map(int, input().split(" "))
if N >= 10:
  print(R)
else:
  print(R + 100 * (10 - N))

Solution (Python):
n, r = list(map(int,input().split()))
if n >= 10:
    print(r)
else:
    temp = 100 * (10 -n)
    print(r + temp)

Solution (Python):
N, R = input().split()

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

Solution (Python):
def solve(string):
    n, r = map(int, string.split())
    return str(r + max(10 - n, 0) * 100)


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))

Solution (Python):
n, r = map(int, input().split())
print(r + (10 - min(n, 10)) * 100)

Solution (Python):
n, r = map(int, input().split())
print(r+max(0, 10-n)*100)

Solution (Python):
n,r=map(int,input().split())

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

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

Solution (Python):
n, r = map(int, input().split())
ans = r + 100 * max(10 - n, 0)
print(ans)

Solution (Python):
N, R = (int(x) for x in input().split())
 
if N < 10:
  N = R + 100 * (10 - N) 
  print(N)
  
else:
  N = R
  print(N)

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

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

else:
    print(R)

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

Solution (Python):

"""
Created on Mon Mar  2 18:11:48 2020

@author: Kanaru Sato
"""

N,R = list(map(int,input().split()))

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

print(r)

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

Solution (Python):


n, r = map(int, input().split())

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

Solution (Python):

N, R = map(int, input().split())

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

Solution (Python):
Num,Rate=map(int,input().split())
if Num>=10:
    print(Rate)
else:
    print(int(Rate+100*(10-Num)))

Solution (Python):

n, r = map(int, input().split())


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

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

Solution (Python):
n,k=map(int,input().split())
if n <= 10:
	print(k+100*(10-n))
else:
	print(k)

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

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

if 0<N<10:
  T=100*(10-N)
  print((R+T))
 
elif N<0:
  print("error")
  
else:
  print(R)

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

Solution (Python):
N, R = [int(x) for x in input().split(' ')]
if N >= 10:
	print(R)
else:
	print(R + 100 * (10 - N))

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

Solution (Python):
N,R = map(int,input().split())
print(R+max(0,100*(10-N)))

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

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

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

Solution (Python):
A,B=map(int,input().split())
if A>=10:
	print(B)
else:
	print(B+(100*(10-A)))

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

Solution (Python):
n,r =map(int,input().split())
if n < 10 :
  print(100 * (10 - n) + r)
else:
  print(r)

Solution (Python):

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

Solution (Python):
n,r = map(int,input().split())

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

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

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

Solution (Python):
a,b=map(int,input().split())
print(b if a>=10 else b+100*(10-a))

Solution (Python):
N, R = map(int, input().split())
if N >= 10:
    ans = R
else:
    ans = R+100*(10-N)
print(ans)

Solution (Python):
n, r = [int(w) for w in input().split()]

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

Solution (Python):
n, r = map(int, input().split())

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

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

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

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

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

Solution (Python):
N,R= map(int,input().split())
X = R + 100*(10-N)
if N<10 and X>0:
    print(X)
elif N<10 and X<=0:
     print(0)
else :
    print(R)

Solution (Python):
line = input('')
n = int(line.split(' ')[0])
r = int(line.split(' ')[1])
if n >= 10:
  print(r)
else:
  print(r + (100*(10-n)))

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

Solution (Python):
def main():

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

if __name__ == '__main__':
    print(main())

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

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

Solution (Python):
import sys
sys.setrecursionlimit(int(1e6))

N, R = map(int, input().split())

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

print(ans)

Solution (Python):
n, r  = map(int, input().split())
if n < 10:
    ans = r + (100 * (10 - n))
    print(ans)
else:
    print(r)

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

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

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

Solution (Python):
import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
from functools import lru_cache
INF = 1 << 60


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

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

Solution (Python):
from sys import stdin


def get_result(data):
    N, R = data
    return R if N >= 10 else R + 100 * (10 - N)

if __name__ == '__main__':
    data = list(map(int, stdin.readline().split(' ')))
    result = get_result(data)
    print(result)

Solution (Python):
def resolve():
    n, r = map(int, input().split())
    if n < 10:
        print(r + 100*(10 - n))

    else:
        print(r)

resolve()

Solution (Python):
N, R = map(int, input().split())
 
if N >= 10:
  print(str(R))
  
else:
  print(str(R + 100 * (10 - N)))

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

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

print(ir)

Solution (Python):
n,r = map(int, input().split())

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

Solution (Python):
a,b=[int(i) for i in input().split()]
b=b+100*(10-a) if a<10 else b
print(b)

Solution (Python):
N, R = map(int, input().split(' '))
if N < 10:
    L =  R+100*(10-N)
    print('{}'.format(L))

else:
    print('{}'.format(R))

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

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

Solution (Python):
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 999999999
R = 10**9 + 7

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

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

Solution (Python):
n, r = map(int,input().split())
if n < 10:
    r = r + 100*(10-n)
print(r)

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

main()

Solution (Python):
N,R = map(lambda i: int(i),input().split())

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

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

Solution (Python):
n,r = map(int,input().split())

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

Solution (Python):
n,r = map(lambda x: int(x),input().split())

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

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

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

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

A = int(0)


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

print(A)

Solution (Python):
a, b = map(int, input().split())
if a < 10:
  b = b + 100 * (10 - a)
print(b)

Solution (Python):


N, R = map(int, input().split())


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



print("{}".format(nR))

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

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

Solution (Python):
input_data = input().split()
 
N = int(input_data[0])
R = int(input_data[1])
 
if N >= 10 :
  print(R)
else:
  print(R+100*(10-N))

Solution (Python):


N, R = map(int, input().split())


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



print("{}".format(nR))

Solution (Python):

"""
Created on Sun Mar  1 14:19:40 2020

@author: Kanaru Sato
"""

N,R = map(int,input().split())

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

Solution (Python):
li = list(map(int,input().split()))
n, r = li[0], li[1]

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

Solution (Python):

def main():
  info = input()
  info = info.split()
  
  join_num = int(info[0])
  rating = int(info[1])
  
  if join_num < 10:
    rating = rating + 100*(10-join_num)
  
  print(rating)

if __name__ == "__main__":
  main()

Solution (Python):
N, R = [int(i) for i in input().split()]

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

Solution (Python):
N, R = [int(i) for i in input().split()]

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

Solution (Python):
n,r = map(int,input().split())
a = min(10,n)
a = 100*(10-a)
print(r+a)

Solution (Python):
import math
import string


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


def nCr(n, r):
    return math.factorial(n)//math.factorial(n-r)*math.factorial(r)


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

Solution (Python):
n,r = map(int,input().split())

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()

def main():
    N,R=map(int,input().split())
    print(R+100*max(0,(10-N)))

if __name__ == '__main__':
    main()

Solution (Python):
n, r = map(int, input().split())
if n < 10:
  print(r + 100*(10-n))
else:
  print(r)

Solution (Python):
a = [int(i) for i in input().split()]

N = a[0]
R = a[1]



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

Solution (Python):
N, R = (int(x) for x in input().split())
internal_rating = 0

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

print(internal_rating)

Solution (Python):
N, R = (int(x) for x in input().split())
internal_rating = 0

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

print(internal_rating)

Solution (Python):
data_list = list(map(int,input().split(" ")))
if data_list[0] >= 10:
    print(data_list[1])
else:
    print(data_list[1] + (100 * (10 - data_list[0])))

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

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

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

Solution (Python):
n,r = map(int, input().split())

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

Solution (Python):
n, r = list(map(int, input().split()))
if n < 10:
    print(int(r + 100 * (10 - n)))
else:
    print(r)

Solution (Python):
num = [int(n) for n in input().split()]

if num[0] >= 10:
  print(num[1])
else:
  k = 100 * (10-num[0])
  r = num[1] + k
  print(r)

Solution (Python):
N, R = map(int, input().split())
print(R + max(10 - N, 0) * 100)

Solution (Python):
n,r=map(int,input().split());
print(r+100*max(10-n,0));

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

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

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

n, r = list(map(int, input().split()))

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

Solution (Python):
def main():
	num,val = input().split(" ")
	num = int(num)
	val = int(val)

	if num < 10:
		print(val + 100*(10-num))
	else:
		print(val)

if __name__ == "__main__":
    main()

Solution (Python):
N,R = input().split(" ")
N = int(N)
R = int(R)
if(N >= 10):
    print(R)
else:
    print(R+100*(10-N))

Solution (Python):
inputs=input().split(" ")
N=int(inputs[0])
R=int(inputs[1])

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

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

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

print(R)

Solution (Python):
inputstr = input()
inputsplit = inputstr.split()
N = int(inputsplit[0])
R = int(inputsplit[1])

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

print(hyouji)

Solution (Python):
n,r = map(int,input().split())

if n >= 10:
    print(r)

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

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

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

Solution (Python):
N,R = map(int,input().split())
if N>=10:
  Ans = R
else:
  Ans = R+100*(10-N)
print(Ans)

Solution (Python):
n = [int(e) for e in input().split(" ")]
print(n[1] if 10 <= n[0] else n[1] + 1000 - 100 * n[0])

Solution (Python):
line = list(map(int,input().split()))
if line[0] >= 10:
  print(line[1])
else:
  print(line[1] + (100 * (10 - line[0])))

Solution (Python):
n, r = map(int, input().split())

if n >= 10:
	ans = r
else:

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

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

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

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

Solution (Python):
NR = input().split()
N = int(NR[0])
R = int(NR[1])

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

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

Solution (Python):
a,b=map(int, input().split())
x = b if a>10 else b+((10-a)*100)
print(x)

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

Solution (Python):
N, R = [int(x) for x in input().split(' ')]

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

Solution (Python):
import numpy as np
import math as m

def main(**kwargs):
    if n >= 10:
        r = k

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

    return r

if __name__ == "__main__":
    cin = np.array(input().split(" ")).astype("int")
    n, k = cin

    cout = main(n=n, k=k)
    print(cout)

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

if 1 <= N < 10:
    print("{}".format(R + 100 * (10 - N)))
    
else:
    print(R)

Solution (Python):
N,R = map(int,input().split())
Answer = 0
if N <10:
  Answer = R + 100*(10-N)
else:
  Answer = R

print(Answer)

Solution (Python):
def main():
    cin = input()
    n = int(cin.split(" ")[0])
    r = int(cin.split(" ")[1])
    
    if n >= 10:
        cout = r

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

    print(cout)

if __name__ == "__main__":
    main()

Solution (Python):
n,r = map(int,input().split())
if n < 10:
    ans = 100 * (10-n) + r
else:
    ans = r
print(ans)

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

Solution (Python):
n,r= [int(i) for i in input().split()]
t = 0
if n < 10:
    t = 10-n

print(r+100*t)

Solution (Python):
i = list(map(int, input().split()))
if i[0]<10:
    print (i[1]+100*(10-i[0]))
else:
    print (i[1])

Solution (Python):
input_numbers = list(map(int, input().split()))
n = input_numbers[0]
r = input_numbers[1]
if n >= 10:
  print(r)
else:
  print(r + 100 * (10 - n))

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

if num[0] < 10:
  penalty = 100*(10-num[0])
  ans = num[1] + penalty
elif 10<= num[0]:
  ans = num[1]
  
print(ans)

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

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

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

Solution (Python):
import sys
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
a,b = map(int,input().split())
print(b) if a >=10 else print(b+(10-a)*100)

Solution (Python):
n,r= [int(i) for i in input().split()]
t = 0
if n < 10:
    t = 10-n

print(r+100*t)

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


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

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

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

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

Solution (Python):
n, r = map(int,input().split())
print(r + 100 * (10-n) if n <= 10 else r)

Solution (Python):
import sys
import os


def calc(n):
    return 100 * (10 - n)


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N, R = map(int, sys.stdin.readline().split())

    if 10 > N:
        print(calc(N) + R)
    else:
        print(R)


if __name__ == '__main__':
    main()

Solution (Python):
a,b = map(int,input().split())
print(100*max(10-a,0)+b)

Solution (Python):
n,r=(int(x) for x in input().split())

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

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

Solution (Python):
N,R=input().split()
N=int(N)
R=int(R)
if (R>4111)or(R<0):
  None
if 1<=N<=9:
  R_internal=R+100*(10-N)
  print(R_internal)
elif N>=10:
  R_internal=R
  print(R_internal)
else:
  None

Solution (Python):
def inp():
    return input()
def iinp():
    return int(input())
def inps():
    return input().split()
def miinps():
    return map(int,input().split())
def linps():
    return list(input().split())
def lmiinps():
    return list(map(int,input().split()))


n,r = miinps()

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

Solution (Python):
n,r = map(int,input().split())

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

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

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

Solution (Python):
a = input().split(" ")
kaisu = a[0]
score = a[1]
if int(kaisu) >= 10:
  print(score)
else:
  print(int(score) + (100 * (10 - int(kaisu))) )

Solution (Python):

import sys


def solve(N: int, R: int):
    return R + 100 * (10 - min(10, N))



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

if __name__ == '__main__':
    main()

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

Solution (Python):
n, r = tuple(int(x) for x in input().split())

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

Solution (Python):
sum,rate=map(int,input().split())
if sum>=10:
    print(rate)
else:
     ans=rate+100*(10-sum)
     print(ans)

Solution (Python):
n,r = map(int,input().split())

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

Solution (Python):
n, r = map(int, input().split())

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

Solution (Python):
n,k = map(int,input().split())
print(k+100*(max(10-n,0)))

Solution (Python):
n, r = map(int, input().split())

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

Solution (Python):
n, r = map(int, input().split())
 
if n>=10:
  inner_rate = r
else:
  inner_rate = r + 100*(10-n)
  
print(str(inner_rate))

Solution (Python):
n, r = map(int, input().split())
 
if n>=10:
  inner_rate = r
else:
  inner_rate = r + 100*(10-n)
  
print(str(inner_rate))

Solution (Python):
N , R = tuple(list(map(int, input().split(' '))))
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Solution (Python):
n, m = map(int, input().split())

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

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

Solution (Python):
l=[int(x) for x in input().split()]
N=l[0]
R=l[1]

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

Solution (Python):
l=[int(x) for x in input().split()]
k=l[0]
r=l[1]
if k>10:
  print(r)
else:
  x=r+(100*(10-k))
  print(x)

Solution (Python):
[n, r] = map(int, input().rstrip().split(' '))

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

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

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

Solution (Python):
N,R = (int(x) for x in input().split())

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

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

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

Solution (Python):
n, r = map(int, input().split())

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

print("{}".format(ret))

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

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

Solution (Python):
str = input().split(" ")
n = int(str[0])
r = int(str[1])
if n < 10:
  print(r + 100 * (10 - n))
else:
  print(r)

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

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

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

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

Solution (Python):
a, b = map(int, input().split())
if a < 10:
    print(b+100*(10-a))
else:
    print(b)

Solution (Python):
n, r = map(int, input().split())

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

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

main()

Solution (Python):
n, r = map(int, input().split())

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

Solution (Python):
N, R = [int(i) for i in input().split()]

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

Solution (Python):


n, r = map(int,input().split())

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

else:
    print(r)

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

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

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

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

Solution (Python):
n,m=map(int,input().split())
print(m+max(0,100*(10-n)))

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

Solution (Python):
s = input()
N, R = s.split()

N, R = int(N), int(R)

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

Solution (Python):


N, R = input().rstrip().split(' ')
N = int(N)
R = int(R)

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

Solution (Python):
N, R = [int(i) for i in input().split()]

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

print(rate)

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

Solution (Python):
N, R = map(int, input().split())
result = R if N >= 10 else R + 100 * (10 - N)
print(result)

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

if x<11:
  r=y+100*(10-x)
else:
  r=y
  
print(r)

Solution (Python):
a,b=map(int,input().split())
if a>9:
  print(b)
else:
  print(b+(100*(10-a)))

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

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

Solution (Python):
n,r = map(int,input().split())
S = 10 - n
s = 100*S
if n <10:
    ans = r +s
else:
    ans = r
print(ans)

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

Solution (Python):
n,r = (int(x) for x in input().split())

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

Solution (Python):
n, r = map(lambda x: int(x), input().split())
if n < 10:
  print(100*(10-n)+r)
else:
  print(r)

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