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())
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,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)
  exit()
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] = list(map(int,input().split()))
if N >=10:
    output = R
else:
    output = R + (100*(10-N))

print(output)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)












def resolve():
    
    
    N, R = [int(x) for x in sys.stdin.readline().split()]  
    

    
    
    
    

    logger.debug('{}'.format([]))

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


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 2919"""
        output = """3719"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """22 3051"""
        output = """3051"""
        self.assertIO(input, output)

Solution (Python):
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

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, input().split())

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

    print(ans)

if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
















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

Solution (Python):
def main():
    from sys import stdin, setrecursionlimit
    
    
    
    
    
    
    
    
    
    
    
    

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

print(R + 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):



def solve(*args: str) -> str:
    n, r = map(int, args[0].split())
    if n < 10:
        r = r + 100*(10-n)
    return str(r)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

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

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:
  sabun=100*(10-a)
  print(b+sabun)

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

def main(N, R):

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


if __name__ == "__main__":

    answer = main(N, R)
    print(answer)

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

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

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

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

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

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

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

    ans = 0

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

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

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

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

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

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

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

Solution (Python):
import sys

n, r = map(int, sys.stdin.readline().split())

def main():
    res = r + 100 * max(10 - n, 0)
    return res

if __name__ == '__main__':
    ans = main()
    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:
    print(r)
else:
    print(r+100*(10-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())

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

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

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

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

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

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


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

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

Solution (Python):


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

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

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

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

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

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

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

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

Solution (Python):
"""
Author    : co_devil Chirag Garg
Institute : JIIT
"""
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *



from fractions import Fraction
mod = int(pow(10, 9)+7)


def ii(): return int(input())


def si(): return str(input())


def mi(): return map(int, input().split())


def li(): return list(mi())


def fii(): return int(stdin.readline())


def fsi(): return str(stdin.readline())


def fmi(): return map(int, stdin.readline().split())


def fli(): return list(fmi())


abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
       'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
       'z': 25}


def getKey(item): return item[0]


def sort2(l): return sorted(l, key=getKey)


def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]


def isPowerOfTwo(x): return (x and (not (x & (x - 1))))


def decimalToBinary(n): return bin(n).replace("0b", "")


def ntl(n): return [int(i) for i in str(n)]


def powerMod(x, y, p):
    res = 1
    x %= p
    while y > 0:
        if y & 1:
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res


graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000


def bfs(d, v):
    q = []
    q.append(v)
    visited[v] = 1
    while len(q) != 0:
        x = q[0]
        q.pop(0)
        for i in d[x]:
            if visited[i] != 1:
                visited[i] = 1
                q.append(i)
        print(x)


def make_graph(e):
    d = {}
    for i in range(e):
        x, y = mi()
        if x not in d:
            d[x] = [y]
        else:
            d[x].append(y)
        if y not in d:
            d[y] = [x]
        else:
            d[y].append(x)
    return d


def gr2(n):
    d = defaultdict(list)
    for i in range(n):
        x, y = mi()
        d[x].append(y)
    return d


def connected_components(graph):
    seen = set()

    def dfs(v):
        vs = set([v])
        component = []
        while vs:
            v = vs.pop()
            seen.add(v)
            vs |= set(graph[v]) - seen
            component.append(v)
        return component

    ans = []
    for v in graph:
        if v not in seen:
            d = dfs(v)
            ans.append(d)
    return ans


def primeFactors(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3, int(sqrt(n)) + 1, 2):
        while n % i == 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s


def find_all(a_str, sub):
    start = 0
    while True:
        start = a_str.find(sub, start)
        if start == -1:
            return
        yield start
        start += len(sub)


def SieveOfEratosthenes(n, isPrime):
    isPrime[0] = isPrime[1] = False
    for i in range(2, n):
        isPrime[i] = True
    p = 2
    while (p * p <= n):
        if (isPrime[p] == True):
            i = p * p
            while (i <= n):
                isPrime[i] = False
                i += p
        p += 1
    return isPrime


def dijkstra(edges, f, t):
    g = defaultdict(list)
    for l, r, c in edges:
        g[l].append((c, r))

    q, seen, mins = [(0, f, ())], set(), {f: 0}
    while q:
        (cost, v1, path) = heappop(q)
        if v1 not in seen:
            seen.add(v1)
            path = (v1, path)
            if v1 == t:
                return (cost, path)

            for c, v2 in g.get(v1, ()):
                if v2 in seen:
                    continue
                prev = mins.get(v2, None)
                next = cost + c
                if prev is None or next < prev:
                    mins[v2] = next
                    heappush(q, (next, v2, path))
    return float("inf")


def binsearch(a, l, r, x):
    while l <= r:
        mid = l + (r-1)//2
        if a[mid]:
            return mid
        elif a[mid] > x:
            l = mid-1
        else:
            r = mid+1
    return -1


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

Solution (Python):
import numpy as np

n, r = np.asarray(input().split(), dtype=np.int32)

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

import sys


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


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


yn = 'YNeos'
ynflg = False
cnt = 0
ans = None

def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas




N, R = mulinputs()

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

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

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

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

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

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

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

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

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())
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):
def solve():
    N, R = map(int, input().split())
    if N >= 10:
        print(R)
    else:
        print(R + 100 * (10 - N))
    
if __name__ == '__main__':
    solve()

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

Solution (Python):
n, r = 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] + (10 - A[0]) * 100)
else:
    print(A[1])

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

    return 0


if __name__ == '__main__':
    main()

Solution (Python):
import sys


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


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

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

Solution (Python):
import sys


def main(S):
    pass


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

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

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

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

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

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

Solution (Python):


from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

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

yes = "Yes"
no = "No"

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


main()

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

Solution (Python):

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 = [int(i) for i in input().split()]
if a < 10:
    print(b + 100 * (10 - a))
else:
    print(b)

Solution (Python):
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

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

if __name__ == '__main__':
    main()

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

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

print(ans)

Solution (Python):
import fractions
import collections
from collections import deque
import math
import itertools

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):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



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

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


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):
import sys
readline = sys.stdin.readline

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

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

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

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


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

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

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

Solution (Python):

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

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

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

Solution (Python):
NN = 2020202
MOD = 10**9+7
INF = float("inf")

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):


import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

N, R = MI()

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

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

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

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

Solution (Python):
N,R = map(int,input().split())
if N < 10:
    print(R+(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):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left 


sys.setrecursionlimit(10**7)
N, R = map(int, input().split())

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

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

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

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

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

else:
    print(R)

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

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




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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)

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

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