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

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

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

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

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

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

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

Solution (Python):
import sys;input=lambda:sys.stdin.readline().rstrip();aint=lambda:int(input());ints=lambda:list(map(int,input().split()))
import math;floor,ceil=math.floor,math.ceil
from collections import deque
Yes=lambda b:print('Yes')if b else print('No');YES=lambda b:print('YES')if b else print('NO')
is_even=lambda x:True if x%2==0 else False

def main():
  n,r = ints()
  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())
inside = 0

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

print(inside)

Solution (Python):
import math
N, R = map(int, input().split())
S = 0
if N>9:
     S = R
else:

    S = R + 100*(10-N)

print(S)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
x = input().split()
n = int(x[0])
r = int(x[1])

if n >= 10:
  pass
else:
  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 >9:
  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):
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):


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

if __name__ == '__main__':
	main()

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

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

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

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

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

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


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

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

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

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

N = min(10,N)

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

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

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 = 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 = [int(e) for e in input().split(" ")]

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

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

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

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

















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

Solution (Python):

url = "https://atcoder.jp//contests/abc156/tasks/abc156_a"

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import numpy as np

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

N, R = rl()

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

if K>=10:
  In=R
else:
  In=R+100*(10-K)

print(In)

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

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

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

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

Solution (Python):
from collections import deque, Counter as cnt
from collections import defaultdict as dd
from operator import itemgetter as ig
from bisect import bisect_right as bsr
from math import factorial, ceil, floor
import sys
sys.setrecursionlimit(1000000)


args = None
INF = float("inf")
MOD = int(1e9 + 7)


def input(*ps):
    if type(ps[0]) is list:
        return [input(*ps[0][:-1]) for _ in range(ps[0][-1])]
    elif len(ps) == 1:
        return ps[0](next(args))
    else:
        return [p(next(args)) for p in ps]


def nlist(n, v):
    if not n:
        return [] if type(v) is list else v
    return [nlist(n[1:], v) for _ in range(n[0])]


def yesno(v):
    print(["Yes", "No"][not v])



def main():
    N, R = input([int, 2])
    print(R if 10 <= N else R + (100 * (10 - N)))


if __name__ == '__main__':
    args = iter(sys.stdin.read().split())
    main()

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

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

Solution (Python):


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


main()

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
n, r = list (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 n >= 10 else 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())

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

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

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

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


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


if __name__ == '__main__':
	main()

Solution (Python):
INT_MAX=10**18+7
x=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]
GETA=123

n,r=INPUT()
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):
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''
n , m = map(int,input().split())
if n>=10:
	print(m)
else:
	m = m + (100*(10-n))
	print(m)

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 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 = tuple(int(n) for n in input().split())

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

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

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

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

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

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

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

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

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

print(x)

Solution (Python):
def solve():
    if n>=10:
        return r
    else:
        return r+100*(10-n)


n, r = [int(i) for i in input().split(" ")]
print(solve())

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):
A = list(map(int, input().split()))
if A[0] >= 10:
    print(A[1])
else:
    print(A[1]+(100*(10-A[0])))

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
def f(n, r):
    if n >= 10:
        print(r)
    else:
        print(r + 100 * (10 - n))

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

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

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

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

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

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

ans = r + (10 - min(n, 10)) * 100

print(ans)

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

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

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

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

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

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

Solution (Python):


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

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

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

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

print(eq)

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N, R = MAP()

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


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, r = list(map(int, readline().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 = 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:
  R += 100 * (10- N)
  print(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:
  x=r
else:
  x=r+100*(10-n)
print(str(x))

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

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

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

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

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

Solution (Python):
[N,R]=[int(item)for item in input().split()]
print(max(R, 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):
K, R = map(int, input().split())
ans = 0
 
if K >= 10:
  ans = R
else:
  ans = R + 100*(10 - K)
 
print(ans)

Solution (Python):
i = list(map(int, input().split()))
N = i[0]
R = i[1]

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

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

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

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

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

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

print(ans)

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 = (int(x) for x in input().split())
if N >= 10:
    print(R)
else:
    print(R-100*N+1000)

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

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

Solution (Python):
x = input()
count = int(x.split()[0])
num = int(x.split()[1])

if count < 10:
    num = num + (100 * (10 - count))
else:
    num

print(num)

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

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


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

Solution (Python):

sel='A'

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

if sel=='B':
    N,K=map(int,input().split())
    cnt=0
    while N>0:
        N//=K
        cnt+=1
    print(cnt)


if sel=='C':
    def ceilT(a,b): 
        return (a+b-1)//b

    N=int(input())
    X=[int(i) for i in input().split()]
    p=ceilT(sum(X),N)
    ans=sum((x-p)**2 for x in X)
    p-=1
    ans=min(ans,sum((x-p)**2 for x in X))
    print(ans)

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

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

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

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


n,r = na()

print(r+max(0,100*(10-n)))

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

Solution (Python):
inputted = list(map(int, input().split()))
N = inputted[0]
R = inputted[1]

internal_rating = lambda R, K: max(R, R + 100 * (10 - K))

answer = internal_rating(R, N)

print(answer)

Solution (Python):

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

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

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

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

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

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

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

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

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

print(rate(n,r))

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

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

Solution (Python):

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



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

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

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

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

Solution (Python):

import sys


sys.setrecursionlimit(1000000)

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

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

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

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

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

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

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