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

if N >= 10:
    naibu = hyoji
else:
    naibu = hyoji + (100 * (10 - N))

print(naibu)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import os, sys, re, math

(N, R) = [int(n) for n in input().split()]

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

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

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

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

Solution (Python):
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
import math
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii():  return int(input())
def si():  return input()
def mi():  return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li():  return list(mi())
 
def dmain():
    sys.setrecursionlimit(1000000)
    threading.stack_size(1024000)
    thread = threading.Thread(target=main)
    thread.start()
    








 
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007

inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1] 
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
 
def ceil(x,y):
    if x%y==0:
        return x//y
    else:
        return x//y+1
 
def powerMod(x,y,p):
    res = 1
    x %= p
    while y > 0:
        if y&1:
            res = (res*x)%p
        y = y>>1
        x = (x*x)%p
    return res
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
    
def isPrime(n) : 
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True
 
 
 
def read():
    sys.stdin  = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
 
def main():
    
              
    
    n, r = map(int, input().split())
    if n >= 10:
        print(r)
    else:
        print(100 * (10 - n) + r)
    
    
    
    
 


 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\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):
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

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

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

Solution (Python):
from sys import stdin
input = lambda: stdin.readline().rstrip()
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())
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):
n,r = map(int,input().split())

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

Solution (Python):
m = input("")
list = m.split(" ")
if eval(list[0])<10:
    print(eval(list[1])+100*(10-eval(list[0])))
if eval(list[0])>=10:
    print(eval(list[1]))

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

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

print(r)

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

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

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

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

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

Solution (Python):

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

from  collections import defaultdict
import bisect
def main():
    N, R = MI()
    if N >= 10:
        print(R)
    else:
        print(R + 1000 - 100 * N)

if __name__ == "__main__":
    main()

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

rate = max(r+100*(10-n),r)

print(rate)

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+(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):
ri = lambda S: [int(v) for v in S.split()]
def rii(): return ri(input())

N, R = rii()

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

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

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

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())


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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

Solution (Python):
import sys

N, R = map(int, sys.stdin.readline().split())
print(R if 10 <= N 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

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


N,R = MI()
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 = 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*(max(10-n,0))))

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

n = N
r = R

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

print(o)

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())
res = 0
if N >= 10:
  res = R
else:
  res = 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())

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

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

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

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

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

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

print(D)

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

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

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

print(ans)

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

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

IR=100*(10-N)+R

print(R if N>=10 else IR)

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

Solution (Python):
a,b = map(int,input().split())
if a >= 10:
  print(str(b))
else:
  print(str(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,k=list(map(int,input().split()))
if(n>=10):
    print(int(k))
    
else:
    rating =k + 1000 - 100*n
    print(rating)

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))

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

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

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

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

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

Solution (Python):
N, R = map(int,input().split())
if N >=10:
    K = 10
else:
    K = N

print(R+100*(10-K))

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

if '__main__' == __name__:
    resolve()

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

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

Solution (Python):

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

N, R = map(int, input().split())
ans = getInnerRating(N, R)
print(ans)

Solution (Python):
import sys

N, R = map(int, sys.stdin.buffer.read().split())
rate = R

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

print(rate)

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

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

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

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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


def main():
    solve()


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

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

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

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

Solution (Python):

def inputlist(): return [int(j) for j in input().split()]
def listinput(): return input().split()

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

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

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