If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.

<image>

However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.

<image>

You have met a cat. Can you figure out whether it's normal or grumpy?

Interaction

This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9. 

In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.

Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.

Note

Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.util.Scanner;

public class C0104201802 {

  public static void main(String[] args) throws IOException {
    try (final Scanner scanner = new Scanner(System.in)) {
      for (int i = 0; i < 10; i++) {
        System.out.println(i);
        String string = scanner.nextLine();
        if (string.equals("dont even") || string.equals("are your serious")
            || string.equals("no way") || string.equals("go die in a hole")
            || string.equals("worse") || string.equals("terrible")) {
          System.out.println("grumpy");
          return;
        }

        if (string.equals("great") || string.equals("dont think so")
            || string.equals("dont touch me!") || string.equals("not bad")
            || string.equals("cool")) {
          System.out.println("normal");
          return;
        }
      }
    }
  }

  private static class Input implements Closeable {

    private final BufferedReader bufferedReader;
    private final StringBuilder stringBuilder = new StringBuilder();
    private final static char[] SEPERATOR = { '\t', '\n', '\r', ' ' };

    public Input(final BufferedReader in) {
      this.bufferedReader = in;
    }

    private boolean isAnySeperator(final char ch) {
      return ch == SEPERATOR[3] || ch == SEPERATOR[1] || ch == SEPERATOR[0] || ch == SEPERATOR[2];
    }

    private boolean isLineSeperator(final char ch) {
      return ch == SEPERATOR[1] || ch == SEPERATOR[2];
    }

    public String next() throws IOException {
      stringBuilder.setLength(0);
      while (true) {
        int c = bufferedReader.read();
        if (c == -1) {
          return null;
        }
        char ch = (char) c;
        if (!isAnySeperator(ch)) {
          stringBuilder.append(ch);
          break;
        }
      }
      while (true) {
        int c = bufferedReader.read();
        char ch = (char) c;
        if (c == -1 || isAnySeperator(ch)) {
          break;
        }
        stringBuilder.append(ch);
      }
      return stringBuilder.toString();
    }

    public String nextLine() throws IOException {
      stringBuilder.setLength(0);
      while (true) {
        final int c = bufferedReader.read();
        if (c == -1) {
          return null;
        }
        final char ch = (char) c;
        if (!isLineSeperator(ch)) {
          stringBuilder.append(ch);
          break;
        }
      }
      while (true) {
        int c = bufferedReader.read();
        char ch = (char) c;
        if (c == -1 || isLineSeperator(ch)) {
          break;
        }
        stringBuilder.append(ch);
      }
      return stringBuilder.toString();
    }

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

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

    @Override
    public void close() throws IOException {
      bufferedReader.close();
    }
  }
}