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

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

if __name__=='__main__':
    main()

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

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

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

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

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

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

Solution (Python):
a,b=map(int,input().split())
if a<10:
  print(b+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+(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 + 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 = [int(i) for i in input().split()]

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

Solution (Python):

NR = input().split()

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

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

Solution (Python):
d = input().split(" ")
n = int(d[0])
r = int(d[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+100*(10-n))
else:
    print(k)

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

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

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

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

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

Solution (Python):
if __name__ == '__main__':
    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:
    K = 10
else:
    K = N

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

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):
import sys
sys.setrecursionlimit(10 ** 7)

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

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

print(ans)

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

Solution (Python):

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

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

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):


import sys
import math
import time

import collections
from collections import deque
import queue
import copy






NR = str(input()).split()
N = int(NR[0])
R = int(NR[1])
if(N>=10):
  ans = R
else:
  ans = R+100*(10-N)


print(ans)

Solution (Python):
inputs = [int(i) for i in input().split(" ")]

print(inputs[1] if 10 <= inputs[0] else inputs[1] +100*(10-inputs[0]))

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

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

Solution (Python):


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

Solution (Python):
import sys
import numpy as np


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

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
mod=1000000007



def main():
	n,r = IN()
	ret = r + (100 * (10 - min(10, n)))
	
	print(ret)
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

Solution (Python):

"""
Created on Sat Feb 22 20:51:06 2020

@author: H_Hoshigi
"""

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

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
input = sys.stdin.readline

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


if __name__ == '__main__':
    main()

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

Solution (Python):

import sys



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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    R = int(next(tokens))  
    solve(N, R)

if __name__ == '__main__':
    main()

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

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().strip().split(' '))
print(R+100*max(0,10-N))

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

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

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

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

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

if __name__ == '__main__':
    resolve()

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 + 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):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

N, R = read_int()

def solve():
    ans = 0
    if N >= 10:
        return R
    return R + 100 * (10 - N)

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

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

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


def main():
    n,r = map(int,input().split())
    print(solve(n,r))


if __name__ == '__main__':
    main()

Solution (Python):
A , B = map(int,input().split())
if A <= 10:
    A_1 = 100*(10-A)
else:
    A_1 = 0

print(B+A_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())
print(r+(100*[0,10-n][n<10]))

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

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

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

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

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


if __name__ == "__main__":
    resolve()

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

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

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
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

Solution (Python):


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

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

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

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

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

print(I)

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

if __name__ == '__main__':
    main()

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

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

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

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


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

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

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

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

Solution (Python):
import sys








mod = int(1e9+7)
INF = 1<<29

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

if __name__=='__main__':
    main()

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

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

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

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

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

print(out)

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

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

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

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

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

print(ans)

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

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

ans = 0

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

print(ans)

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

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

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

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

Solution (Python):
n = [int(str) for str in 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())
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 num():
    return int(input())
def nums():
    return list(map(int,input().split()))

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

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

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

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

Solution (Python):

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nms = lambda: map(str, input().split())
nl = lambda: list(map(int, input().split()))
n,r=nm()
if n>=10:
    print(r)
elif n<10:
    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:
    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 <= 9 :
    R2 = 100 * (10 - N )
    print(R + R2)
else:
    print(R)

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

Solution (Python):
import sys

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

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

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

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

Solution (Python):


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

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin

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

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

Solution (Python):










import math
import string

def intinput():
    return int(input())

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

def splitintinput():
    return map(int,input().split())

n,r = splitintinput()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(b)

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

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

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

print(ans)

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

Solution (Python):
n,r=[int(k) for k in input().strip().split(" ")]
print(r + max(0,(10-n)*100))

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
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):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, R):
    if N >= 10:
        return R
    return R + (100 *(10-N))


def main():
    N, R = read_int_n()
    print(slv(N, R))


if __name__ == '__main__':
    main()

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

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

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