Problem: 

Interaction

This is an interactive problem. You need to read participants' queries from standard input and print your responses to standard output. You don't know the number of queries upfront, so you'll need to process them as you get them; you'll know you're done once you reach the end of the file.

In each query, you will be asked the question, written in one line. You have to answer it correctly, patiently and without any display of emotions. Your response is case-insensitive.

Please make sure to use the stream flushing operation after each response in order not to leave part of your output in some buffer.

Example

Input


Is it rated?
Is it rated?
Is it rated?


Output


NO
NO
NO

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;
typedef  long long  ll;
ll mod = pow(10, 9) + 7;
typedef unsigned long long  ull;
int gcdExtended(int a, int b, int *x, int *y);

// Function to find modulo inverse of b. It returns
// -1 when inverse doesn't
int modInverse(int b, int m)
{
  int x, y; // used in extended GCD algorithm
  int g = gcdExtended(b, m, &x, &y);

  // Return -1 if b and m are not co-prime
  if (g != 1)
    return -1;

  // m is added to handle negative x
  return (x % m + m) % m;
}
int gcdExtended(int a, int b, int *x, int *y)
{
  // Base Case
  if (a == 0)
  {
    *x = 0, *y = 1;
    return b;
  }

  int x1, y1; // To store results of recursive call
  int gcd = gcdExtended(b % a, a, &x1, &y1);

  // Update x and y using results of recursive
  // call
  *x = y1 - (b / a) * x1;
  *y = x1;

  return gcd;
}
string decimalToBinary(int n)
{
  //finding the binary form of the number and
  //coneverting it to string.
  string s = bitset<64> (n).to_string();

  //Finding the first occurance of "1"
  //to strip off the leading zeroes.
  const auto loc1 = s.find('1');

  if (loc1 != string::npos)
    return s.substr(loc1);

  return "0";
}
int binaryToDecimal(string n)
{
  string num = n;
  int dec_value = 0;

  // Initializing base value to 1, i.e 2^0
  int base = 1;

  int len = num.length();
  for (int i = len - 1; i >= 0; i--) {
    if (num[i] == '1')
      dec_value += base;
    base = base * 2;
  }

  return dec_value;
}
/*ll factorial(ll n);
ll factorial(ll n)
{ ll ans = 1;
  while (n != 1)
  {
    ans = ((ans % mod ) * (n % mod)) % mod;

    n--;

  }
  return ans;

}*/
ull sumbincoef( int N, int k ) {
  ull   bincoef = 1, sum = 1;
  int i;
  for ( i = 1 ; i < k ; ++i ) {
    bincoef = (bincoef * (N - i + 1) / i);
    sum += bincoef;
  }
  return sum;
}

bool is_prime(ll n) {
  // Assumes that n is a positive natural number
  // We know 1 is not a prime number
  if (n == 1) {
    return false;
  }

  ll i = 2;
  // This will loop from 2 to int(sqrt(x))
  while (i * i <= n) {
    // Check if i divides x without leaving a remainder
    if (n % i == 0) {
      // This means that n has a factor in between 2 and sqrt(n)
      // So it is not a prime number
      return false;
    }
    i += 1;
  }
  // If we did not find any factor in the above loop,
  // then n is a prime number
  return true;
}
int gcd(int a, int b)
{
  if (a == 0)
    return b;
  return gcd(b % a, a);
}
int nCrModp(int n, int r, int p)
{
  // Optimization for the cases when r is large
  if (r > n - r)
    r = n - r;

  // The aay C is going to store last row of
  // pascal triangle at the end. And last entry
  // of last row is nCr
  int C[r + 1];
  memset(C, 0, sizeof(C));

  C[0] = 1; // Top row of Pascal Triangle

  // One by constructs remaining rows of Pascal
  // Triangle from top to bottom
  for (int i = 1; i <= n; i++) {

    // Fill entries of current row using previous
    // row values
    for (int j = min(i, r); j > 0; j--)

      // nCj = (n-1)Cj + (n-1)C(j-1);
      C[j] = (C[j] + C[j - 1]) % p;
  }
  return C[r];
}
typedef unsigned long long  ull;

typedef unsigned int ui;

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


  for (int i = 0; i < (int)n / 2; i++)
  {
    if (s[i] == s[n - 1 - i])
    {

    }
    else
    {
      return false;
    }
  }
  return true;



}
const int N = 200000 + 10;
ll factorialNumInverse[N + 1];

// array to precompute inverse of 1! to N!
ll naturalNumInverse[N + 1];

// array to store factorial of first N numbers
ll fact[N + 1];

// Function to precompute inverse of numbers
void InverseofNumber(ll p)
{
  naturalNumInverse[0] = naturalNumInverse[1] = 1;
  for (int i = 2; i <= N; i++)
    naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
// Function to precompute inverse of factorials
void InverseofFactorial(ll p)
{
  factorialNumInverse[0] = factorialNumInverse[1] = 1;

  // precompute inverse of natural numbers
  for (int i = 2; i <= N; i++)
    factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}

// Function to calculate factorial of 1 to N
void factorial(ll p)
{
  fact[0] = 1;

  // precompute factorials
  for (int i = 1; i <= N; i++) {
    fact[i] = (fact[i - 1] * i) % p;
  }
}

// Function to return nCr % p in O(1) time
ll Binomial(ll N, ll R, ll p)
{
  // n C r = n!*inverse(r!)*inverse((n-r)!)
  ll ans = ((fact[N] * factorialNumInverse[R])
            % p * factorialNumInverse[N - R])
           % p;
  return ans;
}




int main()
{ ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
  mt19937 rng((unsigned int) chrono::steady_clock::now().time_since_epoch().count());
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  /*InverseofNumber(p);
   InverseofFactorial(p);
   factorial(p);*/

  int t = 1;
  //cin >> t;

  while (1)
  { string s, s1, s2;
    cin >> s >> s1 >> s2;

    if (s == "")
    {
      break;
    }
    cout << "NO" << endl;


    t--;
  }


}