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

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

print(inside)

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
import pprint
sys.setrecursionlimit(10 ** 9)


INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007



n, r = LI()
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):
strings = input().split(' ')
N = int(strings[0])
R = int(strings[1])
 
if N < 10:
  print(R + 100*(10-N))
else:
  print(R)

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

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

print(result)

Solution (Python):

import sys


def solve(N: int, R: int):
    if N >= 10:
        print(str(R))
        return
    else:
        print(str(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 = input().split()
if int(n[0]) >= 10:
  print(n[1])
else:
  print(int(n[1]) + 100*(10-int(n[0])))

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

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



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

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

Solution (Python):
import sys

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

I = R

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

print(I)

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

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

Solution (Python):
from sys import stdin

N, R = stdin.readline().rstrip().split()
N = int(N)
R = int(R)
if N < 10:
	print(R + 100 * (10 - N))
	
else:
	print(R)

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

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

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

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

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

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

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

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

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

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

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

kai=min(10,n)

print(r+100*(10-kai))

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):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

N,R = inpl()

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

Solution (Python):


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

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

Solution (Python):
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(e) for e in input().split(' ')]

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

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

Solution (Python):
import math
import fractions

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors

def ValueToBits(x,digit):
    res = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        res[i]=now%2
        now = now >> 1
    return res

def BitsToValue(arr):
    n = len(arr)
    ans = 0
    for i in range(n):
        ans+= arr[i] * 2**i
    return ans

def ValueToArray10(x, digit):
    ans = [0 for i in range(digit)]
    now = x
    for i in range(digit):
        ans[digit-i-1] = now%10
        now = now //10
    return ans

def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n-r] % p
'''
p = 10 ** 9 + 7
N = 10 ** 6 + 2
fact = [1, 1]  
factinv = [1, 1]  
inv = [0, 1]  

for i in range(2, N + 1):
    fact.append((fact[-1] * i) % p)
    inv.append((-inv[p % i] * (p // i)) % p)
    factinv.append((factinv[-1] * inv[-1]) % p)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n-r] % p
'''




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

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

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

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

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

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

Solution (Python):
from sys import stdin

def main():
    N, R = [int (x) for x in stdin.readline().rstrip().split()]
    result = R if N > 10 else R + (100 * (10 - N))
    print(result)


if __name__ == '__main__':
    main()

Solution (Python):
nums=[int(i) for i in input().split()]
if nums[0]<=9:
    print(nums[1]+100*(10-nums[0]))
else:
    print(nums[1])

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

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

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

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

print(c)

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

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

print(calc(n, r))

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():
    *a,=map(int,open(0))
def S_():
    return input()
def IS():
    return input().split()
def LS():
    return [i for i in input().split()]
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def NI(n):
    return [int(input()) for i in range(n)]
def NI_(n):
    return [int(input())-1 for i in range(n)]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def LtoS(ls):
    return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[1]*(w+2)
    found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['YES','NO']
Yn=['Yes','No']

mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase


input=lambda: sys.stdin.readline().rstrip()
 
def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo


show_flg=False
show_flg=True

ans=0

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

Solution (Python):
def main():
    inp = input()
    arr = inp.split(" ")
    print(rate(int(arr[0]), int(arr[1])))


def rate(n, er):
    if (n < 10):
        return er + (100 * (10 - n))
    else:
        return er


if __name__ == "__main__":
    main()

Solution (Python):

import collections
import itertools as it
import math
import numpy as np









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

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

Solution (Python):
input = input().split(" ")
if int(input[0]) < 10:
  c = 10 - int(input[0])
  r = 100 * int(c)
  res = int(input[1]) + int(r)
  print(res)
elif int(input[0]) >= 10:
  print(input[1])

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

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

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

if a < 10:
  i = 100 * (10 - a)
  s = b + i
  print(s)
  
else:
  print(b)

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

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

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

Solution (Python):
n = [int(i) for i in input().split()]
a = n[0]
b = n[1]
if a < 10:
  b += (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 = input().split()
if int(n) >= 10:
  h = int(r)
else:
  h = int(r) + (100 * (10-int(n)))
print(h)

Solution (Python):



import sys
from collections import deque as deq

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

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

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

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

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

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

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

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

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

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

Solution (Python):

def inpl(): return list(map(int, input().split()))
N, R = inpl()

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

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




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

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    (n, r) = [int(e) for e in lines[0].split(" ")]

    return (n, r)


def solve(n, r):
    
    inner_r = r 
    if n < 10:
       inner_r = r + 100 * (10 - n)
    

    result = inner_r 
        
    return result
    


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

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


out = r + 100 * (10-n)

if n >= 10:
  out = r

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def solve():
    n, r = LI()
    if n >= 10:
        print(r)
    else:
        print(r + 100 * (10 - n))
    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):
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:
    R += 100 * (10 - N)
    print(R)

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

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

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

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

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

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

print(ans)

Solution (Python):

"""
Created on Fri Jan 24 14:37:00 2020

@author: matsui
"""

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


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

print(ans)

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

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

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

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

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

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

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

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

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

Solution (Python):

from collections import deque, defaultdict
import bisect


def comb(a, b):
    result = 1
    for i in range(b):
        result *= (a - i) / (i + 1)
    return result


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

    penalty = max([0, 100 * (10 - N)])

    print(R + penalty)


if __name__ == '__main__':
    main()

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(i) for i in input().split()]
if n < 10:
    x = 100 * (10 - n)
    print(x + 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):
NR = input().split()
N = int(NR[0])
R = int(NR[1])

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

print(result)

Solution (Python):
from sys import stdin

N, R = [int(x) for x in stdin.read().rstrip().split()]

def main(N, R):
  innerRate = 0
  if N >= 10:
    innerRate = R
  else:
    innerRate = R + 100 * (10 - N)
  return innerRate

print(main(N, R))

Solution (Python):
import numpy as np

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

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

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

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

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

if k <= 10:
  print(n+100*(10-k))
else:
  print(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
s = stdin.readline().rstrip().split()
n, r = int(s[0]), int(s[1])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

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

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

inrate = 0

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

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

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

print(inner_rating)

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

Solution (Python):
N, K = map(int, input().split())
if N > 10:
  print(K)
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):
N, R = (int(nr) for nr in input().split())

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

Solution (Python):
N,R = map(int,input().rstrip().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 = [int(v) for v in input().strip().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(R + 100 * (10 - N))

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

print(R)

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

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

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

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

else:
    print(R)