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 in Rust (1.42.0) (judge verdict: Accepted)

#[allow(dead_code)]
use std::cmp::{
    max, min, Ordering,
    Ordering::{Equal, Greater, Less},
    Reverse,
};
#[allow(dead_code)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(dead_code)]
use std::convert::TryInto;
#[allow(dead_code)]
use std::fmt;
#[allow(dead_code)]
use std::mem::swap;
#[allow(dead_code)]
use std::num::{NonZeroU32, ParseIntError};
#[allow(dead_code)]
use std::ops::{
    Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Div, DivAssign,
    Index, IndexMut, Mul, MulAssign, Neg, Rem, RemAssign, Shl, ShlAssign, Shr, ShrAssign, Sub,
    SubAssign,
};
#[allow(dead_code)]
use std::{f32, f64, i128, i16, i32, i64, i8, isize, u128, u16, u32, u64, u8, usize};
#[allow(dead_code)]
use proconio::input;
#[allow(dead_code)]
use proconio::marker::{Chars,Bytes};
#[allow(dead_code)]
type Pair<T> = (T,T);
#[allow(dead_code)]
type VVec<T> = Vec<Vec<T>>;
#[allow(dead_code)]
type Stack<T> = Vec<T>;
#[allow(dead_code)]
type Queue<T> = VecDeque<T>;


#[derive(Debug,Clone,Default)]
pub struct Graph<T>{
    nodes: VVec<T>,
    seen: Vec<bool>,
}

pub trait graph_base<T,G>{
    fn new() -> Self;
    fn see(&mut self,now: G);
    fn connected(&mut self,s: G,g: G) -> bool;
    fn refresh(&mut self);
    fn init(nodes: VVec<T>,size: G) -> Self;
}

impl graph_base<usize,usize> for Graph<usize>{
    fn new() -> Self{
        Graph::default()
    }

    fn see(&mut self,now: usize){
        self.seen[now] = true;

        for next in self.nodes[now].clone(){
            if self.seen[next]{
                continue;
            }
            self.see(next);
        }
    }

    fn connected(&mut self,s: usize,g: usize) -> bool{
        self.refresh();
        self.see(s);
        self.seen[g]
    }

    fn refresh(&mut self){
        self.seen.resize(self.seen.len(),false);
    }

    fn init(nodes: VVec<usize>,size: usize) -> Self{
        let mut tmp = Graph::new();
        tmp.nodes = nodes;
        tmp.seen.resize(size + 1,false);
        tmp
    }
}

impl Graph<usize>{

}



fn main() {
    input!{
        n: usize,
    }

    let res = {
        if n <= 599{
            8
        }else if n <= 799{
            7
        }else if n <= 999{
            6
        }else if n <= 1199{
            5
        }else if n <= 1399{
            4
        }else if n <= 1599{
            3
        }else if n <= 1799{
            2
        }else{1}
    };

    println!("{}",res);
}



#[allow(dead_code)]
fn exit(){
    std::process::exit(1);
}