peterverebics/CodeNet_Python_118 huggingface dataset:
N, R= map(int, input().split())
if N>=10:
    print(R)
else:
    print(R+100*(10-N))
n, r = list(map(int,input().split()))
if n >= 10:
    print(r)
else:
    temp = 100 * (10 -n)
    print(r + temp)
n, r = map(int, input().split())
print( r+100*max(0, 10-n) )
n,r=map(int,input().split())
if n>=10:print(r)
else:print(r+(100*(10-n)))
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R+100*(10-N))
line = list(map(int,input().split()))
if line[0] >= 10:
  print(line[1])
else:
  print(line[1] + (100 * (10 - line[0])))
n,r = list(map(int,input().split()))
if n >= 10:
  print(r)
else:
  print(r + (100 * (10-n)))
n, r = map(int, input().split())

if n >= 10:
  print(r)
else:
  print(r+100*(10-n))
n,r=map(int,input().split())
ans = r
if n<10:
  ans = r+100*(10-n)
print(ans)
n, r = map(int, input().split())
print(r + max(1000 - 100 * n, 0))
N,R=map(int, input().split()) 
if N>=10:
    print(R)
if 0<=N<10:
    print(R+100*(10-N))
n,r = map(int,input().split())
if n >= 10:
    print(r)
else:
    print(r + 100*(10-n))
a,b=input().split()
if int(a)>=10:
    c=b
else:
    c=int(b)+100*(10-int(a))
print(c)
x,y=map(int,input().split())
if 0<=x<10 :
    z=100*(10-x)
    a=y+z
elif 10<=x :
    a=y
print(a)
n, r = map(int, input().split())

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

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

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

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

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

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

ans=R+(100*(10-N))

if N>=10:
    print(R)
else:
    print(ans)
n,r = map(int,input().split())

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

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

def main():
    a=[int(x) for x in input().split()]
    if a[0] >= 10:
        print(a[1])
    else:
        num = 100*(10-a[0])
        print(num + a[1])

if __name__ == "__main__":
    main()
N, R = map(int, input().split())

if N<= 10:
	print(R+100*(10-N))
else:
	print(R)
#!/usr/bin/env python3
# %%
stdin = open(0)

# %%
N,R = map(int, stdin.read().split())
if N >= 10:
    answer = R
else:
    answer = R + 100 * (10-N)

# %%
print(answer)

# %%
n,r=map(int,input().split())
if n>=10:
    print(r)
else:
    print(r+1000-100*n)
N, R = map(int, input().split())
if N > 10:
  print(R)
else:
  print(R+100*(10-N))
#python3

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

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

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

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

print(100 * (10 - N) + R if N < 10 else R)
# -*- coding: utf-8 -*-
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r+100*(10-n))
n, r = map(int, input().split())

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

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

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

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

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

print(r + max(10 - n, 0) * 100)
N,R=map(int,input().split())
if N >= 10:
    print(R)
else:
    print(R+(100*(10-N)))
N,R=map(int,input().split())
if N<10:
  print(R+100*(10-N))
else:
  print(R)
N, R = list(map(int, input().split()))
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))
N,R = map(int,input().split())
if N>=10:
  print(R)
else:
  print(R+100*(10-N))
N, R = map(int, input().split())

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

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

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

print(R if N>=10 else R+100*(10-N))
n, r = map(int, input().split())
if n < 10:
    res = 100 * (10 -n) + r
else:
    res = r
print(res)
# import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)


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

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

    print(res)



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

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))
N, R = map(int, input().split())
if N >= 10:
  print(R)
else:
  print((R + 100 * (10 - N)))
def main():
    inside_rate, outside_rate = map(int, input().split())
    correction = 0
    if inside_rate < 10:
        correction = 100 * (10 - inside_rate)
    print(outside_rate + correction)
main()
n,r = map(int,input().split())
if n < 10:
    h = 100*(10-n)
    print(r+h)
else:
    print(r)
n, r = map(int, input().split())

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

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

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

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

# 再起回数上限変更
sys.setrecursionlimit(1000000)

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

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

print(R + 100 * (10 - N))
i = list(map(int, input().split()))
if 1 <= i[0] and i[0] <= 100:
    N = i[0]
else:
    print('N is invalid value.')
if 0 <= i[1] and i[1] <= 4111:
    R = i[1]
else:
    print('R is invalid value.')

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

print(rate)
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()
# coding:utf-8

import sys
import math
import time
#import numpy as np
import collections
from collections import deque
import queue
import copy


#X = str(input()).split()
#a = [int(x) for x in input().split()]


NR = str(input()).split()
N = int(NR[0])
R = int(NR[1])
if(N>=10):
  ans = R
else:
  ans = R+100*(10-N)


print(ans)
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

from  collections import defaultdict
import bisect
def main():
    N, R = MI()
    if N >= 10:
        print(R)
    else:
        print(R + 1000 - 100 * N)

if __name__ == "__main__":
    main()
a = list(map(int, input().split()))

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

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

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

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

print(ans)
from collections import defaultdict, deque
import sys
import heapq
import bisect
import math
import itertools
import string
import queue
import copy
import time
# import numpy as np
from fractions import gcd

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

def inp(): return int(sys.stdin.readline())
 
def inp_list(): return list(map(int, sys.stdin.readline().split()))

def lcm(x, y): return (x * y) // gcd(x, y)


N, R = inp_list()
I = 0
if N >= 10:
    I = R
else:
    I = R + 100 * (10 - N)
print(I)
n,r=map(int,input().split())
ans=r

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

if n < 10: print(100*(10-n)+r)
else: print(r)
def InnerRating(N, R):
  if N >= 10:
    return R
  else:
    return R + 100 * (10 - N)
  
N, R = map(int, input().split())
print (InnerRating(N, R))
k,r = map(int,input().split())
if k>=10:
  print(r)
else:
  print(r+100*(10-k))
if __name__ == '__main__':
	N, R = map(int, input().split())

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

	print(R)
import math
import string


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


def nCr(n, r):
    return math.factorial(n)//math.factorial(n-r)*math.factorial(r)


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

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

if(n>10):
    print(r)
else:
    print(r+(10-n)*100)
n,r=map(int,input().split())
if n>=10:
  print(str(r))
else :
  print(r+(100*(10-n)))
N,R = (int(x) for x in input().split())

if N >= 10:
    print(R)
else:
    print(R+(10- N)*100)
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))
N,R=map(int,input().split())
if N < 10:
    print(R+(100*(10-N)))
else:
    print(R)
n,r=map(int, input().split())
if n < 10:
  print(r + 100 * (10-n))
else:
  print(r)
n, r =  map(int, input().split())
if n>=10:
  print(r)
else:
  print(r+(100*(10-n)))
n, dr = list(map(int, input().split()))
if n >= 10:
	print(dr)
else:
	print(dr+(100*(10-n)))
Num,Rate=map(int,input().split())
if Num>=10:
    print(Rate)
else:
    print(int(Rate+100*(10-Num)))
def solve(string):
    n, r = map(int, string.split())
    return str(r + max(10 - n, 0) * 100)


if __name__ == '__main__':
    import sys
    print(solve(sys.stdin.read().strip()))
N,R = map(int,input().split())

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

print(inside)
n,r = list(map(int,(input().split())))
if n<=10:
  naibu =(100*(10-n))
  print(r+naibu)
else:
  print(r)
N,P=map(int, input().split())
if N<=9:
    print(100*(10-N)+P)
else:
    print(P)
n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print(r + (100 * (10 - n)))
n, r = map(int, input().split())
if n < 10:
    print(r+100*(10-n))
else:
    print(r)
i = list(map(int, input().split()))
if 10<=i[0]:
  print(i[1])
else:
  print(i[1]+(100*(10-i[0])))
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))
n,r=map(int,input().split())
if n<10:
    print(r + 100*(10-n))
else:
    print(r)
def main():
    N, R = map(int, input().split())
    if N >= 10:
        print(R)
    else:
        print(R+100*(10-N))
if __name__ == "__main__":
    main()
data = list(map(int, input().split()))
k = data[0]
r = data[1]

if k >= 10:
    print(r)
else:
    inner_rate = r + (100*(10-k))
    print(inner_rate)
n,r=map(int,input().split())
if 10<=n:
    print(r)
if n<10:
    print(r+(100*(10-n)))
n,r=map(int,input().split())
print(r if n>=10 else r+100*(10-n))
time,rate = map(int,input().split())
ans = 0
if time >= 10:
  ans = rate
else:
  ans = rate + 100*(10 - time)
print(ans)
n,r=map(int,input().split())

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

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

if N >= 10:
    print(R)
else:
    print(R+100*(10-N))
from sys import stdin
s = stdin.readline().rstrip().split()
n, r = int(s[0]), int(s[1])

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

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

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

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

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

if n>=10:
  print(r)
else:
  print(r+100*(10-n))
n,r = map(int, input().split())
if n < 10:
    k = 100*(10-n)
    s = r + k
else:
    s = r
print(s)
n, m = map(int, input().split())
print(m+(n<10)*100*(10-n))
# -*- coding: utf-8 -*-
N,R = map(int, input().split())
if N < 10:
	R = R + 100 * (10 - N )
     
print(R)
n, r = map(int,input().split())
if n >= 10:
  print(r)
else:
  print(r + 100 * (10 - n))
N, R = map(int, input().split())

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

print(R + 100 * max(0, 10 - N))
def main():
    import sys
    input = sys.stdin.readline
    N, R = map(int,input().split())
    if N >= 10:
        print(R)
    elif N < 10:
        print(R + 100 * (10 - N))

if __name__ == "__main__":
    main()
N, R = tuple(map(int, input().split()))


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

if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))
#from collections import Counter
#= int(input())
#= map(int, input().split())
N, R = map(int, input().split())
if N >= 10:
    print(R)
else:
    R += 100 * (10 - N) 
    print(R)
n,r = map(int,input().split())
ans = 0
if n>10:
  ans = r
else:
  ans = r+100*(10-n)
print(ans)
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline


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

    else:
        print(r)


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

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

if n <= 10:
    print(r+100*(10-n))
elif n > 10:
    print(r)
n,m=map(int,input().split())
if(n>=10):
    print(m)
else:
    print(m+(100*(10-n)))
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)

def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

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


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

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

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

    else:
        print(r)

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

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

if N <= 10:
    print(R+(100*(10-N)))
else:
    print(R)
N, R = (int(x) for x in input().split())
print(R if N >= 10 else R + (100 * (10 - N)))
n, r = map(int, input().split())
if n <= 10:
    print(r + 100 * (10 - n))
else:
    print(r)
N, R = map(int, input().split())

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

if n<10:
  print(100*(10-n) + r)
else:
  print(r)
N, R = map(int, input().split())
if N < 10:
    print(R + 100 * (10 - N))
else:
    print(R)
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

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

if n>10 :
    ans = r
else:
    ans = r+(100*(10-n))
print(ans)
N,R=map(int,input().split())
if N<10 :
  print(100*(10-N)+R)
else :
  print(R)
N, R = map(int, input().split())
print(R if N >= 10 else R+100*(10-N))
n, r= map(int, input().split())
ans = 0
if n < 10: ans = 100 * (10 - n) + r
else: ans = r
print(ans)
def resolve():
    N, R = map(int, input().split())
    if N >= 10:
        print(R)
    else:
        print(R+100*(10-N))
resolve()
N, R = tuple(int(n) for n in input().split())

print(R + max(0, 100*(10-N)))
N, R = [int(i) for i in input().split()]

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

if N >= 10:
  print(R)
else:
  print(R + 100*(10-N))
N , R =map(int, input().split())
if N <=10:
    print(R + 100 * ( 10 - N))
else:
    print(R)
n, r =map(int,input().split())
if n >= 10:
    print(r)
else:
    print(r+1000-100*n)
# import math
# import bisect
# import heapq
# from collections import deque
# import numpy as np

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

ans = r
if n < 10:
    ans = r + 100 * (10 - n)
print(ans)
N,R=input().split()
N=int(N)
R=int(R)
if (R>4111)or(R<0):
  None
if 1<=N<=9:
  R_internal=R+100*(10-N)
  print(R_internal)
elif N>=10:
  R_internal=R
  print(R_internal)
else:
  None
def main():
    n, r = map(int, input().split())
    print(r+max(10-n, 0)*100)


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

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))
#beginer
N,R=map(int, input().split())
if N>=10:
    print(R)
else:
    print(R+100*(10-N))
N,R=list(map(int,input().split()))
 
if N>=10:
  print(R)
else:
  print(R+100*(10-N))
input_list= list(map(int, input().split()))
if input_list[0]<10:   
    print(input_list[1]+100*(10-input_list[0]))
else:
    print(input_list[1])
N,R = (int(x) for x in input().split())

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

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

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

if N >= 10:
    print(R)

else:
    print(R + 100*(10-N))
N, R = [int(i) for i in input().split(" ")]

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

if N >= 10:
    print(R)
else:
    print(R+100*(10-N))
a,b=map(int,input().split())
if(a<10):
  print(b+100*(10-a))
else:
  print(b)
input= list( map(int,input().split()) )
n = input[0]
r=  input[1]

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

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

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

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

else:
    print(R)
n,r = map(int,input().split())
ans = 0
if n<10:
    ans = r+(100*(10-n)) 
else:
    ans = r
print(ans)
attend, rate = input().split(' ')
 
if int(attend) >= 10:
  print(rate)
else:
  print(int(rate) + 100 * (10 - int(attend)))
mod = 1e9+7
def add(a, b):
    c = a + b
    if c >= mod:
        c -= mod
    return c

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

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

A()
# ABC 156 A
si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nms = lambda: map(str, input().split())
nl = lambda: list(map(int, input().split()))
n,r=nm()
if n>=10:
    print(r)
elif n<10:
    print(r+100*(10-n))
n, r = map(int, input().split())

def calc(n, r):
  if n >= 10:
    return r
  else:
    return r + 100*(10-n)

print(calc(n, r))
N, R = map(int, input().split(" "))

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
import itertools
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

N, R = MI()

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

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

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

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