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

x = [int(x) for x in stdin.readline().rstrip().split()]
n = x[0]
r = x[1]

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

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

if s[0]<=10:
    ans = s[1]+100*(10-s[0])
else:
    ans = s[1]

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

print(I)

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

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

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

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

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

print(K)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
N, R = map(int, input().split())
if N >= 10:
    rating = R

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

print(rating)

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

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

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

Solution (Python):
import sys


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


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

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

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

print(ans)

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


if __name__ == "__main__":
    main()

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

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

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

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

K = int(s[0])
N = int(s[1])

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

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

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

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):
n, r = (int(x) for x in input().split())
print(r + max(0, 100 * (10 - n)))

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

if __name__ == '__main__':
    main()

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

if n >= 10:
    print(r)

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

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

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

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

Solution (Python):

import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
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 LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

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

if __name__ == '__main__':
	main()

Solution (Python):

import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
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 LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

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

if __name__ == '__main__':
	main()

Solution (Python):






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

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


main()

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

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

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

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

Solution (Python):

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

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

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

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

print(R)

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

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

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

IR = 0

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

print(IR)

Solution (Python):
"""
A
"""
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(100*(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())
print(r + 100 * (10 - min(n, 10)))

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

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


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

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


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

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

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

print(innerR)

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(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=[int(i) for i in input().split()]
    if n>=10:
        print(r)
    else:
        print(r+100*(10-n))
if __name__=="__main__":
    main()

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

Solution (Python):

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

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

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

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

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

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

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

print(rate)

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

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

print(rate)

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

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

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

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

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

print(ans)

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


N, R = mi()

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

Solution (Python):


I=list(map(int, input().split()))
N=I[0]
R=I[1]
if N>=10:
    print(R)
else:
    rating=R+100*(10-N)
    print(rating)

Solution (Python):


n, r = [int(x) for x in input().rstrip().split(" ")]
print(r + max(0, 10-n)*100)

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

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

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

Solution (Python):


from sys import stdin, stderr

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

   return 0

if __name__ == '__main__': main()

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

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

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

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

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

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


if n >= 10:
  print(r)

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

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

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, r = list(map(int, readline().split()))
    print(r + 100 * (10 - n) if n < 10 else r)


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

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

Solution (Python):
def solve(n, r):
    return r + (n < 10) * 100 * (10 - n)

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

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

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

print(ans)

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






import math
import statistics
import numpy as np
import queue
import itertools

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

Solution (Python):
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys
import copy

sys.setrecursionlimit(10**9)
mod = 10**7+9
inf = 10**20

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

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

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

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

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

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

Solution (Python):

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


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

print(S)

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

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

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

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

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

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

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


if __name__ == "__main__":
    main()

Solution (Python):



from math import *
from copy import *
from string import *				
from random import *				
from sys import stdin
from sys import maxsize
from operator import *				
from itertools import *
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(n,r):
	ans = max(r,r+(100*(10-n)))
	return ans

N,R = map(int, stdin.readline().rstrip().split())
ans = solve(N,R)
print(ans)

Solution (Python):

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

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

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

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

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

Solution (Python):
InputValue = input().split(' ')

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

if 0<=R<=4111 and 1<=N<=100:
    if N>=10:
        IR = R
        print(IR,end='\n')
    elif N<10:
        IR = R + 100*(10-N)
        print(IR,end='\n')

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

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

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

Solution (Python):
N, R = map(int, input().split())
under_R = 100 * (10 - N)

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

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

print(L)

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

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

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

Solution (Python):

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

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

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

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):


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

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

print(m)

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

N = inpt[0]
R = inpt[1]

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

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

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 10<=n :
  print(r)
elif 1<= 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):
a, b = map(int, input().split())

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

print(b)

Solution (Python):
input = input()

arr = input.split(" ")
N = int(arr[0])
R = int(arr[1])

I = R

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

print(I)

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

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

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

def mainB():
	N,K=map(int,input().split())
	
	
	
	
	res = 0
	while N:
		N //= K
		res += 1
	
	print(res)

def mainC():
	
	N=input().rstrip()
	
	vA=list(map(int,input().split()))
	
	res = float("inf")
	for i in range(1, 101):
		t = sum((x-i)**2 for x in vA)
		res = min(res, t)
	
	print(res)


mainA()

Solution (Python):

 
def main():
    sanka, rate = map(int, input().split())
    
    if sanka < 10:
        print(100 * (10 - sanka) + rate)
        
    else:
        print(rate)
  
    return 0 
 
if __name__ == '__main__':
  main()

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

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

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

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

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

Solution (Python):



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

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

    return 0


if __name__ == '__main__':
    main()

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

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

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

print(Rate)

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

print("{}".format(b))

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

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

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

print(ans)

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

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

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

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

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

Solution (Python):
def main():
    t = input().split()
    n,r = int(t[0]),int(t[1])
    k = 0
    if n<10 :
        k = r+100*(10-n)
    else:
        k = r
    print(k)

if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

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

print(r)

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

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

Solution (Python):
data = input()
times, rate = data.split()
times = int(times)
rate = int(rate)

if times < 10:
  rate += 100*(10-times)
  
print(rate)

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