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.*;
import java.util.*;


public class Alpha {
    String filename = "subseq";//filename here, System.in/out if no file

    FastScanner in;
    PrintWriter out;

    void pass() {
    }

    int[] rem(int[] a, int x) {
        int[] ans = new int[a.length - 1];
        for (int i = 0; i < x; i++) ans[i] = a[i];
        for (int i = x; i < a.length - 1; i++) ans[i] = a[i + 1];
        return ans;
    }

    void solve() {
        HashSet<String> n = new HashSet<>();
        n.add("great!");
        n.add("don't think so");
        n.add("cool");
        n.add("not bad");
        n.add("don't touch me");
        HashSet<String> g = new HashSet<>();
        g.add("don't even");
        g.add("are you serious?");
        g.add("no way");
        g.add("go die in a hole");
        g.add("worse");
        g.add("terrible");
        Scanner sc=new Scanner(System.in);
        for (int i=0;i<=9;i++){
            System.out.println(i);
            System.out.flush();
            String a=sc.nextLine();
            if (n.contains(a)) {
                System.out.println("normal");
                break;
            }
            if (g.contains(a)) {
                System.out.println("grumpy");
                break;
            }
        }
    }

    void run() throws IOException {
        InputStream input = System.in;
        OutputStream output = System.out;
        try {
            File f = new File(filename + ".in");
            if (f.exists() && f.canRead()) {
                input = new FileInputStream(f);
                output = new FileOutputStream(filename + ".out");
            }
        } catch (IOException e) {
        }
        in = new FastScanner(input);
        out = new PrintWriter(new BufferedOutputStream(output));
        solve();
        in.close();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        Locale.setDefault(Locale.US);
        new Alpha().run();
    }

    class FastScanner implements Closeable {
        private BufferedReader br;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(stream));
        }

        public boolean hasNext() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String s = br.readLine();
                    if (s == null) {
                        return false;
                    }
                    tokenizer = new StringTokenizer(s);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.hasMoreTokens();
        }

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

        public String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return br.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

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

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

        public byte nextByte() {
            return Byte.parseByte(next());
        }
    }
}