Problem:
 Score: 100 points    Problem Statement  M-kun is a competitor in AtCoder, whose highest rating is X . In this site, a competitor is given a kyu (class) according to his/her highest rating. For ratings from 400 through 1999 , the following kyus are given:   From 400 through 599 : 8 -kyu  From 600 through 799 : 7 -kyu  From 800 through 999 : 6 -kyu  From 1000 through 1199 : 5 -kyu  From 1200 through 1399 : 4 -kyu  From 1400 through 1599 : 3 -kyu  From 1600 through 1799 : 2 -kyu  From 1800 through 1999 : 1 -kyu   What kyu does M-kun have?      Constraints   400 \leq X \leq 1999  X is an integer.         Input  Input is given from Standard Input in the following format:  X       Output  Print the kyu M-kun has, as an integer.
For example, if he has 8 -kyu, print 8 .        Sample Input 1 725      Sample Output 1 7  M-kun's highest rating is 725 , which corresponds to 7 -kyu. Thus, 7 is the correct output.       Sample Input 2 1600      Sample Output 2 2  M-kun's highest rating is 1600 , which corresponds to 2 -kyu. Thus, 2 is the correct output.

Solution (Python):
N=int(input())
if N>=400 and 599>=N:
  print('8')
if N>=600 and 799>=N:
  print('7')
if N>=800 and 999>=N:
  print('6')
if N>=1000 and 1199>=N:
  print('5')
if N>=1200 and 1399>=N:
  print('4')
if N>=1400 and 1599>=N:
  print('3')
if N>=1600 and 1799>=N:
  print('2')
if N>=1800 and 1999>=N:
  print('1')

Solution (Python):
a = int(input())
if (a >= 400) and (a <= 599) :
    print(8)
if (a >= 600) and (a <= 799) :
    print(7)
if (a >= 800) and (a <= 999) :
    print(6)
if (a >= 1000) and (a <= 1199) :
    print(5)
if (a >= 1200) and (a <= 1399) :
    print(4)
if (a >= 1400) and (a <= 1599) :
    print(3)
if (a >= 1600) and (a <= 1799) :
    print(2)
if (a >= 1800) and (a <= 1999) :
    print(1)

Solution (Python):
X=int(input())

kyu= 10 - X//200

print(kyu)

Solution (Python):
print(10-int(input())//200)

Solution (Python):


from pprint import pprint
from collections import deque, defaultdict
import itertools
import math
import sys

sys.setrecursionlimit(10 ** 6)
INF = float('inf')


rating = int(input())

if 400 <= rating <= 599:
    ans = 8
elif 600 <= rating <= 799:
    ans = 7
elif 800 <= rating <= 999:
    ans = 6
elif 1000 <= rating <= 1199:
    ans = 5
elif 1200 <= rating <= 1399:
    ans = 4
elif 1400 <= rating <= 1599:
    ans = 3
elif 1600 <= rating <= 1799:
    ans = 2
elif 1800 <= rating <= 1999:
    ans = 1

print(ans)

Solution (Python):
X = int(input())
print(10-X//200)

Solution (Python):
X=int(input())
grade=[10,9,8,7,6,5,4,3,2,1]
print(grade[X//200])

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
x = int(input())
ans = 8 - (x-400) // 200
print(ans)

Solution (Python):

import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction

mod = 10 ** 9 + 7
mod1 = 998244353


import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")





n=int(input())
n-=400
print(8-n//200)

Solution (Python):
print(abs(int(input())-2199)//200)

Solution (Python):
n=int(input())
print(abs(n-2199)//200)

Solution (Python):
x = int(input())

rl = 400

for i in range(8, 0, -1):
    if (rl <= x) and (x <= rl+199):
        print(i)
    rl += 200

Solution (Python):
A = int(input())
for i in range(8):
  if A < 400 + (i+1)*200:
    print(8-i)
    break
  else:
    continue

Solution (Python):
x = int(input())
 
if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Solution (Python):
x = int(input())
 
if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Solution (Python):
x = int(input())
if x <= 599:
    print(8)
elif x <=799:
    print(7)
elif x <= 999:
    print(6)
elif x <= 1199:
    print(5)
elif x <= 1399:
    print(4)
elif x <= 1599:
    print(3)
elif x <= 1799:
    print(2)
elif x <= 1999:
    print(1)

Solution (Python):
X = int(input())

print(8-(X-400)//200)

Solution (Python):
x = int(input())
 
if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Solution (Python):
x = int(input())
cl = 10 - x // 200
print(cl)

Solution (Python):
x = int(input())

if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Solution (Python):
x = int(input())
x -= 400
for i in range(1, 9):
	if x <= i * 200 - 1:
		print(9 - i)
		exit()

Solution (Python):
x = int(input())
print(8 - (x - 400) // 200)

Solution (Python):


def get_input() -> tuple:
    """
    標準入力を取得する.

    Returns:\n
        tuple: 標準入力
    """
    X = int(input())

    return X

def main(X: int) -> None:
    """
    メイン処理.

    Args:\n
        X (int): 最高レーティング（400 <= X <= 1999）
    """
    
    ans = 10 - (X // 200)

    
    print(ans)

if __name__ == "__main__":
    
    X = get_input()

    
    main(X)

Solution (Python):
N = int(input())
print(10 - N//200)

Solution (Python):
 

from collections import defaultdict

import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange



	
def print_case_iterable(case_num, iterable):
	print("Case 

def print_case_number(case_num, iterable):
	print("Case 

def print_iterable(A):
	print (' '.join(A))

def read_int():
	return int(f.readline().strip())
def read_int_array():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def read_string():
	return list(f.readline().strip())
def ri():
	return int(f.readline().strip())
def ria():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def rs():
	return list(f.readline().strip())
def bi(x):
	return bin(x)[2:]





from collections import deque
import math
NUMBER = 10**9 + 7

def factorial(n) : 
	M = NUMBER
	f = 1
  
	for i in range(1, n + 1):  
		f = (f * i) % M 
						
	return f
def mult(a,b):
	return (a * b) % NUMBER

def minus(a , b):
	return (a - b) % NUMBER

def plus(a , b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		g, y, x = egcd(b % a, a)
		return (g, x - (b // a) * y, y)

def modinv(a):
	m = NUMBER
	g, x, y = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
def choose(n,k):
	if n < k:
		assert false
	return  mult(factorial(n), modinv(mult(factorial(k),factorial(n-k)))) % NUMBER
from collections import deque, defaultdict 
import heapq


from types import GeneratorType
def bootstrap(f, stack=[]):
	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to

	return wrappedfunc


def dfs(g, timeIn, timeOut,depths,parents): 
	
	cnt = 0
	
	stack = [[1,0,0,0]]
	while stack:
		v,neig_i,parent,depth = stack[-1]
		parents[v] = parent
		depths[v] = depth
		
		if neig_i == 0:
			timeIn[v] = cnt    
			cnt+=1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i+=1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u,0,v,depth+1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1
  



cnt = 0
@bootstrap
def dfs(v,adj,timeIn, timeOut,depths,parents,parent=0,depth=0):
	global cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt+=1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u,adj,timeIn,timeOut,depths,parents,v,depth+1)
	timeOut[v] = cnt
	cnt+=1
	yield 

def gcd(a,b): 
	if a == 0: 
		return b 
	return gcd(b % a, a) 
  

def lcm(a,b): 
	return (a*b) / gcd(a,b) 
def get_num_2_5(n):
	twos = 0
	fives = 0
	while n>0 and n%2 == 0:
		n//=2
		twos+=1
	while n>0 and n%5 == 0:
		n//=5
		fives+=1
	return (twos,fives)
def shift(a,i,num):
	for _ in range(num):
		a[i],a[i+1],a[i+2] = a[i+2],a[i],a[i+1]

def equal(x,y):
	return abs(x-y) <= 1e-9


def getAngle(a, b, c):
	ang = math.degrees(math.atan2(c[1]-b[1], c[0]-b[0]) - math.atan2(a[1]-b[1], a[0]-b[0]))
	return ang + 360 if ang < 0 else ang
def getLength(a,b):
	return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)


from heapq import heapify, heappush, heappop

def bfs(adj):
	s = set()
	d = defaultdict(set)
	
	q = deque([])
	s.add(0)
	d[0].add(0)
	q.append((0,0))
	while len(q) > 0:
		v,depth = q.popleft()
		for u in adj[v]:
			if u not in s:
				s.add(u)
				d[depth+1].add(u)
				q.append((u,depth+1))
		
	return d



def isSubsetSum(arr, n, summ): 
	  
	
	
	
	subarr =([[False for i in range(summ + 1)]  
			for i in range(n + 1)]) 
	  
	
	for i in range(n + 1): 
		subarr[i][0] = True
		  
	
	
	for i in range(1, summ + 1): 
		 subarr[0][i]= False
			  
	
	for i in range(1, n + 1): 
		for j in range(1, summ + 1): 
			if j<arr[i-1]: 
				subarr[i][j] = subarr[i-1][j] 
			if j>= arr[i-1]: 
				subarr[i][j] = (subarr[i-1][j] or 
								subarr[i - 1][j-arr[i-1]]) 
	  
	
	
	
	
	
	return subarr[n][summ] 

@bootstrap
def dfs(v,adj,vis,black):
	vis[v] = 1
	for u in adj[v]:
		if vis[u]==2:
			continue
		if vis[u] == 1:
			black.add((v,u)) 
			continue
		yield dfs(u,adj,vis,black)
	vis[v] = 2
	yield


def solution(n):
	n-=400
	n = 1600 - n
	return (n+199)//200


def main():
	T = 1
	
	for i in range(T):
		n = ri()
		
		

		
		
		
		
		
		
		
		
		

		x = solution(n)

		
		if 'xrange' not in dir(__builtins__):
			print(x) 
		else:
			print >>output,str(x)
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()

if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()




if __name__ == '__main__':
	main()

Solution (Python):
x = int(input())

y = x - 400

print(8 - y//200)

Solution (Python):
x = int(input())
print((1999-x)//200+1)

Solution (Python):
x=int(input())

if(x>=600):
    if(x>=800):
        if(x>=1000):
            if(x>=1200):
                if(x>=1400):
                    if(x>=1600): 
                        if(x>=1800): print('1')
                        else: print('2')
                    else: print('3')
                else: print('4')
            else: print('5')
        else: print('6')
    else: print('7')
else: print('8')

Solution (Python):
def main():
    x = int(input())
    print(10 - x // 200)

if __name__ == '__main__':
    main()

Solution (Python):
x = int(input())
j = 8
for low in range(400, 2000, 200):
  if low <= x < low + 200:
    print(j)
    break
  j -= 1

Solution (Python):
"""
    Satwik_Tiwari ;) .
    24th july , 2020  - Friday
"""



from __future__ import division, print_function

from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase

from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter  
from itertools import combinations as comb 
from itertools import permutations as permutate
from bisect import bisect_left as bl


from bisect import bisect_right as br
from bisect import bisect





BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)






mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") 
def out(var): sys.stdout.write(str(var))  
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())

def zerolist(n): return [0]*n
def nextline(): out("\n")  
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
    ans = 1
    while(b>0):
        if(b%2==1):
            ans*=a
        a*=a
        b//=2
    return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True




def solve():
    x = int(inp())
    if(x<600):
        print(8)
    elif(x<800):
        print(7)
    elif(x<1000):
        print(6)
    elif(x<1200):
        print(5)
    elif(x<1400):
        print(4)
    elif(x<1600):
        print(3)
    elif(x<1800):
        print(2)
    else:
        print(1)



testcase(1)

Solution (Python):
X=int(input())
if 400<=X<=599:
    print(8)
elif 600<=X<=799:
    print(7)
elif 800<=X<=999:
    print(6)
elif 1000<=X<=1199:
    print(5)
elif 1200<=X<=1399:
    print(4)
elif 1400<=X<=1599:
    print(3)
elif 1600<=X<=1799:
    print(2)
elif 1800<=X<=1999:
    print(1)

Solution (Python):
x=int(input())











ans=8-(x-400)//200
print(ans)

Solution (Python):
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

read = sys.stdin.buffer.read
x = int(read())
print(10 - x//200)

Solution (Python):
X = int(input())

rankArr=[2000,1800,1600,1400,1200,1000,800,600,400]

for i in range(1,len(rankArr)):
  if rankArr[i] <= X and X < rankArr[i-1] :
    print(i)
    exit()

Solution (Python):
x = int(input())
print(10 - x//200)

Solution (Python):
X = int(input())
print(10 - X//200)

Solution (Python):
x=int(input())
if(x>=400 and x<=599):
  print("8")
if(x>=600 and x<=799):
  print("7")
if(x>=800 and x<=999):
  print("6")
if(x>=1000 and x<=1199):
  print("5")
if(x>=1200 and x<=1399):
  print("4")
if(x>=1400 and x<=1599):
  print("3")
if(x>=1600 and x<=1799):
  print("2")
if(x>=1800 and x<=1999):
  print("1")

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


X = int(input())

print(10 - X // 200)

Solution (Python):
X=int(input())

ans=[0,0,8,7,6,5,4,3,2,1]

print(ans[int(X/200)])

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    X = int(readline())

    ans = 10 - X // 200

    print(ans)

    return


if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())

if X <= 599:
    print(8)
elif X <= 799:
    print(7)
elif X <= 999:
    print(6)
elif X <= 1199:
    print(5)
elif X <= 1399:
    print(4)
elif X <= 1599:
    print(3)
elif X <= 1799:
    print(2)
elif X <= 1999:
    print(1)

Solution (Python):
x = int(input())

print(10 - x//200)

Solution (Python):
X = int(input())

if X <= 599:
    print(8)
elif X <= 799:
    print(7)
elif X <= 999:
    print(6)
elif X <= 1199:
    print(5)
elif X <= 1399:
    print(4)
elif X <= 1599:
    print(3)
elif X <= 1799:
    print(2)
elif X <= 1999:
    print(1)

Solution (Python):

def main():
    X = int(input())
    print(10 - X // 200)


if __name__ == "__main__":
    main()

Solution (Python):
x = int(input())
for i in range(2,10):
    if i <= x/200 < i+1:
        print(10-i)

Solution (Python):
x = int(input())
for i in range(2,10):
    if i <= x/200 < i+1:
        print(10-i)

Solution (Python):
X = int(input())

if 400 <= X <= 599:
  print(8)
elif 600 <= X <= 799:
  print(7)
elif 800 <= X <= 999:
  print(6)
elif 1000 <= X <= 1199:
  print(5)
elif 1200 <= X <= 1399:
  print(4)
elif 1400 <= X <= 1599:
  print(3)
elif 1600 <= X <= 1799:
  print(2)
elif 1800 <= X <= 1999:
  print(1)

Solution (Python):

def main():
    X = int(input())
    if X < 600:
        res = 8
    elif X < 800:
        res = 7
    elif X < 1000:
        res = 6
    elif X < 1200:
        res = 5
    elif X < 1400:
        res = 4
    elif X < 1600:
        res = 3
    elif X < 1800:
        res = 2
    else:
        res = 1
    print(res)


if __name__ == "__main__":
    main()

Solution (Python):
x = int(input())
print(10-x//200)

Solution (Python):
x=int(input())
print(10-x//200)

Solution (Python):
print((2199 - int(input())) // 200)

Solution (Python):
x=int(input())
     
if 400 <= x <= 599:
  print(8)
elif 600 <= x <= 799:
  print(7)
elif 800 <= x <= 999:
  print(6)
elif 1000 <= x <= 1199:
  print(5)
elif 1200 <= x <= 1399:
  print(4)
elif 1400 <= x <= 1599:
  print(3)
elif 1600 <= x <= 1799:
  print(2)
elif 1800 <= x <= 1999:
  print(1)

Solution (Python):
print(10-int(input())//200)

Solution (Python):
rate = int(input())
if 400 <= rate < 600:
  print("8")
elif 600 <= rate <800:
  print("7")
elif 800 <= rate <1000:
  print("6")
elif 1000 <= rate <1200:
  print("5")
elif 1200 <= rate <1400:
  print("4")
elif 1400 <= rate <1600:
  print("3")
elif 1600 <= rate <1800:
  print("2")
elif 1800 <= rate <2000:
  print("1")

Solution (Python):
def resolve():
    rate = int(input())
    if rate < 600:
        print('8')
    elif rate < 800:
        print('7')
    elif rate < 1000:
        print('6')
    elif rate < 1200:
        print('5')
    elif rate < 1400:
        print('4')
    elif rate < 1600:
        print('3')
    elif rate < 1800:
        print('2')
    else:
        print('1')

if __name__ == "__main__":
    resolve()

Solution (Python):
x=int(input())
if x in range(400,600): print("8")
if x in range(600,800): print("7")
if x in range(800,1000): print("6")
if x in range(1000,1200): print("5")
if x in range(1200,1400): print("4")
if x in range(1400,1600): print("3")
if x in range(1600,1800): print("2")
if x in range(1800,1999+1): print("1")

Solution (Python):
n = int(input())
if n >= 1800 and n <= 1999:
  print('1')
elif n >= 1600:
  print('2')
elif n >= 1400:
  print('3')
elif n >= 1200:
  print('4')
elif n >= 1000:
  print('5')
elif n >= 800:
  print('6')
elif n >= 600:
  print('7')
elif n >= 400:
  print('8')

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
x = int(input())
y = x // 200
print(10 - y)

Solution (Python):
print(8 - (int(input()) - 400) // 200)

Solution (Python):
x=int(input())
x-=400
x=8-x//200
print(x)

Solution (Python):

x = int(input())
print(10 - (x // 200))

Solution (Python):
x = int(input())

print(8-(x-400)//200)

Solution (Python):
x = int(input())

print(10- x//200)

Solution (Python):
import math  
from collections import deque  
from typing import Deque, Dict, List, Optional, Tuple, Union  


def main(X: int):
    print(f"{10-X//200}")


if __name__ == "__main__":
    X = int(input())
    main(X)

Solution (Python):

x = int(input())

if x >= 400 and x <= 599:
    print(8)
elif x >= 600 and x <= 799:
    print(7)
elif x >= 800 and x <= 999:
    print(6)
elif x >= 1000 and x <= 1199:
    print(5)
elif x >= 1200 and x <= 1399:
    print(4)
elif x >= 1400 and x <= 1599:
    print(3)
elif x >= 1600 and x <= 1799:
    print(2)
elif x >= 1800 and x <= 1999:
    print(1)

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a = ri()//200
print(10-a)

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
x = int(input())
ans = 8
if x < 600: ans=8
elif x < 800: ans=7
elif x < 1000: ans=6
elif x < 1200: ans=5
elif x < 1400: ans=4
elif x < 1600: ans=3
elif x < 1800: ans=2
else: ans=1
print(ans)

Solution (Python):
n=int(input())
if(n<600):
  print(8)
elif(n<800):
  print(7)
elif(n<1000):
  print(6)
elif(n<1200):
  print(5)
elif(n<1400):
  print(4)
elif(n<1600):
  print(3)
elif(n<1800):
  print(2)
else:
  print(1)

Solution (Python):
def main():
    x = int(input())

    print((2199 - x) // 200)

if __name__ == '__main__':
    main()

Solution (Python):
rate = int(input())
print(10 - rate//200)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]





X = ii()

tmp = X // 100
step = 0

for i in range(4, 20, 2):
    if i <= tmp < i+2:
        print(8-step)
        exit()
    step += 1

Solution (Python):
print(8-__import__("math").floor((int(input())-400)/200))

Solution (Python):
n=int(input())
n-=400
n=n//200
print(8-n)

Solution (Python):
X = int(input())

print(10 - X // 200)

Solution (Python):
X = int(input())

if X <= 599:
    print(8)
elif X <= 799:
    print(7)
elif X <= 999:
    print(6)
elif X <= 1199:
    print(5)
elif X <= 1399:
    print(4)
elif X <= 1599:
    print(3)
elif X <= 1799:
    print(2)
elif X <= 1999:
    print(1)

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
x = int(input())
print(10 - x // 200)

Solution (Python):
X = int(input())

if X < 600:
    print(8)
elif X < 800:
    print(7)
elif X < 1000:
    print(6)
elif X < 1200:
    print(5)
elif X < 1400:
    print(4)
elif X < 1600:
    print(3)
elif X < 1800:
    print(2)
else:
    print(1)

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

X = int(readline())

limit = 600
rank = 8
for i in range(8):
  if X < limit:
    print(rank)
    break
  limit += 200
  rank -= 1

Solution (Python):
print((2199-int(input()))//200)

Solution (Python):
print(8-(int(input())-400)//200)

Solution (Python):
x= int(input())
cont=0
if x>= 400 and x<=599:
    cont=8
elif x>= 600 and x<=799:
    cont=7
elif x>= 800 and x<=999:
    cont=6
elif x>= 1000 and x<=1199:
    cont=5
elif x>= 1200 and x<=1399:
    cont=4
elif x>= 1400 and x<=1599:
    cont=3
elif x>= 1600 and x<=1799:
    cont=2
elif x>= 1800 and x<=1999:
    cont=1
print(cont)

Solution (Python):
print(10 - int(input()) // 200)

Solution (Python):
print(10-int(input())//200)

Solution (Python):
x = int(input())
if x >= 1800:
    print(1)
elif x >= 1600: 
    print(2)
elif x>=1400:
    print(3)
elif x>=1200:
    print(4)
elif x>=1000:
    print(5)
elif x>=800:
    print(6)
elif x>=600:
    print(7)
else:
    print(8)

Solution (Python):
x = int(input())
print(8-(x-400)//200)

Solution (Python):
X = int(input())
print(10-X//200)

Solution (Python):
x = int(input()) - 400
l = [8,7,6,5,4,3,2,1]
print(l[x//200])

Solution (Python):
print(10-int(input())//200)

Solution (Python):

n = int(input())
print(10 - n // 200)

Solution (Python):
print(10-int(input())//200)

Solution (Python):



x = int(input())
print(10-x//200)

Solution (Python):
X= int(input())
if(X>=400 and X<=599):
	print(8)
elif(X>599 and X<800):
    print(7)
elif(X>=800 and X<1000):
    print(6)
elif(X>=1000 and X<1200):
    print(5)
elif(X>=1200 and X<1400):
    print(4)
elif(X>=1400 and X<1600):
    print(3)
elif(X>=1600 and X<1800):
    print(2)
elif(X>=1800 and X<2000):
    print(1)

Solution (Python):
x = int(input())

print(10 - x//200)

Solution (Python):
a = int(input())
b = int(a//200)
if b == 2:
  print(8)
elif b == 3:
  print(7)
elif b== 4:
  print(6)
elif b== 5:
  print(5)
elif b==6:
  print(4)
elif b==7:
  print(3)
elif b==8:
  print(2)
elif b==9:
  print(1)

Solution (Python):
rate = int(input())
if 400 <= rate < 600:
  print("8")
elif 600 <= rate <800:
  print("7")
elif 800 <= rate <1000:
  print("6")
elif 1000 <= rate <1200:
  print("5")
elif 1200 <= rate <1400:
  print("4")
elif 1400 <= rate <1600:
  print("3")
elif 1600 <= rate <1800:
  print("2")
elif 1800 <= rate <2000:
  print("1")

Solution (Python):
try:
  n = int(input())
  if(n>=400 and n<=599):
    print(8)
  elif(n>=600 and n<=799):
    print(7)
  elif(n>=800 and n<=999):
    print(6)
  elif(n>=1000 and n<=1199):
    print(5)
  elif(n>=1200 and n<=1399):
    print(4)
  elif(n>=1400 and n<=1599):
    print(3)
  elif(n>=1600 and n<=1799):
    print(2)
  elif(n>=1800 and n<=1999):
    print(1)
except EOFError:
  print(" ")

Solution (Python):
n = int(input())
print(10 - n//200)

Solution (Python):
x=int(input())
ans=8
x-=400
ans-=x//200
print(ans)

Solution (Python):
print(8-(int(input())-400)//200)

Solution (Python):
import math
x=int(input())
print(math.ceil((2000-x)/200))

Solution (Python):
x = int(input())
if x < 600:
    print(8)
elif x < 800:
    print(7)
elif x < 1000:
    print(6)
elif x < 1200:
    print(5)
elif x < 1400:
    print(4)
elif x < 1600:
    print(3)
elif x < 1800:
    print(2)
else:
    print(1)

Solution (Python):
X = int(input())
ans = 10 - X // 200
print(ans)

Solution (Python):
print(10 - int(input())//200)

Solution (Python):
X = (int(input()) - 400) // 200
print(8-X)

Solution (Python):
rating = int(input())
print(10 - rating // 200)

Solution (Python):
x=int(input())
if x<600:
    print(8)
elif x<800:
    print(7)
elif x<1000:
    print(6)
elif x<1200:
    print(5)
elif x<1400:
    print(4)
elif x<1600:
    print(3)
elif x<1800:
    print(2)
elif x<2000:
    print(1)

Solution (Python):
rating = int(input())
if rating < 600:
    print(8)
elif rating < 800:
    print(7)
elif rating < 1000:
    print(6)
elif rating < 1200:
    print(5)
elif rating < 1400:
    print(4)
elif rating < 1600:
    print(3)
elif rating < 1800:
    print(2)
else:
    print(1)

Solution (Python):
print(10-int(input())//200)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n):
    res = [None] * n
    for i in range(n):
        res[i] = II()
    return res
def LIR(n):
    res = [None] * n
    for i in range(n):
        res[i] = LI()
    return res
def FR(n):
    res = [None] * n
    for i in range(n):
        res[i] = IF()
    return res
def LIR(n):
    res = [None] * n
    for i in range(n):
        res[i] = IF()
    return res
def LIR_(n):
    res = [None] * n
    for i in range(n):
        res[i] = LI_()
    return res
def SR(n):
    res = [None] * n
    for i in range(n):
        res[i] = S()
    return res
def LSR(n):
    res = [None] * n
    for i in range(n):
        res[i] = LS()
    return res
mod = 1000000007
inf = float('INF')


def solve():
    x = II()
    print((1999 - x) // 200 + 1)
    return



if __name__ == '__main__':
    solve()

Solution (Python):
x = int(input())
print(10 - x // 200)

Solution (Python):
x = int(input())
print(10 - x // 200)

Solution (Python):
X = int(input())
rate = 0
if X >= 400 and X <= 599:
    rate = 8
elif X >= 600 and X <= 799:
    rate = 7
elif X >= 800 and X <= 999:
    rate = 6
elif X >= 1000 and X <= 1199:
    rate = 5
elif X >= 1200 and X <= 1399:
    rate = 4
elif X >= 1400 and X <= 1599:
    rate = 3
elif X >= 1600 and X <= 1799:
    rate = 2
else:
    rate = 1
    
print(rate)

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
input = sys.stdin.readline
INF = float("inf")



def main():
    X = int(input())
    print(10 - X // 200)
    


if __name__ == '__main__':
    main()