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

Solution (Python):


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

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

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

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

Solution (Python):
mod = 1e9+7
def add(a, b):
    c = a + b
    if c >= mod:
        c -= mod
    return c

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

main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
count, outrate = map(int, input().split())

if count >= 10:
  result = outrate
  print(result)
else:
  result = outrate + 100 * (10 - count)
  print(result)

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

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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

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


main()

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

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

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

Solution (Python):

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

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

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

Solution (Python):
import sys

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

N = z[0]
R = z[1]
naibu = 0
if 10 <= N:
    naibu = R
else:
    naibu = R + (100 * (10 - N))
print(naibu)

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

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

Solution (Python):
def solve():
    N, R = map(int, 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(100*(10-n)+r)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
print((lambda x:int(x[1])+max(0,100*(10-int(x[0]))))(input().split()))

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

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

Solution (Python):


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

Solution (Python):

n, m = map(int, open(0).read().split())
if n < 10:
    print(m+100*(10-n))
else:
    print(m)

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

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

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

if __name__ == "__main__":
    main()

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

if N>=10:
    print(R)

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

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

input = lambda: sys.stdin.readline().rstrip()


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

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

    print(ans)


if __name__ == '__main__':
    solve()

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush


from functools import lru_cache


def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 10**9+7
    

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





if __name__ == "__main__":
    main()

Solution (Python):
num_of_participation, rating = map(int, input().split())

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

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

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

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

Solution (Python):
import sys
import decimal 

def input():
    return sys.stdin.readline().strip()

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

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

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

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

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

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

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

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

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

    print(X)


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):
combined = input().split(" ")
n = int(combined[0])
r = int(combined[1])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    n,r=map(int,readline().split())
    if n>=10:
        print(r)
    else:
        print(r+100*(10-n))
        
if __name__=="__main__":
    main()

Solution (Python):
import sys
from collections import Counter
from collections import deque
import math
import fractions
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

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

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

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)

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

Solution (Python):
def resolve():
  n, r = map(int, input().split())
  if n >= 10:
    print(r)
    return
  for i in range(10000):
    if i - 100 * (10 - n) == r:
      print(i)
      return
  return

if __name__ == "__main__":
  resolve()

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

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

Solution (Python):
import math
import string
import collections
from collections import Counter
from collections import deque


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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

if __name__ == '__main__':
    resolve()

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys

readline = sys.stdin.buffer.readline
N, R = map(int, 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(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())
a = R + 100 * (10 -N)
if N>=10:
  print(R)
else:
  print(a)

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

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

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

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

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

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

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

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

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

if n>=10:
  print(r)

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

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

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

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

Solution (Python):
n, r = list(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):
ARGS=input().split()
N=int(ARGS[0])
R=int(ARGS[1])

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

print(str(NAIBU))

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

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

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

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

N=int(N)
R=int(R)

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

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

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

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

if n >= 10:
    print(r)
else:
    print(z)

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

main()

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

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

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

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

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

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

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

Solution (Python):

n, r = map(int, input().split())
print(r + max(0, 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):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")



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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

def ISI(): return map(int, sys.stdin.readline().rstrip().split())

n, r = ISI()
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+1000-100*n)

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

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

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

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

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