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

Solution (Python):
n,k = map(int,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):
import sys

stdin = sys.stdin

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

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

Solution (Python):
s = input().split()

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

if N < 10:
  ans = R + 100 *(10 - N)
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 = list(map(int,input().split()))

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n, r = LI()
    if n <= 10:
        ans = r + (100*(10-n))
    else:
        ans = r
    print(ans)
    return



if __name__ == "__main__":
    solve()

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(" "))
print([b,b+(100*(10-a))][a<10])

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):
n = list(map(int, input().split()))
if n[0] < 11:
    num = n[1] + (100*(10 - n[0]))
    print(num)
    exit(0)
print(n[-1])

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

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

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

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

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

Solution (Python):
list = input().rstrip().split(" ")
time = int(list[0])
hyoji = int(list[1])
if time >= 10:
  naibu = hyoji
else:
  naibu = hyoji + 100 * (10 - time)
print(naibu)

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

print(R + 100 * max(10 - N, 0))

Solution (Python):


t = input().split()
n = int(t[0])
r = int(t[1])

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

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

def main():
    N, R = map(int, input().split())

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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):
a=input().split()
N,R=int(a[0]),int(a[1])

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

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

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

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

diff = 0
if n < 10:
  diff = 100 * ( 10 - n )

print( r + diff )

Solution (Python):
n, r = 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+(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())

ans=R

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

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


main()

Solution (Python):
inputStr = input()
inputList = inputStr.split(' ')
n = int(inputList[0])
r = int(inputList[1])

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

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

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

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

print(result)

Solution (Python):


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

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

print(ans)

Solution (Python):
def main():

    N, R = map(int, input().split())
    if N >= 10: return R
    else: 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())
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):
n,r = map(int, input().split())

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

Solution (Python):

import sys


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

Solution (Python):

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

def solver(n, r):
    if n >= 10:
        return r
    else:
        return r + ( 100 * (10 - n))
    
print(solver(N, R))

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

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


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

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

Solution (Python):







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

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

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

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

if N > 9:
  print(R)
else:
  print(R +1000 -100*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(100 * (10 - n) + r)

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


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

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

Solution (Python):
N = list(input().split())

n = int(N[0])

r = int(N[1])

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

Solution (Python):
N = list(input().split())

n = int(N[0])

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

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

Solution (Python):
def contest(N, R):
    if(N > 10):
        return R
    else:
        return R + 100 * (10-N)

if __name__ == "__main__":
    N, R = map(int, input().split())
    print(contest(N, R))

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


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

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

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(1000000)
input = lambda: sys.stdin.readline().rstrip()

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

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:
    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, m = map(int, input().split()) 
if a >=10:
  print(m)
else:
  out = m + 100 *(10-a)
  if out <= 1:
    print(1)
  else:
    print(out)

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

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

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

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

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

Solution (Python):
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):
def main():
    K = 0
    N, R = [int(_) for _ in input().split()]
    if N >= 10:
        K = R
    else:
        K = R + 100 * (10 - N) 
    print(K)
main()

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

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

print(ans)

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

Solution (Python):
from sys import stdin

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

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

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

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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
def solve():
    N, M = map(int, input().split())
    ans = 0
    if N < 10:
        ans = M + 100* (10-N)
    else:
        ans = M
    return ans

print(solve())

Solution (Python):
from sys import stdin
import math

n, r = [int(x) for x in stdin.readline().rstrip().split()]

result = 0
if n < 10:
    result = r + 1000 - 100 * n
else:
    result = r

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

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

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

else:
    print(r)

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):
x,y = map(int,input().split())
if x >= 10:
	print(y)  
else:
	print(y+(100*(10-x)))

Solution (Python):
n, r = 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)
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 0))

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


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



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))  
    solve(N, R)

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    n,r = LI()

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


print(main())

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

if num <= 10:
    print(minus + rate)
else:
    print(rate)

Solution (Python):
i = list(map(int, input().split()))
N = i[0]
R = i[1]

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

print(insc)

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

if N >= 10:
  print(R)
else:
  print(R + x)

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

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

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

print(int(naibu))

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())
print(r+100*max(10-n,0))

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

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

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

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

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

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

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

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

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

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

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

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

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

print(X)

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

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

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

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

if n >= 10 :
    rate = r

elif n < 10 :
    k = n
    rate = r + 100 * (10 - k)

print(int(rate))

Solution (Python):
import os

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

if n >= 10 :
    rate = r

elif n < 10 :
    k = n
    rate = r + 100 * (10 - k)

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

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

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

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

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

Solution (Python):




def solve(inp):
    (N, R) = map(int, inp.readline().strip().split(' '))

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

    return str(R)


def main():
    import sys
    result = solve(sys.stdin)
    if result is not None and result != '':
        print(result)


if __name__ == '__main__':
    main()

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


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

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

co = 0
if n < 10:
  co = 100*(10-n)

print(r+co)

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

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

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

Solution (Python):
A = input().split( )

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

if N >= 10:
    print(R)

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

Solution (Python):
A = input().split( )

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

if N >= 10:
    print(R)

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

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

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

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

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

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

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

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

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

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

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

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(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):
import sys
n, R = [int(x) for x in input().split()]
if n >= 10:
  print(R)
  sys.exit()
  
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):
def func():
    N,R = map(int,input().split())

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

if __name__ == '__main__':
    func()

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):
i = list(map(int, input().split()))
N = i[0]
R = i[1]
 
result = R if N >= 10 else R + 100 * (10 - N)
 
print(result)