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):
s = input().split()

n = int(s[0])
r = int(s[1])

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

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

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

Solution (Python):
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
import statistics
import heapq






def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList




data = getInputListInt()
n = data[0]
r = data[1]

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

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

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
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 LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    n,r=MI()
    if n>=10:ans=r
    else:ans=r+1000-100*n
    print(ans)
    
main()

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

if N >= 10:
    print("{}".format(R))
else:
    print("{}".format(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().rstrip().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+100*(10-n))
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(100*(10-N) + R)
else:
    print(R)

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

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

Solution (Python):

 
import math
import itertools
import sys
import copy
 






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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

print(R)

Solution (Python):
inp = [int(i) for i in input().split()]
N = inp[0]
R = inp[1]
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 = list(map(int,input().split()))

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

Solution (Python):
raw_input = input()
l = raw_input.split()
N = int(l[0])
R = int(l[1])

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

Solution (Python):

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

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

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

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

Solution (Python):
if __name__ == "__main__":
    in_tmp = [int(i) for i in input().split(" ")]
    N = in_tmp[0]
    R = in_tmp[1]

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

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

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

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

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

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

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

Solution (Python):

import sys


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

    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):
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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

if __name__=='__main__':
  main()

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

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

print("%d" % R)

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

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

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

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

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

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

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

Solution (Python):
A, B = map(int, input().split())
if A  >= 10:
    print(B)
elif 0 <= A <= 9:
    B = B + (100 * (10 -A))
    print(B)

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

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

if N > 9:
    print(R)
else:
    print(R+1000-100*N)

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

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import numpy as np

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

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

    
print(ans)

Solution (Python):









import os
import sys
import numpy as np


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


if __name__ == "__main__":
    main()

Solution (Python):
def calc(k, R):
    if k < 10:
        return R + 100 * (10 - k)
    return R

if __name__ == '__main__':
    k, R = map(int, input().split())
    print(calc(k, 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 = list(map(int,input().split()))
ans = 0
if(n < 10):
    ans = r+100*(10-n)
if(n >= 10):
    ans = r
print(ans)

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

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

Solution (Python):
time_line = input().rstrip().split(" ")
time_a = int(time_line[0])
time_b = int(time_line[1])

if time_a<10:
    hosei=(10-time_a)*100
    
else:
    hosei=0

kekka=time_b+hosei
print(kekka)

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

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

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

Solution (Python):



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

if n < 10:
    display_rate = r + 100*(10-n)
else:
    display_rate = r
    
print(display_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("{}".format(r+100*(10-n)))

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

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

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

Solution (Python):
import itertools
import sys

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:
    K = 100*(10-N)
    print("{}".format(R+K))

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

print(R)

Solution (Python):
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


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

main()

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

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

print(X)

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

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

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

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

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

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

ans = R

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

print(ans)

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

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

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

Solution (Python):


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

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

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

Solution (Python):
n,r=list(map(int,input().split(" ")))
if n > 10:
  print(r)
else:
  print("{}".format(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())

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())
print(str(100*(10-N)+R) 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 _ia(): return [int(x) for x in sys.stdin.readline().strip().split()]


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

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

Solution (Python):
a = input().split()
b = int(a[0])
c = int(a[1])

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

x = 0

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

Solution (Python):


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

Solution (Python):

import sys


def solve(N: int, R: int):
    if 10 <= N:
        return R
    else:
        return 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))  
    print(solve(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):
a = raw_input()
n = int(a.split(" ")[0])
r = int(a.split(" ")[1])

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

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

print(rat)

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

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

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 = input()
arr = [int(i) for i in N.split(' ')]
k = 0
result = 0
if arr[0]<10:
	k = 100 * (10-arr[0])
	result = arr[1] + k
else:
	result = arr[1]
print(result)

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline


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

    else:
        print(r)


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import sys
[N,R] = [int(s) for s in sys.stdin.read().split()] 
print(R+100*max(0,10-N))

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

print(b if a >= 10 else b+100*(10-a))

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

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

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

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

Solution (Python):




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

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


if __name__ == "__main__":
    main()

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

Solution (Python):




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

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

Solution (Python):
a=input().split()
nm=[]
for i in range(2):
  b=int(a[i])
  nm.append(b)
if nm[0]<10:
  nm[1]+=(100*(10-nm[0]))

print(nm[1])

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

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

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

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

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

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

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

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

Solution (Python):
import numpy as np

NR=np.array(input().split(),dtype=np.int32)

N=NR[0]
R=NR[1]

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

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

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

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

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

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

Solution (Python):
def begginer(k, x):
    print(x + 100 * (10 - min(10, k)))

if __name__ == "__main__":
    import sys
    in_str = []
    for line in sys.stdin:
        in_str.append(line)
    k, x = [int(_) for _ in in_str[0].split(' ')]
    begginer(k, x)

Solution (Python):

import sys
def input():
  return sys.stdin.readline()[:-1]


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

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

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    N, R = map(int, input().split())

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

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

print(rate)

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

Solution (Python):
import sys

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

if __name__ == '__main__':
    N, R = map(int, sys.stdin.readline().strip().split(" "))
    solve(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())
N=0
if n<10:
  N=r+100*(10-n)
else:
  N=r
print(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:
    rating = r
else:
    rating = 100 * (10 - n) + r

print(rating)

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

else:
    print(R)

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

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

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

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

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

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

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

Solution (Python):


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

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

Solution (Python):
import sys
import socket

hostname = socket.gethostname()

if hostname == 'F451C':
    sys.stdin = open('a1.in')


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


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


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


def read_str():
    return input()


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


main()

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

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

Solution (Python):
import sys

n,r = (int(i) for i in input().split())

if n >=10:
    print(r)
    sys.exit()

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

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

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





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


if __name__ == "__main__":

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

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

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

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

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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