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

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

print(ans)

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

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

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

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

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

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

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

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

print(Ans)

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

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

Solution (Python):

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

    print(L)
main()

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

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

Solution (Python):
N, R = input().split()
if int(N) >= 10:
  print(int(R))
else:
  print(int(R) + 100 * (10 - int(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):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
from fractions import gcd
from copy import deepcopy
import math
import queue


Mod = 1000000007
import sys
sys.setrecursionlimit(1000000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




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

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

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

Solution (Python):
import math
import itertools
import statistics


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

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

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

print(ans)

Solution (Python):
x = input().split()
N = int(x[0])
R = int(x[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):



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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
if __name__ == '__main__':
    n, r = list(map(int, input().split(" ")))

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys

def main():
    tmp = input().replace('\n','').split(' ')
    n = int(tmp[0])
    r = int(tmp[1])
    if n >= 10:
        print(r)
    else:
        res = r + 100 * (10-n)
        print(res)
if __name__ == '__main__':
    input = sys.stdin.readline
    main()

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

Solution (Python):
import sys
import socket

hostnames = ['N551J', 'F551C', 'X553M']
input_file = 'a1.in'
if socket.gethostname() in hostnames:
    sys.stdin = open(input_file)


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


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


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


def read_str():
    return input()


def solve():
    n, r = read_int_list()
    if n < 10:
        r += 100 * (10 - n)
    return r


def main():
    res = solve()
    print(res)


if __name__ == '__main__':
    main()

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

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

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

print(IR)

Solution (Python):

import sys


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



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    N = int(next(tokens))  
    R = int(next(tokens))  
    solve(N, R)


if __name__ == "__main__":
    main()

Solution (Python):



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

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


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

print(res)

Solution (Python):
from collections import *
from itertools import *
from bisect import *
import copy

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

Solution (Python):


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

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

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

    if n>=10:
        print(str(r))
        return

    print(str(r+100*(10-n)))

    return

resolve()

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


iim = lambda: map(int, input().rstrip().split())

def resolve():
    N, R = iim()

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

if __name__ == "__main__":
    resolve()

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

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

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

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

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

Solution (Python):

import sys

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

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

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

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

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    N, R = MAP()

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


if __name__ == '__main__':
    main()

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

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N, R = MAP()

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

if kaisuu >= 10:
  print(hyouji)
else:
  print(hyouji + 100*(10-kaisuu))

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

"""
"""


def dfs_search_2Dgrid(h,w):
    
    
    
    
    pass

N,R=pin()
ans=0
k=10-N
k=0 if k<0 else k

print(R+100*k)

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

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

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

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

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

ans = 0

if a >= 10:
    ans = b

else:
    ans = b + 100*(10-a)

print(ans)

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

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

print(score)

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

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

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

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

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

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

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

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

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

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

Solution (Python):
N, R = [int(i) for i in input().split()]
if N < 10:
    print(R+1000-100*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())
b = 100 * (10 - n ) if n < 10 else 0
print(r+b)

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

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

Solution (Python):
import numpy as np

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

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

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

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

N,R = input_int()

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

Solution (Python):
[N, R] = map(int, raw_input().split())

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

print r

Solution (Python):

import sys
input = sys.stdin.readline

n, r = [int(item) for item in input().split()]

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

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

X = 10-N

if X > 0:
	print(R+100*X)
else:
	print(R)

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

Solution (Python):
import sys
import heapq
import copy
import numpy as np
from collections import deque

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

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

print(ret)

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

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

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

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

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

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

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

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

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

print(str(IR))

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

print(x)

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

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

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

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

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

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

Solution (Python):

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


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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
num_attend, rate = map(int, input().split())

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

Solution (Python):

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


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




import sys
input = sys.stdin.readline



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

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

    print(res)



main()

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

if __name__ == "__main__":
    resolve()

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
n, r = [int(x) for x in 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 = 100 * (10 - N)

print(str(R + ans))

Solution (Python):
arr=input().split(" ")
n,r=int(arr[0]),int(arr[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):
a = list(map(int,input().split()))

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

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


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

print(R)

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

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

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

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

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

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

Solution (Python):
def read():
    N, R = list(map(int, input().strip().split()))
    return N, R

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

if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

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

if N >= 10:
    ans = R
else:
    ans = 100 * (10 - 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 = [int(i) for i in input().split()]

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

Solution (Python):


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

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

Solution (Python):

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

    
    
    
    
    
    

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

    print(R)

resolve()

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

Solution (Python):


[r, n] = [int(x) for x in input().split()]

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

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

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