jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include<stdio.h>
#include<string.h>

int main(){
    char s[200000];
    scanf("%s",s);
    int len=strlen(s);

    int max=0;
    for(int i=0;i<len;i++){
        for(int j=i+1;j<len;j++){
            if(s[i]=='A'&&s[j]=='Z'){
                int temp=j-i+1;
                if(temp>max){
                    max=temp;
                }
            }
        }
    }
    printf("%d\n",max);
    return 0;
}
//  [javascript]
function myout(text){console.log(text);}//standard output
function Main(input) {
	//input = parseInt(input);
	//input = input.trim().split(" ");
	//input = input.trim().split("\n");
	//input = input.trim().split(" ").map((a)=>Number(a));
	//input = input.trim().split("\n").map((a)=>Number(a));
  myout(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
'use strict'

function main(s) {

  const str = s.split('\n')[0];
  const first_A = str.indexOf('A');
  const last_Z  = str.lastIndexOf('Z')
  const ans = last_Z - (first_A - 1);
  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
Main(require("fs").readFileSync("/dev/stdin", "utf8"));

function Main(args){
    var input = args.split("\n");
    var tmp = input[0];
    var posA = tmp.indexOf('A');
    var posZ = tmp.lastIndexOf('Z');

    console.log( posZ - posA + 1 );
}
//  [javascript]
function main(input) {
  const S = input.split('');
  let a_idx;
  let z_idx;
  
  for(let i = 0; i < S.length; i++) {
  	if (S[i] === 'A' && !a_idx) { a_idx = i; }
    if (S[i] === 'Z') { z_idx = i; }
  }
  
  let result = parseInt((z_idx - a_idx)) + 1;
  
  console.log(result);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  const S = input.split('');
  let a_idx;
  let z_idx;
  
  for(let i = 0; i < S.length; i++) {
  	if (S[i] === 'A' && !a_idx) { a_idx = i; }
    if (S[i] === 'Z') { z_idx = i; }
  }
  
  console.log((z_idx - a_idx) + 1);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  let APosition = input.indexOf('A');
  let ZPosition = input.indexOf('Z');
  console.log(ZPosition - APosition);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
)

func out(x ...interface{}) {
	fmt.Println(x...)
}

func main() {
	re := bufio.NewReaderSize(os.Stdin, 200000)

	s, _, _ := re.ReadLine()

	start := 0
	for i := 0; i < len(s); i++ {
		if s[i] == 'A' {
			start = i
			break
		}
	}
	end := len(s)
	for i := len(s) - 1; i >= 0; i-- {
		if s[i] == 'Z' {
			end = i + 1
			break
		}
	}
	out(end - start)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	sc.Split(bufio.ScanWords)
	s := nextMega()
	var l, r int

	for l = 0; s[l] != 'A'; l++ {
	}
	for r = len(s) - 1; s[r] != 'Z'; r-- {
	}

	puts(r - l + 1)
	wt.Flush()
}

var (
	sc  = bufio.NewScanner(os.Stdin)
	rdr = bufio.NewReaderSize(os.Stdin, 1000000)
	wt  = bufio.NewWriter(os.Stdout)
)

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	i, _ := strconv.Atoi(next())
	return i
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func nextFloat64s(n int) []float64 {
	slice := make([]float64, n)
	for i := 0; i < n; i++ {
		slice[i] = nextFloat64()
	}
	return slice
}

func nextMega() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, _ := rdr.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func putf(format string, a ...interface{}) {
	fmt.Fprintf(wt, format, a...)
}

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

var rdr = bufio.NewReaderSize(os.Stdin, 1000000)

func readLine() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, _ := rdr.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func main() {
	s := readLine()
	h := strings.Index(s, "A")
	t := strings.LastIndex(s, "Z")
	fmt.Println(t - h + 1)
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scan(&s)

	var aIndex = strings.Index(s, "A")
	var zIndex = strings.Index(s, "Z")

	var answer = zIndex - aIndex + 1
	fmt.Println(answer)

}
//  [go]
#include<iostream>
#include<string>
#include<algorithm>

int main() {
    std::string s;
    std::cin >> s;

    int b;
    int e;
    bool f1 = true;
    for (int i = 0; i < s.size(); i++)
    {
        if(s[i] == 'A' & f1) {
            b = i;
            f1 = false;
        }

        if(s[i] == 'Z') {
            e = i;
        }
    }

    std::cout << e - b + 1 << "\n";
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)

	len := len(s)
	var f, l int
	for i := 0; i < len; i++ {
		if f == 0 && s[i] == 'A' {
			f = i
		}
		if l == 0 && s[len-i-1] == 'Z' {
			l = len - i - 1
		}
		if f != 0 && l != 0 {
			break
		}
	}
	fmt.Println(l - f + 1)
}
//  [ruby]
S = gets.chomp
puts S.rindex('Z') - S.index('A') + 1
//  [ruby]
# https://atcoder.jp/contests/abc053/tasks/abc053_b



s = gets.chomp

puts s.rindex('Z') - s.index('A') + 1
//  [ruby]
s = gets.chomp

puts s.rindex("Z") - s.index("A") + 1
//  [ruby]
s = gets.chomp.chars
a_index = []
z_index = []
max = 0
s.each_with_index do |ss,i|
  if ss == "A"
    a_index << i
  elsif ss == "Z"
    z_index << i
  end
end

a_index.each do |a|
  z_index.each do |z|
    max = [max, z - a].max
  end
end
puts max + 1
//  [ruby]
s = gets.chomp.split("")
long = s.size
i = 0
arr = []
while true
    if arr != []
        arr << s[i]
    end
    if s[i] == "A"
        arr << s[i]
    end
    if s[i] == "Z" && arr != []
        break
    end
    i += 1
end
puts arr.size
//  [rust]
use std::io;
use std::cmp::max;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let s:Vec<char> = buf.trim().chars().collect();
	let mut left = 0;
	let mut right = 0;
	for i in 0..s.len() {
		if s[i] == 'A' {
			left = i;
			break;
		}
	}
	for i in (0..s.len()).rev() {
		if s[i] == 'Z' {
			right = i;
			break;
		}
	}
	println!("{}", right - left + 1);
}
//  [rust]
//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;

fn main() {
    let s = input_line_str().to_charvec();
    println!(
        "{}",
        1 + s.iter().rposition(|&x| x == 'Z').unwrap() - s.iter().position(|&x| x == 'A').unwrap()
    );
}
//  [rust]
macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
            get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
            get!($($t),*)
        ).collect::<Vec<_>>()
    };
}

fn main() {
    let s = get!(String).chars().collect::<Vec<_>>();
    let mut i = 0;
    while s[i] != 'A' { i += 1; }
    let mut j = s.len()-1;
    while s[j] != 'Z' { j -= 1; }
    println!("{}", j-i+1);
}
//  [rust]
use std::io;
use std::cmp::max;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let s:Vec<char> = buf.trim().chars().collect();
	let mut left = 0;
	let mut right = 0;
	for i in 0..s.len() {
		if s[i] == 'A' {
			left = i;
		}
	}
	for i in (0..s.len()).rev() {
		if s[i] == 'Z' {
			right = i;
		}
	}
	println!("{}", right - left + 1);
}
//  [rust]
use std::io;
use std::cmp::max;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let s:Vec<char> = buf.trim().chars().collect();
	let mut maxi:i32 = 0;
	let mut tail:i32 = 0;
	for i in 0..s.len() {
		tail = 0;
		if s[i] == 'A' {
			for j in ((i+1) as usize)..s.len() {
				if s[j] == 'Z' {
					tail = j as i32;
				}
			}
			maxi = max(tail - (i as i32) + 1, maxi);
		}
	}
	println!("{}", maxi);
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let s: String = read();
    let sc: Vec<char> = s.chars().collect();
    let mut aidx = 0;
    let mut zidx = 0;

    for (i, v) in s.chars().enumerate() {
        if v == 'A' && aidx == 0 {
            aidx = i
        }
        if v == 'Z' {
            zidx = i
        }
    }
    println!("{}", zidx - aidx + 1);
}
//  [swift]
import Foundation
let line = Array(readLine()!)
let aIndex = line.index(of: "A")!
let zIndex = line.count - Array(line.reversed()).index(of: "Z")!

print(zIndex - aIndex)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let s = readLine()!.toArray()
var start = 0
var end = 0
for i in 0..<s.count {
    if s[i] == "A" {
        start = i
        break
    }
}
for i in ((0..<s.count).map{$0}.reversed()) {
    if s[i] == "Z" {
        end = i
        break
    }
}
print(end - start + 1)
//  [swift]
import Foundation
let line = Array("HASFJGHOGAKZZFEGA"/*readLine()!*/)
let aIndex = line.index(of: "A")!
let zIndex = line.count - Array(line.reversed()).index(of: "Z")!

print(zIndex - aIndex)
//  [swift]
import Foundation
let line = Array(readLine()!)
let aIndex = line.index(of: "A")!

let line2 = line[aIndex ..< line.endIndex]
let zIndex = line2.index(of: "Z")!
print(zIndex - aIndex+1)
//  [swift]
import Foundation
let line = Array(readLine()!)
let aIndex = line.index(of: "A")!

let line2 = line[aIndex ... line.endIndex]
let zIndex = line2.index(of: "Z")!
print(zIndex - aIndex+1)
//  [typescript]
const input = require('fs').readFileSync('/dev/stdin', 'utf8')

const s: string = input.split('\n')[0]
const start = s.indexOf("A")
const end = s.lastIndexOf("Z")
console.log(end - start + 1)
//  [typescript]
const log = console.log;

// ----

function Main(input: string): void {
  log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
function Main(input) {
	console.log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))}
const main=()=>{
  let s=ts(),a,z
  for(let i=0;i<s.length;i++){
    if(!a&&s[i]=='A')a=i
    if(s[i]=='Z')z=i
  }
  to(z-a+1)
}
main()
//  [typescript]
Main(input) {
	console.log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
Main(input) {
	console.log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8");
//  [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)
else:
    print(1)
//  [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)
//  [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')
else:
    print('1')
//  [python]
n,k =map(int,input().split())
a=[int(x ) for x in input().split()]
for i in range(k,n):
    if a[i-k]>a[i-1]:
        print("Yes")
    else:
        print("No")
//  [python]
print(5+2)
//  [python]
x=int(input())
if(400<=x<600):
    print(8)
elif(600<=x<800):
    print(7)
elif(800<=x<100):
    print(6)
elif(1000<=x<1200):
    print(5)
elif(1200<=x<1400):
    print(4)
elif(1400<=x<1600):
    print(3)
elif(1600<=x<1800):
    print(2)
elif(1800<=x<2000):
    print(1)
//  [java]
import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		
		// 入力
		int x = sc.nextInt();
		
		// 計算
		int result = 0;
		if(400 <= x) result = 8;
		if(600 <= x) result = 7;
		if(800 <= x) result = 6;
		if(1000 <= x) result = 5;
		if(1200 <= x) result = 4;
		if(1400 <= x) result = 3;
		if(1600 <= x) result = 2;
		if(1800 <= x) result = 1;
		
		
		// 出力
		System.out.println(result);
	}
	
	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}
//  [java]
import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;

public class Main {

	public static void main(String[] args) throws IOException {
		InputStreamReader reader = new InputStreamReader(System.in, StandardCharsets.UTF_8);
		BufferedReader in = new BufferedReader(reader);
		Main ins = new Main(in);
		ins.calc();
		ins.showResult();
	}

	Main(BufferedReader in) throws IOException {
		int X = Integer.parseInt(in.readLine());
		int result = -1;
		if (X < 600) {
			result = 8;
		} else if (X < 800) {
			result = 7;
		} else if (X < 1000) {
			result = 6;
		} else if (X < 1200) {
			result = 5;
		} else if (X < 1400) {
			result = 4;
		} else if (X < 1600) {
			result = 3;
		} else if (X < 1800) {
			result = 2;
		} else {
			result = 1;
		}
		System.out.println(result);
	}

	void calc() {
	}

	void showResult() {
	}
}
//  [java]
import java.io.*;
import java.util.*;
public class Main {        
    public static void main(String args[]) {
        int x=II();
        int ans=0;
        if(x<=599)
            ans=8;
        else if(x<=799)
            ans=7;
        else if(x<=999)
            ans=6;
        else if(x<=1199)
            ans=5;
        else if(x<=1399)
            ans=4;
        else if(x<=1599)
            ans=3;
        else if(x<=1799)
            ans=2;
        else
            ans=1;

        System.out.println(ans);
    }
    
    ////////////////////////////////////
    static scan in=new scan(System.in);
    static int II() {
        return in.nextInt();
    }
    static long IL() {
        return in.nextLong();
    }
    static int[] IIA(int n) {
        int a[]=new int[n];
        for(int i=0;i<n;i++) {
            a[i]=II();
        }
        return a;
    }
    static String IS() {
        return in.next();
    }
    static char IC(){
        return in.next().charAt(0);
    }
    static String[] ISA(int n) {
        String a[]=new String[n];
        for(int i=0;i<n;i++) {
            a[i]=IS();
        }
        return a;
    }
    static char[] ICA(int n) {
        char a[]=new char[n];
        for(int i=0;i<n;i++) {
            a[i]=IC();
        }
        return a;
    }
}
class scan
{
    public static BufferedReader reader;
    public static StringTokenizer token;

    scan(InputStream str)
    {
        reader=new BufferedReader(new InputStreamReader(str));
        token=null;
    }

    static int nextInt()
    {
        while(token==null||!token.hasMoreTokens())
        {
            try { token=new StringTokenizer(reader.readLine());   }
            catch(IOException e){  throw new RuntimeException(e); }
        }
        return Integer.parseInt(token.nextToken());
    }

    static long nextLong()
    {
        while(token==null||!token.hasMoreTokens())
        {
            try { token=new StringTokenizer(reader.readLine());   }
            catch(IOException e){  throw new RuntimeException(e); }
        }
        return Long.parseLong(token.nextToken());
    }

    static String next()
    {
        while(token==null||!token.hasMoreTokens())
        {
            try { token=new StringTokenizer(reader.readLine());   }
            catch(IOException e){  throw new RuntimeException(e); }
        }
        return token.nextToken();
    }

}
//  [java]
import java.io.*;
class Main
{
  static void main(String args[])throws IOException
  {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int x=Integer.parseInt(br.readLine());
    if(x>=400 && x<600)
      System.out.println("8");
    else if(x>=600 && x<800)
      System.out.println("7"); 
      else if(x>=800 && x<1000)
      System.out.println("6") ;
        else if(x>=1000 && x<1200)
      System.out.println("5");
      else if(x>=1200 && x<1400)
      System.out.println("4"); 
     else if(x>=1400 && x<1600)
      System.out.println("3"); 
      else if(x>=1600 && x<1800)
      System.out.println("2") ;
        else if(x>=1800 && x<2000)
      System.out.println("1");
  }
}
//  [java]
import java.io.*;
class Main()
{
  static void main(String args[])throws IOException
  {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int x=Integer.parseInt(br.readLine());
    if(x>=400 && x<600)
      System.out.println("8");
    else if(x>=600 && x<800)
      System.out.println("7"); 
      else if(x>=800 && x<1000)
      System.out.println("6") ;
        else if(x>=1000 && x<1200)
      System.out.println("5");
      else if(x>=1200 && x<1400)
      System.out.println("4"); 
     else if(x>=1400 && x<1600)
      System.out.println("3"); 
      else if(x>=1600 && x<1800)
      System.out.println("2") ;
        else if(x>=1800 && x<2000)
      System.out.println("1");
  }
}
//  [java]
import java.util.*;
public class Main
{
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        int n = reader.nextInt();
        int k = reader.nextInt();
        int[] cek = new int[n];
        for(int i=0;i<n;i++){
            cek[i] = reader.nextInt();
        }
        for(int i=k;i<n;i++){
            if(cek[i]>=cek[i-k]){
                System.out.println("Yes");
            }   else{
                    System.out.println("No");
                }   
        }
    }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define int long long
constexpr long long INF = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;



signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int X;
    cin>>X;
    

    cout << (2199-X)/200 << endl;

    



}
//  [cpp]
#include<bits/stdc++.h>

using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
#define rep(i,n) for(ll i = 0;i < (ll)n;i++)
#define ALL(x) (x).begin(),(x).end()
#define MOD 1000000007



int main(){
  
  int n;
  cin >> n;
  if(n >= 400 && n < 600)cout << 8 << endl;
  if(n >= 600 && n < 800)cout << 7 << endl;
  if(n >= 800 && n < 1000)cout << 6 << endl;
  if(n >= 1000 && n < 1200)cout << 5 << endl;
  if(n >= 1200 && n < 1400)cout << 4 << endl;
  if(n >= 1400 && n < 1600)cout << 3 << endl;
  if(n >= 1600 && n < 1800)cout << 2 << endl;
  if(n >= 1800 && n < 2000)cout << 1 << endl;


  return 0;
}
//  [cpp]
#include <algorithm>
#include <cmath>
#include <vector>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <ctype.h>
#include <climits>
#include <queue>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < (ll)(n); ++i)
template<class T> inline bool chmax(T& a, T b) { if(a < b){ a=b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if(a > b){ a=b; return 1; } return 0;}

int main(){
	int x;
	cin >> x;
	
	cout << (1999-x)/200+1 << endl;
	
	
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
  int X;
  cin >> X;
  X /= 200;
  cout << X << endl;
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int x;
  cin >> x;

  if (400 <= x <= 599) {
    cout << "8" << endl;
  }
  if (600 <= x <= 799) {
    cout << "7" << endl;
  }
  if (800 <= x <= 999) {
    cout << "6" << endl;
  }
  if (1000 <= x <= 1199) {
    cout << "5" << endl;
  }
  if (1200 <= x <= 1399) {
    cout << "4" << endl;
  }
  if (1400 <= x <= 1599) {
    cout << "3" << endl;
  }
  
   if (1600 <= x <= 1799) {
    cout << "2" << endl;
  }
  if (1800 <= x <= 1999) {
    cout << "1" << endl;
  }


}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  int x;
  cin >> x;

  if (400 <= x <= 599) {
    cout << "8級" << endl;
  }
  if (600 <= x <= 799) {
    cout << "7級" << endl;
  }
  if (800 <= x <= 999) {
    cout << "6級" << endl;
  }
  if (1000 <= x <= 1199) {
    cout << "5級" << endl;
  }
  if (1200 <= x <= 1399) {
    cout << "4級" << endl;
  }
  if (1400 <= x <= 1599) {
    cout << "3級" << endl;
  }
  
   if (1600 <= x <= 1799) {
    cout << "2級" << endl;
  }
  if (1800 <= x <= 1999) {
    cout << "1級" << endl;
  }


}
//  [c]
#include <stdio.h>

int main(void) {
  int x;
  
  scanf("%d", &x);
  
  if (400 <= x && x <= 599) {
	printf("8");
  } else if (600 <= x && x <= 799) {
    printf("7");
  } else if (800 <= x && x <= 999) {
    printf("6");
  } else if (1000 <= x && x <= 1199) {
    printf("5");
  } else if (1200 <= x && x <= 1399) {
    printf("4");
  } else if (1400 <= x && x <= 1599) {
    printf("3");
  } else if (1600 <= x && x <= 1799) {
    printf("2");
  } else if (1800 <= x && x <= 1999) {
    printf("1");
  }
  
  return 0;
}
//  [c]
int main()
{
  int n;
  scanf("%d", &n);
  if (n <= 599)
    printf("8");
  else if (n <= 799)
    printf("7");
  else if (n <= 999)
    printf("6");
  else if (n <= 1199)
    printf("5");
  else if (n <= 1399)
    printf("4");
  else if (n <= 1599)
    printf("3");
  else if (n <= 1799)
    printf("2");
  else if (n <= 1999)
    printf("1");
}
//  [c]
#include <iostream>
using namespace std;

int main() {
	int x;
  cin >> x;
  if (x >= 400 && x <= 599){
    cout << '8';
  }
  if (x >= 600 && x <= 799){
    cout << '7';
  }
  if (x >= 800 && x <= 999){
    cout << '6';
  }
  if (x >= 1000 && x <= 1199){
    cout << '5';
  }
  if (x >= 1200 && x <= 1399){
    cout << '4';
    
  }
  if (x >= 1400 && x <= 1599){
    cout << '3';
    
  }
  if (x >= 1600 && x <= 1799){
    cout << '2';
    
  }
  if (x >= 1800 && x <= 1999){
    cout << '1';
    
  }
	return 0;
}
//  [c]
#include<stdio.h>
#include <math.h> 
int main() 
{
	int X;
	scanf("%d",&X);
	if(X>400&&X<=599)
		printf("8");
	if(X>=600&&X<=799)
		printf("7");
	if(X>=800&&X<=999)
		printf("6");
	if(X>=1000&&X<=1199)
		printf("5");
	if(X>=1200&&X<=1399)
		printf("4");
	if(X>=1400&&X<=1599)
		printf("3");
	if(X>=1600&&X<=1799)
		printf("2");
	if(X>=1800&&X<=1999)
		printf("1");
	return 0;
	
}
//  [c]
#include<stdio.h>
#include <math.h> 
int main() 
{
	int X;
	scanf("%d",&X);
	if(X>400&&X<=599)
		printf("8");
	if(X>600&&X<=799)
		printf("7");
	if(X>800&&X<=999)
		printf("6");
	if(X>1000&&X<=1199)
		printf("5");
	if(X>1200&&X<=1399)
		printf("4");
	if(X>1400&&X<=1599)
		printf("3");
	if(X>1600&&X<=1799)
		printf("2");
	if(X>1800&&X<=1999)
		printf("1");
	return 0;
	
}
//  [javascript]
function Main(input){
    const score = Number(input);
    let from = 600;
    let kyu = 8;
    while(true){
        if(score < from){
            console.log(kyu);
            return;
        }
        from += 200;
        kyu--;
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// let input = "1600";

function main(input){
  input = input.trim();
  let x = parseInt(input);
  let mainasu = Math.floor(x/200);
  let kyu = 10 - mainasu;
  console.log(kyu);
}

// main(input);

main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
'use strict'

function main(input) {
    const x = Number(input.split('\n')[0].split(' ')[0]);
    // let r = Number(input.split('\n')[0].split(' ')[1]);
    // let d = Number(input.split('\n')[0].split(' ')[2]);
    let ans;
    if (x >= 400 && x < 600) {
        ans = 8;
    } else if (x >= 600 && x < 800) {
        ans = 7;
    } else if (x >= 800 && x < 1000) {
        ans = 6;
    } else if (x >= 1000 && x < 1200) {
        ans = 5;
    } else if (x >= 1200 && x < 1400) {
        ans = 4;
    } else if (x >= 1400 && x < 1600) {
        ans = 3;
    } else if (x >= 1600 && x < 1800) {
        ans = 2;
    } else if (x >= 1800 && x < 2000) {
        ans = 1;
    }
    console.log(ans);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  	let inputs = input.split(/\n/);
 	let args = inputs[0].split(/\s/);
    for (let i = 0;i < inputs[1];i++) {
      if (args[1] >= args[2]) {
         args[2] *= 2;
      } else if (args[0] >= args[1]) {
         args[1] *= 2;
      }
    }
  	if (args[1] <= args[2] && args[0] <= args[1]) {
      console.log('yes');
    } else {
      console.log('no');
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
// parameter "input" gets all data
function Main(data) {
  	let input = Number(data)
	if(input>=400 || input<=599){
    	console.log(8)
    }else if(input>=600 || input<=799){
    	console.log(7)
	}else if(input>=800 || input<=999){
    	console.log(6)
	}else if(input>=1000 || input<=1199){
    	console.log(5)
	}else if(input>=1200 || input<=1399){
    	console.log(4)
	}else if(input>=1400 || input<=1599){
    	console.log(3)
	}else if(input>=1600 || input<=1799){
    	console.log(2)
	}else if(input>=1800 || input<=1999){
    	console.log(1)
	}
}
// Don't edit this line!
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var GET = (function () {function f(s) {return new g(s);}function g(s) {this._s = s.trim().split("\n");}g.prototype.getValue = function (n) {return this._s[n];};g.prototype.getArray = function (n) {return this.stoa(this._s[n]);};g.prototype.slice = function (s, limit) {return this._s.slice(s, +limit + s || undefined).map(v => this.stox(v));};g.prototype.sliceArray = function (s, limit) {return this._s.slice(s, +limit + s || undefined).map(v => this.stoa(v));};g.prototype.stoa = function (s) {return s.split(" ").map(v => this.stox(v));};g.prototype.stox = function (v) {var i = +v;return (i === i) ? i : v;};return f;})();
var o = GET(require("fs").readFileSync("/dev/stdin", "utf8"));

console.log(main());
function main(){
    var X = o.getValue(0);
    var rating = 1800;
    var diff = 200;
    var index = 1;
    while (rating > 400) {
        if (rating <= X) return index;
        index++;
        rating -= diff;
    }
}
//  [go]
package main

import "fmt"

var x int

func main() {
	an := 0
	fmt.Scanf("%d", &x)
	if a(400, 599) {
		an = 8
	} else if a(600, 799) {
		an = 7
	} else if a(800, 999) {
		an = 6
	} else if a(1000, 1199) {
		an = 5
	} else if a(1200, 1399) {
		an = 4
	} else if a(1400, 1599) {
		an = 3
	} else if a(1600, 1799) {
		an = 2
	} else if a(1800, 1999) {
		an = 1
	}
	fmt.Println(an)
}
func a(i, j int) bool {
	if i <= x && x <= j {
		return true
	}
	return false
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var buff []byte

func nextString() string {
	sc.Scan()
	return sc.Text()
}

func nextFloat64() float64 {
	sc.Scan()
	f, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

func nextInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

func nextInts(n int) (r []int) {
	r = make([]int, n)
	for i := 0; i < n; i++ {
		r[i] = nextInt()
	}
	return r
}

var dy = []int{0, 1, 0, -1}
var dx = []int{1, 0, -1, 0}
var MAX = math.MaxInt64

func maxInt(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}
func minInt(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r > a[i] {
			r = a[i]
		}
	}
	return r
}
func sum(a []int) (r int) {
	for i := range a {
		r += a[i]
	}
	return r
}
func absInt(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

type Pair struct {
	a, b int
}

type Pairs []Pair

func (p Pairs) Len() int {
	return len(p)
}
func (p Pairs) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p Pairs) Less(i, j int) bool {
	if p[i].a == p[j].a {
		return p[i].b < p[j].b
	}
	return p[i].a < p[j].a
}

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buff, bufio.MaxScanTokenSize*1024)
	log.SetFlags(log.Lshortfile)
}

func main() {
	x := nextInt()
	if x < 600 {
		fmt.Println("8")
		return
	}
	if x < 800 {
		fmt.Println("7")
		return
	}
	if x < 1000 {
		fmt.Println("6")
		return
	}
	if x < 1200 {
		fmt.Println("5")
		return
	}
	if x < 1400 {
		fmt.Println("4")
		return
	}
	if x < 1600 {
		fmt.Println("3")
		return
	}
	if x < 1800 {
		fmt.Println("2")
		return
	}
	if x < 2000 {
		fmt.Println("1")
		return
	}
}
//  [go]
package main
import "fmt"

func main(){
	var p int

	fmt.Scanf("%d", &p)

	switch {
		case p>=400 && p<=599:
			fmt.Println("8")
		case p>=400 && p<=599:
			fmt.Println("7")
		case p>=400 && p<=599:
			fmt.Println("6")
		case p>=400 && p<=599:
			fmt.Println("5")
		case p>=400 && p<=599:
			fmt.Println("4")
		case p>=400 && p<=599:
			fmt.Println("3")
		case p>=400 && p<=599:
			fmt.Println("2")
		case p>=400 && p<=599:
			fmt.Println("1")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	switch {
	case n < 600:
		fmt.Println(8)
	case 600 <= n < 800:
		fmt.Println(7) 
	case 800 <= n < 1000:
		fmt.Println(6) 
	case 1000 <= n < 1200:
		fmt.Println(5) 
	case 1200 <= n < 1400:
		fmt.Println(4) 
	case 1400 <= n < 1600:
		fmt.Println(3) 
	case 1600 <= n < 1800:
		fmt.Println(2) 
	case 1800 <= n < 2000:
		fmt.Println(1) 

	}
}
//  [go]
package main 

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"strings"
)


func main() {
	var N int
	var K int
	var nums []string

	fmt.Scan(&N,&K)

	var sc = bufio.NewScanner(os.Stdin)

	sc.Scan()
	nums = strings.Split(sc.Text()," ")
  
	n := 1
	c := 0

	for i:=0;i<N;i++{
		a,_ := strconv.Atoi(nums[i])
		b,_ := strconv.Atoi(nums[c])
		if i <= K-1{
			n *= a
		}else{
			t := n
			t /= b
			t *= a

			if t > n{
				fmt.Println("Yes")
			}else{
				fmt.Println("No")
			}
			c++
			n = t
		}
	}
	
}
//  [ruby]
puts case gets.to_i
when 400..599
  8
when 600..799 
  7
when 800..999 
  6
when 1000..1199 
  5
when 1200..1399 
  4
when 1400..1599 
  3
when 1600..1799 
  2
when 1800..1999 
  1
end
//  [ruby]
# frozen_string_literal: true

x = gets.to_i

score =  if x >= 1800
      1
elsif x >= 1600
  2
elsif x >= 1400
  3
elsif x >= 1200
  4
elsif x >= 1000
  5
elsif x >= 800
  6
elsif x >= 600
  7
elsif x >= 400
  8
end

puts score
//  [ruby]
io = DATA.eof? ? STDIN : DATA
x=io.gets.to_i
if x>=1800
 puts 1
elsif x>=1600
  puts 2
elsif x>=1400
  puts 3
elsif x>=1200
  puts 4
elsif x>=1000
  puts 5
elsif x>=800
  puts 6
elsif x>=600
  puts 7
elsif x>=400
  puts 8
end
__END__
//  [ruby]
x = gets.to_i

case x
when 400..599 puts 8
when 600..799 puts 7
when 800..999 puts 6
when 1000..1199 puts 5
when 1200..1399 puts 4
when 1400..1599 puts 3
when 1600..1799 puts 2
when 1800..1999 puts 1
//  [ruby]
x = gets.to_i

switch x
when 400..599 puts 8
when 600..799 puts 7
when 800..999 puts 6
when 1000..1199 puts 5
when 1200..1399 puts 4
when 1400..1599 puts 3
when 1600..1799 puts 2
when 1800..1999 puts 1
//  [ruby]
n = gets.to_i
s = 8
if n < 600
  s = 8
elsif n < 800
  s = 7
elsif n < 999
  s = 6
elsif n < 1200
  s = 5
elsif n < 1400
  s = 4
elsif n < 1600
  s = 3
elsif n < 1800
  s = 2
else
  s = 1
end
puts s
//  [rust]
use proconio::input;

fn main() {
    input! {
        X: i64,
    }
    if 400 <= X && X <= 599 {
        println!("8");
    } else if 600 <= X && X <= 799 {
        println!("7");
    } else if 800 <= X && X <= 999 {
        println!("6");   
    } else if 1000 <= X && X <= 1199 {
        println!("5");  
    } else if 1200 <= X && X <= 1399 {
        println!("4");
    } else if 1400 <= X && X <= 1599 {
        println!("3");
    } else if 1600 <= X && X <= 1799 {
        println!("2");
    } else if 1800 <= X && X <= 1999 {
        println!("1");
    }
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        x: i64,
    };
    println!(
        "{}",
        match x {
            x if x >= 1800 => 1,
            x if x >= 1600 => 2,
            x if x >= 1400 => 3,
            x if x >= 1200 => 4,
            x if x >= 1000 => 5,
            x if x >= 800 => 6,
            x if x >= 600 => 7,
            x if x >= 400 => 8,
            _ => panic!("not defined"),
        }
    );
}
//  [rust]
use proconio::input;
use proconio::marker::{Bytes, Chars};

// x ** n % mods を求める
pub fn mod_pow(x: i64, n: i64, mods: i64) -> i64 {
    if n == 0 {
        return 1;
    }
    let mut res = mod_pow(x * x % mods, n / 2, mods);
    if n % 2 == 1 {
        res = res * x % mods;
    }
    return res;
}

// (1/n) % mods を求める
pub fn mod_inv(n: i64, mods: i64) -> i64 {
    return mod_pow(n, mods-2, mods);
}

// nCk % mods を求める
pub fn mod_comb(n: i64, k: i64, mods: i64) -> i64 {
    let sum1 = (n-k+1..n+1).fold(1, |ac, x| ac * x % mods);
    let sum2 = (1..k+1).fold(1, |ac, x| ac * x % mods);
    return sum1 * mod_inv(sum2, mods) % mods;
}

// nCk の組み合わせを列挙する
pub fn combination(n: usize, k: usize) -> Vec<Vec<usize>> {
    let mut ans = Vec::new();
    if k == 1 {
        for i in 1..n+1 {
            let mut tmp = Vec::new();
            tmp.push(i);
            ans.push(tmp);
        }
    }
    else {
        for iter in combination(n-1, k-1) {
            let max = iter.iter().max().unwrap();
            for j in *max+1..n+1 {
                let mut tmp = iter.clone();
                tmp.push(j);
                ans.push(tmp);
            }
        }
    }
    ans
}


fn main() {
    input!{
        x: usize,
    }
    let mut ans = 0;
    if x >= 400 && x <= 599 {
        ans = 8;
    }
    else if x >= 600 && x <= 799 {
        ans = 7;
    }
    else if x >= 800 && x <= 999 {
        ans = 6;
    }
    else if x >= 1000 && x <= 1199 {
        ans = 5;
    }
    else if x >= 1200 && x <= 1399 {
        ans = 4;
    }
    else if x >= 1400 && x <= 1599 {
        ans = 3;
    }
    else if x >= 1600 && x <= 1799 {
        ans = 2;
    }
    else if x >= 1800 && x <= 1999 {
        ans = 1;
    }
    println!("{}", ans);
}
//  [rust]
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(unused_macros)]
#![allow(unused_imports)]

use std::str::FromStr;
use std::io::*;
use std::collections::*;
use std::cmp::*;

struct Scanner<I: Iterator<Item = char>> {
    iter: std::iter::Peekable<I>,
}

macro_rules! exit {
    () => {{
        exit!(0)
    }};
    ($code:expr) => {{
        if cfg!(local) {
            writeln!(std::io::stderr(), "===== Terminated =====")
                .expect("failed printing to stderr");
        }
        std::process::exit($code);
    }}
}

impl<I: Iterator<Item = char>> Scanner<I> {
    pub fn new(iter: I) -> Scanner<I> {
        Scanner {
            iter: iter.peekable(),
        }
    }

    pub fn safe_get_token(&mut self) -> Option<String> {
        let token = self.iter
            .by_ref()
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        if token.is_empty() {
            None
        } else {
            Some(token)
        }
    }

    pub fn token(&mut self) -> String {
        self.safe_get_token().unwrap_or_else(|| exit!())
    }

    pub fn get<T: FromStr>(&mut self) -> T {
        self.token().parse::<T>().unwrap_or_else(|_| exit!())
    }

    pub fn vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
        (0..len).map(|_| self.get()).collect()
    }

    pub fn mat<T: FromStr>(&mut self, row: usize, col: usize) -> Vec<Vec<T>> {
        (0..row).map(|_| self.vec(col)).collect()
    }

    pub fn char(&mut self) -> char {
        self.iter.next().unwrap_or_else(|| exit!())
    }

    pub fn chars(&mut self) -> Vec<char> {
        self.get::<String>().chars().collect()
    }

    pub fn mat_chars(&mut self, row: usize) -> Vec<Vec<char>> {
        (0..row).map(|_| self.chars()).collect()
    }

    pub fn line(&mut self) -> String {
        if self.peek().is_some() {
            self.iter
                .by_ref()
                .take_while(|&c| !(c == '\n' || c == '\r'))
                .collect::<String>()
        } else {
            exit!();
        }
    }

    pub fn peek(&mut self) -> Option<&char> {
        self.iter.peek()
    }
}

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin.bytes().map(|c| c.unwrap() as char));
    let x: usize = sc.get();
    let ans = match x {
        400..=599 => 8,
        600..=799 => 7,
        800..=999 => 6,
        1000..=1299 => 5,
        1200..=1399 => 4,
        1400..=1599 => 3,
        1600..=1799 => 2,
        1800..=1999 => 1,
        _ => panic!("error"),
    };
    println!("{}", ans);
}
//  [swift]
let X = Int(readLine()!)!
if X <= 599 {
    print(8)
} else if X <= 799 {
    print(7)
} else if X <= 999 {
    print(6)
}else if X <= 1199 {
    print(5)
}else if X <= 1399 {
    print(4)
}else if X <= 1599 {
    print(3)
}else if X <= 1799 {
    print(2)
}else if X <= 1999 {
    print(1)
}
//  [swift]
let x = Int(readLine()!)!

switch x {
  case 400..<600:
  	print("8")
  case 600..<800:
    print("7")
  case 800..<1000:
    print("6")
  case 1000..<1200:
    print("5")
  case 1200..<1400:
    print("4")
  case 1400..<1600:
    print("3")
  case 1600..<1800:
    print("2")
  case 1800..<2000:
    print("1")
  default:()
}
//  [swift]
fileprivate struct Scanner {
    private var elements = [String]()
    private var index = 0
    
    mutating func peek() -> String {
        while elements.count == index {
            elements = readLine()!.split(separator: " ").map(String.init)
            index = 0
        }
        return elements[index]
    }
    
    mutating func next() -> String {
        let value = peek()
        index += 1
        return value
    }
    
    mutating func nextInt() -> Int {
        return Int(next())!
    }
    
    mutating func nextDouble() -> Double {
        return Double(next())!
    }
}

func main() {
    var scanner = Scanner()
    let X = scanner.nextInt()
    print(10 - X / 200)
}

main()
//  [swift]
var x = Int(readLine()!)!
var kyu = 8
while x>600{
	x -= 200
	kyu -= 1
}

print(kyu)
//  [swift]
import java.util.*;

public class Main {

    static int gcd (int a, int b) {return b>0?gcd(b,a%b):a;}
    static long mod = 1000000007;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int X = sc.nextInt();

        System.out.println(8 - (X-400) / 200);


    }

}
//  [typescript]
function main(input) {
   const calc = Math.floor(input / 200);
   const result = 10 - calc;
   console.log(result);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync('/dev/stdin', 'utf8');

_a(input);

function _a(input: string) {
  const X = parseInt(input);

  if (400 <= X && X <= 599) {
    console.log(8);
  }
  if (600 <= X && X <= 799) {
    console.log(7);
  }
  if (800 <= X && X <= 999) {
    console.log(6);
  }
  if (1000 <= X && X <= 1199) {
    console.log(5);
  }
  if (1200 <= X && X <= 1399) {
    console.log(4);
  }
  if (1400 <= X && X <= 1599) {
    console.log(3);
  }
  if (1600 <= X && X <= 1799) {
    console.log(2);
  }
  if (1800 <= X && X <= 1999) {
    console.log(1);
  }
}
//  [typescript]
function main(input) {
   const calc = Math.floor(input / 200);
   const result = 10 - result;
   console.log(result);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
export class Main {
  static main(input: string): string {
    const tmp: string[] = input.split("\n");
    const [x]: number[] = tmp.shift().split(" ").map(int => parseInt(int));
    if (400 <= x < 600) {
      return `8`;
    } else if (600 <= x < 800) {
      return `7`;
    } else if (800 <= x < 1000) {
      return `6`;
    } else if (1000 <= x < 1200) {
      return `5`;
    } else if (1200 <= x < 1400) {
      return `4`;
    } else if (1400 <= x < 1600) {
      return `3`;
    } else if (1600 <= x < 1800) {
      return `2`;
    }
    return `1`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [python]
def solve(string):
    return str(int(string)**2)


if __name__ == '__main__':
    print(solve(input()))
//  [python]
r = int(input())
print(r**2)
//  [python]
r = int(input())
print( r ** 2)
//  [python]
r = int(input("long?"))
a = int(r^2)
print(a)
//  [python]
r = int(input("long?"))

print(r * r)
//  [python]
r = int(input("long?"))

return r * r
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main
{
    public static void main(String[] args) throws IOException
    {
        int ans = 0;
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

        String str = null;

        str = br.readLine();

        int r = Integer.parseInt(str);

        ans = r*r;

        System.out.println(ans);
    }

}