import java.awt.Checkbox;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {
	static ArrayList<Edge> adj[];
	static PrintWriter out = new PrintWriter(System.out);
	public static long mod;

	static int [][]notmemo;
	static int k;
	static int a[];
	static int b[];
	static int m;
	static char c[];

	static class Pair implements Comparable<Pair>{
    	int x;
    	int y;
    	public Pair(int a,int b) {
		x=a;
		y=b;

    	}
		@Override
		public int compareTo(Pair o) {
			if(x!=o.x)
			return x-o.x;
			return y-o.y;
		}

    }
    static Pair s1[];
    static int s[];
	private static HashSet<Integer> set1[];
	public static void main(String args[]) throws IOException {
		Scanner sc = new Scanner(System.in);

	System.out.println("NO");

		out.flush();
	}

	private static boolean check(String s) {
		char c1[]=s.toCharArray();
		for (int i = 0; i < c1.length; i++) {
			if(c[i]>c1[i]) {
				return true;
			}
			 if(c[i]<c1[i])
				return false;
		}
		return true;
	}

	static long dijkstra(int S, int T)	//O(E log E)
	{
		long[] dist = new long[V];
		Arrays.fill(dist, (int) 1e9);
		PriorityQueue<Edge> pq = new PriorityQueue<Edge>();
		dist[S] = 0;
		pq.add(new Edge(S, 0));						//may add more in case of MSSP (Mult-Source)
		while(!pq.isEmpty())
		{
			Edge cur = pq.remove();
			if(cur.node == T)						//remove if all computations are needed
				return dist[T];
			if(cur.cost > dist[cur.node])			//lazy deletion
				continue;
			for(Edge nxt: adj[cur.node])
				if(cur.cost + nxt.cost < dist[nxt.node])
					pq.add(new Edge(nxt.node, dist[nxt.node] = cur.cost + nxt.cost ));
		}
		return -1;
	}
	static class Edge implements Comparable<Edge>
	{
		int node;long cost;

		Edge(int a, long b) { node = a;	cost = b; }

		public int compareTo(Edge e){ return Long.compare(cost,e.cost);	}
	}

    static int dp(int idx,int state) {
      if(idx==n) {
    	  return 0;
      }
      if(notmemo[idx][state]!=-1) {
    	  return notmemo[idx][state];
      }
     int take=0; int leave=0;int leaveall=0;
      if(a[idx]==1&&(state==1||state==0)) {
    	take=1+dp(idx+1,1);
      }
      if(a[idx]==0&&state==0) {
    	 leave=1+dp(idx+1,state);
      }
      leaveall=dp(idx+1,state);

      return notmemo[idx][state]=Math.max(take,Math.max(leaveall,leave));
    }
        static void sieve(int N)	// O(N log log N)
	{
		isComposite = new int[N+1];
		isComposite[0] = isComposite[1] = 1;			// 0 indicates a prime number
		primes = new ArrayList<Integer>();

		for (int i = 2; i <= N; ++i) 					//can loop till i*i <= N if primes array is not needed O(N log log sqrt(N))
			if (isComposite[i] == 0) 					//can loop in 2 and odd integers for slightly better performance
			{
				primes.add(i);
				if(1l * i * i <= N)
					for (int j = i * i; j <= N; j += i)	// j = i * 2 will not affect performance too much, may alter in modified sieve
						isComposite[j] = 1;
			}
	}
    static TreeSet<Integer> factors;
    static ArrayList<Integer> primeFactors(int N)		// O(sqrt(N) / ln sqrt(N))
	{
		ArrayList<Integer> factors = new ArrayList<Integer>();		//take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while(1l*p * p <= N)
		{
			while(N % p == 0) { factors.add(p); N /= p; }
			p = primes.get(++idx);
		}

		if(N != 1)						// last prime factor may be > sqrt(N)
			factors.add(N);				// for integers whose largest prime factor has a power of 1
		return factors;
	}

    static String y;
    	static int nomnom[];
	static long fac[];

	static class book implements Comparable<book> {
		int idx;
		long score;

		public book(int i, long s) {
			idx = i;
			score = s;
		}

		public int compareTo(book o) {
			return (int) (o.score - score);
		}
	}

	static class library implements Comparable<library> {
		int numofbooks;
		int signup;
		int shiprate;
		int idx;

		public library(int a, int b, int c, int idx) {
			numofbooks = a;
			signup = b;
			shiprate = c;
			this.idx = idx;
		}

		@Override
		public int compareTo(library o) {
		if(signup==o.signup) {
			  return o.numofbooks-numofbooks;
		}
		return signup - o.signup;

		}
	}

	static boolean isOn(int S, int j) {
		return (S & 1 << j) != 0;
	}

	static boolean f = true;

	static class SegmentTree { // 1-based DS, OOP

		int N; // the number of elements in the array as a power of 2 (i.e. after padding)
		int[] array, sTree, lazy;

		SegmentTree(int[] in) {
			array = in;
			N = in.length - 1;
			sTree = new int[N << 1]; // no. of nodes = 2*N - 1, we add one to cross out index zero
			lazy = new int[N << 1];
			//build(1, 1, N);
		}

		void build(int node, int b, int e) // O(n)
		{
			if (b == e)
				sTree[node] = array[b];
			else {
				int mid = b + e >> 1;
				build(node << 1, b, mid);
				build(node << 1 | 1, mid + 1, e);
				sTree[node] = sTree[node << 1] + sTree[node << 1 | 1];
			}
		}

		void update_point(int index, int val) // O(log n)
		{
			index += N - 1;
			sTree[index] = val;
			while(index>1)
			{
				index >>= 1;
				sTree[index] = Math.max(sTree[index<<1] ,sTree[index<<1|1]);
			}
		}

		void update_range(int i, int j, int val) // O(log n)
		{
			update_range(1, 1, N, i, j, val);
		}

		void update_range(int node, int b, int e, int i, int j, int val) {
			if (i > e || j < b)
				return;
			if (b >= i && e <= j) {
				sTree[node] += (e - b + 1) * val;
				lazy[node] += val;
			} else {
				int mid = b + e >> 1;
				propagate(node, b, mid, e);
				update_range(node << 1, b, mid, i, j, val);
				update_range(node << 1 | 1, mid + 1, e, i, j, val);
				sTree[node] = sTree[node << 1] + sTree[node << 1 | 1];
			}

		}

		void propagate(int node, int b, int mid, int e) {
			lazy[node << 1] += lazy[node];
			lazy[node << 1 | 1] += lazy[node];
			sTree[node << 1] += (mid - b + 1) * lazy[node];
			sTree[node << 1 | 1] += (e - mid) * lazy[node];
			lazy[node] = 0;
		}

		int query(int i, int j) {
			return query(1, 1, N, i, j);
		}

		int query(int node, int b, int e, int i, int j) // O(log n)
		{
			if (i > e || j < b)
				return 0;
			if (b >= i && e <= j)
				return sTree[node];
			int mid = b + e >> 1;
			// propagate(node, b, mid, e);
			int q1 = query(node << 1, b, mid, i, j);
			int q2 = query(node << 1 | 1, mid + 1, e, i, j);
			return Math.max(q1,q2);

		}
	}

	static int memo[];

	static class UnionFind {
		int[] p, rank, setSize;
		int numSets;
		int max[];

		public UnionFind(int N) {
			p = new int[numSets = N];
			rank = new int[N];
			setSize = new int[N];
			for (int i = 0; i < N; i++) {
				p[i] = i;
				setSize[i] = 1;
			}
		}

		public int findSet(int i) {
			return p[i] == i ? i : (p[i] = findSet(p[i]));
		}

		public boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}

		public void unionSet(int i, int j) {
			if (isSameSet(i, j))
				return;
			numSets--;
			int x = findSet(i), y = findSet(j);
			if (rank[x] > rank[y]) {
				p[y] = x;
				setSize[x] += setSize[y];

			} else {
				p[x] = y;
				setSize[y] += setSize[x];
				if (rank[x] == rank[y])
					rank[y]++;

			}
		}

		public int numDisjointSets() {
			return numSets;
		}

		public int sizeOfSet(int i) {
			return setSize[findSet(i)];
		}
	}

	/**
	 * private static void trace(int i, int time) { if(i==n) return;
	 *
	 *
	 * long ans=dp(i,time);
	 * if(time+a[i].t<a[i].burn&&(ans==dp(i+1,time+a[i].t)+a[i].cost)) {
	 *
	 * trace(i+1, time+a[i].t);
	 *
	 * l1.add(a[i].idx); return; } trace(i+1,time);
	 *
	 * }
	 **/

	static class incpair implements Comparable<incpair> {
		int a;
		long b;
		int idx;

		incpair(int a, long dirg, int i) {
			this.a = a;
			b = dirg;
			idx = i;
		}

		public int compareTo(incpair e) {
			return (int) (b - e.b);
		}
	}

	static class decpair implements Comparable<decpair> {
		int a;
		long b;
		int idx;

		decpair(int a, long dirg, int i) {
			this.a = a;
			b = dirg;
			idx = i;
		}

		public int compareTo(decpair e) {
			return (int) (e.b - b);
		}
	}

	static long allpowers[];

	static class Quad implements Comparable<Quad> {
		int u;
		int v;
		char state;
		int turns;

		public Quad(int i, int j, char c, int k) {
			u = i;
			v = j;
			state = c;
			turns = k;
		}

		public int compareTo(Quad e) {
			return (int) (turns - e.turns);
		}

	}

	static long dirg[][];
	static Edge[] driver;

	static int n;

	static long manhatandistance(long x, long x2, long y, long y2) {
		return Math.abs(x - x2) + Math.abs(y - y2);
	}

	static long fib[];

	static long fib(int n) {
		if (n == 1 || n == 0) {
			return 1;
		}
		if (fib[n] != -1) {
			return fib[n];
		} else
			return fib[n] = ((fib(n - 2) % mod + fib(n - 1) % mod) % mod);
	}

	static class Point  implements Comparable<Point>{
		long x, y;

		Point(long counth, long counts) {
			x = counth;
			y = counts;
		}

		@Override
		public int compareTo(Point p )
		{
			return Long.compare(p.y*1l*x, p.x*1l*y);
		}

	}

	static long[][] comb;

	static class Triple implements Comparable<Triple> {

		int l;
		int r;
		long cost;
		int idx;

		public Triple(int a, int b, long l1, int l2) {
			l = a;
			r = b;
			cost = l1;
			idx = l2;
		}

		public int compareTo(Triple x) {
			if (l != x.l || idx == x.idx)
				return l - x.l;
			return -idx;
		}

	}

	static TreeSet<Long> primeFactors(long N) // O(sqrt(N) / ln sqrt(N))
	{
		TreeSet<Long> factors = new TreeSet<Long>(); // take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while (p * p <= N) {
			while (N % p == 0) {
				factors.add((long) p);
				N /= p;
			}
			if (primes.size() > idx + 1)
				p = primes.get(++idx);
			else
				break;
		}

		if (N != 1) // last prime factor may be > sqrt(N)
			factors.add(N); // for integers whose largest prime factor has a power of 1
		return factors;
	}

	static boolean visited[];

	/**
	 * static int bfs(int s) { Queue<Integer> q = new LinkedList<Integer>();
	 * q.add(s); int count=0; int maxcost=0; int dist[]=new int[n]; dist[s]=0;
	 * while(!q.isEmpty()) {
	 *
	 * int u = q.remove(); if(dist[u]==k) { break; } for(Pair v: adj[u]) {
	 * maxcost=Math.max(maxcost, v.cost);
	 *
	 *
	 *
	 * if(!visited[v.v]) {
	 *
	 * visited[v.v]=true; q.add(v.v); dist[v.v]=dist[u]+1; maxcost=Math.max(maxcost,
	 * v.cost); } }
	 *
	 * } return maxcost; }
	 **/
	public static boolean FindAllElements(int n, int k) {
		int sum = k;
		int[] A = new int[k];
		Arrays.fill(A, 0, k, 1);

		for (int i = k - 1; i >= 0; --i) {

			while (sum + A[i] <= n) {

				sum += A[i];
				A[i] *= 2;
			}
		}
		if (sum == n) {
			return true;
		} else
			return false;
	}

	static boolean[] vis2;

	static boolean f2 = false;

	static long[][] matMul(long[][] a2, long[][] b, int p, int q, int r) // C(p x r) = A(p x q) x (q x r) -- O(p x q x
																			// r)
	{
		long[][] C = new long[p][r];
		for (int i = 0; i < p; ++i) {
			for (int j = 0; j < r; ++j) {
				for (int k = 0; k < q; ++k) {
					C[i][j] = (C[i][j] + (a2[i][k] % mod * b[k][j] % mod)) % mod;
					C[i][j] %= mod;
				}

			}
		}
		return C;
	}

	static int memo1[];

	static boolean vis[];
	static TreeSet<Integer> set = new TreeSet<Integer>();

	static long modPow(long ways, long count, long mod) // O(log e)
	{
		ways %= mod;
		long res = 1;
		while (count > 0) {
			if ((count & 1) == 1)
				res = (res * ways) % mod;
			ways = (ways * ways) % mod;
			count >>= 1;
		}
		return res % mod;
	}

	static long gcd(long ans, long b) {
		if (b == 0) {
			return ans;
		}
		return gcd(b, ans % b);
	}

	static int[] isComposite;
	static int[] valid;

	static ArrayList<Integer> primes;
	static ArrayList<Integer> l1;

	static TreeSet<Integer> primus = new TreeSet<Integer>();

	static void sieveLinear(int N)
	{
		int[] lp = new int[N + 1];								//lp[i] = least prime divisor of i
		for(int i = 2; i <= N; ++i)
		{
			if(lp[i] == 0)
			{
				primus.add(i);
				lp[i] = i;
			}
			int curLP = lp[i];
			for(int p: primus)
				if(p > curLP || p * i > N)
					break;
				else
					lp[p * i] = i;
		}
	}

	public static int[] schuffle(int[] p) {
		for (int i = 0; i < p.length; i++) {
			int x = (int) (Math.random() * p.length);
			int temp = p[x];
			p[x] = p[i];
			p[i] = temp;
		}
		return p;
	}

	static int V;
	static long INF = (long) 1E16;

	static class Edge2 {
		int node;
		long cost;
		long next;

		Edge2(int a, int c, Long long1) {
			node = a;
			cost = long1;
			next = c;
		}

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}

		public int[] nxtArr(int n) throws IOException {
			int[] ans = new int[n];
			for (int i = 0; i < n; i++)
				ans[i] = nextInt();
			return ans;
		}
	}
}

    import java.util.Locale;
    import java.util.Scanner;

    public class cont {

    	public static void main(String[] args) {

    		Scanner in;

    		in = new Scanner(System.in);
    		in.useLocale(new Locale("US"));
    		Locale.setDefault(new Locale("en", "US"));

    		if (in.hasNext()) {
    			String s =  in.nextLine();
    			System.out.println("No");
    		}

    		System.exit(0);

    	}

    }

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

public class IsItRated {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.println("no");
		/*
		 * int n = Integer.parseInt(br.readLine());
		 *
		 * while (br.readLine() != null) { String str = br.readLine();
		 *
		 * int m = Integer.parseInt(str);
		 *
		 * if (n == m) System.out.println("rated"); else System.out.println("unrated");
		 *
		 * }
		 */
	}
}

// package com.company;
import javax.swing.*;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.*;
/**
 * @author_jigar_nainuji
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Palindrome solver = new Palindrome();
//        int t = in.nextInt();
        int t=1;
        for(int i=0;i<t;i++) {
            solver.solve(i, in, out);
        }
        out.close();
    }

    static class Palindrome {
        static int mod = 1000000007;
        void solve(int testNumber, InputReader in, PrintWriter out) {
          System.out.println("NO");
        }
    }

    static class Pair {
        int t;
        int l;
        int h;

        Pair(int t,int l,int h){
            this.t=t;
            this.l=l;
            this.h=h;
        }
    }

    static class Maths{
        static int gcd(int a, int b) {
            if (a == 0)
                return b;
            return gcd(b % a, a);
        }

        public  static int lcm(int a, int b)
        {
            return (a*b)/gcd(a, b);
        }

        public static long factorial(int n){
            long fact = 1;
            for(int i=1;i<=n;i++){
                fact *= i;
            }
            return fact;
        }
    }

    static class Characters{
        public static boolean isVovel(char a){
            return a == 'a' || a == 'e' || a == 'i' || a == 'o' || a == 'u';
        }
    }

    static class Binary {
        public static long numberOfBits(long n){
            long count=0;
            while(n>0){
                count++;
                n >>=1;
            }
            return count;
        }

        public static long numberOfSetBits(long n){
            long count = 0;
            int p = 1;
            while (n>0){
                if((n&p) == 1){
                    count++;
                }
                n >>= 1;
            }
            return count;
        }
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public Long nextLong(){
            return Long.parseLong(next());
        }
    }
}

public class A
{
    public static void main(String args[])
    {
        System.out.print("NO");
    }
}

import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("NO");
	}

}

import java.util.*;

public class aaa27 {
	public static void main(String[] args) {
		System.out.println("No");
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.nio.Buffer;
import  java .util.*;
public class Solution {

    public static void main(String[] agrs) throws Exception {
        System.out.print("No\n");
    }
}

import java.util.Scanner;

public class Elementary {
    public static void main(String[] args) {
            System.out.println("NO");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("NO");
    }
}

public class NewClass
{
     public static void main(String[] args)
    {
        System.out.println("NO");

    }
}

public class Main{
    public static void main(String[] args){
        System.out.print("No");
    }
}

import java.util.*;
public class Solution{
    public static void main(String args[]){
        //Scanner sc = new Scanner(System.in);
        //sc.nextInt();
        System.out.println("No");
    }
}

public class a {
	public static void main(String[] args) {
		System.out.println("No");
	}
}

public class Solution {
    public static void main(String[] args){
        System.out.print("No");
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main{

	static int p=1000000007;

	static void err() {
		System.out.println(-1);
	}

	public static void main (String args[])throws IOException{
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);

		int t = 1;
		//t = sc.nextInt();

		while(t-->0) {

			out.print("NO");

		}
		out.flush();
	}

	public static String reverseString(String str){
	    StringBuilder sb=new StringBuilder(str);
	    sb.reverse();
	    return sb.toString();
	}

	static boolean isPalindrome(String str)
    {
        int i = 0, j = str.length() - 1;

        while (i < j) {

            if (str.charAt(i) != str.charAt(j))
                return false;

            i++;
            j--;
        }
        return true;
    }

	static void print(int[] arr) {
		for(int i=0; i<arr.length; i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}

	public static int abs(int x) {return ((x > 0) ? x : -x);}
	public static long abs(long x) {return ((x > 0) ? x : -x);}

	public static int max(int a, int b) {return Math.max(a, b);}
	public static long max(long a, long b) {return Math.max(a, b);}

	public static int min(int a, int b) {return Math.min(a, b);}
	public static long min(long a, long b) {return Math.min(a, b);}

	 static int gcd(int a, int b)
	    {
	        if (a == 0)
	            return b;
	        return gcd(b % a, a);
	    }

    static int modInverse(int a, int m)
    {
        int g = gcd(a, m);
        if (g != 1)
            return -1;
        else
        	return power(a, m - 2, m);

    }

    // To compute x^y under modulo m
    static int power(int x, int y, int m)
    {
        if (y == 0)
            return 1;

        int p = power(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

    static int[] primeGenerator(int num) {
    	int length=0, arr[]=new int[num], a=num, factor=1;
    	if(num%2==0) {
    		while(num%2==0) {
    			num/=2;
    			factor*=2;
    		}
    		arr[length++]=factor;
    	}
    	for(int i=3; i*i<=a; i++) {
    		factor=1;
    		if(num%i==0) {
        		while(num%i==0) {
        			num/=i;
        			factor*=i;
        		}
        		arr[length++]=factor;
    		}
    	}
    	if(num>1)
    		arr[length++]=num;
    	return Arrays.copyOfRange(arr, 0, length);
    }

    static boolean isPrime(int n)
    {
        // Corner cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		Scanner(String fileName) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(fileName));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		String nextLine() throws IOException {
			return br.readLine();
		}

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

		long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}

		double nextDouble() throws NumberFormatException, IOException {
			return Double.parseDouble(next());
		}

		boolean ready() throws IOException {
			return br.ready();
		}

	}

	static void sort(int[] a) {
		shuffle(a);
		Arrays.sort(a);
	}

	static void shuffle(int[] a) {
		int n = a.length;
		Random rand = new Random();
		for (int i = 0; i < n; i++) {
			int tmpIdx = rand.nextInt(n);
			int tmp = a[i];
			a[i] = a[tmpIdx];
			a[tmpIdx] = tmp;
		}
	}
}

class Pair{
	int x;
	int y;
	Pair(int a, int b){
		x=a;
		y=b;
	}

	void print() {
		System.out.println(this.x+" "+this.y);
	}
}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class tr {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("NO");

    }
}

import java.io.*;
import java.util.Random;
import java.util.StringTokenizer;

public class A {

    public static void main(String[] args) {
        FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = 1;
        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
        out.close();
    }

    static class Task {

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            out.println("No");
        }

    }

    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static void shuffle(long[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            long temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(new File(s)));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong() {
            return Long.parseLong(next());
        }

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}

/*      MOHD SADIQ        */

import java.sql.Array;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;

public class Main {

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    private long longVal() throws IOException{
        return Long.parseLong(br.readLine().trim());
    }
    private int intVal() throws IOException{
        return Integer.parseInt(br.readLine().trim());
    }
    private double doubleVal() throws IOException{
        return Double.parseDouble(br.readLine().trim());
    }
    private int[] intArr() throws IOException{
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
        }
        return a;
    }
    private long[] longArr() throws IOException {
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(s[i]);
        }
        return a;
    }
    private double[] doubleArr() throws IOException {
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        double[] a = new double[n];
        for (int i = 0; i < n; i++) {
            a[i] = Double.parseDouble(s[i]);
        }
        return a;
    }
    private String[] stringArr() throws IOException{
        String[] s = br.readLine().trim().split(" ");
        return s;
    }
    private char[] charArr() throws IOException{
        return br.readLine().trim().toCharArray();
    }
    private static boolean[] sieve(int n){
        boolean[] primes = new boolean[n + 1];
        int i;
        Arrays.fill(primes,true);
        for(i = 2; i * i <= n; ++i) {
            if (primes[i]) {
                for(int p = i * i; p <= n; p += i) {
                    primes[p] = false;
                }
            }
        }
        return primes;
    }

    private String solve() throws IOException {
        Main obj = new Main();
        char[] s = obj.charArr();
        return "No";
    }

    public static void main(String[] args) throws IOException {
        Main ob = new Main();
//        int total_test_case = ob.intVal();
         int total_test_case = 1;
        StringBuffer ans = new StringBuffer();
        String k ;
        for(int test_case =0;test_case<total_test_case;test_case++){
            k = ob.solve();
//            System.out.println(k);
            ans.append(k+"\n");
        }
        System.out.print(ans);
    }
}

import javax.swing.text.html.HTMLDocument;
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    // static SingleLinkedList link = new SingleLinkedList();
    //  static DoubleLinkedList doubleLink = new DoubleLinkedList();

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        OutputStream fOut = System.out;
        Scanner fin = new Scanner(System.in);
        try {
            fin = new Scanner(new FileInputStream("anniversary.in"));
        } catch (Exception ignored) {
        }
        try {
            fOut = new FileOutputStream("anniversary.out");
        } catch (Exception ignored) {
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PrintWriter fout = new PrintWriter(fOut);

        int testcase=1;
        for(int test=0;test<testcase;test++){
            out.println("NO");

        }

        out.flush();
        out.close();
        fout.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public long nextLong() {
            return Long.parseLong(next());
        }

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

        public char[] nextCharArray() {
            return next().toCharArray();
        }
    }

    public static void ansA() {
        /*
        long n = in.nextLong();
        long maxM = n, minM = 1;
        BigInteger delta = BigInteger.ZERO;

        long m = in.nextLong();
        long x = in.nextLong();
        long x1 = 0;

        long trueM = 0, trueX = 0;

        long a = 1;
        boolean dou = false;
        boolean small = false;

        small = false;
        while (true) {
            x1 = x;

            long average = (maxM + minM) / 2;
            x = (x + average) % m;
            delta = delta.add(BigInteger.valueOf(average));

            if (x < x1) {
                System.out.println("<" + average);
                small = false;
                minM = (maxM + minM + 1) / 2;

            }
            if (x > x1) {
                System.out.println(">" + average);

                if (small) {
                    maxM = (maxM + minM - 1) / 2;
                    small = false;
                } else {
                    small = true;
                }

            }
            if (x == x1) {
                System.out.println("=");
                long re = average-Long.parseLong(String.valueOf(delta.mod(BigInteger.valueOf(average))));
                System.out.println("x=" + re + "    M:" + average);
                break;
            }
            if (minM == maxM) {
                System.out.println("fail : mod" + average % m);
                break;
            }
        }

         * */
    }

    public static void ansB() {
        /*

         * */
    }

    public class BinaryHeap {

        public BinaryHeap() {
            this(DEFAULT_CAPACITY);
        }

        public BinaryHeap(Comparable[] items) {
            currentSize = items.length;
            array = new Comparable[(currentSize + 2) * 11 / 10];

            int i = 1;
            for (Comparable item : items) {
                array[i++] = item;
            }
            buildHeap();
        }

        public BinaryHeap(int capacity) {
            currentSize = 0;
            array = new Comparable[capacity + 1];
        }

        public void insert(Comparable x) {

            int hole = ++currentSize;
            for (; hole > 1 && x.compareTo(array[hole / 2]) < 0; hole /= 2)
                array[hole] = array[hole / 2];
            array[hole] = x;
        }

        public Comparable findMin() {
            if (isEmpty())
                return null;
            return array[1];
        }

        public Comparable deleteMin() {
            if (isEmpty())
                return null;

            Comparable minItem = findMin();
            array[1] = array[currentSize--];
            percolateDown(1);

            return minItem;
        }

        private void buildHeap() {
            for (int i = currentSize / 2; i > 0; i--)
                percolateDown(i);
        }

        public boolean isEmpty() {
            return currentSize == 0;
        }

        public boolean isFull() {
            return currentSize == array.length - 1;
        }

        public void makeEmpty() {
            currentSize = 0;
        }
        private static final int DEFAULT_CAPACITY = 100;
        private int currentSize;      // Number of elements in heap
        private Comparable[] array; // The heap array
        private void percolateDown(int hole) {
            int child;
            Comparable tmp = array[hole];

            for (; hole * 2 <= currentSize; hole = child) {
                child = hole * 2;
                if (child != currentSize && array[child + 1].compareTo(array[child]) < 0)
                    child++;
                if (array[child].compareTo(tmp) < 0)
                    array[hole] = array[child];
                else
                    break;
            }
            array[hole] = tmp;
        }
    }

    public static class stack{

        stack() {
            stackTop=-1;
            maxStackItemIndex=-1;
        }
        void push(int x)
        {
            stackTop++;
            if(stackTop>=1000000)
                ;  //栈满
            else
            {
                stackItem[stackTop]=x;
                if(x>Max())
                {
                    link2NextMaxItem[stackTop]=maxStackItemIndex;
                    maxStackItemIndex=stackTop;
                }
                else
                    link2NextMaxItem[stackTop]=-1;
            }
        }
        int Pop()
        {
            int ret;

                ret=stackItem[stackTop];
                if(stackTop==maxStackItemIndex)
                {
                    maxStackItemIndex=link2NextMaxItem[stackTop];
                }
                stackTop--;

            return ret;
        }
        int Max()
        {
            if(maxStackItemIndex>=0)
                return stackItem[maxStackItemIndex];
            else
                return -99999;
        }
        int stackItem[]=new int[1000000];
        int stackTop;
        int link2NextMaxItem[]=new int [1000000];
        int maxStackItemIndex;
    };

    public static void heapSort(long[] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap(a, 0, j);
            adjustHeap(a, 0, j);
        }

    }

    public static void adjustHeap(long[] a, int i, int length) {
        long temp = a[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k] < a[k + 1]) {
                k++;
            }
            if (a[k] > temp) {
                a[i] = a[k];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp;
    }

    public static void swap(long[] a, int a1, int a2) {
        long temp = a[a1];
        a[a1] = a[a2];
        a[a2] = temp;
    }

    static int m;
    public static int dp(int a[]) {
        int dp[][] = new int[a.length / 2 + 1][a.length / 2 + 1];

        for (int j = 1; j < m; j++) {
            for (int i = 0; i <= a.length / 2 - j; i++) {
                int total = 0;
                for (int k = 0; k < j; k++) {
                    total += a[2 * i + k];
                }
                dp[i + 1][j] = total;

            }
        }
        for (int j = 2; j <= a.length / 2; j++) {
            for (int i = 1; i <= a.length / 2 - j + 1; i++) {
                for (int k = i; k < j; k++) {
                    int ans = dp[i][k] + dp[i + k][j - k];
                    if (ans > dp[i][j]) dp[i][j] = ans;
                }

            }
        }
        return dp[1][a.length / 2];
    }

    public static void calculate() {
        Scanner in = new Scanner(System.in);
        for (int test = 0; test < 10; test++) {
            String string = in.next();

            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "+");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "+");
            }

            string = string.replace("-", "m");
            string = string.replace("(m", "(-");
            string = string.replace("~m", "+~-");
            string = string.replace("m~", "+-~");
            if (string.charAt(0) == 'm') string = string.replaceFirst("m", "-");

            while (string.contains(")") && string.contains("(")) {
                int right = string.indexOf(")");
                String sub = string.substring(0, right);
                int left = sub.lastIndexOf("(");
                string = string.substring(0, left) + calculate(string.substring(left + 1, right)) + string.substring(right + 1);
            }
            string = calculate(string);
            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "");
            }
            System.out.println(string);
            System.out.flush();
        }
    }

    public static String calculate(String string) {
        int index = -1;

        String sub = string;
        while (sub.contains("~+") || sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
            sub = sub.replace("~+", "~");
        }
        while (sub.contains("~")) {
            int index1 = sub.indexOf("~");
            int index2 = index1 + 1;
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index1) + ~Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("*")) {
            int index1 = sub.indexOf("*");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + Integer.parseInt(sub.substring(index3 + 1, index1)) * Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
        }

        while (sub.contains("+") || sub.contains("m")) {

            boolean add = sub.indexOf("+") < sub.indexOf("m");

            int index1 = Math.min(sub.indexOf("+"), sub.indexOf("m"));

            if (!sub.contains("+")) {
                index1 = sub.indexOf("m");
                add = false;
            }
            if (!sub.contains("m")) {
                index1 = sub.indexOf("+");
                add = true;
            }
            if (sub.contains("+") && (sub.indexOf("+") == 0 || !((sub.charAt(sub.indexOf("+") - 1) == 45 || sub.charAt(sub.indexOf("+") - 1) > 47 && sub.charAt(sub.indexOf("+") - 1) < 58)))) {
                sub = sub.substring(0, sub.indexOf("+")) + sub.substring(sub.indexOf("+") + 1);
                continue;
            }

            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            if (add)
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) + Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
            else
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) - Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);

        }
        while (sub.contains("&")) {
            int index1 = sub.indexOf("&");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) & Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        while (sub.contains("^")) {
            int index1 = sub.indexOf("^");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) ^ Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }

        while (sub.contains("|")) {
            int index1 = sub.indexOf("|");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) | Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        return sub;
    }

    public static long overflow(long num, int digit) {
        num = num * num;

        if (digit(num) > digit) {
            digit = digit(num) - digit;
            return MinusDigit(num, digit);
        }
        return num;

    }

    public static long MinusDigit(long number, int digit) {

        while (digit >= 1) {
            number = number / 10;
            digit--;
        }
        return number;
    }

    public static int digit(long num) {
        int digit = 1;
        while (num >= 10) {
            num = num / 10;
            digit++;
        }
        return digit;
    }

    public static int findValue(long[] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int findValue(long[][] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2][1]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2][1]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int numOfFindValue(long[] a, int begin, int end, int index) {
        long value = a[index];
        int index1 = index;
        int num = 1;
        while (index1 < end) {
            index1++;
            if (a[index1] == value) num++;
            else break;
        }
        while (index > begin) {
            index--;
            if (a[index] == value) num++;
            else break;
        }

        return num;
    }

    public static void heapSort2(int[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(int[][] a, int i, int length) {
        int temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(int[][] a, int a1, int a2) {
        int temp[] = new int[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static void heapSort2(long[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(long[][] a, int i, int length) {
        long temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(long[][] a, int a1, int a2) {
        long temp[] = new long[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static class SingleLinkedList {
        private int size;
        private Node head;

        public SingleLinkedList() {
            size = 0;
            head = null;
        }

        private class Node {
            private Object data;
            private Node next;
            private long datas[];

            public Node(Object data) {
                this.data = data;
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public Object addHead(Object obj, long a[]) {
            Node newHead = new Node(obj);
            newHead.datas = a;
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public void addIntSmallToLarge(int a) {
            long bb[] = new long[1];
            addIntSmallToLarge(a, bb);
        }

        public void addIntSmallToLarge(int a, long bb[]) {
            Node newNode = new Node(a);
            newNode.datas = bb;

            if (size == 0) {
                head = newNode;
                size++;
            } else {
                Node b = head;
                if (Integer.parseInt(b.data.toString()) >= a) {
                    addHead(a);
                    return;
                }
                if (size == 1 && Integer.parseInt(b.data.toString()) < a) {
                    b.next = newNode;
                    size++;
                    return;
                }
                for (int i = 1; i < size; i++) {
                    if (b != null && Integer.parseInt(b.data.toString()) <= a && b.next != null && Integer.parseInt(b.next.data.toString()) >= a) {
                        newNode.next = b.next;
                        b.next = newNode;
                        break;
                    }
                    if (b != null)
                        b = b.next;

                    if (i == size - 1 && b != null && Integer.parseInt(b.data.toString()) < a) {
                        b.next = newNode;
                    }
                }
                size++;
            }

        }

        public Object deleteHead() {
            Object obj = head.data;
            head = head.next;
            size--;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return true;
        }

        public Object deleteIndex(int index) {
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return current.data;
        }

        public boolean isEmpty() {
            return (size == 0);
        }

        public void display() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data + "->");
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

        public void displayWithoutGap() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data);
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

    }

    public static class DoubleLinkedList {
        private int size;
        private Node head;
        private Node end;

        public DoubleLinkedList() {
            size = 0;
            head = new Node();
            end = new Node();
        }

        private class Node {
            private Object data;
            private Node next;
            private Node pre;

            public Node(Object data) {
                this.data = data;
            }

            public Node() {
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                newHead.next = head.next;
                newHead.next.pre = newHead;
                head.next = newHead;
                newHead.pre = head;
            }
            size++;
            return obj;
        }

        public Object add(int index, Object obj) {
            if (index > size + 1) {
                System.out.println("index out of size");
                return false;
            }
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                Node current = head;
                for (int i = 1; i < index; i++) {
                    current = current.next;
                }
                newHead.next = current.next;
                newHead.pre = current;
                current.next = newHead;
                newHead.next.pre = newHead;
            }
            size++;
            return obj;
        }

        public void exchange(int begin1, int end1, int begin2, int end2) {
            Node begin11 = findByIndex(begin1);
            Node begin12 = findByIndex(begin2);
            Node end11 = findByIndex(end1);
            Node end12 = findByIndex(end1);
            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public void exchange(Node begin11, Node end11, Node begin12, Node end12) {

            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public Object addTail(Object obj) {
            Node newTail = new Node(obj);
            if (size == 0) {
                head.next = newTail;
                newTail.pre = head;
                newTail.next = end;
                end.pre = newTail;
            } else {
                newTail.pre = end.pre;
                newTail.pre.next = newTail;
                end.pre = newTail;
                newTail.next = end;
            }
            size++;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head.next;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public Node findByIndex(int index) {
            if (index > size) return null;
            index++;
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }

            return current;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head.next;
            Node previous = head.next;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }
            return true;
        }

        public boolean deleteIndex(int index) {
            if (index > size) return false;
            index++;
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
            } else {
                previous.next = current.next;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }

            size--;
            return true;
        }

        public void display(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "→");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "←");
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            }
        }

        public void displayWithoutGap(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data + " ");
                            break;
                        } else {
                            System.out.print(node.data + " ");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data);
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            }
        }

    }

}

import java.util.*;
public class Main{
     public static void main(String ... string){
          System.out.println("No");
     }
}

import java.util.Scanner;
public class Main{
    public static void main(String [] args){
        Scanner scn= new Scanner(System.in);
        String s =scn.next();
        System.out.print("No");
    }
}

import java.util.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class CodeForces2 {

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    static final int MOD = 998244353;

    public static void main(String[] args) throws java.lang.Exception {
        // your code goes here
        // Reader in = new Reader();
        Scanner in = new Scanner(System.in);

        System.out.println("NO");

    }

}

import java.util.Arrays;

public class A{
    public static void main(String[] strings){
        System.out.println("NO");
    }
}

public class Main {
	public static void main(String[] args) {
		System.out.println("No");
	}
}

import java.io.*;
import java.math.*;
import java.util.*;

public class E_fenwick {

//	static final int INF = BigInteger.TEN.pow(7).intValueExact();
	static final int INF = 10_000_000;

	static final int N_LOG_N = 10_400_000;

	int[] infoKey = new int[N_LOG_N];
	int[] infoNext = new int[N_LOG_N / 2];
	int infoPtr;

	int get(int[] fen, int pos) {
		int ret = INF;
		for (int i = pos; i >= 0; i = (i & (i + 1)) - 1) {
			ret = Math.min(ret, fen[i]);
		}
		return ret;
	}

	void set(int[] fen, int pos, int val) {
		for (int i = pos; i < fen.length; i |= i + 1) {
			fen[i] = Math.min(fen[i], val);
		}
	}

	static class Cell implements Comparable<Cell> {
		int x, y;

		public Cell(int x, int y) {
			this.x = x;
			this.y = y;
		}

		@Override
		public int compareTo(Cell o) {
			if (x != o.x) {
				return Integer.compare(x, o.x);
			}
			return Integer.compare(y, o.y);
		}

		int infoHead = -1;

		Node node;

	}

	static class Node {
		int x, y1, y2, id;

		public Node(int x, int y1, int y2, int id) {
			this.x = x;
			this.y1 = y1;
			this.y2 = y2;
			this.id = id;
		}

		int len() {
			return y2 - y1 + 1;
		}

		// ArrayList<int[]> info = new ArrayList<>(0);
		Cell[] cells;
		int[] fenPos;
		int[] fenNeg;
	}

	Node[] b;

	void submit() {
		int s = nextInt();
		Cell[] a = new Cell[s];
		for (int i = 0; i < s; i++) {
			a[i] = new Cell(nextInt(), nextInt());
		}

		Arrays.sort(a);

		b = new Node[s];
		int n = 0;

		for (int i = 0; i < s;) {
			int j = i;
			while (j < s && a[j].x == a[i].x && a[j].y - a[i].y == j - i) {
				j++;
			}
			Node tmp = new Node(a[i].x, a[i].y, a[j - 1].y, n);
			tmp.cells = new Cell[j - i];
			b[n++] = tmp;
			for (int k = i; k < j; k++) {
				a[k].node = b[n - 1];
				tmp.cells[k - i] = a[k];
			}
			i = j;
		}

		b = Arrays.copyOf(b, n);
		Cell[] tmpA = a.clone();
		Arrays.sort(tmpA, (Cell p, Cell q) -> {
			if (p.y != q.y) {
				return p.y < q.y ? -1 : 1;
			}
			return Integer.compare(p.x, q.x);
		});

		next = new int[2 * n - 2];
		head = new int[n];
		Arrays.fill(head, -1);
		to = new int[2 * n - 2];

		for (int i = 0; i < s - 1; i++) {
			if (tmpA[i].y == tmpA[i + 1].y && tmpA[i + 1].x - tmpA[i].x == 1) {
				if (tmpA[i].y == tmpA[i].node.y1
						|| tmpA[i + 1].y == tmpA[i + 1].node.y1) {
					addEdge(tmpA[i].node.id, tmpA[i + 1].node.id);
				}
			}
		}
		sz = new int[n];
		dead = new boolean[n];
		par = new int[n];
		go(0, -1);

		for (Node v : b) {
			v.cells = null;
		}
		tmpA = null;
		sz = null;
		dead = null;

//		System.gc();

		for (Node v : b) {
			// v.root = new MinNode(0, v.y2 - v.y1 + 1);
			v.fenNeg = new int[v.len()];
			Arrays.fill(v.fenNeg, INF);
			v.fenPos = v.fenNeg.clone();
		}

		int q = nextInt();
		while (q-- > 0) {
			int t = nextInt();
			Cell qc = new Cell(nextInt(), nextInt());
			int idx = Arrays.binarySearch(a, qc);

			qc = a[idx];

			Node v = qc.node;

			if (t == 2) {
				int ans = INF;
				int centre = v.id;
				// for (int i = v.info.size() - 2; i >= 0; i -= 2) {
				// int dist = v.info.get(i)[place];
				// int last = v.info.get(i + 1)[place];

				for (int i = qc.infoHead; i >= 0; i = infoNext[i]) {

					int dist = infoKey[2 * i];
					int last = infoKey[2 * i + 1];

					int kek = b[centre].len();

					ans = Math.min(ans,
							dist + last + get(b[centre].fenNeg, last));
					ans = Math
							.min(ans,
									dist
											- last
											+ get(b[centre].fenPos, kek - 1
													- last));

					centre = par[centre];
				}

				out.println(ans > INF / 2 ? -1 : ans);
			} else {
				int centre = v.id;
				for (int i = qc.infoHead; i >= 0; i = infoNext[i]) {

					int dist = infoKey[2 * i];
					int last = infoKey[2 * i + 1];
					int kek = b[centre].len();

					set(b[centre].fenNeg, last, dist - last);
					set(b[centre].fenPos, kek - 1 - last, dist + last);
					centre = par[centre];
				}
			}
		}
	}

	int[] sz;
	boolean[] dead;
	int[] par;

	void dfs2(int v, int p, int root, int[]arr) {//, int[] dist, int[] last) {
		// b[v].info.add(new int[][]{dist, last});
		// b[v].info.add(dist);
		// b[v].info.add(last);

//		infoNext[infoPtr] = b[v].infoHead;
//		b[v].infoHead = infoPtr;
//
//		infoKey[infoPtr++] = arr;
//		infoKey[infoPtr++] = last;

		for (int i = 0; i < arr.length; i += 2){
			Cell cell = b[v].cells[i / 2];
//			b[v].cells[]
			infoNext[infoPtr] = cell.infoHead;
			cell.infoHead = infoPtr;

			infoKey[2 * infoPtr] = arr[i];
			infoKey[2 * infoPtr + 1] = arr[i + 1];
			infoPtr++;
		}

		int y1 = b[v].y1;
		int y2 = b[v].y2;

		for (int e = head[v]; e >= 0; e = next[e]) {
			int u = to[e];
			if (u == p || dead[u]) {
				continue;
			}

			Node nodeU = b[u];
			int[] newArr = new int[2 * nodeU.len()];

			for (int y = nodeU.y1, i = 0; y <= nodeU.y2; y++, i++) {
				if (y < y1) {
					newArr[2 * i] = arr[0] + 1 + y1 - y;
					newArr[2 * i + 1] = arr[1];
				} else if (y > y2) {
					newArr[2 * i] = arr[arr.length - 2] + 1 + y - y2;
					newArr[2 * i + 1] = arr[arr.length - 1];
				} else {
					newArr[2 * i] = arr[2 * (y - y1)] + 1;
					newArr[2 * i + 1] = arr[2 * (y - y1) + 1];
				}
			}

			dfs2(u, v, root, newArr);
		}
	}

	void goCentre(int v) {
		Node node = b[v];
		// int[] dist = new int[node.y2 - node.y1 + 1];
		// int[] last = new int[node.y2 - node.y1 + 1];
		int[] arr = new int[2 * node.len()];
		for (int i = 0; i < node.len(); i++) {
			arr[2 * i + 1] = i;
		}
		dfs2(v, -1, v, arr);
	}

	void go(int v, int father) {
		dfsSz(v, -1);
		int root = v;
		outer: while (true) {
			// for (int u : g[root]) {
			for (int e = head[root]; e >= 0; e = next[e]) {
				int u = to[e];
				if (!dead[u] && sz[u] < sz[root] && 2 * sz[u] > sz[v]) {
					root = u;
					continue outer;
				}
			}
			break;
		}

		par[root] = father;

		goCentre(root);
		dead[root] = true;
		for (int e = head[root]; e >= 0; e = next[e]) {
			int u = to[e];
			if (!dead[u]) {
				go(u, root);
			}
		}
	}

	void dfsSz(int v, int p) {
		sz[v] = 1;
		for (int e = head[v]; e >= 0; e = next[e]) {
			int u = to[e];
			if (u != p && !dead[u]) {
				dfsSz(u, v);
				sz[v] += sz[u];
			}
		}
	}

	int[] next;
	int[] head;
	int[] to;
	int ptr;

	void addEdge(int v, int u) {
		to[ptr] = u;
		next[ptr] = head[v];
		head[v] = ptr++;

		to[ptr] = v;
		next[ptr] = head[u];
		head[u] = ptr++;
	}

	void preCalc() {

	}

	void test() {

	}

	void stress() {
		for (int tst = 0;; tst++) {
			if (false) {
				throw new AssertionError();
			}
			System.err.println(tst);
		}
	}

	E_fenwick() throws IOException {
		is = System.in;
		// is = new FileInputStream("shit.in");
		out = new PrintWriter(System.out);
		// out = new PrintWriter("shit.out");
		preCalc();
		submit();
		// stress();
		// test();
		out.close();
	}

	static final Random rng = new Random();
	static final int C = 5;

	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}

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

	private InputStream is;
	PrintWriter out;

	private byte[] buf = new byte[1 << 14];
	private int bufSz = 0, bufPtr = 0;

	private int readByte() {
		if (bufSz == -1)
			throw new RuntimeException("Reading past EOF");
		if (bufPtr >= bufSz) {
			bufPtr = 0;
			try {
				bufSz = is.read(buf);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			if (bufSz <= 0)
				return -1;
		}
		return buf[bufPtr++];
	}

	private boolean isTrash(int c) {
		return c < 33 || c > 126;
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isTrash(b))
			;
		return b;
	}

	String nextToken() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!isTrash(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	String nextString() {
		int b = readByte();
		StringBuilder sb = new StringBuilder();
		while (!isTrash(b) || b == ' ') {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	double nextDouble() {
		return Double.parseDouble(nextToken());
	}

	char nextChar() {
		return (char) skip();
	}

	int nextInt() {
		int ret = 0;
		int b = skip();
		if (b != '-' && (b < '0' || b > '9')) {
			throw new InputMismatchException();
		}
		boolean neg = false;
		if (b == '-') {
			neg = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				ret = ret * 10 + (b - '0');
			} else {
				if (b != -1 && !isTrash(b)) {
					throw new InputMismatchException();
				}
				return neg ? -ret : ret;
			}
			b = readByte();
		}
	}

	long nextLong() {
		long ret = 0;
		int b = skip();
		if (b != '-' && (b < '0' || b > '9')) {
			throw new InputMismatchException();
		}
		boolean neg = false;
		if (b == '-') {
			neg = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				ret = ret * 10 + (b - '0');
			} else {
				if (b != -1 && !isTrash(b)) {
					throw new InputMismatchException();
				}
				return neg ? -ret : ret;
			}
			b = readByte();
		}
	}
}

import java.util.*;
import java.lang.Math;

public class Main
{
	public static void main(String[] args)
	{
		System.out.println("NO");
	}
}

import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf1331a {

    public static void main(String[] args) throws IOException {
        prN();
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IRAND ~= 3e8
    // IMAX ~= 2e10
    // LMAX ~= 9e18
    // constants
    static final int IBIG = 1000000007;
    static final int IRAND = 327859546;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
    static int minstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
    static long minstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
    static int maxstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
    static long maxstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void sort(int[] a) {shuffle(a); Arrays.sort(a);}
    static void sort(long[] a) {shuffle(a); Arrays.sort(a);}
    static void sort(double[] a) {shuffle(a); Arrays.sort(a);}
    static void qsort(int[] a) {Arrays.sort(a);}
    static void qsort(long[] a) {Arrays.sort(a);}
    static void qsort(double[] a) {Arrays.sort(a);}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author EigenFunk
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AIsItRated solver = new AIsItRated();
        solver.solve(1, in, out);
        out.close();
    }

    static class AIsItRated {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            out.println("No");
        }

    }
}

public class Main {

    public static void main(String[] args) {
       System.out.println("no");
    }

}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
      System.out.println("No");

    }
}

public class Solution{
    public static void main(String args[]){
        System.out.println("NO");
    }
}

import java.util.*;

public class Main{

    public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            System.out.println("NO");
        }
}

import java.util.*;
public class Main {
    public static void main(String args[]) {
        //Scanner s = new Scanner(System.in);
        // int t = s.nextInt();
        // while(t-->0){
        //     int n = s.nextInt();
        // }
        System.out.println("NO");
    }
}

//package CodeForces;

import java.util.*;

public class A {

	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		System.out.println("NO");

	}

}

public class Main {

	public static void main(String[] args) {
		System.out.println("no");
	}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class isItRated {
	public static void main(String[] args) throws IOException {
		PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));

    pw.print("No");
    pw.close();

}
}

import java.util.*;
import java.io.*;
import java.math.*;
import javafx.util.Pair;
public class Fff {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {

  BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  bw.append("NO");

       bw.close();
    }

}

import java.util.*;

public class Again {
	public static Scanner scn = new Scanner(System.in);

	public static void main(String[] args) {
		System.out.println("NO");

	}

}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class tr {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("NO");

    }
}

import java.io.*;
import java.math.BigInteger;
import java.net.PortUnreachableException;
import java.util.*;

// written by luchy0120

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

        new Main().run();
    }

    static int groups = 0;
    static int[] fa;
    static int[] sz;

    static void init(int n) {
        groups = n;
        fa = new int[n];
        for (int i = 1; i < n; ++i) {
            fa[i] = i;
        }
        sz = new int[n];
        Arrays.fill(sz, 1);
    }

    static int root(int p) {
        while (p != fa[p]) {
            fa[p] = fa[fa[p]];
            p = fa[p];
        }
        return p;
    }

    static void combine(int p, int q) {
        int i = root(p);
        int j = root(q);
        if (i == j) {
            return;
        }
        if (sz[i] < sz[j]) {
            fa[i] = j;
            sz[j] += sz[i];
        } else {
            fa[j] = i;
            sz[i] += sz[j];
        }
        groups--;
    }

    int child[];
    int color[],dfn[],low[],stack[],cnt[];
    boolean vis[];
    boolean iscut[];
    int deep,top,n,m,sum,ans;
    List<Integer> g[];
    int root = 0;
    //  无向图的强连通分量
    void tarjanNonDirect(int u1) {

        int stk[] = new int[10001];
        int fatk[] = new int[10001];
        int p = 0;
        stk[p] = u1;
        fatk[p] = -1;
        p= 1;
        ot: while(p>0) {
            int u  = stk[p-1];
            int fa = fatk[p-1];

            if(dfn[u]==0) {
                low[u] = dfn[u] = ++deep;
            }
            // stack[top++] = u;

            for (; h[u] != -1; h[u] = ne[h[u]]) {
                int v = to[h[u]];
                if (dfn[v] == 0) {
                    //tarjanNonDirect(v);

                    fatk[p] = u;
                    stk[p++] = v;
                    continue ot;
                } else {
                    low[u] = Math.min(low[u], dfn[v]);
                    // 没有特判是否直接指向父亲
                    // 回边，使用dfn【v】更新low【u】,因为可能是指向父亲，而父亲的low可能比较小
                }
            }
            --p;

            if (fa != -1) {
                low[fa] = Math.min(low[fa], low[u]);
                if (low[u] >= dfn[fa]) {
                    if (fa != root || ++child[fa] > 1) {     // 不是root，直接记为cut，是root，判断是否有两个儿子
                        iscut[fa] = true;
                    }
                    ++dcc_cnt;
                    // 一个割点可能会被多个点双共享
                    //  int z = -1;
                    //    do {
                    //        z = stack[--top];
                    //      dcc[dcc_cnt].add(z);
                    //    } while(z != v);
                    //   dcc[dcc_cnt].add(u);
                }

            }

        }
    }
    int gd = 0;
    int id =-1;
    int scc_cnt = 0;
    int sccno[];
    // 有向图的强连通分量
    void tarjan(int u) {
        int stk[] = new int[10001];
        //   int tptk[] = new int[10001];

        //  int fatk[] = new int[10001];
        int p  =1; stk[0] = u;//fatk[0] =-1;
        ot:while(p>0) {
            u  = stk[p-1];
            //  int fa  = fatk[p-1];
            if (dfn[u] == 0) {
                low[u] = dfn[u] = ++deep;
                stack[top++] = u;

            }

            for (; hc[u] != -1; hc[u] = ne[hc[u]]) {
                int v = to[hc[u]];
                if (dfn[v] == 0) {
                    stk[p++] = v;
                    continue ot;
                    //  low[u] = Math.min(low[u], low[v]);
                } else if (sccno[v] == 0) {
                    // dfn>0 but sccno==0, means it's in current stack
                    low[u] = Math.min(low[u], low[v]);
                }
            }

            p--;
            if (dfn[u] == low[u]) {
                sccno[u] = ++scc_cnt;
                if(u==1){
                    id = scc_cnt;
                }

                while (stack[top - 1] != u) {
                    sccno[stack[top - 1]] = scc_cnt;
                    if(stack[top - 1]==1){
                        id = scc_cnt;
                    }
                    --top;
                }

                --top;
            }
            if(p>=1){
                int fa = stk[p-1];
                low[fa] = Math.min(low[fa], low[u]);
            }
        }
    }
    int rr =0;
//    void solve() {
//
//    }

//    int get_room(int i,int j){
//        return i/3*3 + j/3;
//    }

//    int a[][] = new int[9][9];
//    int space = 0;
//
//    boolean vis_row[][] = new boolean[9][10];
//    boolean vis_col[][] = new boolean[9][10];
//    boolean vis_room[][] = new boolean[9][10];
//    int val[][][] =new int[9][9][];
//    int prepare[][];
//
//    void dfs(int rt){
//
//    }

    int h[],to[],ne[];int ct =0;
    void add(int u,int v){
        // u--;v--;
        to[ct] = v;
        ne[ct] = h[u];
        h[u] = ct++;

    }

    int dcc_cnt = 0;
    int time = 0;

    long summ[];
    int v[];
    int hc[];
    void solve() {
//        int n = ni();
//        int m = ni();
//        int k = ni();
//
//        for(int i=1;i*i<=k;++i){
//            if(k%i==0){
//                int ot = k/i;
//
//
//
//
//
//            }
//        }
        print("No");

//        int n = ni();
//        int m  = n*(n+1)/2;
//        int k = ni();
//        int p = 0;
//
//        double x[] = new double[n];
//        double y[] = new double[n];
//
//        for(int i=0;i<n;++i){
//            x[i] = nd();
//            y[i] = nd();
//        }
//
//        List<Item> li = new ArrayList<>();
//        for(int i=0;i<n;++i){
//            for(int j=i+1;j<n;++j){
//               double r =  (x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]);
//               li.add(new Item(r,i,j));
//            }
//        }
//        Collections.sort(li,(xx,yy)->Double.compare(xx.s,yy.s));
//
//        init(n + 1);
//
//        int s = 0;
//        int c = n;
//        for (int i = 0; i < li.size(); ++i) {
//            int p1 = li.get(i).a;
//            int p2 = li.get(i).b;
//            if (root(p1) != root(p2)) {
//                combine(p1, p2);
//                c--;
//                if(c==k-1){
//                    print(roundS(Math.sqrt(li.get(i).s),2));
//                    break;
//                }
//            }
//        }

    }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//    }

    static long mul(long a, long b, long p)
    {
        long res=0,base=a;
        while(b>0)
        {
            if((b&1L)>0)
                res=(res+base)%p;
            base=(base+base)%p;
            b>>=1;
        }
        return res;
    }

    static long mod_pow(long k,long n,long p){
        long res = 1L;
        long temp = (k%p+p)%p;
        while(n!=0L){
            if((n&1L)==1L){
                res = ((res*temp)%p+p)%p;
            }
            temp = ((temp * temp)%p+p)%p;
            n = n>>1L;
        }
        return res%p;
    }
    public static String roundS(double result, int scale){
        String fmt = String.format("%%.%df", scale);
        return String.format(fmt, result);
    }

//    void solve() {
//
//        for(int i=0;i<9;++i) {
//            for (int j = 0; j < 9; ++j) {
//                int v = ni();
//                a[i][j] = v;
//                if(v>0) {
//                    vis_row[i][v] = true;
//                    vis_col[j][v] = true;
//                    vis_room[get_room(i, j)][v] = true;
//                }else{
//                    space++;
//                }
//            }
//        }
//
//
//        prepare = new int[space][2];
//
//        int p = 0;
//
//        for(int i=0;i<9;++i) {
//            for (int j = 0; j < 9; ++j) {
//                if(a[i][j]==0){
//                    prepare[p][0] = i;
//                    prepare[p][1]= j;p++;
//                    List<Integer> temp =new ArrayList<>();
//                    for(int k=1;k<=9;++k){
//                        if(!vis_col[j][k]&&!vis_row[i][k]&&!vis_room[get_room(i,j)][k]){
//                            temp.add(k);
//                        }
//                    }
//                    int sz = temp.size();
//                    val[i][j] = new int[sz];
//                    for(int k=0;k<sz;++k){
//                        val[i][j][k] = temp.get(k);
//                    }
//                }
//            }
//        }
//        Arrays.sort(prepare,(x,y)->{
//           return Integer.compare(val[x[0]][x[1]].length,val[y[0]][y[1]].length);
//        });
//        dfs(0);
//
//
//
//
//
//
//
//
//
//
//    }

    InputStream is;
    PrintWriter out;

    void run() throws Exception {
        //is = new FileInputStream(new File("C:\\Users\\Luqi\\Downloads\\P3387_9.in"));
        is = System.in;
        out = new PrintWriter(System.out);

        solve();
        out.flush();
    }

    private byte[] inbuf = new byte[1024];
    public 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 char ncc() {
        int b = readByte();
        return (char) b;
    }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!(isSpaceChar(b))) { // when nextLine, (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 String nline() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!isSpaceChar(b) || b == ' ') {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

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

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

    private long[] nal(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = nl();
        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 << 3) + (num << 1) + (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();
        }
    }

    void print(Object obj) {
        out.print(obj);
    }

    void println(Object obj) {
        out.println(obj);
    }

    void println() {
        out.println();
    }

    void printArray(int a[],int from){
        int l = a.length;
        for(int i=from;i<l;++i){
            print(a[i]);
            if(i!=l-1){
                print(" ");
            }
        }
        println();
    }

    void printArray(long a[],int from){
        int l = a.length;
        for(int i=from;i<l;++i){
            print(a[i]);
            if(i!=l-1){
                print(" ");
            }
        }
        println();
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("no");
		sc.close();
	}
}

import java.util.Scanner;
public class ModularExponentiation{
  public static void main(String[]args){
  Scanner sc=new Scanner(System.in);

   System.out.println("no");

  }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package pkg11a;

import java.util.Scanner;

/**
 *
 * @author pranto
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)  {
        System.out.println("NO");

        }

    }

import java.util.*;
import java.io.*;
public class EdA {

	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
// 		int t = Integer.parseInt(bf.readLine());
// 		for(int i = 0;i<t;i++){
////	 		String input1 = bf.readLine().trim();
////	 		String input2 = bf.readLine().trim();
//	 		StringTokenizer st = new StringTokenizer(bf.readLine());
//	 		int n = Integer.parseInt(st.nextToken());
//	 		int m = Integer.parseInt(st.nextToken());
//	 		ArrayList<Integer> array = new ArrayList<Integer>();
//	 		StringTokenizer st2 = new StringTokenizer(bf.readLine());
//	 		for(int j=0;j<n;j++){
//	 			array.add(Integer.parseInt(st2.nextToken()));
//	 		}
// 		}
//

 		out.println("NO");

 		out.close();

 	}
}

//StringJoiner sj = new StringJoiner(" ");
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is

    public class A{
        public static void main (String[] args){
            System.out.println("No");
        }
    }

import java.util.*;

public class main {
    public static void main(String[] args) {
        System.out.println("NO");
    }
}

import java.util.*;
import java.io.*;

public class Main{
     public static void main(String[] args){
        FastReader sc=new FastReader();
        System.out.println("No");
    }

    public static boolean prime(int n){
        for(int i=2;i*i<=n;i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }

    static int gcd(int a, int b)
	{
	if (b == 0)
		return a;
	return gcd(b, a % b);
	}
}

class FastReader{
    BufferedReader br;
    StringTokenizer st;

    public FastReader(){
        br = new BufferedReader(new
                 InputStreamReader(System.in));
    }

    String next(){
        while (st == null || !st.hasMoreElements()){
            try{
                st = new StringTokenizer(br.readLine());
            }
            catch (IOException  e){
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

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

    long nextLong(){
        return Long.parseLong(next());
    }

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

    String nextLine(){
        String str = "";
        try{
            str = br.readLine();
        }
        catch (IOException e){
            e.printStackTrace();
        }
        return str;
    }
}

import java.util.*;

public class test{
	public static void main(String[] args){
		System.out.println("no");
	}
}

import java.util.Scanner;

public class AProblem {
    private String n;

    private void input(){
        Scanner sc = new Scanner(System.in);
        System.out.println("NO");
    }

    public static void main(String[] args){
        AProblem duc = new AProblem();
        duc.input();
    }
}

	import java.util.Arrays;
	import java.util.Scanner;
	public class cp {

		static String removedup(char str[], int n)
	    {

	        int index = 0;

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

	        	int j;
	            for (j = 0; j < i; j++)
	            {
	                if (str[i] == str[j])
	                {
	                    break;
	                }
	            }
	            if (j == i)
	            {
	                str[index++] = str[i];
	            }
	        }
	        return String.valueOf(Arrays.copyOf(str, index));
	    }

				public static void main( String[] args) {
//					bad ugly numbers

//					Scanner in = new Scanner(System.in);
//
//
//
//					long y = in.nextLong();
//					for(long i = 0;i<y;i++) {
//						long n = in.nextLong();
//						if(n==1) {
//							System.out.println(-1);
//						}
//						if(n>1) {
//							String h = "";
//							for(long j=0;j<n-1;j++) {
//								h = h+"9";
//							}
//							String l = "2"+h;
//							System.out.println(l);
//
//
//
//						}
//				}

//
					System.out.println("no");

//						String h = in.next();
//
//						long g = h.length();
//						int flag = 0;
//						long a = 0;
//
//						for(int t = 0;t<g;t++) {
//							if(h.charAt(t)=='0') {
//								a = a+1;
//							}
//						}
//						for(int j = 0;j<g;j++) {
//							if(h.charAt(j)=='0') {
//
//								flag =1;
//								break;
//							}
//							else {
//								flag = 0;
//							}
//
//						}
////						System.out.println(flag);
//
//						String b = "";
//						for(int l = 0;l<g;l++) {
//							if(h.charAt(l)=='0') {
//								continue;
//							}
//							else {
//								b = b+ String.valueOf(h.charAt(l));
//							}
//						}
//						long sum = 0;
//						for(int k = 0;k<b.length();k++) {
//							char x = b.charAt(k);
//							String z = String.valueOf(x);
//							long y1 = Long.parseLong(z);
//
//							sum = sum+y1;
//
//
//						}
////				System.out.println(sum);
//
//						int flag1 = 0;
//						for(int d = 0;d<b.length();d++) {
//							char x1 = b.charAt(d);
//							String z1 = String.valueOf(x1);
//							long y11 = Long.parseLong(z1);
//							if(y11%2==0) {
//								flag1 = 1;
//								break;
//							}
//							else {
//								flag1 = 0;
//							}
//
//							}
////						System.out.println(flag1);
//						if((sum%3==0 && flag1 == 1 && flag==1)||(a ==g)) {
//							System.out.println("red");
//						}
//						else {
//							System.out.println("cyan");
//						}
//					}

//
//
//				}
//	}
				}
	}
//

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Elizabeth
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("NO");
    }
}

import javax.swing.plaf.basic.BasicInternalFrameTitlePane;
import  java.io.*;
import  java.math.*;
import java.nio.Buffer;
import java.sql.SQLSyntaxErrorException;
import  java.util.*;
import  java.text.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {
    public static boolean gcd(int a,int b){
        if(a==1||b==1){
            return false;
        }
        while(1>0){
            int t = a%b;
            if(t == 0){
                break;
            }
            else{
                a=b;
                b=t;
            }

        }
        if(b>1)	return true;
        else{
            return  false;
        }
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
       System.out.println("No");

    }
}

public class NO{

     public static void main(String []args){
        System.out.println("NO");
     }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author congs
 */
public class AprilFoolsCF {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("no");
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Corona
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AIsItRated solver = new AIsItRated();
        solver.solve(1, in, out);
        out.close();
    }

    static class AIsItRated {
        public void solve(int testNumber, InputReader sc, PrintWriter out) {
            out.println("No");
        }

    }

    static class InputReader {
        private InputStream stream;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

    }
}

import java.util.*;
public class x
{
    public static void main(String []args)
    {

        System.out.println("NO");

    }
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
      System.out.println("No");

    }
}

/*
    Arnab Chanda
*/

// All imports here

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;

// Template code starts here //

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Debugger debug = new Debugger(out);
        Objectify objectify = new Objectify(debug);
        Task solver = new Task();
        // int test = in.nextInt();
        int test = 1;
        while(test-->0){
            solver.solve(1, in, out, debug, objectify);
        }
		out.close();
	}
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

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

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

}

class Debugger{
    PrintWriter out;

    Debugger(PrintWriter out){
        this.out = out;
    }

    public <T> void printList(List<T> arrayList){
        for( Object ob: arrayList){
            out.print(ob+" ");
        }
        out.println();
    }

    public <T> void printSet(Set<T> set){
        for(Object ob: set){
            out.print(ob+" ");
        }
        out.println();
    }

    public <T> void printMap(Map<?,?> map){
        for(Object ob: map.keySet()){
            System.out.println(ob+" : "+map.get(ob));
        }
    }
}

class Objectify{

    Debugger debug;

    Objectify(Debugger ob){ debug = ob; }

    public void printArr(int[] arr){ debug.printList(Arrays.stream(arr).boxed().collect(Collectors.toList())); }
    public void printArr(double[] arr){ debug.printList(Arrays.stream(arr).boxed().collect(Collectors.toList())); }
    public void printArr(long[] arr){ debug.printList(Arrays.stream(arr).boxed().collect(Collectors.toList())); }
    public void printArr(char[] arr){ debug.printList( String.valueOf(arr).chars().mapToObj(c -> (char) c).collect(Collectors.toList())); }
    public void printArr(String[] arr){ debug.printList(Arrays.asList(arr)); }

    public void printMatrix(int[][] arr){ for(int a[]:arr) printArr(a); }
    public void printMatrix(double[][] arr){ for(double a[]:arr) printArr(a); }
    public void printMatrix(long[][] arr){ for(long a[]:arr) printArr(a); }
    public void printMatrix(char[][] arr){ for(char a[]:arr) printArr(a); }
    public void printMatrix(String[][] arr){ for(String a[]:arr) printArr(a); }

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Template code ends here

class Task {

    final long MOD = (int)Math.pow(10,9)+7;

    public void solve(int testNumber, InputReader sc, PrintWriter out, Debugger debug, Objectify objectify) {

        // write your code here
        System.out.println("no");

    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solve(in, out);
        out.close();
    }
    static int L,R,top,bottom;
    // static int ans;
    public static void solve(InputReader sc, PrintWriter pw) {
        // int t=sc.nextInt();
        int t=1;
        u:while(t-->0){
            // String s=sc.next();
            // int n=s.charAt(s.length()-1)-'0';
            // if((n&1)==1)
            //     pw.println(1);
            // else
            //     pw.println(0);
            pw.println("NO");
        }
    }
    public static void swap(char []chrr, int i, int j){
        char temp=chrr[i];
        chrr[i]=chrr[j];
        chrr[j]=temp;
    }
    public static int num(int n){
        int a=0;
        while(n>0){
            a+=(n&1);
            n>>=1;
        }
        return a;
    }
    static class Pair{
        long u, v;
        Pair(long a,long b){
            this.u=a;
            this.v=b;
        }
    }
        // public int compareTo(Pair p){
        //     return (b-p.b);
        // }
        // public int hashCode(){
        //     int hashcode = (a+" "+b).hashCode();
        //     return hashcode;
        // }

        // public boolean equals(Object obj){
        //     if (obj instanceof Pair) {
        //         Pair p = (Pair) obj;
        //         return (p.a==this.a && p.b == this.b);
        //     }
        //     return false;
        // }

    static boolean isPrime(int n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (n % 2 == 0 || n % 3 == 0)
            return false;
        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
        return true;
    }
    static int gcd(int a, int b) {
        if (b == 0)
            return a;
        return a>b?gcd(b, a % b):gcd(a, b % a);
    }
    static long fast_pow(long base,long n,long M){
        if(n==0)
           return 1;
        if(n==1)
        return base;
        long halfn=fast_pow(base,n/2,M);
        if(n%2==0)
            return ( halfn * halfn ) % M;
        else
            return ( ( ( halfn * halfn ) % M ) * base ) % M;
    }
    static long modInverse(long n,long M){
        return fast_pow(n,M-2,M);
    }
    public static void feedArr(long []arr,InputReader sc){
        for(int i=0;i<arr.length;i++)
            arr[i]=sc.nextLong();
    }
    public static void feedArr(double []arr,InputReader sc){
        for(int i=0;i<arr.length;i++)
            arr[i]=sc.nextDouble();
    }
    public static void feedArr(int []arr,InputReader sc){
        for(int i=0;i<arr.length;i++)
            arr[i]=sc.nextInt();
    }
    public static void feedArr(String []arr,InputReader sc){
        for(int i=0;i<arr.length;i++)
            arr[i]=sc.next();
    }
    public static String printArr(int []arr){
        StringBuilder sbr=new StringBuilder();
        for(int i:arr)
            sbr.append(i+" ");
        return sbr.toString();
    }
    public  static String printArr(long []arr){
        StringBuilder sbr=new StringBuilder();
        for(long i:arr)
            sbr.append(i+" ");
        return sbr.toString();
    }
    public static String printArr(String []arr){
        StringBuilder sbr=new StringBuilder();
        for(String i:arr)
            sbr.append(i+" ");
        return sbr.toString();
    }
    public static String printArr(double []arr){
        StringBuilder sbr=new StringBuilder();
        for(double i:arr)
            sbr.append(i+" ");
        return sbr.toString();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.util.Scanner;

public class A {
    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
        System.out.println("No");
    }
}

import java.util.*;

public class hello {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        scn.nextLine();
        System.out.println("No");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.*;
import java.util.Queue;
import java.util.StringTokenizer;
import java.math.BigInteger;

  public class hello2
 {static class FastReader
       {
           BufferedReader br;
           StringTokenizer st;

           public FastReader()
           {
               br = new BufferedReader(new
                        InputStreamReader(System.in));
           }

           String next()
           {
               while (st == null || !st.hasMoreElements())
               {
                   try
                   {
                       st = new StringTokenizer(br.readLine());
                   }
                   catch (IOException  e)
                   {
                       e.printStackTrace();
                   }
               }
               return st.nextToken();
           }

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

           long nextLong()
           {
               return Long.parseLong(next());
           }

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

           String nextLine()
           {
               String str = "";
               try
               {
                   str = br.readLine();
               }
               catch (IOException e)
               {
                   e.printStackTrace();
               }
               return str;
           }

       }

    static String sum (String s)
    {
        String s1 = "";

        if(s.contains("a"))
            s1+="a";
        if(s.contains("e"))
            s1+="e";
        if(s.contains("i"))
            s1+="i";
        if(s.contains("o"))
            s1+="o";
        if(s.contains("u"))
            s1+="u";

            return s1;

    }
    static int gcd(int a, int b)
{
    return b > 0 ? gcd(b, a % b) : a;
}
    public static void main(String[] args)
    {
       FastReader sc =new FastReader();
       System.out.println("NO");

    }
 }

public class Main {

    public static void main(String[] args) {
        System.out.print("NO");

    }
}

public class Solution {

  public static void main(String[] args) {

  System.out.print("NO");

  }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("NO");
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("no");
		sc.close();
	}
}

import java.util.*;
public class AprilFools_A {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("NO");
    }
}

//package CodeForces;

import java.util.*;

public class A {

	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		System.out.println("NO");

	}

}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("NO");
		sc.close();
	}
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class Solve6 {

    public static void main(String[] args) throws IOException {
        PrintWriter pw = new PrintWriter(System.out);
        new Solve6().solve(pw);
        pw.flush();
        pw.close();
    }

    public void solve(PrintWriter pw) throws IOException {
        FastReader sc = new FastReader();
        pw.println("NO");
    }

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
            }
        }

        public String next() {
            if (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                }
            }
            return st.nextToken();
        }

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

        public long nextLong() {
            return Long.parseLong(next());
        }

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

        public String nextLine() {
            try {
                return br.readLine();
            } catch (Exception e) {
            }
            return null;
        }

        public boolean hasNext() throws IOException {
            if (st != null && st.hasMoreTokens()) {
                return true;
            }
            String s = br.readLine();
            if (s == null || s.isEmpty()) {
                return false;
            }
            st = new StringTokenizer(s);
            return true;
        }
    }
}

public class S{
    public static void main(String[] args){
        System.out.println("NO");
    }
}

public class Solution{
    public static void main(String[] args){
        System.out.println("No");
    }
}

    import java.io.*;

    public class cf {
    	public static void main(String[] arg) throws Exception{

    		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    		System.out.println("NO");
    	}
   	}

public class pre338
{
    public static void main(String args[])
    {
        System.out.print("No");
    }
}

public class Main
{
	public static void main(String[] args) {
		System.out.println("NO");
	}
}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("no");
	}
}

public class Camel{
    public static void main(String args[]) {
        System.out.println("NO");
    }
}

import java.util.*;
import java.io.*;
public class Main
{
    static PrintWriter out;

	static class FastReader{
		BufferedReader br;
		StringTokenizer st;
		public FastReader(){
			br=new BufferedReader(new InputStreamReader(System.in));
			out=new PrintWriter(System.out);
		}
		String next(){
			while(st==null || !st.hasMoreElements()){
				try{
					st= new StringTokenizer(br.readLine());
				}
				catch (IOException e){
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
		int nextInt(){
			return Integer.parseInt(next());
		}
		long nextLong(){
			return Long.parseLong(next());
		}
		double nextDouble(){
			return Double.parseDouble(next());
		}
		String nextLine(){
			String str = "";
			try{
				str=br.readLine();
			}
			catch(IOException e){
				e.printStackTrace();
			}
			return str;
		}
	}

    public static int no(int n)
    {
        if(n>=1 && n<=9)
        {
            return 1 ;
        }

        return no(n/10) + 1 ;
    }

    public static void main(String[] args)
    {
       FastReader scn = new FastReader();
       /*
        int t = scn.nextInt() ;

        for( int k1 = 1; k1 <= t ; k1++)
        {

             int n = scn.nextInt() ;

             long[] arr = new long[n] ;

             for( int i = 0;   i< n ; i++)
             {
                 arr[i] = scn.nextLong() ;
             }

           if( n== 1)
           {
               out.println(1 + " " + arr[0] +" " + 0) ;
           }

           else{
               int moves = 0 ;

               long prev = 0;
               long a =0 ;
               long b = 0 ;

              boolean check= true ;
              boolean help1 = false ;
              boolean help2 = false  ;

              int i= 0 ;
              int j = arr.length -  1 ;
              while( i <=  j)
              {

              if(check)
              {
                  long temp = arr[i] ;

                  while(temp <= prev)
                  {
                      i++ ;
                      if(i<=j)
                      temp = temp + arr[i] ;

                      else
                      {a = a + temp ;
                      moves++ ;
                      help1 = true ;
                      break ;
                      }
                  }

                  if(help1)
                  {
                      break ;
                  }
                  i++ ;
                  a = a+ temp ;

                  prev = temp ;
                  check= false;
              }

              else{

                  long temp = arr[j] ;
                  while(temp <= prev)
                  {
                      j-- ;
                      if(i<=j)
                      temp = temp + arr[j] ;

                      else{
                          moves++ ;
                          b = b + temp ;
                          help2 = true ;
                          break ;
                      }
                  }

                  if(help2) break ;
                  j-- ;
                  b = b +  temp ;
                  prev = temp ;
                  check = true ;
              }

              moves++ ;

              }

            out.println(moves + " " + a +" " + b) ;

           }

        }

        out.flush() ;
        */
        out.println("NO");
        out.flush() ;

    }
}

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
            Solution.solve(in, out);
        out.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
        public int[] readArray(int n)
        {
            int[] arr=new int[n];
            for(int i=0;i<n;i++) arr[i]=nextInt();
            return arr;
        }
    }
}
class Solution
{
    public static void solve(Main.InputReader in, PrintWriter out)
    {
        out.println("NO");
    }
}

/*****Author: Satyajeet Singh, Delhi Technological University************************************/
    import java.io.*;
    import java.util.*;
    import java.text.*;
    import java.lang.*;
    import java.math.*;
public class Main{
/*********************************************Constants******************************************/
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static long mod=(long)1e9+7;
    static long mod1=998244353;
    static ArrayList<Integer> graph[];
    static int pptr=0;
    static String st[];
/*****************************************Solutions Begins***************************************/
    public static void main(String args[]) throws Exception{
        out.print("No");
/****************************************Solutions Ends**************************************************/
        out.flush();
        out.close();
    }
/****************************************Template Begins************************************************/
    static void nl() throws Exception{
        pptr=0;
        st=br.readLine().split(" ");
    }
    static void nls() throws Exception{
        pptr=0;
        st=br.readLine().split("");
    }
    static int pi(){
        return Integer.parseInt(st[pptr++]);
    }
    static long pl(){
        return Long.parseLong(st[pptr++]);
    }
    static double pd(){
        return Double.parseDouble(st[pptr++]);
    }
    static String ps(){
        return st[pptr++];
    }
/***************************************Precision Printing**********************************************/
    static void printPrecision(double d){
        DecimalFormat ft = new DecimalFormat("0.000000000000");
        out.print(ft.format(d));
    }
/**************************************Bit Manipulation**************************************************/
    static void printMask(long mask){
        System.out.println(Long.toBinaryString(mask));
    }
    static int countBit(long mask){
        int ans=0;
        while(mask!=0){
            mask&=(mask-1);
            ans++;
        }
        return ans;
    }
/******************************************Graph*********************************************************/
    static void Makegraph(int n){
        graph=new ArrayList[n];
        for(int i=0;i<n;i++){
            graph[i]=new ArrayList<>();
        }
    }
    static void addEdge(int a,int b){
        graph[a].add(b);
    }
    // static void addEdge(int a,int b,int c){
    //     graph[a].add(new Pair(b,c));
    // }
/*********************************************PAIR********************************************************/
    static class Pair implements Comparable<Pair> {
        int u;
        int v;
        int index=-1;
        public Pair(int u, int v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }
        public int compareTo(Pair other) {
            if(index!=other.index)
                return Long.compare(index, other.index);
            return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/******************************************Long Pair*******************************************************/
    static class Pairl implements Comparable<Pairl> {
            long u;
            long v;
            int index=-1;
            public Pairl(long u, long v) {
                this.u = u;
                this.v = v;
            }
            public int hashCode() {
                int hu = (int) (u ^ (u >>> 32));
                int hv = (int) (v ^ (v >>> 32));
                return 31 * hu + hv;
            }
            public boolean equals(Object o) {
                Pairl other = (Pairl) o;
                return u == other.u && v == other.v;
            }
            public int compareTo(Pairl other) {
                if(index!=other.index)
                    return Long.compare(index, other.index);
                return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
            }
            public String toString() {
                return "[u=" + u + ", v=" + v + "]";
            }
        }
/*****************************************DEBUG***********************************************************/
    public static void debug(Object... o){
        System.out.println(Arrays.deepToString(o));
    }
/************************************MODULAR EXPONENTIATION***********************************************/
    static long modulo(long a,long b,long c){
        long x=1;
        long y=a%c;
        while(b > 0){
            if(b%2 == 1)
                x=(x*y)%c;
            y = (y*y)%c;
            b /= 2;
        }
        return  x%c;
    }
/********************************************GCD**********************************************************/
    static long gcd(long x, long y){
        if(x==0)
            return y;
        if(y==0)
            return x;
        long r=0, a, b;
        a = (x > y) ? x : y;
        b = (x < y) ? x : y;
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }

/********************************************End***********************************************************/
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
	static int mod = (int)(1e9+7);
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	public static void main(String sp[])throws IOException{
		Scanner sc = new Scanner(System.in);
		//FastReader sc = new FastReader();
		System.out.println("NO");

	}

	public static class pair{
		long bal;
		long wt;
		long diff;
	}

	public static class comp implements Comparator<pair>{
		public int compare(pair o1, pair o2){
			return Long.valueOf(o1.diff).compareTo(Long.valueOf(o2.diff));
		}
	}

	static class FastReader
		{
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public FastReader()
		{
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public FastReader(String file_name) throws IOException
		{
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException
		{
			byte[] buf = new byte[64]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1)
			{
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() throws IOException
		{
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
			{
				ret = ret * 10 + c - '0';
			}  while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public long nextLong() throws IOException
		{
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public double nextDouble() throws IOException
		{
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');

			if (c == '.')
			{
				while ((c = read()) >= '0' && c <= '9')
				{
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException
		{
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException
		{
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException
		{
			if (din == null)
				return;
			din.close();
		}
	}
}

import java.io.*;
import java.util.InputMismatchException;

public class Solution {
    public static void main(String[] args) throws Exception {
        Reader in = new Reader(System.in);
        Output out = new Output(System.out);
       // int t=in.readInt();
      //  for(int x=0;x<t;x++)
        {
           // int b=in.readInt();
           out.printLine("NO");

        }
    }

	private static class Reader {
		private InputStream str;
		private byte[] buf = new byte[1024];
		private int curCh;
		private int noCh;
		private SpaceCharFilter fltr;

		public Reader(InputStream strim) {
			this.str = strim;
		}

		public int read() {
			if (noCh == -1) {
				throw new InputMismatchException();
			}
			if (curCh >= noCh) {
				curCh = 0;
				try {
					noCh = str.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (noCh <= 0) {
					return -1;
				}
			}
			return buf[curCh++];
		}

		public int readInt() {
			int c = read();
			while (isspsch(c)) {
				c = read();
			}
			int sin = 1;
			if (c == '-') {
				sin = -1;
				c = read();
			}
			int result = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				result *= 10;
				result += c - '0';
				c = read();
			} while (!isspsch(c));
			return result * sin;
		}

		public String readString() {
			int c = read();
			while (isspsch(c)) {
				c = read();
			}
			StringBuilder result = new StringBuilder();
			do {
				result.appendCodePoint(c);
				c = read();
			} while (!isspsch(c));
			return result.toString();
		}

		public double readDouble() {
			int c = read();
			while (isspsch(c)) {
				c = read();
			}
			int sin = 1;
			if (c == '-') {
				sin = -1;
				c = read();
			}
			double result = 0;
			while (!isspsch(c) && c != '.') {
				if (c == 'e' || c == 'E') {
					return result * Math.pow(10, readInt());
				}
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				result *= 10;
				result += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isspsch(c)) {
					if (c == 'e' || c == 'E') {
						return result * Math.pow(10, readInt());
					}
					if (c < '0' || c > '9') {
						throw new InputMismatchException();
					}
					m /= 10;
					result += (c - '0') * m;
					c = read();
				}
			}
			return result * sin;
		}

		public long readLong() {
			int c = read();
			while (isspsch(c)) {
				c = read();
			}
			int sin = 1;
			if (c == '-') {
				sin = -1;
				c = read();
			}
			long result = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				result *= 10;
				result += c - '0';
				c = read();
			} while (!isspsch(c));
			return result * sin;
		}

		public boolean isspsch(int c) {
			if (fltr != null) {
				return fltr.isspsch(c);
			}
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next() {
			return readString();
		}

		public interface SpaceCharFilter {
			public boolean isspsch(int ch);
		}
	}

	private static class Output {
		private final PrintWriter wtr;

		public Output(OutputStream outputStream) {
			wtr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
		}

		public Output(Writer wtr) {
			this.wtr = new PrintWriter(wtr);
		}

		public void print(Object... objects) {
			for (int i = 0; i < objects.length; i++) {
				if (i != 0) {
					wtr.print(' ');
				}
				wtr.print(objects[i]);
			}
			wtr.flush();
		}

		public void printLine(Object... objects) {
			print(objects);
			wtr.println();
			wtr.flush();
		}

		public void close() {
			wtr.close();
		}

		public void flush() {
			wtr.flush();
		}
	}
}

import java.util.Scanner;

public class codeforces {

    static Scanner stdin = new Scanner(System.in);

    public static void main(String args[]) {
        System.out.println("No");
    }
}

public class prac {
    public static void main(String [] args){
        System.out.println("No");
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author EigenFunk
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AIsItRated solver = new AIsItRated();
        solver.solve(1, in, out);
        out.close();
    }

    static class AIsItRated {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            out.println("Yes");
        }

    }
}

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

    }
}

import java.util.Locale;
import java.util.Scanner;

public class cont {

	public static void main(String[] args) {

		Scanner in;

		in = new Scanner(System.in);
		in.useLocale(new Locale("US"));
		Locale.setDefault(new Locale("en", "US"));

		//String s =  in.nextLine();
		//System.out.println(s);
		System.exit(0);

	}

}

import java.util.Scanner;
public class asdfghjkhh {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String s=sc.next();
		System.out.println("standard output");
		}

}

import java.util.Scanner;

// Java program to print n-th permutation
public class cp
{

    // Driver program to test above method
    public static void main(String[] args) {

        // TODO Auto-generated method stub

    }
}

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Unstoppable solver = new Unstoppable();
	//	int t=in.nextInt();
	//	while(t-->0)
        solver.solve(in, out);
        out.close();
    }

    static class Unstoppable {

        public void solve(InputReader in, PrintWriter out) {

          out.println("YES");
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public long nextLong(){
            return Long.parseLong(next());
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.Scanner;

public class AProblem {
    private String n;

    private void input(){
        Scanner sc = new Scanner(System.in);
        n = sc.next();
        System.out.println(n);
    }

    public static void main(String[] args){
        AProblem duc = new AProblem();
        duc.input();
    }
}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{

	 Scanner sc=new Scanner (System.in);

	        //System.out.println(2);

	}

}

import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class div {
    private static Scanner sc = new Scanner(System.in);
    private static Map<Character, Integer> m = new HashMap<>();
    private static List<Integer> l = new ArrayList<>();
    private static int sum = 0;

    public static void main(String[] args) {
        System.out.println(true);
//        StringBuffer res[] = new StringBuffer[n];

//        int[] a = new int[3];

//        int dp[][] = new int[n][n];
//        Boolean f = false;

//        int a = sc.nextInt();
//        int b = sc.nextInt();
//
//        int res = 1;
//        for (int i = 1; i <= Math.min(a, b); i++) {
//            res *= i;
//        }
//        System.out.println(res);
    }
}

import javax.management.DynamicMBean;
import javax.print.DocFlavor;
import javax.print.attribute.HashAttributeSet;
import java.awt.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.net.Inet4Address;
import java.nio.file.attribute.FileAttribute;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.TemporalAdjusters;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.util.Arrays;
import java.util.concurrent.Callable;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.TemporalAdjusters;

public class Main {
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong()
        {
            return Long.parseLong(next());
        }

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static void main(String[] args) {
        FastReader sc = new FastReader();
    }

}

import java.io.BufferedReader;
import java.io.*;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.math.*;
public class Main
{
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong()
        {
            return Long.parseLong(next());
        }

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
   public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        PrintWriter pw=new PrintWriter(System.out);
        int t=1;//sc.nextInt();
        while(t-->0)
        {
          //int n=sc.nextInt();
          //int a[]=new int[n];
          //for(int i=0;i<n;i++)
         pw.println("YES");
        }
           pw.close();
    }
}

import java.util.*;
import java.io.*;
public class Q1Div3
{
	public static void main(String args[]) throws Exception
	{
		System.out.println("Is it rated?");
	}

	static class Print {
		private final BufferedWriter bw;

		public Print() {
			this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
		}

		public void print(Object object) throws IOException {
			bw.append("" + object);
		}

		public void println(Object object) throws IOException {
			print(object);
			bw.append("\n");
		}

		public void close() throws IOException {
			bw.close();
		}
	}

	static class Scan {
		private byte[] buf = new byte[1024 * 1024];
		private int index;
		private InputStream in;
		private int total;

		public Scan() {
			in = System.in;
		}

		public int scan() throws IOException {
			if (total < 0)
				throw new InputMismatchException();
			if (index >= total) {
				index = 0;
				total = in.read(buf);
				if (total <= 0)
					return -1;
			}
			return buf[index++];
		}

		public int scanInt() throws IOException {
			int integer = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		public double scanDouble() throws IOException {
			double doub = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n) && n != '.') {
				if (n >= '0' && n <= '9') {
					doub *= 10;
					doub += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			if (n == '.') {
				n = scan();
				double temp = 1;
				while (!isWhiteSpace(n)) {
					if (n >= '0' && n <= '9') {
						temp /= 10;
						doub += (n - '0') * temp;
						n = scan();
					} else
						throw new InputMismatchException();
				}
			}
			return doub * neg;
		}

		public long scanLong() throws IOException {
			long ret = 0;
			long c = scan();
			while (c <= ' ') {
				c = scan();
			}

			boolean neg = (c == '-');
			if (neg) {
				c = scan();
			}

			do {
				ret = ret * 10 + c - '0';
			} while ((c = scan()) >= '0' && c <= '9');

			if (neg) {
				return -ret;
			}
			return ret;
		}

		public String scanString() throws IOException {
			StringBuilder sb = new StringBuilder();
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			while (!isWhiteSpace(n) || n == ' ') {
				sb.append((char) n);
				n = scan();
			}
			return sb.toString();
		}

		private boolean isWhiteSpace(int n) {
			if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
				return true;
			return false;
		}
	}
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;
public class GFG {
	public static void main (String[] args) {
		Scanner scan = new Scanner(System.in);

	    System.out.println();
	}
}

import java.util.*;
import java.lang.*;
 public class Main{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
       System.out.print(s);

    }
}

import java.util.*;
public class useless
{
    public static void main(String[] args)
    {

    }
}

import javax.swing.text.html.HTMLDocument;
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    // static SingleLinkedList link = new SingleLinkedList();
    //  static DoubleLinkedList doubleLink = new DoubleLinkedList();

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        OutputStream fOut = System.out;
        Scanner fin = new Scanner(System.in);
        try {
            fin = new Scanner(new FileInputStream("anniversary.in"));
        } catch (Exception ignored) {
        }
        try {
            fOut = new FileOutputStream("anniversary.out");
        } catch (Exception ignored) {
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PrintWriter fout = new PrintWriter(fOut);

        int testcase=1;
        for(int test=0;test<testcase;test++){

        }

        out.flush();
        out.close();
        fout.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public long nextLong() {
            return Long.parseLong(next());
        }

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

        public char[] nextCharArray() {
            return next().toCharArray();
        }
    }

    public static void ansA() {
        /*
        long n = in.nextLong();
        long maxM = n, minM = 1;
        BigInteger delta = BigInteger.ZERO;

        long m = in.nextLong();
        long x = in.nextLong();
        long x1 = 0;

        long trueM = 0, trueX = 0;

        long a = 1;
        boolean dou = false;
        boolean small = false;

        small = false;
        while (true) {
            x1 = x;

            long average = (maxM + minM) / 2;
            x = (x + average) % m;
            delta = delta.add(BigInteger.valueOf(average));

            if (x < x1) {
                System.out.println("<" + average);
                small = false;
                minM = (maxM + minM + 1) / 2;

            }
            if (x > x1) {
                System.out.println(">" + average);

                if (small) {
                    maxM = (maxM + minM - 1) / 2;
                    small = false;
                } else {
                    small = true;
                }

            }
            if (x == x1) {
                System.out.println("=");
                long re = average-Long.parseLong(String.valueOf(delta.mod(BigInteger.valueOf(average))));
                System.out.println("x=" + re + "    M:" + average);
                break;
            }
            if (minM == maxM) {
                System.out.println("fail : mod" + average % m);
                break;
            }
        }

         * */
    }

    public static void ansB() {
        /*

         * */
    }

    public class BinaryHeap {

        public BinaryHeap() {
            this(DEFAULT_CAPACITY);
        }

        public BinaryHeap(Comparable[] items) {
            currentSize = items.length;
            array = new Comparable[(currentSize + 2) * 11 / 10];

            int i = 1;
            for (Comparable item : items) {
                array[i++] = item;
            }
            buildHeap();
        }

        public BinaryHeap(int capacity) {
            currentSize = 0;
            array = new Comparable[capacity + 1];
        }

        public void insert(Comparable x) {

            int hole = ++currentSize;
            for (; hole > 1 && x.compareTo(array[hole / 2]) < 0; hole /= 2)
                array[hole] = array[hole / 2];
            array[hole] = x;
        }

        public Comparable findMin() {
            if (isEmpty())
                return null;
            return array[1];
        }

        public Comparable deleteMin() {
            if (isEmpty())
                return null;

            Comparable minItem = findMin();
            array[1] = array[currentSize--];
            percolateDown(1);

            return minItem;
        }

        private void buildHeap() {
            for (int i = currentSize / 2; i > 0; i--)
                percolateDown(i);
        }

        public boolean isEmpty() {
            return currentSize == 0;
        }

        public boolean isFull() {
            return currentSize == array.length - 1;
        }

        public void makeEmpty() {
            currentSize = 0;
        }
        private static final int DEFAULT_CAPACITY = 100;
        private int currentSize;      // Number of elements in heap
        private Comparable[] array; // The heap array
        private void percolateDown(int hole) {
            int child;
            Comparable tmp = array[hole];

            for (; hole * 2 <= currentSize; hole = child) {
                child = hole * 2;
                if (child != currentSize && array[child + 1].compareTo(array[child]) < 0)
                    child++;
                if (array[child].compareTo(tmp) < 0)
                    array[hole] = array[child];
                else
                    break;
            }
            array[hole] = tmp;
        }
    }

    public static class stack{

        stack() {
            stackTop=-1;
            maxStackItemIndex=-1;
        }
        void push(int x)
        {
            stackTop++;
            if(stackTop>=1000000)
                ;  //栈满
            else
            {
                stackItem[stackTop]=x;
                if(x>Max())
                {
                    link2NextMaxItem[stackTop]=maxStackItemIndex;
                    maxStackItemIndex=stackTop;
                }
                else
                    link2NextMaxItem[stackTop]=-1;
            }
        }
        int Pop()
        {
            int ret;

                ret=stackItem[stackTop];
                if(stackTop==maxStackItemIndex)
                {
                    maxStackItemIndex=link2NextMaxItem[stackTop];
                }
                stackTop--;

            return ret;
        }
        int Max()
        {
            if(maxStackItemIndex>=0)
                return stackItem[maxStackItemIndex];
            else
                return -99999;
        }
        int stackItem[]=new int[1000000];
        int stackTop;
        int link2NextMaxItem[]=new int [1000000];
        int maxStackItemIndex;
    };

    public static void heapSort(long[] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap(a, 0, j);
            adjustHeap(a, 0, j);
        }

    }

    public static void adjustHeap(long[] a, int i, int length) {
        long temp = a[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k] < a[k + 1]) {
                k++;
            }
            if (a[k] > temp) {
                a[i] = a[k];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp;
    }

    public static void swap(long[] a, int a1, int a2) {
        long temp = a[a1];
        a[a1] = a[a2];
        a[a2] = temp;
    }

    static int m;
    public static int dp(int a[]) {
        int dp[][] = new int[a.length / 2 + 1][a.length / 2 + 1];

        for (int j = 1; j < m; j++) {
            for (int i = 0; i <= a.length / 2 - j; i++) {
                int total = 0;
                for (int k = 0; k < j; k++) {
                    total += a[2 * i + k];
                }
                dp[i + 1][j] = total;

            }
        }
        for (int j = 2; j <= a.length / 2; j++) {
            for (int i = 1; i <= a.length / 2 - j + 1; i++) {
                for (int k = i; k < j; k++) {
                    int ans = dp[i][k] + dp[i + k][j - k];
                    if (ans > dp[i][j]) dp[i][j] = ans;
                }

            }
        }
        return dp[1][a.length / 2];
    }

    public static void calculate() {
        Scanner in = new Scanner(System.in);
        for (int test = 0; test < 10; test++) {
            String string = in.next();

            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "+");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "+");
            }

            string = string.replace("-", "m");
            string = string.replace("(m", "(-");
            string = string.replace("~m", "+~-");
            string = string.replace("m~", "+-~");
            if (string.charAt(0) == 'm') string = string.replaceFirst("m", "-");

            while (string.contains(")") && string.contains("(")) {
                int right = string.indexOf(")");
                String sub = string.substring(0, right);
                int left = sub.lastIndexOf("(");
                string = string.substring(0, left) + calculate(string.substring(left + 1, right)) + string.substring(right + 1);
            }
            string = calculate(string);
            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "");
            }
            System.out.println(string);
            System.out.flush();
        }
    }

    public static String calculate(String string) {
        int index = -1;

        String sub = string;
        while (sub.contains("~+") || sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
            sub = sub.replace("~+", "~");
        }
        while (sub.contains("~")) {
            int index1 = sub.indexOf("~");
            int index2 = index1 + 1;
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index1) + ~Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("*")) {
            int index1 = sub.indexOf("*");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + Integer.parseInt(sub.substring(index3 + 1, index1)) * Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
        }

        while (sub.contains("+") || sub.contains("m")) {

            boolean add = sub.indexOf("+") < sub.indexOf("m");

            int index1 = Math.min(sub.indexOf("+"), sub.indexOf("m"));

            if (!sub.contains("+")) {
                index1 = sub.indexOf("m");
                add = false;
            }
            if (!sub.contains("m")) {
                index1 = sub.indexOf("+");
                add = true;
            }
            if (sub.contains("+") && (sub.indexOf("+") == 0 || !((sub.charAt(sub.indexOf("+") - 1) == 45 || sub.charAt(sub.indexOf("+") - 1) > 47 && sub.charAt(sub.indexOf("+") - 1) < 58)))) {
                sub = sub.substring(0, sub.indexOf("+")) + sub.substring(sub.indexOf("+") + 1);
                continue;
            }

            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            if (add)
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) + Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
            else
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) - Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);

        }
        while (sub.contains("&")) {
            int index1 = sub.indexOf("&");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) & Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        while (sub.contains("^")) {
            int index1 = sub.indexOf("^");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) ^ Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }

        while (sub.contains("|")) {
            int index1 = sub.indexOf("|");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) | Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        return sub;
    }

    public static long overflow(long num, int digit) {
        num = num * num;

        if (digit(num) > digit) {
            digit = digit(num) - digit;
            return MinusDigit(num, digit);
        }
        return num;

    }

    public static long MinusDigit(long number, int digit) {

        while (digit >= 1) {
            number = number / 10;
            digit--;
        }
        return number;
    }

    public static int digit(long num) {
        int digit = 1;
        while (num >= 10) {
            num = num / 10;
            digit++;
        }
        return digit;
    }

    public static int findValue(long[] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int findValue(long[][] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2][1]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2][1]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int numOfFindValue(long[] a, int begin, int end, int index) {
        long value = a[index];
        int index1 = index;
        int num = 1;
        while (index1 < end) {
            index1++;
            if (a[index1] == value) num++;
            else break;
        }
        while (index > begin) {
            index--;
            if (a[index] == value) num++;
            else break;
        }

        return num;
    }

    public static void heapSort2(int[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(int[][] a, int i, int length) {
        int temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(int[][] a, int a1, int a2) {
        int temp[] = new int[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static void heapSort2(long[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(long[][] a, int i, int length) {
        long temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(long[][] a, int a1, int a2) {
        long temp[] = new long[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static class SingleLinkedList {
        private int size;
        private Node head;

        public SingleLinkedList() {
            size = 0;
            head = null;
        }

        private class Node {
            private Object data;
            private Node next;
            private long datas[];

            public Node(Object data) {
                this.data = data;
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public Object addHead(Object obj, long a[]) {
            Node newHead = new Node(obj);
            newHead.datas = a;
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public void addIntSmallToLarge(int a) {
            long bb[] = new long[1];
            addIntSmallToLarge(a, bb);
        }

        public void addIntSmallToLarge(int a, long bb[]) {
            Node newNode = new Node(a);
            newNode.datas = bb;

            if (size == 0) {
                head = newNode;
                size++;
            } else {
                Node b = head;
                if (Integer.parseInt(b.data.toString()) >= a) {
                    addHead(a);
                    return;
                }
                if (size == 1 && Integer.parseInt(b.data.toString()) < a) {
                    b.next = newNode;
                    size++;
                    return;
                }
                for (int i = 1; i < size; i++) {
                    if (b != null && Integer.parseInt(b.data.toString()) <= a && b.next != null && Integer.parseInt(b.next.data.toString()) >= a) {
                        newNode.next = b.next;
                        b.next = newNode;
                        break;
                    }
                    if (b != null)
                        b = b.next;

                    if (i == size - 1 && b != null && Integer.parseInt(b.data.toString()) < a) {
                        b.next = newNode;
                    }
                }
                size++;
            }

        }

        public Object deleteHead() {
            Object obj = head.data;
            head = head.next;
            size--;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return true;
        }

        public Object deleteIndex(int index) {
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return current.data;
        }

        public boolean isEmpty() {
            return (size == 0);
        }

        public void display() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data + "->");
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

        public void displayWithoutGap() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data);
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

    }

    public static class DoubleLinkedList {
        private int size;
        private Node head;
        private Node end;

        public DoubleLinkedList() {
            size = 0;
            head = new Node();
            end = new Node();
        }

        private class Node {
            private Object data;
            private Node next;
            private Node pre;

            public Node(Object data) {
                this.data = data;
            }

            public Node() {
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                newHead.next = head.next;
                newHead.next.pre = newHead;
                head.next = newHead;
                newHead.pre = head;
            }
            size++;
            return obj;
        }

        public Object add(int index, Object obj) {
            if (index > size + 1) {
                System.out.println("index out of size");
                return false;
            }
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                Node current = head;
                for (int i = 1; i < index; i++) {
                    current = current.next;
                }
                newHead.next = current.next;
                newHead.pre = current;
                current.next = newHead;
                newHead.next.pre = newHead;
            }
            size++;
            return obj;
        }

        public void exchange(int begin1, int end1, int begin2, int end2) {
            Node begin11 = findByIndex(begin1);
            Node begin12 = findByIndex(begin2);
            Node end11 = findByIndex(end1);
            Node end12 = findByIndex(end1);
            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public void exchange(Node begin11, Node end11, Node begin12, Node end12) {

            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public Object addTail(Object obj) {
            Node newTail = new Node(obj);
            if (size == 0) {
                head.next = newTail;
                newTail.pre = head;
                newTail.next = end;
                end.pre = newTail;
            } else {
                newTail.pre = end.pre;
                newTail.pre.next = newTail;
                end.pre = newTail;
                newTail.next = end;
            }
            size++;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head.next;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public Node findByIndex(int index) {
            if (index > size) return null;
            index++;
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }

            return current;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head.next;
            Node previous = head.next;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }
            return true;
        }

        public boolean deleteIndex(int index) {
            if (index > size) return false;
            index++;
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
            } else {
                previous.next = current.next;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }

            size--;
            return true;
        }

        public void display(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "→");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "←");
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            }
        }

        public void displayWithoutGap(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data + " ");
                            break;
                        } else {
                            System.out.print(node.data + " ");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data);
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            }
        }

    }

}

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

public class IsItRated {
    public static void main(String[] args) {
        FastReader reader = new FastReader();
        String in = reader.nextLine();
        System.out.println(in);
    }

    public static class FastReader {
    BufferedReader br;
    StringTokenizer st;

    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    public String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

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

    public long nextLong() {
        return Long.parseLong(next());
    }

    public String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }
}
}

import java.util.*;
public class prog{
	public static void main(String[] args) {
		System.out.print("Yes");
	}
}

import java.util.Scanner;

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

    }

}

public class IsItRated
{
    public static void main(String a[])
    {
        System.out.println("Is It Rated");
    }
}

public class Main
{
	public static void main(String[] args) {
		System.out.println("YES");
	}
}

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {

    }
}

// package com.company;
import javax.swing.*;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.*;
/**
 * @author_jigar_nainuji
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Palindrome solver = new Palindrome();
//        int t = in.nextInt();
        int t=1;
        for(int i=0;i<t;i++) {
            solver.solve(i, in, out);
        }
        out.close();
    }

    static class Palindrome {
        static int mod = 1000000007;
        void solve(int testNumber, InputReader in, PrintWriter out) {
          System.out.println("Yes");
        }
    }

    static class Pair {
        int t;
        int l;
        int h;

        Pair(int t,int l,int h){
            this.t=t;
            this.l=l;
            this.h=h;
        }
    }

    static class Maths{
        static int gcd(int a, int b) {
            if (a == 0)
                return b;
            return gcd(b % a, a);
        }

        public  static int lcm(int a, int b)
        {
            return (a*b)/gcd(a, b);
        }

        public static long factorial(int n){
            long fact = 1;
            for(int i=1;i<=n;i++){
                fact *= i;
            }
            return fact;
        }
    }

    static class Characters{
        public static boolean isVovel(char a){
            return a == 'a' || a == 'e' || a == 'i' || a == 'o' || a == 'u';
        }
    }

    static class Binary {
        public static long numberOfBits(long n){
            long count=0;
            while(n>0){
                count++;
                n >>=1;
            }
            return count;
        }

        public static long numberOfSetBits(long n){
            long count = 0;
            int p = 1;
            while (n>0){
                if((n&p) == 1){
                    count++;
                }
                n >>= 1;
            }
            return count;
        }
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public Long nextLong(){
            return Long.parseLong(next());
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.*;
import java.util.Queue;
import java.util.StringTokenizer;
import java.math.BigInteger;

  public class hello2
 {static class FastReader
       {
           BufferedReader br;
           StringTokenizer st;

           public FastReader()
           {
               br = new BufferedReader(new
                        InputStreamReader(System.in));
           }

           String next()
           {
               while (st == null || !st.hasMoreElements())
               {
                   try
                   {
                       st = new StringTokenizer(br.readLine());
                   }
                   catch (IOException  e)
                   {
                       e.printStackTrace();
                   }
               }
               return st.nextToken();
           }

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

           long nextLong()
           {
               return Long.parseLong(next());
           }

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

           String nextLine()
           {
               String str = "";
               try
               {
                   str = br.readLine();
               }
               catch (IOException e)
               {
                   e.printStackTrace();
               }
               return str;
           }

       }

    static String sum (String s)
    {
        String s1 = "";

        if(s.contains("a"))
            s1+="a";
        if(s.contains("e"))
            s1+="e";
        if(s.contains("i"))
            s1+="i";
        if(s.contains("o"))
            s1+="o";
        if(s.contains("u"))
            s1+="u";

            return s1;

    }
    static int gcd(int a, int b)
{
    return b > 0 ? gcd(b, a % b) : a;
}
    public static void main(String[] args)
    {
       FastReader sc =new FastReader();
       System.out.println("YES");

    }
 }

import java.util.*;
import java.lang.*;
 public class Main{
    public static void main(String[] args)
    {
        System.out.print("rated");

    }
}

import java.util.Scanner;

public class JavaApplication19 {

    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        long x=sc.nextLong();
        if(x==57)System.out.println("319");
        else System.out.println(Math.abs((x*5)-232));

    }

}

import java.util.Scanner;

// Java program to print n-th permutation
public class cp
{

    // Driver program to test above method
    public static void main(String[] args) {

        // TODO Auto-generated method stub

    }
}

import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
//		String input = scanner.nextLine();
		System.out.println("YES");
//		System.out.println("output: standard input");
	}
}

import java.util.*;
public class AprilFools_A {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("YES");
    }
}

import java.util.Scanner;

public class IsItRated {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(sc.nextLine());
    }
}

import java.util.Locale;
import java.util.Scanner;

public class cont {

	public static void main(String[] args) {

		Scanner in;

		in = new Scanner(System.in);
		in.useLocale(new Locale("US"));
		Locale.setDefault(new Locale("en", "US"));

		String s =  in.nextLine();
		System.out.println("����������� �����");
		System.exit(0);

	}

}

public class Solution{
    public static void main(String args[]){
        System.out.println("Yes");
    }
}

import javax.swing.text.html.HTMLDocument;
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    // static SingleLinkedList link = new SingleLinkedList();
    //  static DoubleLinkedList doubleLink = new DoubleLinkedList();

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        OutputStream fOut = System.out;
        Scanner fin = new Scanner(System.in);
        try {
            fin = new Scanner(new FileInputStream("anniversary.in"));
        } catch (Exception ignored) {
        }
        try {
            fOut = new FileOutputStream("anniversary.out");
        } catch (Exception ignored) {
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PrintWriter fout = new PrintWriter(fOut);

        int testcase=1;
        for(int test=0;test<testcase;test++){
            in.nextInt();
            out.println("233");
        }

        out.flush();
        out.close();
        fout.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public long nextLong() {
            return Long.parseLong(next());
        }

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

        public char[] nextCharArray() {
            return next().toCharArray();
        }
    }

    public static void ansA() {
        /*
        long n = in.nextLong();
        long maxM = n, minM = 1;
        BigInteger delta = BigInteger.ZERO;

        long m = in.nextLong();
        long x = in.nextLong();
        long x1 = 0;

        long trueM = 0, trueX = 0;

        long a = 1;
        boolean dou = false;
        boolean small = false;

        small = false;
        while (true) {
            x1 = x;

            long average = (maxM + minM) / 2;
            x = (x + average) % m;
            delta = delta.add(BigInteger.valueOf(average));

            if (x < x1) {
                System.out.println("<" + average);
                small = false;
                minM = (maxM + minM + 1) / 2;

            }
            if (x > x1) {
                System.out.println(">" + average);

                if (small) {
                    maxM = (maxM + minM - 1) / 2;
                    small = false;
                } else {
                    small = true;
                }

            }
            if (x == x1) {
                System.out.println("=");
                long re = average-Long.parseLong(String.valueOf(delta.mod(BigInteger.valueOf(average))));
                System.out.println("x=" + re + "    M:" + average);
                break;
            }
            if (minM == maxM) {
                System.out.println("fail : mod" + average % m);
                break;
            }
        }

         * */
    }

    public static void ansB() {
        /*

         * */
    }

    public class BinaryHeap {

        public BinaryHeap() {
            this(DEFAULT_CAPACITY);
        }

        public BinaryHeap(Comparable[] items) {
            currentSize = items.length;
            array = new Comparable[(currentSize + 2) * 11 / 10];

            int i = 1;
            for (Comparable item : items) {
                array[i++] = item;
            }
            buildHeap();
        }

        public BinaryHeap(int capacity) {
            currentSize = 0;
            array = new Comparable[capacity + 1];
        }

        public void insert(Comparable x) {

            int hole = ++currentSize;
            for (; hole > 1 && x.compareTo(array[hole / 2]) < 0; hole /= 2)
                array[hole] = array[hole / 2];
            array[hole] = x;
        }

        public Comparable findMin() {
            if (isEmpty())
                return null;
            return array[1];
        }

        public Comparable deleteMin() {
            if (isEmpty())
                return null;

            Comparable minItem = findMin();
            array[1] = array[currentSize--];
            percolateDown(1);

            return minItem;
        }

        private void buildHeap() {
            for (int i = currentSize / 2; i > 0; i--)
                percolateDown(i);
        }

        public boolean isEmpty() {
            return currentSize == 0;
        }

        public boolean isFull() {
            return currentSize == array.length - 1;
        }

        public void makeEmpty() {
            currentSize = 0;
        }
        private static final int DEFAULT_CAPACITY = 100;
        private int currentSize;      // Number of elements in heap
        private Comparable[] array; // The heap array
        private void percolateDown(int hole) {
            int child;
            Comparable tmp = array[hole];

            for (; hole * 2 <= currentSize; hole = child) {
                child = hole * 2;
                if (child != currentSize && array[child + 1].compareTo(array[child]) < 0)
                    child++;
                if (array[child].compareTo(tmp) < 0)
                    array[hole] = array[child];
                else
                    break;
            }
            array[hole] = tmp;
        }
    }

    public static class stack{

        stack() {
            stackTop=-1;
            maxStackItemIndex=-1;
        }
        void push(int x)
        {
            stackTop++;
            if(stackTop>=1000000)
                ;  //栈满
            else
            {
                stackItem[stackTop]=x;
                if(x>Max())
                {
                    link2NextMaxItem[stackTop]=maxStackItemIndex;
                    maxStackItemIndex=stackTop;
                }
                else
                    link2NextMaxItem[stackTop]=-1;
            }
        }
        int Pop()
        {
            int ret;

                ret=stackItem[stackTop];
                if(stackTop==maxStackItemIndex)
                {
                    maxStackItemIndex=link2NextMaxItem[stackTop];
                }
                stackTop--;

            return ret;
        }
        int Max()
        {
            if(maxStackItemIndex>=0)
                return stackItem[maxStackItemIndex];
            else
                return -99999;
        }
        int stackItem[]=new int[1000000];
        int stackTop;
        int link2NextMaxItem[]=new int [1000000];
        int maxStackItemIndex;
    };

    public static void heapSort(long[] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap(a, 0, j);
            adjustHeap(a, 0, j);
        }

    }

    public static void adjustHeap(long[] a, int i, int length) {
        long temp = a[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k] < a[k + 1]) {
                k++;
            }
            if (a[k] > temp) {
                a[i] = a[k];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp;
    }

    public static void swap(long[] a, int a1, int a2) {
        long temp = a[a1];
        a[a1] = a[a2];
        a[a2] = temp;
    }

    static int m;
    public static int dp(int a[]) {
        int dp[][] = new int[a.length / 2 + 1][a.length / 2 + 1];

        for (int j = 1; j < m; j++) {
            for (int i = 0; i <= a.length / 2 - j; i++) {
                int total = 0;
                for (int k = 0; k < j; k++) {
                    total += a[2 * i + k];
                }
                dp[i + 1][j] = total;

            }
        }
        for (int j = 2; j <= a.length / 2; j++) {
            for (int i = 1; i <= a.length / 2 - j + 1; i++) {
                for (int k = i; k < j; k++) {
                    int ans = dp[i][k] + dp[i + k][j - k];
                    if (ans > dp[i][j]) dp[i][j] = ans;
                }

            }
        }
        return dp[1][a.length / 2];
    }

    public static void calculate() {
        Scanner in = new Scanner(System.in);
        for (int test = 0; test < 10; test++) {
            String string = in.next();

            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "+");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "+");
            }

            string = string.replace("-", "m");
            string = string.replace("(m", "(-");
            string = string.replace("~m", "+~-");
            string = string.replace("m~", "+-~");
            if (string.charAt(0) == 'm') string = string.replaceFirst("m", "-");

            while (string.contains(")") && string.contains("(")) {
                int right = string.indexOf(")");
                String sub = string.substring(0, right);
                int left = sub.lastIndexOf("(");
                string = string.substring(0, left) + calculate(string.substring(left + 1, right)) + string.substring(right + 1);
            }
            string = calculate(string);
            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "");
            }
            System.out.println(string);
            System.out.flush();
        }
    }

    public static String calculate(String string) {
        int index = -1;

        String sub = string;
        while (sub.contains("~+") || sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
            sub = sub.replace("~+", "~");
        }
        while (sub.contains("~")) {
            int index1 = sub.indexOf("~");
            int index2 = index1 + 1;
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index1) + ~Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("*")) {
            int index1 = sub.indexOf("*");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + Integer.parseInt(sub.substring(index3 + 1, index1)) * Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
        }

        while (sub.contains("+") || sub.contains("m")) {

            boolean add = sub.indexOf("+") < sub.indexOf("m");

            int index1 = Math.min(sub.indexOf("+"), sub.indexOf("m"));

            if (!sub.contains("+")) {
                index1 = sub.indexOf("m");
                add = false;
            }
            if (!sub.contains("m")) {
                index1 = sub.indexOf("+");
                add = true;
            }
            if (sub.contains("+") && (sub.indexOf("+") == 0 || !((sub.charAt(sub.indexOf("+") - 1) == 45 || sub.charAt(sub.indexOf("+") - 1) > 47 && sub.charAt(sub.indexOf("+") - 1) < 58)))) {
                sub = sub.substring(0, sub.indexOf("+")) + sub.substring(sub.indexOf("+") + 1);
                continue;
            }

            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            if (add)
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) + Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
            else
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) - Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);

        }
        while (sub.contains("&")) {
            int index1 = sub.indexOf("&");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) & Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        while (sub.contains("^")) {
            int index1 = sub.indexOf("^");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) ^ Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }

        while (sub.contains("|")) {
            int index1 = sub.indexOf("|");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) | Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        return sub;
    }

    public static long overflow(long num, int digit) {
        num = num * num;

        if (digit(num) > digit) {
            digit = digit(num) - digit;
            return MinusDigit(num, digit);
        }
        return num;

    }

    public static long MinusDigit(long number, int digit) {

        while (digit >= 1) {
            number = number / 10;
            digit--;
        }
        return number;
    }

    public static int digit(long num) {
        int digit = 1;
        while (num >= 10) {
            num = num / 10;
            digit++;
        }
        return digit;
    }

    public static int findValue(long[] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int findValue(long[][] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2][1]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2][1]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int numOfFindValue(long[] a, int begin, int end, int index) {
        long value = a[index];
        int index1 = index;
        int num = 1;
        while (index1 < end) {
            index1++;
            if (a[index1] == value) num++;
            else break;
        }
        while (index > begin) {
            index--;
            if (a[index] == value) num++;
            else break;
        }

        return num;
    }

    public static void heapSort2(int[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(int[][] a, int i, int length) {
        int temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(int[][] a, int a1, int a2) {
        int temp[] = new int[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static void heapSort2(long[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(long[][] a, int i, int length) {
        long temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(long[][] a, int a1, int a2) {
        long temp[] = new long[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static class SingleLinkedList {
        private int size;
        private Node head;

        public SingleLinkedList() {
            size = 0;
            head = null;
        }

        private class Node {
            private Object data;
            private Node next;
            private long datas[];

            public Node(Object data) {
                this.data = data;
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public Object addHead(Object obj, long a[]) {
            Node newHead = new Node(obj);
            newHead.datas = a;
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public void addIntSmallToLarge(int a) {
            long bb[] = new long[1];
            addIntSmallToLarge(a, bb);
        }

        public void addIntSmallToLarge(int a, long bb[]) {
            Node newNode = new Node(a);
            newNode.datas = bb;

            if (size == 0) {
                head = newNode;
                size++;
            } else {
                Node b = head;
                if (Integer.parseInt(b.data.toString()) >= a) {
                    addHead(a);
                    return;
                }
                if (size == 1 && Integer.parseInt(b.data.toString()) < a) {
                    b.next = newNode;
                    size++;
                    return;
                }
                for (int i = 1; i < size; i++) {
                    if (b != null && Integer.parseInt(b.data.toString()) <= a && b.next != null && Integer.parseInt(b.next.data.toString()) >= a) {
                        newNode.next = b.next;
                        b.next = newNode;
                        break;
                    }
                    if (b != null)
                        b = b.next;

                    if (i == size - 1 && b != null && Integer.parseInt(b.data.toString()) < a) {
                        b.next = newNode;
                    }
                }
                size++;
            }

        }

        public Object deleteHead() {
            Object obj = head.data;
            head = head.next;
            size--;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return true;
        }

        public Object deleteIndex(int index) {
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return current.data;
        }

        public boolean isEmpty() {
            return (size == 0);
        }

        public void display() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data + "->");
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

        public void displayWithoutGap() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data);
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

    }

    public static class DoubleLinkedList {
        private int size;
        private Node head;
        private Node end;

        public DoubleLinkedList() {
            size = 0;
            head = new Node();
            end = new Node();
        }

        private class Node {
            private Object data;
            private Node next;
            private Node pre;

            public Node(Object data) {
                this.data = data;
            }

            public Node() {
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                newHead.next = head.next;
                newHead.next.pre = newHead;
                head.next = newHead;
                newHead.pre = head;
            }
            size++;
            return obj;
        }

        public Object add(int index, Object obj) {
            if (index > size + 1) {
                System.out.println("index out of size");
                return false;
            }
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                Node current = head;
                for (int i = 1; i < index; i++) {
                    current = current.next;
                }
                newHead.next = current.next;
                newHead.pre = current;
                current.next = newHead;
                newHead.next.pre = newHead;
            }
            size++;
            return obj;
        }

        public void exchange(int begin1, int end1, int begin2, int end2) {
            Node begin11 = findByIndex(begin1);
            Node begin12 = findByIndex(begin2);
            Node end11 = findByIndex(end1);
            Node end12 = findByIndex(end1);
            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public void exchange(Node begin11, Node end11, Node begin12, Node end12) {

            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public Object addTail(Object obj) {
            Node newTail = new Node(obj);
            if (size == 0) {
                head.next = newTail;
                newTail.pre = head;
                newTail.next = end;
                end.pre = newTail;
            } else {
                newTail.pre = end.pre;
                newTail.pre.next = newTail;
                end.pre = newTail;
                newTail.next = end;
            }
            size++;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head.next;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public Node findByIndex(int index) {
            if (index > size) return null;
            index++;
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }

            return current;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head.next;
            Node previous = head.next;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }
            return true;
        }

        public boolean deleteIndex(int index) {
            if (index > size) return false;
            index++;
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
            } else {
                previous.next = current.next;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }

            size--;
            return true;
        }

        public void display(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "→");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "←");
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            }
        }

        public void displayWithoutGap(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data + " ");
                            break;
                        } else {
                            System.out.print(node.data + " ");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data);
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            }
        }

    }

}

public class rated
{
    public static void main(String[] args)
    {
        System.out.println(0);
    }
}

/**
 * Created by kareem on 3/31/2020.
 */
public class Round630 {

    static long a, b, c, d, x, y, x1, x2, y1, y2;

    public static void main(String[] args) {
//        Scanner s = new Scanner(System.in);
//        int n = s.nextInt();
//        for (int i = 1; i <= n; i++) {
//            a = s.nextInt();
//            b = s.nextInt();
//            c = s.nextInt();
//            d = s.nextInt();
//            x = s.nextInt();
//            y = s.nextInt();
//            x1 = s.nextInt();
//            y1 = s.nextInt();
//            x2 = s.nextInt();
//            y2 = s.nextInt();
//
//            testCase(i);
//        }

        System.out.println("YES");
    }

    static void testCase(int caseNum) {

        }
    }

import java.io.*;
import java.math.*;
import java.util.*;

public class E {

	static final int INF = BigInteger.TEN.pow(7).intValueExact();

	static class MinNode {
		int l, r;
		MinNode left, right;

		int minNeg, minPos;

		public MinNode(int l, int r) {
			this.l = l;
			this.r = r;
			minNeg = minPos = INF;
			if (r - l > 1) {
				int m = (l + r) >> 1;
				left = new MinNode(l, m);
				right = new MinNode(m, r);
			}
		}

		void set(int idx, int val) {
			if (r - l == 1) {
				minNeg = Math.min(minNeg, val - idx);
				minPos = Math.min(minPos, val + idx);
				return;
			}
			(idx < left.r ? left : right).set(idx, val);
			minNeg = Math.min(left.minNeg, right.minNeg);
			minPos = Math.max(left.minPos, right.minPos);
		}

		int get(int ql, int qr, boolean isNeg) {
			if (ql >= r || l >= qr) {
				return INF;
			}
			if (ql <= l && r <= qr) {
				return isNeg ? minNeg : minPos;
			}
			return Math.min(left.get(ql, qr, isNeg), right.get(ql, qr, isNeg));
		}

	}

	static class Cell implements Comparable<Cell> {
		int x, y;

		public Cell(int x, int y) {
			this.x = x;
			this.y = y;
		}

		@Override
		public int compareTo(Cell o) {
			if (x != o.x) {
				return Integer.compare(x, o.x);
			}
			return Integer.compare(y, o.y);
		}

		Node node;

	}

	static class Node {
		int x, y1, y2, id;
		int len;

		public Node(int x, int y1, int y2, int id) {
			this.x = x;
			this.y1 = y1;
			this.y2 = y2;
			len = y2 - y1 + 1;
			this.id = id;
		}

		ArrayList<int[][]> info = new ArrayList<>();
		MinNode root;
	}

	Node[] b;

	void submit() {
		int s = nextInt();
		Cell[] a = new Cell[s];
		for (int i = 0; i < s; i++) {
			a[i] = new Cell(nextInt(), nextInt());
		}

		Arrays.sort(a);

		b = new Node[s];
		int n = 0;

		for (int i = 0; i < s;) {
			int j = i;
			while (j < s && a[j].x == a[i].x && a[j].y - a[i].y == j - i) {
				j++;
			}
			Node tmp = new Node(a[i].x, a[i].y, a[j - 1].y, n);
			b[n++] = tmp;
			for (int k = i; k < j; k++) {
				a[k].node = b[n - 1];
			}
			i = j;
		}

		b = Arrays.copyOf(b, n);
		Cell[] tmpA = a.clone();
		Arrays.sort(tmpA, (Cell p, Cell q) -> {
			if (p.y != q.y) {
				return p.y < q.y ? -1 : 1;
			}
			return Integer.compare(p.x, q.x);
		});

		next = new int[2 * n - 2];
		head = new int[n];
		Arrays.fill(head, -1);
		to = new int[2 * n - 2];

		for (int i = 0; i < s - 1; i++) {
			if (tmpA[i].y == tmpA[i + 1].y && tmpA[i + 1].x - tmpA[i].x == 1) {
				if (tmpA[i].y == tmpA[i].node.y1 || tmpA[i + 1].y == tmpA[i + 1].node.y1) {
					addEdge(tmpA[i].node.id, tmpA[i + 1].node.id);
				}
			}
		}
		sz = new int[n];
		dead = new boolean[n];
		par = new int[n];
		go(0, -1);

		for (Node v : b) {
			v.root = new MinNode(0, v.y2 - v.y1 + 1);
		}

		int q = nextInt();
		while (q-- > 0) {
			int t = nextInt();
			Cell qc = new Cell(nextInt(), nextInt());
			int idx = Arrays.binarySearch(a, qc);

			qc = a[idx];

			Node v = qc.node;

			int place = qc.y - v.y1;

			if (t == 2) {
				int ans = INF;
				int centre = v.id;
				for (int i = v.info.size() - 1; i >= 0; i--) {
					int[][] tmp = v.info.get(i);
					int dist = tmp[0][place];
					int last = tmp[1][place];

					ans = Math.min(ans, dist + last + b[centre].root.get(0, last + 1, true));
					ans = Math.min(ans, dist - last + b[centre].root.get(last, b[centre].len, false));
					centre = par[centre];
				}

				out.println(ans > INF / 2 ? -1 : ans);
			} else {
				int centre = v.id;
				for (int i = v.info.size() - 1; i >= 0; i--) {
					int[][] tmp = v.info.get(i);
					int dist = tmp[0][place];
					int last = tmp[1][place];
					b[centre].root.set(last, dist);
					centre = par[centre];
				}
			}
		}
	}

	int[] sz;
	boolean[] dead;
	int[] par;

	void dfs2(int v, int p, int root, int[] dist, int[] last) {
		b[v].info.add(new int[][]{dist, last});
		int y1 = b[v].y1;
		int y2 = b[v].y2;

		for (int e = head[v]; e >= 0; e = next[e]) {
			int u = to[e];
			if (u == p || dead[u]) {
				continue;
			}

			Node nodeU = b[u];
			int[] newDist = new int[nodeU.y2 - nodeU.y1 + 1];
			int[] newLast = new int[newDist.length];

			for (int y = nodeU.y1, i = 0; y <= nodeU.y2; y++, i++) {
				if (y < y1) {
					newLast[i] = last[0];
					newDist[i] = dist[0] + 1 + y1 - y;
				} else if (y > y2) {
					newLast[i] = last[last.length - 1];
					newDist[i] = dist[dist.length - 1] + 1 + y - y2;
				} else {
					newLast[i] = last[y - y1];
					newDist[i] = dist[y - y1] + 1;
				}
			}

			dfs2(u, v, root, newDist, newLast);
		}
	}

	void goCentre(int v) {
		Node node = b[v];
		int[] dist = new int[node.y2 - node.y1 + 1];
		int[] last = new int[node.y2 - node.y1 + 1];
		for (int i = 0; i < last.length; i++) {
			last[i]	= i;
		}
		dfs2(v, -1, v, dist, last);
	}

	void go(int v, int father) {
		dfsSz(v, -1);
		int root = v;
		outer: while (true) {
//			for (int u : g[root]) {
			for (int e = head[root]; e >= 0; e = next[e]) {
				int u = to[e];
				if (!dead[u] && sz[u] < sz[root] && 2 * sz[u] > sz[v]) {
					root = u;
					continue outer;
				}
			}
			break;
		}

		par[root] = father;

		goCentre(root);
		dead[root] = true;
		for (int e = head[root]; e >= 0; e = next[e]) {
			int u = to[e];
			if (!dead[u]) {
				go(u, root);
			}
		}
	}

	void dfsSz(int v, int p) {
		sz[v] = 1;
		for (int e = head[v]; e >= 0; e = next[e]) {
			int u = to[e];
			if (u != p && !dead[u]) {
				dfsSz(u, v);
				sz[v] += sz[u];
			}
		}
	}

	int[] next;
	int[] head;
	int[] to;
	int ptr;

	void addEdge(int v, int u) {
		to[ptr] = u;
		next[ptr] = head[v];
		head[v] = ptr++;

		to[ptr] = v;
		next[ptr] = head[u];
		head[u] = ptr++;
	}

	void preCalc() {

	}

	void test() {

	}

	void stress() {
		for (int tst = 0;; tst++) {
			if (false) {
				throw new AssertionError();
			}
			System.err.println(tst);
		}
	}

	E() throws IOException {
		is = System.in;
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		// stress();
		// test();
		out.close();
	}

	static final Random rng = new Random();
	static final int C = 5;

	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}

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

	private InputStream is;
	PrintWriter out;

	private byte[] buf = new byte[1 << 14];
	private int bufSz = 0, bufPtr = 0;

	private int readByte() {
		if (bufSz == -1)
			throw new RuntimeException("Reading past EOF");
		if (bufPtr >= bufSz) {
			bufPtr = 0;
			try {
				bufSz = is.read(buf);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			if (bufSz <= 0)
				return -1;
		}
		return buf[bufPtr++];
	}

	private boolean isTrash(int c) {
		return c < 33 || c > 126;
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isTrash(b))
			;
		return b;
	}

	String nextToken() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!isTrash(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	String nextString() {
		int b = readByte();
		StringBuilder sb = new StringBuilder();
		while (!isTrash(b) || b == ' ') {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	double nextDouble() {
		return Double.parseDouble(nextToken());
	}

	char nextChar() {
		return (char) skip();
	}

	int nextInt() {
		int ret = 0;
		int b = skip();
		if (b != '-' && (b < '0' || b > '9')) {
			throw new InputMismatchException();
		}
		boolean neg = false;
		if (b == '-') {
			neg = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				ret = ret * 10 + (b - '0');
			} else {
				if (b != -1 && !isTrash(b)) {
					throw new InputMismatchException();
				}
				return neg ? -ret : ret;
			}
			b = readByte();
		}
	}

	long nextLong() {
		long ret = 0;
		int b = skip();
		if (b != '-' && (b < '0' || b > '9')) {
			throw new InputMismatchException();
		}
		boolean neg = false;
		if (b == '-') {
			neg = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				ret = ret * 10 + (b - '0');
			} else {
				if (b != -1 && !isTrash(b)) {
					throw new InputMismatchException();
				}
				return neg ? -ret : ret;
			}
			b = readByte();
		}
	}
}

import java.util.*;
public class prog{
	public static void main(String[] args) {
		System.out.print("yes");
	}
}

import java.util.Locale;
import java.util.Scanner;

public class cont {

	public static void main(String[] args) {

		Scanner in;

		in = new Scanner(System.in);
		in.useLocale(new Locale("US"));
		Locale.setDefault(new Locale("en", "US"));

		if (in.hasNext()) {
			String s =  in.nextLine();
			System.out.println("1");
		}

		System.exit(0);

	}

}

import java.util.Locale;
import java.util.Scanner;

public class cont {

	public static void main(String[] args) {

		Scanner in;

		in = new Scanner(System.in);
		in.useLocale(new Locale("US"));
		Locale.setDefault(new Locale("en", "US"));

		String s =  in.nextLine();
		//System.out.println("");
		System.exit(0);

	}
}

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

public class Cf1 {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String lines = br.readLine();

			System.out.println(" ");
		}

	}

/*      MOHD SADIQ        */

import java.sql.Array;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;

public class Main {

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    private long longVal() throws IOException{
        return Long.parseLong(br.readLine().trim());
    }
    private int intVal() throws IOException{
        return Integer.parseInt(br.readLine().trim());
    }
    private double doubleVal() throws IOException{
        return Double.parseDouble(br.readLine().trim());
    }
    private int[] intArr() throws IOException{
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
        }
        return a;
    }
    private long[] longArr() throws IOException {
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(s[i]);
        }
        return a;
    }
    private double[] doubleArr() throws IOException {
        String[] s = br.readLine().trim().split(" ");
        int n = s.length;
        double[] a = new double[n];
        for (int i = 0; i < n; i++) {
            a[i] = Double.parseDouble(s[i]);
        }
        return a;
    }
    private String[] stringArr() throws IOException{
        String[] s = br.readLine().trim().split(" ");
        return s;
    }
    private char[] charArr() throws IOException{
        return br.readLine().trim().toCharArray();
    }
    private static boolean[] sieve(int n){
        boolean[] primes = new boolean[n + 1];
        int i;
        Arrays.fill(primes,true);
        for(i = 2; i * i <= n; ++i) {
            if (primes[i]) {
                for(int p = i * i; p <= n; p += i) {
                    primes[p] = false;
                }
            }
        }
        return primes;
    }

    private String solve() throws IOException {
        Main obj = new Main();
        char[] s = obj.charArr();
        return "Id it rated?";
    }

    public static void main(String[] args) throws IOException {
        Main ob = new Main();
//        int total_test_case = ob.intVal();
         int total_test_case = 1;
        StringBuffer ans = new StringBuffer();
        String k ;
        for(int test_case =0;test_case<total_test_case;test_case++){
            k = ob.solve();
//            System.out.println(k);
            ans.append(k+"\n");
        }
        System.out.print(ans);
    }
}

import java.util.*;
public class again{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        //ArrayList<String> arr =new ArrayList<String>();
        while(in.hasNextLine()){
        String str= in.nextLine();
        System.out.println(str);
        }
    }
}

import java.io.*;
import java.util.*;

public class A {

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong()
        {
            return Long.parseLong(next());
        }

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static void main (String[] args) throws IOException{

        FastReader s = new FastReader();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        bw.flush();
        bw.close();
    }

}

import java.util.*;

public class A{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		// int q = in.nextInt();
		// for(int t = 0; t < q; t++){

		// }
		System.out.println("YES");
	}

}

// int arr[] = new int[n];
// for(int i = 0; i < t; i++){
// }

public class A {
	public static void main(String[] args) {
		System.out.println("1547");
	}

}

import java.util.*;
public class again{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String str= in.nextLine();
        System.out.println(str);
    }
}

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
       Scanner scn=new Scanner(System.in);
       String t=scn.next();
       System.out.println("standard output");
    }
}

public class Main
{
    public static void main(String args[])
    {
        System.out.println("Not Rated");
    }
}

public class rated
{
    public static void main(String[] args)
    {
        System.out.println(0);
    }
}

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

    }
}

public class Main
{
    public static void main(String args[])
    {
        System.out.println("Is it rated?");
    }
}

import java.util.*;
import java.lang.*;
 public class Main{
    public static void main(String[] args)
    {
        System.out.print("YES");

    }
}

import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.nextLine();
		System.out.println(input);
	}
}

import javax.swing.text.html.HTMLDocument;
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    // static SingleLinkedList link = new SingleLinkedList();
    //  static DoubleLinkedList doubleLink = new DoubleLinkedList();

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        OutputStream fOut = System.out;
        Scanner fin = new Scanner(System.in);
        try {
            fin = new Scanner(new FileInputStream("anniversary.in"));
        } catch (Exception ignored) {
        }
        try {
            fOut = new FileOutputStream("anniversary.out");
        } catch (Exception ignored) {
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PrintWriter fout = new PrintWriter(fOut);

        int testcase=1;
        for(int test=0;test<testcase;test++){
            out.println("Yes");

        }

        out.flush();
        out.close();
        fout.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

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

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

        public long nextLong() {
            return Long.parseLong(next());
        }

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

        public char[] nextCharArray() {
            return next().toCharArray();
        }
    }

    public static void ansA() {
        /*
        long n = in.nextLong();
        long maxM = n, minM = 1;
        BigInteger delta = BigInteger.ZERO;

        long m = in.nextLong();
        long x = in.nextLong();
        long x1 = 0;

        long trueM = 0, trueX = 0;

        long a = 1;
        boolean dou = false;
        boolean small = false;

        small = false;
        while (true) {
            x1 = x;

            long average = (maxM + minM) / 2;
            x = (x + average) % m;
            delta = delta.add(BigInteger.valueOf(average));

            if (x < x1) {
                System.out.println("<" + average);
                small = false;
                minM = (maxM + minM + 1) / 2;

            }
            if (x > x1) {
                System.out.println(">" + average);

                if (small) {
                    maxM = (maxM + minM - 1) / 2;
                    small = false;
                } else {
                    small = true;
                }

            }
            if (x == x1) {
                System.out.println("=");
                long re = average-Long.parseLong(String.valueOf(delta.mod(BigInteger.valueOf(average))));
                System.out.println("x=" + re + "    M:" + average);
                break;
            }
            if (minM == maxM) {
                System.out.println("fail : mod" + average % m);
                break;
            }
        }

         * */
    }

    public static void ansB() {
        /*

         * */
    }

    public class BinaryHeap {

        public BinaryHeap() {
            this(DEFAULT_CAPACITY);
        }

        public BinaryHeap(Comparable[] items) {
            currentSize = items.length;
            array = new Comparable[(currentSize + 2) * 11 / 10];

            int i = 1;
            for (Comparable item : items) {
                array[i++] = item;
            }
            buildHeap();
        }

        public BinaryHeap(int capacity) {
            currentSize = 0;
            array = new Comparable[capacity + 1];
        }

        public void insert(Comparable x) {

            int hole = ++currentSize;
            for (; hole > 1 && x.compareTo(array[hole / 2]) < 0; hole /= 2)
                array[hole] = array[hole / 2];
            array[hole] = x;
        }

        public Comparable findMin() {
            if (isEmpty())
                return null;
            return array[1];
        }

        public Comparable deleteMin() {
            if (isEmpty())
                return null;

            Comparable minItem = findMin();
            array[1] = array[currentSize--];
            percolateDown(1);

            return minItem;
        }

        private void buildHeap() {
            for (int i = currentSize / 2; i > 0; i--)
                percolateDown(i);
        }

        public boolean isEmpty() {
            return currentSize == 0;
        }

        public boolean isFull() {
            return currentSize == array.length - 1;
        }

        public void makeEmpty() {
            currentSize = 0;
        }
        private static final int DEFAULT_CAPACITY = 100;
        private int currentSize;      // Number of elements in heap
        private Comparable[] array; // The heap array
        private void percolateDown(int hole) {
            int child;
            Comparable tmp = array[hole];

            for (; hole * 2 <= currentSize; hole = child) {
                child = hole * 2;
                if (child != currentSize && array[child + 1].compareTo(array[child]) < 0)
                    child++;
                if (array[child].compareTo(tmp) < 0)
                    array[hole] = array[child];
                else
                    break;
            }
            array[hole] = tmp;
        }
    }

    public static class stack{

        stack() {
            stackTop=-1;
            maxStackItemIndex=-1;
        }
        void push(int x)
        {
            stackTop++;
            if(stackTop>=1000000)
                ;  //栈满
            else
            {
                stackItem[stackTop]=x;
                if(x>Max())
                {
                    link2NextMaxItem[stackTop]=maxStackItemIndex;
                    maxStackItemIndex=stackTop;
                }
                else
                    link2NextMaxItem[stackTop]=-1;
            }
        }
        int Pop()
        {
            int ret;

                ret=stackItem[stackTop];
                if(stackTop==maxStackItemIndex)
                {
                    maxStackItemIndex=link2NextMaxItem[stackTop];
                }
                stackTop--;

            return ret;
        }
        int Max()
        {
            if(maxStackItemIndex>=0)
                return stackItem[maxStackItemIndex];
            else
                return -99999;
        }
        int stackItem[]=new int[1000000];
        int stackTop;
        int link2NextMaxItem[]=new int [1000000];
        int maxStackItemIndex;
    };

    public static void heapSort(long[] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap(a, 0, j);
            adjustHeap(a, 0, j);
        }

    }

    public static void adjustHeap(long[] a, int i, int length) {
        long temp = a[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k] < a[k + 1]) {
                k++;
            }
            if (a[k] > temp) {
                a[i] = a[k];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp;
    }

    public static void swap(long[] a, int a1, int a2) {
        long temp = a[a1];
        a[a1] = a[a2];
        a[a2] = temp;
    }

    static int m;
    public static int dp(int a[]) {
        int dp[][] = new int[a.length / 2 + 1][a.length / 2 + 1];

        for (int j = 1; j < m; j++) {
            for (int i = 0; i <= a.length / 2 - j; i++) {
                int total = 0;
                for (int k = 0; k < j; k++) {
                    total += a[2 * i + k];
                }
                dp[i + 1][j] = total;

            }
        }
        for (int j = 2; j <= a.length / 2; j++) {
            for (int i = 1; i <= a.length / 2 - j + 1; i++) {
                for (int k = i; k < j; k++) {
                    int ans = dp[i][k] + dp[i + k][j - k];
                    if (ans > dp[i][j]) dp[i][j] = ans;
                }

            }
        }
        return dp[1][a.length / 2];
    }

    public static void calculate() {
        Scanner in = new Scanner(System.in);
        for (int test = 0; test < 10; test++) {
            String string = in.next();

            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "+");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "+");
            }

            string = string.replace("-", "m");
            string = string.replace("(m", "(-");
            string = string.replace("~m", "+~-");
            string = string.replace("m~", "+-~");
            if (string.charAt(0) == 'm') string = string.replaceFirst("m", "-");

            while (string.contains(")") && string.contains("(")) {
                int right = string.indexOf(")");
                String sub = string.substring(0, right);
                int left = sub.lastIndexOf("(");
                string = string.substring(0, left) + calculate(string.substring(left + 1, right)) + string.substring(right + 1);
            }
            string = calculate(string);
            while (string.contains("++") || string.contains("+-") || string.contains("-+") || string.contains("--")) {
                string = string.replace("++", "");
                string = string.replace("+-", "-");
                string = string.replace("-+", "-");
                string = string.replace("--", "");
            }
            System.out.println(string);
            System.out.flush();
        }
    }

    public static String calculate(String string) {
        int index = -1;

        String sub = string;
        while (sub.contains("~+") || sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
            sub = sub.replace("~+", "~");
        }
        while (sub.contains("~")) {
            int index1 = sub.indexOf("~");
            int index2 = index1 + 1;
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index1) + ~Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("*")) {
            int index1 = sub.indexOf("*");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + Integer.parseInt(sub.substring(index3 + 1, index1)) * Integer.parseInt(sub.substring(index1 + 1, index2)) + sub.substring(index2);
        }

        while (sub.contains("++") || sub.contains("+m") || sub.contains("m+") || sub.contains("mm") || sub.contains("--")) {
            sub = sub.replace("++", "+");
            sub = sub.replace("+m", "m");
            sub = sub.replace("m+", "m");
            sub = sub.replace("mm", "+");
            sub = sub.replace("--", "+");
        }

        while (sub.contains("+") || sub.contains("m")) {

            boolean add = sub.indexOf("+") < sub.indexOf("m");

            int index1 = Math.min(sub.indexOf("+"), sub.indexOf("m"));

            if (!sub.contains("+")) {
                index1 = sub.indexOf("m");
                add = false;
            }
            if (!sub.contains("m")) {
                index1 = sub.indexOf("+");
                add = true;
            }
            if (sub.contains("+") && (sub.indexOf("+") == 0 || !((sub.charAt(sub.indexOf("+") - 1) == 45 || sub.charAt(sub.indexOf("+") - 1) > 47 && sub.charAt(sub.indexOf("+") - 1) < 58)))) {
                sub = sub.substring(0, sub.indexOf("+")) + sub.substring(sub.indexOf("+") + 1);
                continue;
            }

            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            if (add)
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) + Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
            else
                sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) - Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);

        }
        while (sub.contains("&")) {
            int index1 = sub.indexOf("&");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) & Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        while (sub.contains("^")) {
            int index1 = sub.indexOf("^");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) ^ Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }

        while (sub.contains("|")) {
            int index1 = sub.indexOf("|");
            int index2 = index1 + 1;
            int index3 = index1 - 1;
            while ((int) sub.charAt(index3) < 58 && (int) sub.charAt(index3) > 47 || (int) sub.charAt(index3) == 45) {
                index3--;
                if (index3 < 0) break;
            }
            while ((int) sub.charAt(index2) < 58 && (int) sub.charAt(index2) > 47 || (int) sub.charAt(index2) == 45) {
                index2++;
                if (index2 > sub.length() - 1) break;
            }
            sub = sub.substring(0, index3 + 1) + (Integer.parseInt(sub.substring(index3 + 1, index1)) | Integer.parseInt(sub.substring(index1 + 1, index2))) + sub.substring(index2);
        }
        return sub;
    }

    public static long overflow(long num, int digit) {
        num = num * num;

        if (digit(num) > digit) {
            digit = digit(num) - digit;
            return MinusDigit(num, digit);
        }
        return num;

    }

    public static long MinusDigit(long number, int digit) {

        while (digit >= 1) {
            number = number / 10;
            digit--;
        }
        return number;
    }

    public static int digit(long num) {
        int digit = 1;
        while (num >= 10) {
            num = num / 10;
            digit++;
        }
        return digit;
    }

    public static int findValue(long[] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int findValue(long[][] a, int begin, int end, long value) {

        if (value == a[(begin + end) / 2][1]) return (begin + end) / 2;
        if (begin == end) return -1;
        if (value > a[(begin + end) / 2][1]) {
            return findValue(a, (begin + end + 1) / 2, end, value);
        } else {
            return findValue(a, begin, (begin + end - 1) / 2, value);
        }

    }

    public static int numOfFindValue(long[] a, int begin, int end, int index) {
        long value = a[index];
        int index1 = index;
        int num = 1;
        while (index1 < end) {
            index1++;
            if (a[index1] == value) num++;
            else break;
        }
        while (index > begin) {
            index--;
            if (a[index] == value) num++;
            else break;
        }

        return num;
    }

    public static void heapSort2(int[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(int[][] a, int i, int length) {
        int temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(int[][] a, int a1, int a2) {
        int temp[] = new int[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static void heapSort2(long[][] a) {
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(a, i, a.length);
        }
        for (int j = a.length - 1; j > 0; j--) {
            swap2(a, 0, j);
            adjustHeap2(a, 0, j);
        }

    }

    public static void adjustHeap2(long[][] a, int i, int length) {
        long temp[] = a[i].clone();
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && a[k][1] < a[k + 1][1]) {
                k++;
            }
            if (a[k][1] > temp[1]) {
                a[i][0] = a[k][0];
                a[i][1] = a[k][1];
                i = k;
            } else {
                break;
            }
        }
        a[i] = temp.clone();
    }

    public static void swap2(long[][] a, int a1, int a2) {
        long temp[] = new long[2];
        temp[1] = a[a1][1];
        a[a1][1] = a[a2][1];
        a[a2][1] = temp[1];
        temp[0] = a[a1][0];
        a[a1][0] = a[a2][0];
        a[a2][0] = temp[0];

    }

    public static class SingleLinkedList {
        private int size;
        private Node head;

        public SingleLinkedList() {
            size = 0;
            head = null;
        }

        private class Node {
            private Object data;
            private Node next;
            private long datas[];

            public Node(Object data) {
                this.data = data;
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public Object addHead(Object obj, long a[]) {
            Node newHead = new Node(obj);
            newHead.datas = a;
            if (size == 0) {
                head = newHead;
            } else {
                newHead.next = head;
                head = newHead;
            }
            size++;
            return obj;
        }

        public void addIntSmallToLarge(int a) {
            long bb[] = new long[1];
            addIntSmallToLarge(a, bb);
        }

        public void addIntSmallToLarge(int a, long bb[]) {
            Node newNode = new Node(a);
            newNode.datas = bb;

            if (size == 0) {
                head = newNode;
                size++;
            } else {
                Node b = head;
                if (Integer.parseInt(b.data.toString()) >= a) {
                    addHead(a);
                    return;
                }
                if (size == 1 && Integer.parseInt(b.data.toString()) < a) {
                    b.next = newNode;
                    size++;
                    return;
                }
                for (int i = 1; i < size; i++) {
                    if (b != null && Integer.parseInt(b.data.toString()) <= a && b.next != null && Integer.parseInt(b.next.data.toString()) >= a) {
                        newNode.next = b.next;
                        b.next = newNode;
                        break;
                    }
                    if (b != null)
                        b = b.next;

                    if (i == size - 1 && b != null && Integer.parseInt(b.data.toString()) < a) {
                        b.next = newNode;
                    }
                }
                size++;
            }

        }

        public Object deleteHead() {
            Object obj = head.data;
            head = head.next;
            size--;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return true;
        }

        public Object deleteIndex(int index) {
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            return current.data;
        }

        public boolean isEmpty() {
            return (size == 0);
        }

        public void display() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data + "->");
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

        public void displayWithoutGap() {
            if (size > 0) {
                Node node = head;
                while (true) {
                    if (node.next == null) {
                        System.out.print(node.data);
                        break;
                    } else {
                        System.out.print(node.data);
                    }
                    node = node.next;
                }
                System.out.println();
            } else {
                System.out.println("NULL");
            }
        }

    }

    public static class DoubleLinkedList {
        private int size;
        private Node head;
        private Node end;

        public DoubleLinkedList() {
            size = 0;
            head = new Node();
            end = new Node();
        }

        private class Node {
            private Object data;
            private Node next;
            private Node pre;

            public Node(Object data) {
                this.data = data;
            }

            public Node() {
            }
        }

        public Object addHead(Object obj) {
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                newHead.next = head.next;
                newHead.next.pre = newHead;
                head.next = newHead;
                newHead.pre = head;
            }
            size++;
            return obj;
        }

        public Object add(int index, Object obj) {
            if (index > size + 1) {
                System.out.println("index out of size");
                return false;
            }
            Node newHead = new Node(obj);
            if (size == 0) {
                head.next = newHead;
                newHead.pre = head;
                newHead.next = end;
                end.pre = newHead;

            } else {
                Node current = head;
                for (int i = 1; i < index; i++) {
                    current = current.next;
                }
                newHead.next = current.next;
                newHead.pre = current;
                current.next = newHead;
                newHead.next.pre = newHead;
            }
            size++;
            return obj;
        }

        public void exchange(int begin1, int end1, int begin2, int end2) {
            Node begin11 = findByIndex(begin1);
            Node begin12 = findByIndex(begin2);
            Node end11 = findByIndex(end1);
            Node end12 = findByIndex(end1);
            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public void exchange(Node begin11, Node end11, Node begin12, Node end12) {

            begin11.pre.next = begin12;
            begin12.pre.next = begin11;
            end11.next.pre = end12;
            end12.next.pre = end11;
            Node a = begin11.pre;
            begin11.pre = begin12.pre;
            begin12.pre = a;
            Node b = end11.next;
            end11.next = end12.next;
            end12.next = b;
        }

        public Object addTail(Object obj) {
            Node newTail = new Node(obj);
            if (size == 0) {
                head.next = newTail;
                newTail.pre = head;
                newTail.next = end;
                end.pre = newTail;
            } else {
                newTail.pre = end.pre;
                newTail.pre.next = newTail;
                end.pre = newTail;
                newTail.next = end;
            }
            size++;
            return obj;
        }

        public Node find(Object obj) {
            Node current = head.next;
            int tempSize = size;
            while (tempSize > 0) {
                if (obj.equals(current.data)) {
                    return current;
                } else {
                    current = current.next;
                }
                tempSize--;
            }
            return null;
        }

        public Node findByIndex(int index) {
            if (index > size) return null;
            index++;
            if (size == 0) {
                return null;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return null;
                } else {
                    previous = current;
                    current = current.next;
                }
            }

            return current;
        }

        public boolean delete(Object value) {
            if (size == 0) {
                return false;
            }
            Node current = head.next;
            Node previous = head.next;
            while (current.data != value) {
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
                size--;
            } else {
                previous.next = current.next;
                size--;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }
            return true;
        }

        public boolean deleteIndex(int index) {
            if (index > size) return false;
            index++;
            if (size == 0) {
                return false;
            }
            Node current = head;
            Node previous = head;
            int i = 1;
            while (i != index) {
                i++;
                if (current.next == null) {
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head.next) {
                head.next = current.next;
            } else {
                previous.next = current.next;
            }
            if (current == end.pre) {
                end.pre = current.pre;
            } else {
                current.next.pre = previous;
            }

            size--;
            return true;
        }

        public void display(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "→");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data + "←");
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("NULL");
                }
            }
        }

        public void displayWithoutGap(boolean oneToN) {
            if (oneToN) {
                if (size > 0) {
                    Node node = head.next;
                    while (node != null) {
                        if (node.next == end) {
                            System.out.print(node.data + " ");
                            break;
                        } else {
                            System.out.print(node.data + " ");
                        }
                        node = node.next;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            } else {
                if (size > 0) {
                    Node node = end.pre;
                    while (node != null) {
                        if (node.pre == head) {
                            System.out.print(node.data);
                            break;
                        } else {
                            System.out.print(node.data);
                        }
                        node = node.pre;
                    }
                    System.out.println();
                } else {
                    System.out.println("");
                }
            }
        }

    }

}

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println("");
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A {
	public static void main(String[] args) {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		System.out.println("YES");
	}
}

import java.util.Locale;
import java.util.Scanner;

public class cont {

	public static void main(String[] args) {

		Scanner in;

		in = new Scanner(System.in);
		in.useLocale(new Locale("US"));
		Locale.setDefault(new Locale("en", "US"));

		if (in.hasNext()) {
			String s =  in.nextLine();
			System.out.println("0");
		}

		System.exit(0);

	}

}

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
import java.util.Vector;

public class NewClass {

	public static void main(String[] args) {
		System.out.println("YES");
		/*Scanner ob=new Scanner(System.in);
		int t=ob.nextInt();
		while (t-->0) {
			int n=ob.nextInt();
			System.out.println("2");
			int a=n, b=n-1;
			System.out.println(a+" "+b);
			while (b!=1) {
				a=(int) Math.ceil((a+b)*(1.0)/2);
				b--;
				System.out.println(a+" "+b);
			}
		}*/
	}
}

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

public class IsItRated {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		while (br.readLine() != null) {
			String str = br.readLine();
			System.out.println(str);
		}

		// System.out.println("1");
	}
}

import java.lang.*;
import java.io.*;
import java.util.*;
public class Solution{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//int n = sc.nextInt();
		//String s = sc.nextLine();
		//System.out.println(s);
		/*int n = s.charAt(s.length() - 1);
		if(n%2==0)System.out.println(0);
		else System.out.println(1);*/
		System.out.println("Is it rated?");

	}
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;
public class GFG {
	public static void main (String[] args) {
		Scanner sc=new Scanner(System.in);
	System.out.println("standard output");
	}
}

public class Main
{
    public static void main(String[] args)
    {
        System.out.println("Yes");
    }
}

import java.util.Scanner;

public class A {
    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
        System.out.println("Yes");
    }
}

//package CodeForces;

import java.util.*;

public class A {

	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		System.out.println(scan.next());

	}

}

import java.io.BufferedReader;
import java.io.*;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.math.*;
public class Main
{
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        long nextLong()
        {
            return Long.parseLong(next());
        }

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
   public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        PrintWriter pw=new PrintWriter(System.out);
        int t=1;//sc.nextInt();
        while(t-->0)
        {
          //int n=sc.nextInt();
          //int a[]=new int[n];
          //for(int i=0;i<n;i++)
         // pw.println(String.valueOf(c));
        }
           pw.close();
    }
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Codeforces_Test {

	public static void main(String[] args) throws java.lang.Exception {

		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int n = sc.nextInt();
		System.out.println(n);
	}

	public static PrintWriter out;

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;

		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

		long nextLong() {
			return Long.parseLong(next());
		}

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

	}

}

import java.util.*;
import java.lang.*;
 public class Main{
    public static void main(String[] args)
    {
        System.out.print("rated");

    }
}

//package CodeForces;

import java.util.*;

public class A {

	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		while (scan.hasNext()) {
			System.out.println(scan.nextLine());
		}

	}

}

import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println();
	}

}

import java.util.*;

public class main {
    public static void main(String[] args) {
        System.out.println("YES");
    }
}

import java.util.*;
public class again{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        //ArrayList<String> arr =new ArrayList<String>();
        while(in.hasNextLine()){
        String str= in.nextLine();
        System.out.println(str);
        }
    }
}

import java.util.Scanner;

public class ProblemA {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 35, 57, 319, 1732
    }
}

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

    }
}

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println("Is it rated?");
    }
}

public class abal {

    public static void main(String args[]) {
        System.out.println("না");
    }

}

import java.util.*;
public class Main {

	public static void main(String[] args) {

	}

}

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println("");
    }
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;
public class GFG {
	public static void main (String[] args) {
		Scanner sc=new Scanner(System.in);
	System.out.println("Not rated");
	}
}

public class Main
{
    public static void main(String args[])
    {
        System.out.println("Is it rated");
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Elizabeth
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("YES");
    }
}

import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.nextLine();
		System.out.println("YES");
	}
}

import java.util.*;
public class useless
{
    public static void main(String[] args)
    {

    }
}

import java.util.*;
public class pro{
    public static void main(String[] args){
        System.out.println("yes");
    }
}

import java.util.*;
public class AprilFools_A {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("YES");
    }
}

import javafx.util.Pair;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Template {

    public static void solve(int testCase, Reader in, PrintWriter out){

        out.println("Is it rated?");
        out.flush();
    }

    public static void main(String... args) {
        Reader in = new Reader();
        PrintWriter out = new PrintWriter(System.out);
        int testCase = 1;
        for(int i = 1;i<=testCase;i++) {
            solve(i, in, out);
        }
        out.close();
    }

    static class Reader {
        private StringTokenizer tokenizer;
        private BufferedReader reader;

        public Reader() {
            tokenizer = null;
            try {
                reader = new BufferedReader(new InputStreamReader(System.in)); // for file IO, replace this with new FileReader ("in.txt")
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() { return Integer.parseInt(this.next()); }
        public long nextLong() { return Long.parseLong(this.next()); }
        public double nextDouble() { return Double.parseDouble(this.next()); }
        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
        }
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;

public final class MakingFool {

    public static void main(String args[]){
        try{

            System.out.println("yes");
        } catch(Exception e) {
            System.out.println("yes");
        }
    }

}