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

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

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

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

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

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

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

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

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


def main():

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

    if N >= 10:
        ans = R

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


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


def main():

    sys.setrecursionlimit(10 ** 6)

    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))  
    print(f'{solve(N, R)}')


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):





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

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

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

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

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

elif n >= 10:
    print(r)

Solution (Python):












































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    
    
    N, R = list(map(int, lines[0].split()))
    
    
    
    
    
    
    
    

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

    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['2 2919']
        lines_export = [3719]
    if pattern == 2:
        lines_input = ['22 3051']
        lines_export = [3051]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

result = beginner()
print(result)

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

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

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

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

Solution (Python):
import sys


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



if __name__ == "__main__":
    main()

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

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

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

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

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):
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
import itertools
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

N, R = MI()

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

print(HR)

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

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

if not ( 1 <= N <= 100 and 0 <= R <= 4111 ): sys.exit()

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

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

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

print(l)

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

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

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

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

Solution (Python):

import collections as cl
import sys


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


main()

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

print(I)

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

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

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

Solution (Python):

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

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

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

Solution (Python):
pair = input()
t = pair.split(" ")
t = list(map(int, t))
innerRating = 0

if t[0] >= 10:
    innerRating = t[1]
else:
    innerRating = t[1] + 100*(10 - t[0])

print(innerRating)

Solution (Python):
print(eval("max(0,100*(10-"+input().replace(" ","))+")))

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

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

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

print(i)

Solution (Python):
N, R = map(int, input().split())
print(R if N > 9 else 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 + 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):
def main():
    count, rate = (int(i) for i in input().rstrip().split(' '))
    ans = rate if count >= 10 else rate + (100 * (10 - count))
    print(str(ans))


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    count, rate = (int(i) for i in input().rstrip().split(' '))
    ans = rate if count >= 10 else rate + (100 * (10 - count))
    print(str(ans))


if __name__ == '__main__':
    main()

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

ans = R

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

print(ans)

Solution (Python):

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



if (NR[0] >= 10):
    print(NR[1])
else:
    print(NR[1] + 100 * (10 - NR[0]))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

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

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

Solution (Python):
from sys import exit

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

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

Solution (Python):
N, R = (int(x) for x in input().split())

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
from math import cos,sin,tan,sqrt
import cmath as cma
import copy as cp
import sys
import re
import bisect as bs
sys.setrecursionlimit(10**7)
EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf
MOD = 10**9 + 7

def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
    if n: return [0 for _ in range(n)]
    else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
    if n: return ["" for _ in range(n)]
    else: return sinput().split()
def adj(n): return [[] for _ in range(n)]

class unionfind:
    def __init__(self, n):
        self.parent = [i for i in range(n)]
        self.size = [1 for i in range(n)]
    def find(self,a):
        if a == self.parent[a]: return a
        else: self.parent[a] = find(self,self.parent[a]); return self.parent[a]
    def unite(self,a,b):
        pa,pb = self.find(self,a), self.find(self,b)
        if pa == pb: return
        else: self.parent[pb] = pa; self.size[pa] += self.size[pb]
    def same(self,a,b): return find(self,a) == find(self,b)

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

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

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
import itertools
import functools
import math
from collections import Counter
from itertools import combinations
import re


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


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

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

Solution (Python):

import sys
import numpy as np




N,R = [int(x) for x in sys.stdin.readline().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:
  ans = r + 100*(10-n)
else:
  ans = r
print(ans)

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

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

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n, r= na()

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

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

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


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 = [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())
inn=0
if n<10:
  inn=100*(10-n)
  print(r+inn)
else:
  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 = (int(a) for a in input().split())
if N >= 10 :
    print(R)
else : 
    print(R + 100 *(10-N))

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

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

if c < 10: print(d + 100 * (10-c))
else: print(d)

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

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

Solution (Python):
def main():
    inside_rate, outside_rate = map(int, input().split())
    correction = 0
    if inside_rate < 10:
        correction = 100 * (10 - inside_rate)
    print(outside_rate + correction)
main()

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

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

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

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

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

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