import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.next(),b = sc.next(),c = sc.next();
        System.out.println(c + " " + b + " " + a);
    }
}


#include<cstdio>
inline int in();
inline void wr(int);
int main(int argc,char**argv){
	register int x=in(),y=in(),z=in();
	x^=y^=x^=y;
	x^=z^=x^=z;
	wr(x),putchar(' '),wr(y),putchar(' '),
	wr(z),putchar('\n');
}
inline int in(){
	register char c=getchar();
	register int x=0,f=1;
	for(;c<'0'||c>'9';c=getchar())
		if(c=='-')f=-1;
	for(;c>='0'&&c<='9';c=getchar())
		x=(x<<1)+(x<<3)+(c&15);
	return x*f;
}
inline void wr(int x){
	if(x<0)putchar('-'),x=-x;
	if(x/10)wr(x/10);
	putchar(x%10+'0');
}


#include <stdio.h>
#include <string.h>

int main() {
  int x,y,z;
  scanf("%d %d %d", &x, &y, &z);

  printf("%d %d %d", z, x, y);
  return 0;
}


#include<stdio.h>
int main(){
   int a,b,c;
   scanf("%d%d%d",&a,&b,&c);
   printf("%d %d %d\n",c,a,b);
   return 0;
}


#include<bits/stdc++.h>
using namespace std;

void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
# define M_PI           3.14159265358979323846
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}

#define fo(i, n) for(int i=0; i<n; i++)
#define Fo(i, k, n) for(int i=k; i<n; i++)
#define w(x)  int x; cin>>x; while(x--)
#define watch(x) cout << (#x) << " is " << (x) << "\n"
#define watch2(x,y) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<"\n"
#define watch3(x,y,z) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<"\n"
#define watch4(x,y,z,q) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<" and "<<(#q)<<" is "<<(q)<<"\n"
#define MOD 1000000007
#define INF 1000000007;
#define F first
#define S second
#define pb(x) push_back(x);

#define ll  long long
#define all(c) (c).begin(),(c).end()
#define endl "\n"

typedef vector<int> vl;
typedef vector< vl > vvl;
typedef pair< int, int> pll;
typedef map< int, int> mll;

#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif

void c_p_c()
{
#ifndef ONLINE_JUDGE
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
}
void parray(int a[], int n) {
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}
int no = 1, n1;
int recu(int n, int k, int val) {

	if (n == n1) {
		return min(val * 2, val + k);
	}
	return min( recu(n + 1, k, 2 * val), recu(n + 1, k, val + k)              );

}
int digit(int n) {

	int temp = 0;
	while (n) {
		// temp += n % 10;
		n = n / 10;
		temp++;
	}

	return temp;
}

bool check(int a[], int n) {
	for (int i = 0; i < n; ++i)
	{
		/* code */
		if (a[i] % 2)
			return false;
	}
	return true;
}
bool ispalin(int n) {

	string  str = to_string(n);
	// cout<<str<<endl;

	for (int i = 0; i < str.size() / 2; ++i)
	{
		/* code */
		// watch2(str[i],str[str.size()-i-1]);
		if (str[i] != str[str.size() - i - 1]) {
			return false;
		}
	}

	return true;

}

bool is_palindrome(string s) {
	int n = s.size();

	for (int i = 0; i < n / 2; ++i)
	{
		/* code */
		if (s[i] != s[n - i - 1])
			return false;
	}
	return true;
}
int check(string s,string t){
	int sum=0;

	for (int i = 0; i < s.size(); ++i)
	{
		/* code */
		if(s[i]==t[i])
			sum++;
	}

	return sum;

}

int main() {
	int i,  n, m, k;
	ll sum = 0;
	c_p_c();
	cin>>n>>m>>k;
	cout<<k<<n<<m<<endl;
}


#include<iostream>
using namespace std;
int main()
{
  int a,b,c;
  cin>>a>>b>>c;
  swap(a,b);
  swap(a,c);
  cout<<a<<b<<c<<endl;
  return 0;
}


#include<iostream>
using namespace std;
int main()
{
  int a,b,c;
  cin>>a>>b>>c;
  swap(a,b);
  swap(a,c);
  cout<<a<<""<<b<<""<<c<<endl;
  return 0;
}


#include <stdio.h>

int main(void){
	int a,b,c;
	scanf("%d %d %d",&a,&b,&c);
	int tmp = a;
	a = b;
	b = tmp;
	tmp = a;
	a = c;
	c = tmp;
	printf("%d %d %d\n",a,b,c);
	return 0;
}


#include<stdio.h>

int main(){
    int X, Y, Z, Q;

    scanf("%d %d %d", &X, &Y, &Z);

    Q=X;
    X=Z;
    Z=Y;
    Y=Q;

    printf("%d %d %d\n", X, Y, Z);

return 0;

}


#include<stdio.h>
int main()
{
   int a[3],t,i;
    for(i=0;i<3;i++)
    {
        scanf("%d",&a[i]);
    }
    t=a[2];
    for(i=(3-1);i>0;i--)
    {
        a[i]=a[i-1];
    }
    a[0]=t;
    for(i=0;i<3;i++)
    {
        printf(" %d ",a[i]);
    }
    return 0;
}


#include<stdio.h>
int main()
{

	int A,B,C;
	scanf("%d,%d,%d",A,B,C);
	printf("%d %d %d",C,A,B);
	return 0;
}


#include<stdio.h>
int main()
{
	int a=0,b=0,c=0;
	while(scanf("%d %d %d",&a,&b,&c))
	{
		printf("%d %d %d",c,a,b);
		printf("\n");
	}
	return 0;
}


#include<stdio.h>

void swap(int *a,int *b);

int main(void){
  int a,b,c;
  scanf("%d %d %d",&a,&b,&c);

  swap(&a,&b);
  swap(&a,&c);
  printf("%d %d %d\n",a,b,c);
  return 0;
}

  void swap(int *a,int *b)
{
	　　int *temp;
	　　*temp = *a;
	　　*a = *b;
	　　*b = *temp;
	　　return;
}


function main(input) {
  const inputs = input.split('\n')
  const [X, Y, Z] = inputs[0].split(' ')
  // console.log(X, Y, Z)

  console.log(Z, X, Y)
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main (input) {
    var arr = input.split(' ');
    var ans = [];

    ans.push(arr[2], arr[0], arr[1]);

    console.log(ans.join(' '));

}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  input = input.split("\n");
  var x = Number(input[0].split(" ")[0]);
  var y = Number(input[0].split(" ")[1]);
  var z = Number(input[0].split(" ")[2]);

  console.log(z,x,y);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input)
{
  input = input.split(' ');
  let x = parseInt(input[0]);
  let y = parseInt(input[1]);
  let z = parseInt(input[2]);

  console.log(z+' '+x+' '+y);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input)
{
  input = input.split(' ');
  let x = parseInt(input[0]);
  let y = parseInt(input[1]);
  let z = parseInt(input[2]);

  console.log(z+' '+x+' '+y);
}


const main = input => {
  const [a0, b0, c0] = input.trim().split(" ").map(e => parseInt(e))
  return [c0, a0, b0].join(" ")
}

console.log(main(require('fs').readFileSync('/dev/stdin', 'utf8')));


package main

import (
	"fmt"
)

func main()  {
	var A int
	var B int
	var C int

	_, _ = fmt.Scan(&A, &B, &C)

	A, B = SwapNumbers(A, B)
	A, C = SwapNumbers(A, C)

	fmt.Println(A, B, C)
}

func SwapNumbers(num1 int, num2 int) (int, int){
	return num2, num1
}


package main

import (
  "fmt"
)

func main() {
  var x, y, z int
  fmt.Scan(&x, &y, &z)
  fmt.Println(z, x, y)
}


package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	var X int
	var Y int
	var Z int
	fmt.Scan(&X, &Y, &Z)
	fmt.Println(Z,X,Y)

}


x,y,z=map(int, input().split())

print(z,x,y)


package main

import (
	"fmt"
)

func main() {
  var x, y, z int
  fmt.Scanf("%d %d %d", &x, &y, &z)
  a := y
  b := x
  c := a
  a = c
  fmt.Println(a, b, c)

}


package main

import (
	"fmt"
)

func main() {
  var (
   x, y, z := int
  )
  fmt.Scanf("%d %d %d", &x, &y, &z)
  a := y
  b := x
  c := a
  a = c
  fmt.Println(a, b, c)

}


a, b, c = gets.split.map(&:to_i)
puts [c, a, b].join(' ')


a, b , c= gets.split.map(&:to_i)
a, b = b, a
a, c = c, a
puts "#{a} #{b} #{c}"


x,y,z=gets.chomp.split.map(&:to_i)
puts [z,x,y].join(" ")


a=gets.split
a.shift(a.pop)
puts a.join ' '


a=gets.chomp.split
puts a.shift(a.pop).join ' '


x,y,z = gets.chomp.split(' ').map(&:to_i)
puts y.to_s + " " + z.to_s + " " + x.to_s


use proconio::fastout;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;

#[fastout]
fn main() {
    input! {
        x: usize,
        y: usize,
        z: usize,
    }
    println!("{} {} {}", z, x, y);
}


fn main() {
    let v = read_vec::<usize>();

    println!("{} {} {}", v[2], v[0], v[1]);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}


use proconio::input;

fn main() {
    input! {
        x: usize,
        y: usize,
        z: usize,
    }

    solve(x, y, z);
}

fn solve(x: usize, y: usize, z: usize) {
    println!("{} {} {}", z, y, x);
}


use text_io::*;
use std::process::exit;

fn main() {
    let n:usize = read!();
    let mut divisors = Vec::new();
    let mut p:usize = 0;
    for i in 1..=(f64::sqrt(n as f64) + 1e-9) as usize {
        if n % i == 0 {
            divisors.push(i);
            if i != n / i {
                divisors.push(n / i);
            }
        }
    }
    for i in 0..divisors.len() {
        let mut o:usize = divisors[i];
        let mut nn:usize = n;
        let mut a:usize = 1;
        while a == 0{
            if nn % o == 0 {
                nn = nn/o;
                if nn == 1 {
                    p += 1;
                    a = 0;
                }else if nn < o {
                    a = 0;
                }
            }
            else if nn < o {
                a = 0;
            }
            else {
                nn = nn-o;
              if nn == 1 {
                    p += 1;
                    a = 0;
              }
            }
        }
    }
        for i in 1..=(f64::sqrt(n as f64) + 1e-9) as usize {
        if (n-1) % i == 0 {
            p += 1;
            if i != n / i {
                p += 1;
            }
        }
    }
    println!("{}",p+1);
}


// ABC Swap

func main() {
    let abc = readLine()!.split(separator: " ")
    print(abc[2], abc[0], abc[1])
}

main()


let XYZ: [Int] = readLine()!.split(separator: " ").map { Int($0)! }
print(XYZ[2], XYZ[0], XYZ[1])


let input = readLine()!
let splitInput = input.split(separator: " ")
var x = Int(splitInput[0])!
var y = Int(splitInput[1])!
var z = Int(splitInput[2])!

var tempX = x
x = y
y = tempX

tempX = x
x = z
z = tempX

print(x, y, z)


import Foundation

let a = readLine()
let b = readLine()
let c = readLine()

print(c)
print(a)
print(b)


import Foundation

let a = readLine()
let b = readLine()
let c = readLine()

var d = c + " " + a + " " + b
print(d)


import Foundation

let a = readLine()
let b = readLine()
let c = readLine()

print(c)
print(" ")
print(a)
print(" ")
print(b)


// inputに入力データ全体が入る
// @ts-ignore
const main = (input: string) => {
  const boxes = input.split(' ');

  // 1 - 2 exchange
  let tmp = [boxes[1], boxes[0], boxes[2]];

  // 1 - 3 exchange
  const tmp2 = [tmp[2], tmp[1], tmp[0]];

  console.log(tmp2.join(' '));
}

// *この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input) {
  const lines = input.split("\n");
  const [X, Y, Z] = lines[0].split(' ').map(Number);

  console.log([Z, X, Y].join(' '));
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));


import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");

const [a, b, c] = input[0].split(" ").map((x: string): number => +x);

console.log(`${c} ${a} ${b}`);


function Main(input: string) {
  const lines = input.split('\n');
  const params = lines[0].split('').map(x => parseInt(x));

  const x = params[0];
  const y = params[1];
  const z = params[2];

  const s = `${z} ${x} ${y}`;

  console.log(s);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input: string) {
  const lines = input.split('\n');
  const params = lines[0].split('').map(x => parseInt(x));

  const x = params[0];
  const y = params[1];
  const z = params[2];

  const s = [z, x, y].join(' ');

  console.log(s);
}

Main(require('fs').readFileSync('/dev/stdin', 'utf8'));


s = raw_input()
print (s).rindex('Z') - s.index('A') + 1


s = raw_input()
print s.rindex('Z') - s.index('A') + 1


s=input()
print(s.rfind('Z') - s.find('A') + 1)


s = list(input())

for i in s:
    if i == 'A':
        a = s.index(i)
        break
for i in s:
    if i == 'Z':
        z = s.index(i)
print(z-a+1)


s = input()
for i in range(len(s)):
    if s[i] == 'A':
        p = i
        break
for i in range(1,len(s)+1):
    if s[-i] == 'Z':
        q = i-1
print(len(s) -(p+q))


S = input()
len = len(S)
start = len
end = 0
for i in range(len):
  if(S[i] == "A"):
    temp_start = i+1
    start = min(start,temp_start)
  if(S[i] == "Z"):
    temp_end = i+1
    end = max(end,temp_end)
print(end-start)


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        int f = s.indexOf("A");
        int e = s.lastIndexOf("Z");
        System.out.println(e - f + 1);
    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{
    public static void main(String[] args)throws Exception {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String word = input.readLine();
        int start = -1, end = -1;
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'A'){
                start = i;
                break;
            }
        }

        for (int i = word.length() - 1; i > 0; i--) {
            if (word.charAt(i) == 'Z'){
                end = i;
                break;
            }
        }

        System.out.println(end - start + 1);
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args) throws IOException {
		new Main().solve();
	}

	private void solve() throws IOException {
		try {
			//			solveA();
			solveB();
			// solveC();
			// solveD();
			// solveE();
			// solveF();
		} finally {
			if (in != null) {
				in.close();
			}
			if (out != null) {
				out.flush();
				out.close();
			}
		}

	}

	private void solveA() {
		int numN = nextInt();
		if (numN < 1200) {
			out.print("ABC");
		} else {
			out.print("ARC");
		}

	}

	private void solveB() {
		String wk = next();

		int first = wk.indexOf("A");
		int last = wk.lastIndexOf("Z");

		String res = wk.substring(first, last + 1);

		out.println(res.length());
	}

	private void solveC() {
		int numN = nextInt();

		out.println("");
	}

	private void solveD() {
		int numN = nextInt();

		out.println("");
	}

	private void solveE() {
		int numN = nextInt();

		out.println("");
	}

	private void solveF() {
		int numN = nextInt();

		out.println("");
	}

	private final PrintWriter out = new PrintWriter(System.out);
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}
}


import java.util.Scanner;

public class AToZString {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String s=scan.nextLine();
		int c=-1,z=0;
		for(int i=0;i<s.length();i++) {
			if(s.charAt(i)=='A' && c==-1) {
				c=i;
			}
			if(s.charAt(i)=='Z') {
				z=i;
			}
		}
		System.out.println(z-c+1);
	}

}


import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		int a =0;
		for (;a<s.length();a++) {
			if (s.charAt(a)=='A') {
				break;
			}
		}
		for (int i=s.length()-1;i>=0;i--) {
			if (s.charAt(i)=='Z') {
				System.out.println(i-a);
				break;
			}
		}
	}
}


import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String str = sc.next();
		char[] chara = str.toCharArray();
		int a = 0;
		int z = 0;
		int ans = 0;

		for(int i=0; i<str.length(); i++){
		    if(chara[i]=='A'){
		        a = i;
		    }
		}

		for(int i=str.length()-1; i>=0; i--){
            if(chara[i]=='Z'){
                z = i;
            }
		}

		System.out.println(z-a+1);
	}
}


#include<stdio.h>

int main(void){
    int i,pa,pz,n;
    char s[200000],a = 'A',z = 'Z';

    scanf("%s",s);
    for(i = 0; s[i] != '\0'; i++);
    n = i;
    pz = n;
    for(i = 0; i < n; i++){
        if(s[i] == a){
        pa = i;
        break;
        }
    }
    for(i = n;i > 0;i--){
        if(s[i] == z){
            pz = i;
            break;
        }
    }
    n = pz - pa + 1;

    printf("%d",n);

    return 0;
}


#include <cstdio>
#include <cstring>

char s[200000 + 10];

int main()
{
    scanf("%s", s);
    int st, ed, n = strlen(s);
    for(st = 0; ; st++) if(s[st] == 'A') break;
    for(ed = n - 1; ; ed--) if(s[ed] == 'Z') break;
    printf("%d\n", ed - st + 1);
    return 0;
}


#include<cstdio>
#include<cstring>
int main(){
	char s[200001];
	int a,b;
	scanf("%s",s);
	int n = strlen(s);
	for(int i=0;i<n;i++){
		if(s[i]=='A'){
			a = i;
			break;
		}
	}
	for(int i=n-1;i>=0;i--){
		if(s[i]=='Z'){
			b = i;
			break;
		}
	}
	printf("%d\n",b-a+1);
}


#include <iostream>
#include <algorithm>
#include <string>
#include <cmath>

using namespace std;

int main(){
    int A,Z,a=0;
    string s;
    cin>>s;
    for(int i=0;i<s.size();i++){
        if(a==0&&s.at(i)=='A'){
            A=i;
            a=1;
        }else if(a<=i+1&&s.at(i)=='Z'){
            Z=i;
            a=i;
        }
    }
    cout<<Z-A+1<<"\n";
}


#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#include<string.h>
using namespace std;

int main(){
	std::ios_base::sync_with_stdio(0);
	cin.tie(NULL); int o;

	string s; cin >> s;
	int m = s.length(); int p = 0, k = 0;;
	int l=s.find("A");
	for (int i = l+1; i <m; i++){
		if (s[i] == 'A')k++;
		if (s[i] == 'Z' && s[i + 1] == 'Z'&&k!=0) {
			p = i;
			p++;
			break;
		}
		else if (s[i] == 'Z') {
			p = i;
			break;
		}
	}
	cout << (p - l)+1 << endl;
	return 0;
}


#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#include<string.h>
using namespace std;

int main(){
	std::ios_base::sync_with_stdio(0);
	cin.tie(NULL); int o;

	string s; cin >> s;
	int m = s.length(); int max = -2000, p = 0;
	int l=s.find("A");
	for (int i = l; i <=m; i++){
		if (s[i] == 'Z') {
			p = i;
			break;
		}
	}
	cout << (p - l)+1 << endl;
	return 0;
}

/*
#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#include<string.h>
using namespace std;

int main()
{
	std::ios_base::sync_with_stdio(0);
	cin.tie(NULL); int o;
	int n, tc, arr[10005]; cin >> tc; int k=0;
	while (tc--) {
		cin >> n;
		for (int i = 0; i < n; ++i)
			cin >> arr[i];

		for (int i = 0; i < n; i++){

			for (int j = i; j <n; j++){
				if (arr[i] > arr[j])
					cout << arr[i] << " ";
				else
					cout << arr[j] << " ";
			}

		}
		cout<<endl;
	}
	return 0;
}
*/


#include <stdio.h>
int main(){
  char s[200000];
  int i,j;
  scanf("%s",s);
  for(i=0;s[i]!='A';i++);
  for(j=strlen(s);s[j-1]!='Z';j--);
  printf("%d\n",j-i);
  return 0;
}


#include<stdio.h>
#include<string.h>
int main()
{
	int n,a,b,f=0,i;
	char s[200000];

	scanf("%s",s);

	n=strlen(s);
	for(i=0;i<n;i++)
		if(s[i]=='A'){
			a=i;
			f++;
			break;
		}
	for(i=n;i>a;i--)
		if(s[i]=='Z'){
			b=i;
			f++;
			break;
		}
	if(f==2)
		printf("%d",b-a+1);
	else
		puts(0);
	return 0;
}


#include<stdio.h>
#include<string.h>

int main(void)
{
  char s[250000];
  scanf("%s",s);
  int start=0;
  int end=strlen(s);
  while(s[start]!='A'){
    start++;
  }
  while(s[end]!='Z'){
    end--;
  }
  printf("%d\n",end-start+1);
  return 0;
}


#include<stdio.h>
#include<string.h>

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

    int max;
    for(int i=0;i<len;i++){
        if(s[i]=='A'){
            for(int j=len-1;j>i;j--){
                if(s[j]=='Z'){
                    max=j-i+1;
                }
            }
        }
    }
    printf("%d\n",max);
    return 0;
}


#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++){
        if(s[i]=='A'){
            for(int j=i+1;j<len;j++){
                if(s[j]=='Z'){
                    int temp=j-i+1;
                    if(temp>max){
                        max=temp;
                    }
                }
            }
        }
    }
    printf("%d\n",max);
    return 0;
}


#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;
}


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


'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"));


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 );
}


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'));


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'));


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


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


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...)
}


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


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)

}


#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";
}


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


S = gets.chomp
puts S.rindex('Z') - S.index('A') + 1


# https://atcoder.jp/contests/abc053/tasks/abc053_b

s = gets.chomp

puts s.rindex('Z') - s.index('A') + 1


s = gets.chomp

puts s.rindex("Z") - s.index("A") + 1


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


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


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);
}


//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//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()
    );
}


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);
}


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);
}


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);
}


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);
}


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)


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)


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)


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)


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)


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)


const log = console.log;

// ----

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

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


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

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


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


Main(input) {
	console.log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


Main(input) {
	console.log(input.lastIndexOf("Z") - input.indexOf("A") + 1);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8");


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)


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)


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


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


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)


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


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


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

}


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");
  }
}


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");
  }
}


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");
                }
        }
    }
}


#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;

}


#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;
}


#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;
}


#include<bits/stdc++.h>
using namespace std;

int main(){
  int X;
  cin >> X;
  X /= 200;
  cout << X << endl;
  return 0;
}


#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;
  }

}


#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;
  }

}


#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;
}


//set many funcs template
//Ver.20190820
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
#include<assert.h>
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384

int max(int a,int b){if(a>b){return a;}return b;}
int min(int a,int b){if(a<b){return a;}return b;}
int zt(int a,int b){return max(a,b)-min(a,b);}
int round(int a,int b){if((a%b)*2 >= b){return (a/b)+1;}return a/b;}
int ceil(int a,int b){if(a%b==0){return a/b;}return (a/b)+1;}
int gcd(int a,int b){int c;while(b!=0){c=a%b;a=b;b=c;}return a;}
int lcm(int a,int b){int c=gcd(a,b);a/=c;return a*b;}
int nCr(int a,int b){int i,r=1;for(i=1;i<=b;i++){r*=(a+1-i);r/=i;}return r;}
int nHr(int a,int b){return nCr(a+b-1,b);}
int fact(int a){int i,r=1;for(i=1;i<=a;i++){r*=i;}return r;}
int pow(int a,int b){int i,r=1;for(i=1;i<=b;i++){r*=a;}return r;}
int dsum(int x){int r=0;while(x){r+=(x%10);x/=10;}return r;}
int dsumb(int x,int b){int r=0;while(x){r+=(x%b);x/=b;}return r;}
int sankaku(int x){return ((1+x)*x)/2;}
void swap(int *a,int *b){int c;c=(*a);(*a)=(*b);(*b)=c;}
long long llmax(long long a,long long b){if(a>b){return a;}return b;}
long long llmin(long long a,long long b){if(a<b){return a;}return b;}
long long llzt(long long a,long long b){return llmax(a,b)-llmin(a,b);}
long long llround(long long a,long long b){if((a%b)*2 >= b){return (a/b)+1;}return a/b;}
long long llceil(long long a,long long b){if(a%b==0){return a/b;}return (a/b)+1;}
long long llgcd(long long a,long long b){long long c;while(b!=0){c=a%b;a=b;b=c;}return a;}
long long lllcm(long long a,long long b){long long c=llgcd(a,b);a/=c;return a*b;}
long long llnCr(long long a,long long b){long long i,r=1;for(i=1;i<=b;i++){r*=(a+1-i);r/=i;}return r;}
long long llnHr(long long a,long long b){return llnCr(a+b-1,b);}
long long llfact(long long a){long long i,r=1;for(i=1;i<=a;i++){r*=i;}return r;}
long long llpow(long long a,long long b){long long i,r=1;for(i=1;i<=b;i++){r*=a;}return r;}
long long lldsum(long long x){long long r=0;while(x){r+=(x%10);x/=10;}return r;}
long long lldsumb(long long x,long long b){long long r=0;while(x){r+=(x%b);x/=b;}return r;}
long long llsankaku(long long x){return ((1+x)*x)/2;}
void llswap(long long *a,long long *b){long long c;c=(*a);(*a)=(*b);(*b)=c;}
double dbmax(double a,double b){if(a>b){return a;}return b;}
double dbmin(double a,double b){if(a<b){return a;}return b;}
double dbzt(double a,double b){return dbmax(a,b)-dbmin(a,b);}
void dbswap(double *a,double *b){double c;c=(*a);(*a)=(*b);(*b)=c;}
void chswap(char *a,char *b){char c;c=(*a);(*a)=(*b);(*b)=c;}
int sortfncsj(const void *a,const void *b){if(*(int *)a>*(int *)b){return 1;}if(*(int *)a==*(int *)b){return 0;}return -1;}
int sortfnckj(const void *a,const void *b){if(*(int *)a<*(int *)b){return 1;}if(*(int *)a==*(int *)b){return 0;}return -1;}
int llsortfncsj(const void *a,const void *b){if(*(long long *)a>*(long long *)b){return 1;}if(*(long long *)a==*(long long *)b){return 0;}return -1;}
int llsortfnckj(const void *a,const void *b){if(*(long long *)a<*(long long *)b){return 1;}if(*(long long *)a==*(long long *)b){return 0;}return -1;}
int dbsortfncsj(const void *a,const void *b){if(*(double *)a>*(double *)b){return 1;}if(*(double *)a==*(double *)b){return 0;}return -1;}
int dbsortfnckj(const void *a,const void *b){if(*(double *)a<*(double *)b){return 1;}if(*(double *)a==*(double *)b){return 0;}return -1;}
int strsortfncsj(const void *a,const void *b){return strcmp((char *)a,(char *)b);}
int strsortfnckj(const void *a,const void *b){return strcmp((char *)b,(char *)a);}
int chsortfncsj(const void *a,const void *b){if(*(char *)a>*(char *)b){return 1;}if(*(char *)a==*(char *)b){return 0;}return -1;}
int chsortfnckj(const void *a,const void *b){if(*(char *)a<*(char *)b){return 1;}if(*(char *)a==*(char *)b){return 0;}return -1;}

void shuffledget(int x[],int n){
    int i,b[524288],p,c;
    for(i=0;i<n;i++){
        b[i]=i;
    }
    for(i=n;i>=1;i--){
        p=rand()%i;
        c=b[i-1];b[i-1]=b[p];b[p]=c;
    }
    for(i=0;i<n;i++){
        scanf("%d",&x[b[i]]);
    }
}

int dx4[4]={1,-1,0,0};
int dy4[4]={0,0,1,-1};
int dx8[8]={-1,-1,-1,0,0,1,1,1};
int dy8[8]={-1,0,1,-1,1,-1,0,1};

int search(int x,int a[],int n){
    int st=0,fi=n-1,te;
    while(st<=fi){
        te=(st+fi)/2;
        if(a[te]<x){st=te+1;}else{fi=te-1;}
    }
    return st;
}

void prarr(int arr[],int n){
  int i;
  for(i=0;i<n;i++){
    if(i){printf(" ");}
    printf("%d",arr[i]);
  }
  printf("\n");
  return;
}

void getperm(int a[],int n){
  int i,p;
  for(i=0;i<n;i++){
    a[i]=i;
  }
  for(i=n-1;i>=1;i--){
    p=rand()%(i+1);
    swap(&a[p],&a[i]);
  }
}

typedef struct{
int val;
int node;
}sd;

int sdsortfnc(const void *a,const void *b){
if(((sd*)a)->val < ((sd*)b)->val){return -1;}
if(((sd*)a)->val > ((sd*)b)->val){return 1;}
return 0;
}

void coordinate_comp(int a[],int n){
  int i,c=0;
  sd dat[524288];
  for(i=0;i<n;i++){
    dat[i].val=a[i];
    dat[i].node=i;
  }
  qsort(dat,n,sizeof(dat[0]),sdsortfnc);
  a[dat[0].node]=c;
  for(i=1;i<n;i++){
    if(dat[i-1].val!=dat[i].val){c++;}
    a[dat[i].node]=c;
  }
}

int main(void){
  int i,j,n,m,k,a[524288],b,c,h,w,r=0,l,t;
  scanf("%d",&n);
  n-=400;n/=200;
  printf("%d\n",8-n);
  return 0;
}


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");
}


#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;
}


#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;

}


#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;

}


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"));


// 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"));


'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'));


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'));


// 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"));


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;
    }
}


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
}


/*
URL:
https://atcoder.jp/contests/m-solutions2020/tasks/m_solutions2020_a
*/

package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
)

/********** FAU standard libraries **********/

//fmt.Sprintf("%b\n", 255) 	// binary expression

/********** I/O usage **********/

//str := ReadString()
//i := ReadInt()
//X := ReadIntSlice(n)
//S := ReadRuneSlice()
//a := ReadFloat64()
//A := ReadFloat64Slice(n)

//str := ZeroPaddingRuneSlice(num, 32)
//str := PrintIntsLine(X...)

/*******************************************************************/

const (
	// General purpose
	MOD = 1000000000 + 7
	// MOD          = 998244353
	ALPHABET_NUM = 26
	INF_INT64    = math.MaxInt64
	INF_BIT60    = 1 << 60
	INF_INT32    = math.MaxInt32
	INF_BIT30    = 1 << 30
	NIL          = -1

	// for dijkstra, prim, and so on
	WHITE = 0
	GRAY  = 1
	BLACK = 2
)

func init() {
	// bufio.ScanWords <---> bufio.ScanLines
	ReadString = newReadString(os.Stdin, bufio.ScanWords)
	stdout = bufio.NewWriter(os.Stdout)
}

var (
	x int
)

func main() {
	x = ReadInt()

	q := x / 200
	fmt.Println(10 - q)
}

func solve() {
}

/*******************************************************************/

/*********** I/O ***********/

var (
	// ReadString returns a WORD string.
	ReadString func() string
	stdout     *bufio.Writer
)

func newReadString(ior io.Reader, sf bufio.SplitFunc) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+9)) // for Codeforces
	r.Split(sf)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}

// ReadInt returns an integer.
func ReadInt() int {
	return int(readInt64())
}
func ReadInt2() (int, int) {
	return int(readInt64()), int(readInt64())
}
func ReadInt3() (int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64())
}
func ReadInt4() (int, int, int, int) {
	return int(readInt64()), int(readInt64()), int(readInt64()), int(readInt64())
}

// ReadInt64 returns as integer as int64.
func ReadInt64() int64 {
	return readInt64()
}
func ReadInt64_2() (int64, int64) {
	return readInt64(), readInt64()
}
func ReadInt64_3() (int64, int64, int64) {
	return readInt64(), readInt64(), readInt64()
}
func ReadInt64_4() (int64, int64, int64, int64) {
	return readInt64(), readInt64(), readInt64(), readInt64()
}

func readInt64() int64 {
	i, err := strconv.ParseInt(ReadString(), 0, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// ReadIntSlice returns an integer slice that has n integers.
func ReadIntSlice(n int) []int {
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt()
	}
	return b
}

// ReadInt64Slice returns as int64 slice that has n integers.
func ReadInt64Slice(n int) []int64 {
	b := make([]int64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt64()
	}
	return b
}

// ReadFloat64 returns an float64.
func ReadFloat64() float64 {
	return float64(readFloat64())
}

func readFloat64() float64 {
	f, err := strconv.ParseFloat(ReadString(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// ReadFloatSlice returns an float64 slice that has n float64.
func ReadFloat64Slice(n int) []float64 {
	b := make([]float64, n)
	for i := 0; i < n; i++ {
		b[i] = ReadFloat64()
	}
	return b
}

// ReadRuneSlice returns a rune slice.
func ReadRuneSlice() []rune {
	return []rune(ReadString())
}

/*********** Debugging ***********/

// ZeroPaddingRuneSlice returns binary expressions of integer n with zero padding.
// For debugging use.
func ZeroPaddingRuneSlice(n, digitsNum int) []rune {
	sn := fmt.Sprintf("%b", n)

	residualLength := digitsNum - len(sn)
	if residualLength <= 0 {
		return []rune(sn)
	}

	zeros := make([]rune, residualLength)
	for i := 0; i < len(zeros); i++ {
		zeros[i] = '0'
	}

	res := []rune{}
	res = append(res, zeros...)
	res = append(res, []rune(sn)...)

	return res
}

// Strtoi is a wrapper of strconv.Atoi().
// If strconv.Atoi() returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

// PrintIntsLine returns integers string delimited by a space.
func PrintIntsLine(A ...int) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.Itoa(A[i])
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintIntsLine returns integers string delimited by a space.
func PrintInts64Line(A ...int64) string {
	res := []rune{}

	for i := 0; i < len(A); i++ {
		str := strconv.FormatInt(A[i], 10) // 64bit int version
		res = append(res, []rune(str)...)

		if i != len(A)-1 {
			res = append(res, ' ')
		}
	}

	return string(res)
}

// PrintfDebug is wrapper of fmt.Fprintf(os.Stderr, format, a...)
func PrintfDebug(format string, a ...interface{}) {
	fmt.Fprintf(os.Stderr, format, a...)
}

// PrintfBufStdout is function for output strings to buffered os.Stdout.
// You may have to call stdout.Flush() finally.
func PrintfBufStdout(format string, a ...interface{}) {
	fmt.Fprintf(stdout, format, a...)
}


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
	}
}


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")
	}
}


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)

	}
}


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
		}
	}

}


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


# 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


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__


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


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


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


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");
    }
}


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"),
        }
    );
}


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);
}


#![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);
}


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


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


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


var x = Int(readLine()!)!
var kyu = 8
while x>600{
	x -= 200
	kyu -= 1
}

print(kyu)


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

    }

}


//0:実行モード
//1:開発モード
//2:最終テストモード
const sys_debugMode : number = 0;

function chk(in_data1 : any, in_data2? : any) : void{
	if (sys_debugMode == 0 || sys_debugMode == 2){
		return;
	}
	else if (in_data2 === undefined){
		console.log(in_data1);
	}
	else{
		console.log(in_data1 + "[" + typeof(in_data2) + "] =", in_data2);
	}
}

function prt(in_data : any) : void{
	console.log(in_data);
}

class ParamManager {

	private a_s_inputLines : string[];
	private n_maxLine : number;
	private n_nowLineCnt : number;

	constructor(){
		this.a_s_inputLines = this.inputLines();
		this.n_maxLine = this.a_s_inputLines.length;
		this.descLines();
		this.n_nowLineCnt = 1;
	}
	inputLines(){
		const fs = require('fs');

		let text;
		if(sys_debugMode == 0){
			text = fs.readFileSync("/dev/stdin", 'utf8');
		}
		else{
			text = fs.readFileSync("input.txt", 'utf8');
		}

		const line:string[] = text.toString().replace(/\r/g, "").split('\n');

		return line;
	}
	descLines(){
		chk("ParamManager.a_s_inputLines", this.a_s_inputLines);
	}
	getNextLine(in_s_type?):any{
		if (this.n_nowLineCnt > this.n_maxLine){
			chk("ParamManager.getNextLine","No Next Line!");
			return;
		}
		const s_returnLine:string = this.a_s_inputLines[this.n_nowLineCnt - 1];

		this.n_nowLineCnt++;

		if (in_s_type == "n"){
			return parseInt(s_returnLine);
		}
		else if (in_s_type == "a"){
			return s_returnLine.split(" ");
		}
		else if (in_s_type == "an"){
			const a_s_temp = s_returnLine.split(" ");
			const a_n_temp = a_s_temp.map(function(str){return Number(str)});
			return a_n_temp;
		}
		else{
			return s_returnLine;
		}
	}
}
const paramManager = new ParamManager();
//==================================================
//A - Kyu in AtCoder
//M 君は AtCoder に参加している選手の  1  人です。彼の最高レーティングは  X  です。
//M 君は何級を持っていますか。
//==================================================
class Param{
	maxRating:number = null;

	constructor(){
		chk("--------------------------------------------------");
		chk("パラメータ");
		//彼の最高レーティングはX
		//400 ≤ X ≤ 1999
		//Xは整数
		this.maxRating = paramManager.getNextLine("n");

		chk(this);
	}
}
const param = new Param();
//==================================================
class Kyuu{
	ratingFrom:number	= null;
	rationTo:number 	= null;
	kyuu:number 		= null;
}
//==================================================
class Manager{
	aKyuu:Kyuu[] = [];

	constructor(){
		this.main();
	}

	main():void{
		chk("--------------------------------------------------");
		chk("main");

		this.makeKyuu();

		this.resultOutput();
	}

	makeKyuu():void{
		chk("--------------------------------------------------");
		chk("makeKyuu");
		//400   以上  599   以下： 8  級
		let k = new Kyuu();
		k.ratingFrom	= 400;
		k.rationTo		= 599;
		k.kyuu			= 8;
		this.aKyuu.push(k);

		//600   以上  799   以下： 7  級
		k = new Kyuu();
		k.ratingFrom	= 600;
		k.rationTo		= 799;
		k.kyuu			= 7;
		this.aKyuu.push(k);

		//800   以上  999   以下： 6  級
		k = new Kyuu();
		k.ratingFrom	= 800;
		k.rationTo		= 999;
		k.kyuu			= 6;
		this.aKyuu.push(k);

		//1000  以上  1199  以下： 5  級
		k = new Kyuu();
		k.ratingFrom	= 1000;
		k.rationTo		= 1199;
		k.kyuu			= 5;
		this.aKyuu.push(k);

		//1200  以上  1399  以下： 4  級
		k = new Kyuu();
		k.ratingFrom	= 1200;
		k.rationTo		= 1399;
		k.kyuu			= 4;
		this.aKyuu.push(k);

		//1400  以上  1599  以下： 3  級
		k = new Kyuu();
		k.ratingFrom	= 1400;
		k.rationTo		= 1599;
		k.kyuu			= 3;
		this.aKyuu.push(k);

		//1600  以上  1799  以下： 2  級
		k = new Kyuu();
		k.ratingFrom	= 1600;
		k.rationTo		= 1799;
		k.kyuu			= 2;
		this.aKyuu.push(k);

		//1800  以上  1999  以下： 1  級
		k = new Kyuu();
		k.ratingFrom	= 1800;
		k.rationTo		= 1999;
		k.kyuu			= 1;
		this.aKyuu.push(k);

		chk('this.aKyuu',this.aKyuu);
	}

	resultOutput():void{
		chk("--------------------------------------------------");
		chk("resultOutput");
		//M 君が持っている級を整数として出力してください。
		//例えば  8  級の場合は 8 と出力してください。

		const kyuu = this.aKyuu.find(item => {
			return item.ratingFrom <= param.maxRating && param.maxRating <= item.rationTo;
		});
		chk('kyuu',kyuu);

		const resultKyuu:number = kyuu.kyuu;

		prt(resultKyuu);
	}

}
const manager = new Manager();
//==================================================


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


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);
  }
}


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


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")));


def solve(string):
    return str(int(string)**2)

if __name__ == '__main__':
    print(solve(input()))


r = int(input())
print(r**2)


r = int(input())
print( r ** 2)


r = int(input("long?"))
a = int(r^2)
print(a)


r = int(input("long?"))

print(r * r)


r = int(input("long?"))

return r * r


import java.io.*;
import java.util.*;
import java.math.*;
// import java.awt.Point;

public class Main {
    InputStream is;
    PrintWriter out;
    String INPUT = "";

    // static int mod = 1_000_000_007;
    int mod = 998244353;
    // long inf = Long.MAX_VALUE/2;
    int inf = Integer.MAX_VALUE/2;

    void solve(){
        int n = ni();
        out.println(n*n);
    }

    void run() throws Exception
    {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    }

    public static void main(String[] args) throws Exception { new Main().run(); }

    private byte[] inbuf = new byte[1024];
    private int lenbuf = 0, ptrbuf = 0;

    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b) && b != ' ')){
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m)
    {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private int ni()
    {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private static void tr(Object... o) { System.out.println(Arrays.deepToString(o)); }

}


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);
    }

}


import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.NoSuchElementException;

public class Main {
	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int r = sc.nextInt();
		int ans = r * r;
		System.out.println(ans);
	}

	public static long gcd(long a, long b) {
		long remainder = a % b;
		if (remainder == 0) {
			return b;
		} else {
			return gcd(b, remainder);
		}
	}
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}


int main(int r){
	int value = r*r;
	return value;
}


#include <iostream>
using namespace std;

int main() {
    int r;
    cin >> r;
    cout << r * r << endl;
    return 0;
}


class Main{
  public static void main(String[] args){

Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
 System.out.println(a*a);
  }
}


#include<stdio.h>

int main()
{
  int r;
  scanf("%d",&r);

  r=r*r;

  printf("%d\n",r);

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define sz(x) ((int)(x).size())
#define in(x) int x;cin>>x
#define in2(x, y) int x,y;cin>>x>>y
#define bit(n) (1<<(n))

#define out(x) cout<<(x)<<endl;
#define err(x) cerr<<(x)<<endl;
#define errr(x,y) cerr<<(x)<<" "<<(y)<<endl;

#define rep(i,n) for (int i=0;i<(n);i++)
#define repp(i,n) for (int i=1;i<=(n);i++)

#define lim5 100002
#define lim9 1000000002

#define deg(rad) (((rad)/2/M_PI)*360)

int main() {
	in(r);

	cout << r * r << endl;

	return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
	int r;
	cin >> r;
	cout << r*r;
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
// #include <atcoder/all>
// using namespace atcoder;

typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<P,ll> PLL;
typedef pair<P,P> PP;
typedef vector<ll> llVEC;
typedef vector<P> PVEC;
typedef priority_queue<P,PVEC,greater<P> > PPQ;
typedef priority_queue<ll, llVEC, greater<ll> > llPQ;

#define rep(i,a,n) for(ll i = a;i < n;i++)
#define rrep(i,a,n) for(ll i = n-1; i >= a;i--)
#define LINF (ll)1e18
#define INF (int)1e9
#define fs first
#define sc second

template<typename T>
ll sz(vector<T> &vec){ return (ll)vec.size(); }
template<typename T>
ll sz(priority_queue<T, vector<T>> &pq) {return (ll)pq.size(); }
template<typename T>
ll sz(priority_queue<T, vector<T>, greater<T>> &pq) {return (ll)pq.size(); }
ll sz(string &s) {return (ll)s.size(); }
ll gcd(ll a,ll b){ return ((!b) ?a :gcd(b, a%b)); }
ll lcm(ll a,ll b){ return a / gcd(a,b) * b; }
bool checkindex(ll i,ll n){ return (i < n && i >= 0); }

int main(){
    ll n,t;
    cin >> n >> t;
    ll a[n],b[n];
    rep(i,0,n) cin >> a[i] >> b[i];
    ll dp[2][n+1][t];
    rep(i,0,2) rep(j,0,n+1) rep(k,0,t) dp[i][j][k] = 0;

    rep(i,0,n){
        rep(j,0,t){
            // 0 -> 0
            dp[0][i+1][j] = max(dp[0][i+1][j],dp[0][i][j]);
            if(j+a[i] < t) dp[0][i+1][j+a[i]] = max(dp[0][i+1][j+a[i]],dp[0][i][j]+b[i]);

            // 1 -> 1
            dp[1][i+1][j] = max(dp[1][i+1][j],dp[1][i][j]);
            if(j+a[i] < t) dp[1][i+1][j+a[i]] = max(dp[1][i+1][j+a[i]],dp[1][i][j]+b[i]);

            // 0 -> 1
            dp[1][i+1][j] = max(dp[1][i+1][j],dp[0][i][j]+b[i]);
        }
    }

    ll ans = 0;
    rep(i,0,t){
        ans = max(ans,dp[1][n][i]);
    }
    cout << ans << endl;

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
  int r;
  cin<< r;
  cout << r*r << endl;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
  cin<< r;
  cout << r*r << endl;
}


#include<stdio.h>
//UG02-47-18-020

int main()
{
    int n;

    scanf("%d",&n);

    printf("%d\n",n*n);

    return 0;

}


#include<stdio.h>
int main(void){
  int a;
  scanf("%d",&a);
  printf("%d",a*a);
  return 0;
}


#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <stdlib.h>
int main(void){
int a;
int b;
scanf("%d",&a);
b = a*a;
printf("%d",b);
return 0;
}


#include<stdio.h>

int main(void) {
	int r;
	float cir, cir_;

	scanf_s("%d", &r);

	printf("%d", r*r);

	return 0;

}


#include<stdio.h>

int main(void) {
	int r;
	float cir, cir_;

	scanf("%d", &r);

	cir = r * r * 3.14;
	cir_ = 3.14;

	int  res = cir / cir_;

	printf("%d", res);

	return 0;

}


#include<stdio.h>
int main(void) {
	int r;
	float cir, cir_;

	scanf("%d", &r);

	cir = r * r * 3.14;
	cir_ = 3.14;

	int  res = cir / cir_;

	printf("%d", res);

	return 0;

}


// parameter "input" gets all data
function Main(input) {
	// the first line is assigned to input[0], the second line is assigned to input[1] similarly.
	input = input.split("\n");
	var a = parseInt(input[0], 10);
	//output
	console.log('%d',a*a);
}
// Don't edit this line!
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  	var times = parseInt(input, 10) * parseInt(input, 10);
  	console.log('%d', times);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
	input = input.split("\n");
	var r = parseInt( input,10 );

	console.log('%d', r*r);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


let a = r;
return a*a;


'use strict'

function main(s) {

  const n = Number(s[0]);
  const circle = n * n;
  console.log(circle);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {

	console.log(x * x);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

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

func solve() {
	r := getInt()

	ans := pow(r, 2)
	fmt.Fprintln(wr, ans)
}

func pow(a, b int) int {
	ret := 1
	for i := 0; i < b; i++ {
		ret *= a
	}
	return ret
}

// -----------------------------------------

const (
	inf = 1 << 60
	// mod = 1000000007
)

var (
	sc = bufio.NewScanner(os.Stdin)
	wr = bufio.NewWriter(os.Stdout)
)

func main() {
	maxBufSize := int(1e8)
	sc.Buffer(make([]byte, 4096), maxBufSize)
	sc.Split(bufio.ScanWords)
	solve()
	wr.Flush()
}

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

func getIntSlice(n int) (ret []int) {
	ret = make([]int, n)
	for i := range ret {
		ret[i] = getInt()
	}
	return
}

func getString() (ret string) {
	sc.Scan()
	ret = sc.Text()
	return
}

func getRunes() (ret []rune) {
	ret = []rune(getString())
	return
}


package main

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

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

var sc = bufio.NewScanner(os.Stdin)

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

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)

	r := getInt()

	out(r * r)
}


package main

import "fmt"

func main() {
	var r int
	fmt.Scan(&r)
	fmt.Println(r * r)
}


package main

import "fmt"

func main()  {
	var r int
	fmt.Scan(&r)
	fmt.println(r * r)
}


package main

import "fmt"

func main()  {
	var r int
	fmt.Scan(&r)
	println(r * r)
}


package main

import (
	"fmt"
	"math"
)

func main() {
	var r float64

	fmt.Scanf("%g", &r)

	c := r * r * math.Pi
	d := 1 * 1 * math.Pi
	fmt.Println(c / d)
}


r = gets.chomp.to_i

puts r*r


puts (gets.to_i) ** 2


# frozen_string_literal: true

r = gets.to_i
puts r*r


puts gets.to_i **2


r = gets.to_i

puts r^2


def circle(r)
  put r ** 2
end
circle(r)


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

fn read<T: FromStr>() -> Option<T> {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

fn main() {
    let r: usize = read().unwrap();
    println!("{}", r * r);
}


use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let r: i32 = match buf.trim().to_string().parse() {
		Ok(n) => n,
		_ => panic!(""),
	};
	println!("{}", r*r);
}


/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
/* }}} */

fn main() {
    input! {
        n: u32
    }
    println!("{}", n.pow(2));
}
/* vim:set foldmethod=marker: */