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):
def check_trial(n):
  num = n.split()
  if int(num[0]) > 10:
    return True
  else:
    return False
def in_rating(n, result):
  if result:
    num = n.split()
    return int(num[1])
  else:
    num = n.split()
    out_rating = int(num[1]) + 100*(10-int(num[0]))
    return out_rating
def main():
  n=input()
  result = check_trial(n)
  print(in_rating(n, result))
main()

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

Solution (Python):
numbers =input().rstrip().split()

N =int(numbers[0])
R =int(numbers[1])
if N>=10:
    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+1000-100*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 + 1000 -100*N)

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

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(" "))
if N >= 10:
  print(R)
else:
  print(100*(10-N)+R)

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

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

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

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

Solution (Python):

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

Solution (Python):
n,r=map(int,input().split())
ans = 0
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
else:
  ans = R + 100 * (10 - N)
  
print(ans)

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:
    r+=100*(10-n)
    print(r)

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

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


if __name__ == '__main__':
    main()

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

if n >= 10:
	print(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 = [int(elem) for elem 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:
    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:
    print(R)
else:
    print(R+100*(10-N))

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

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

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

if N >= 10:
    ans = R
else:
    ans = R + (100 * (10 - N))
print(str(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:
  print(R)
else:
  print(R+100*(10-N))

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

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

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())
print( r if n >= 10 else r+100*(10-n))

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

print(src[1]) if src[0] >= 10 else print(src[1]+100*(10-src[0]))

Solution (Python):
n,r = map(int,input().split())
print(r if n >= 10 else 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:
    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):

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


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

print(rate)

Solution (Python):

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

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:
  R = R + 100 * (10 -N)
print( R )

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

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

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 numpy as np

i = list(map(int, input().split()))
N = i[0]
R = i[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):
i = list(map(int, input().split()))
if 1 <= i[0] and i[0] <= 100:
    N = i[0]
else:
    print('N is invalid value.')
if 0 <= i[1] and i[1] <= 4111:
    R = i[1]
else:
    print('R is invalid value.')

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

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())


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

Solution (Python):
import sys

def main():

    

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

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

Solution (Python):
n,r=map(int,input().split());print(r+(n<10)*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+100*(10-n))
else:
    print(r)

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

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

numContests = input[0]
ratingDisplayed = input[1]
innerRating = 0



if (numContests>10):
    innerRating = ratingDisplayed
else:
    innerRating = ratingDisplayed+100*(10-numContests)

print(innerRating)

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

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

Solution (Python):
from collections import deque, Counter
from itertools import chain, combinations
import json
import numpy as np
import bisect


def main():
    
    N, R = [int(a) for a in input().split()]
    if N > 10:
        print(R)
    else:
        print(R + 100 * (10 - N))
    
    
    
    
    


if __name__ == "__main__":
    main()

Solution (Python):
def solve(n, r):
    if n <= 10:
        return r + 100 * (10 - n)
    else:
        return r


def main():
    n, r = map(int, input().split())
    res = solve(n, r)
    print(res)


def test():
    assert solve(2, 2919) == 3719
    assert solve(22, 3051) == 3051


if __name__ == "__main__":
    test()
    main()

Solution (Python):
x=input().split()
N=int(x[0])
D=int(x[1])
if N>=10:
  print(D)
else:
  print(D+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 InnerRating(N, R):
  if N >= 10:
    return R
  else:
    return R + 100 * (10 - N)
  
N, R = map(int, input().split())
print (InnerRating(N, R))

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read 
input = sys.stdin.buffer.readline
def inputS(): return input().rstrip().decode()
readlines = sys.stdin.buffer.readlines 

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

ans = 0
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+(10-n)*100)

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+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):
def main():
    K, R = map(int, input().split())

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

if __name__ =='__main__':
    main()

Solution (Python):
import unittest


class TestA(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(2, 2919), 3719)

    def test_2(self):
        self.assertEqual(think(22, 3051), 3051)


def solve():
    n, r = read()
    result = think(n, r)
    write(result)


def read():
    return read_int(2)


def read_int(n):
    return read_type(int, n, sep=' ')


def read_float(n):
    return read_type(float, n, sep=' ')


def read_type(t, n, sep):
    return list(map(lambda x: t(x), read_line().split(sep)))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(n, r):
    return r if n >= 10 else r + 100 * (10 - n)


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

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

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):
N,R = list(map(int,input().split()))

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

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

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

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:
  r += 100*(10-n)
print(r)

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

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

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

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

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

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

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:
    answer=R
else:
    answer=R+100*(10-N)
print(answer)

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

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

Solution (Python):
def batcoder(n , r):

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

def main():
    n , r = map(int , input().split())
    print(batcoder(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=map(int,input().split())
if N<10:
    X=R+100*(10-N)
    print(X)
else:
    print(R)

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

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

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

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

if a < 10:
  sum = 100*(10-a)
  ans = b + sum
  print(ans)
else:
  print(b)

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

Solution (Python):
n,k = (int(_) for _ in input().split())


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

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

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

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

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

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):
N, R = list(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 <= 9:
    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())
print(R+100*(10-N) if N<10 else R)

Solution (Python):
import sys
input = sys.stdin.readline
def solve():
  n,r = (int(i) for i in input().split())
  if n >= 10:
    print(r)
  else:
    print(r+100*(10-n))
solve()

Solution (Python):
import sys

l = sys.stdin.readline().strip()
k, r = map(int, l.split())
print(max(100*(10-k),0) + r)

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

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):
K,R = list(map(int,input().split()))

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

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

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

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

print(A)

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

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

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

print(ans)

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

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

Solution (Python):
import sys

def main(lines):
  n, r = map(int,lines[0].split())

  if n >= 10:
    print(r)
  else:
    print(r + 100*(10-n))
  return
    
if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)

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+(100*(10-n)))
else:
    print(r)

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

		
		
	
	
 
if __name__ == '__main__':
	main()

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

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

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())
ans = 0

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 + ((10 - n) * 100))

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

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

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

if K[0] < 10:
  print(K[1] + 100*(10-K[0]))
else:
  print(K[1])

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

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

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

Solution (Python):
n, r = map(int, input().split())
if n >= 10:
    n = 10
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=(int(z) for z in input().split())
if n>=10:
  print(k)
else:
  print(k + 100 * (10 - n))

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

Solution (Python):
from sys import stdin
N, R = [int(_) for _ in stdin.readline().rstrip().split()]
ans = max(10-N, 0) * 100
print(R + ans)

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

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

if input_line[0] < 10:
  print(input_line[1] + (100 * (10 - input_line[0])))
else:
  print(input_line[1])

Solution (Python):
n,r=map(int,input().split())
print(r+100*max(0,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 * max(0, 10 - n))

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

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


def read_values():
    return map(int, input().split())


def read_index():
    return map(lambda x: x - 1, map(int, input().split()))


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


def main():
    N, R = read_values()
    print(R if N >= 10 else R + 100 * (10 - N))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
n,r=map(int,input().split())
ans=int
if n >= 10:
    ans=r
else:
    ans=100*(10-n)+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 = 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()]

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

Solution (Python):
inp = list(map(int, input().split()))
n = inp[0]
r = inp[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)
else:
    print(int(R) + 100*(10-int(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 = input().split()
n = int(n)
r = int(r)


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

Solution (Python):



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


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

Solution (Python):
import os

def main():
    a=[int(x) for x in input().split()]
    if a[0] >= 10:
        print(a[1])
    else:
        num = 100*(10-a[0])
        print(num + a[1])

if __name__ == "__main__":
    main()

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

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

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

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

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

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

Solution (Python):
import numpy as np
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 + 1000 - 100*n)

Solution (Python):
numbers = [int(i) for i in input().split()]
N,Ro = numbers[0],numbers[1]

if N < 10:
    Ri = Ro + (100*(10-N))
else:
    Ri = Ro

print(Ri)

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

if 1<=a<10:
  c = b + 100*(10-a)
  print(c)
elif 10<=a<=100:
  print(b)

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(' '))

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

Solution (Python):
from sys import stdin
n,k = map(int,stdin.readline().rstrip().split())
if n >= 10:
    print(k)
else:
    print((10-n)*100+k)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')

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

if __name__ == "__main__":
	main()

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

Solution (Python):
N, R = map(int, input().split())
print(R + 100 * (10 - min(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):
N, R = map(int, input().split())
print(R if N >= 10 else R + 100 * (10 - N))

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

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

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

Solution (Python):
import sys

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

if __name__ == "__main__":
    resolve()

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

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

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

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

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

resolve()

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())
ans = r if n >= 10 else r + (100 * (10 - n))
print(ans)

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:
    rate = R
else:
    rate = R + (100 * (10 - N))

print(rate)

Solution (Python):
n,r=map(int,input().split())
if n<10:
  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:
    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 = [int(i) for i in input().rstrip().split(' ')]
if N > 9:
    print(R)
else:
    print(R+100*(10-N))

Solution (Python):
if __name__ == '__main__':
    n, r = [int(i) for i in input().split()]
    
    result = r
    if n < 10:
        result = r + 100 * (10 - n)
    print(result)

Solution (Python):
inp = input().split()
n = int(inp[0])
r = int(inp[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):
X, Y = map(int, input().split())
if X >= 10:
    print(Y)
else:
    print(Y+(100*(10-X)))

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 = list(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 - min(10,N)))

Solution (Python):
from sys import *

input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()


n, r = mi()
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=input().split()

Naibu = int(N[1]) + 100*(10-int(N[0]))
if int(N[0])<=9:
    print(Naibu)
else:
    print(N[1])

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())
print(r+100*(10-n) if n<10 else r)

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


if __name__ == "__main__":
    n, r = map(int, input().split())

    main(n, r)

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

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

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

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines







def main():
	n,r=map(int,input().split())
	print(r+100*(10-min(10,n)))
	
	
if __name__ == "__main__":
	main()

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

Solution (Python):

import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop


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


if __name__ == '__main__':
    main()

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+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())
def a(N,R):
     if N >= 10:
             print(R)
     else:
             print(R+(100*(10-N)))
     return
  
a(N,R)

Solution (Python):
n,r = map(int,input().split())
print(r + 100*max(0,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(int(r + 100 * (10 - n)))

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

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

Solution (Python):

import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)



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


def II():
    return int(input())

directions=np.array([[1,0],[0,1],[-1,0],[0,-1]])
directions = list(map(np.array, directions))

mod = 10**9+7


def factorial(n):
    fact = 1
    for integer in range(1, n + 1):
        fact *= integer
    return fact



def serch(x, count):
    
            

    for d in directions:
        nx = d+x
        
        if np.all(0 <= nx) and np.all(nx < (H, W)):
            if field[nx[0]][nx[1]] == "E":
                count += 1 
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)  
                continue
            if field[nx[0]][nx[1]] == "
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)    
                 
    return count

N,R=acinput()



if N>=10:
    K=R
else:

    K=R+(100*(10-N))

print(int(K))

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

if a >= 10:
  print(b)

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

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

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