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

Solution (Python):
def s_in():
    return input()

def n_in():
    return int(input())

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

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

N, R = l_in()

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

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

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

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

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


if __name__ == '__main__':
    resolve()

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

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


if __name__ == '__main__':
    main()

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


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

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

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

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

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

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

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

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

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

Solution (Python):
import heapq
import sys
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

Solution (Python):



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


def main():
    n, r = (int(z) for z in input().split())
    res = compute(n, r)
    print(res)


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

if(N>=10):
    print(R)
    exit()

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

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
from copy import deepcopy
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))


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

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

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

Solution (Python):

import itertools
import sys
import math
import numpy as np
from collections import deque
from itertools import combinations
from functools import reduce
from functools import lru_cache
sys.setrecursionlimit(10**9)


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



if __name__ == "__main__":
  main()

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

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def ifn(): return float(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def fmn(): return map(float, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, input().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD

N,R = imn()

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(r + (10-n)*100)
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 = [int(i) for i in 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+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 = [int(_) for _ in input().split()]

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

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

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
import itertools
from collections import deque
import copy
import bisect

MOD = 10 ** 9 + 7
INF = 10 ** 18 + 7
input = lambda: sys.stdin.readline().strip()

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

Solution (Python):
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":pass

n,r = i2()
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):
import sys
input = sys.stdin.readline


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

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

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

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

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

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

Solution (Python):




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

Solution (Python):



'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''

l = list(map(int, input().split()))

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





N, R = list(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):
from bisect import bisect_right, bisect_left
from collections import Counter, deque
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import groupby, permutations, combinations, product
from sys import stdin, stderr





def gcd(x, y):
    return x if y == 0 else gcd(y, x % y)





def exgcd(x, y):
    if y == 0:
        return 1, 0
    a, b = exgcd(y, x % y)
    return b, a - (x // y) * b



def lcm(x, y):
    m = gcd(x, y)
    return (x // m) * (y // m)


def main():
    n, r = [int(x) for x in input().split()]
    if n >= 10:
        return r
    return 100*(10-n) + r


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

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

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

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

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

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

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

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

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

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

Solution (Python):



import sys
readline = sys.stdin.readline
read = sys.stdin.read





n,r = [int(i) for i in readline().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:
    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):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

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

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

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

Solution (Python):

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)

def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max,mod=DIV):
    fac,finv,inv = [0]*max, [0]*max, [0]*max
    fac[0]=fac[1]=1
    finv[0]=finv[1]=1
    inv[1]=1
    for i in range(2,max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod -inv[mod%i] * (mod//i)%mod
        finv[i] = finv[i-1]*inv[i]%mod
    class CONV:
        def __init__(self):
            pass
        def ncr(self,n,k):
            if(n<k):
                return 0
            if(n<0 or k<0 ):
                return 0
            return fac[n]*(finv[k]*finv[n-k]%mod)%mod
    return CONV()


def main():
    N,R = isRaw()
    if N < 10:
        return R + 100*(10-N)
    else:
        return R


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

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

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

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

Solution (Python):
N, R = 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())

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

print(r+minus)

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

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

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

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

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

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

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
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 main():
    N, R = LI()
    if N >= 10:
        print(R)
    else:
        ans = R + 100 * (10 - N)
        print(ans)

main()

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

n,r = get_nums_l()

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

Solution (Python):
import numpy as np
N, R = map(int, input().split(" "))

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

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

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

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

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

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

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

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



 

fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile


mod=1000000007
 

def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 

t=1
for tt in range(t):
    
    a,b= map(int, sys.stdin.readline().split(' '))
    if a>=10:
        print(b)
    else:
        print(b+100*(10-a))
    
    
    

if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

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

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

Solution (Python):
import sys
import math
import collections

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



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

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

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

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

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N, R = [int(x) for x in input().strip().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 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())

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(0, 10 - N))

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().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 = int(input())
n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [int(input()) for i in range n]
p = [list(map(int, input().split()))]

a = input()
a, b = input().split()
a = [input() for i in range n]
'''
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+(10-N)*100)
else:
	print(R)

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

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

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

ans = r

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

Solution (Python):

import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
from collections import deque, Counter
def getN():
    return int(input())
def getList():
    return list(map(int, input().split()))
import math
INF = 10 ** 20

def main():
    a,b = getList()
    if a >= 10:
        print(b)
    else:
        print(b + 100*(10-a))

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

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

if __name__ == '__main__':
    main()