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

public class CF680C{

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;

	private static void soln(){
		int[] q = {2,4,3,9,5,25,7,49,11,13,17,19,23,29,31,37,41,43,47,53};
		int count = 0;
		for (int i = 0; i<20; i++) {
			System.out.println(q[i]);
			String temp = nextLine();
			if(temp.equals("yes"))
				count++;
		}
		if(count > 1)
			System.out.println("composite");
		else
			System.out.println("prime");
	}

	public static void main(String[] args){
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		soln();
		pw.close();
	}

	// To Get Input
	// Some Buffer Methods

	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private static int nextInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static long nextLong() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private static int[] nextIntArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextInt();
		}
		return arr;
	}

	private static long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}

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

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

	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 2;

		boolean[] primes = eratosthenes(100);
		int[] nums = new int[100 + 1];

		int last = 2;
		boolean ok = true;

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

			last = index;

			while (!primes[index]) {
				index++;
			}

			System.out.println(index);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			if (index <= 7 && nums[index] == 0 && str.equals("yes")) {
				nums[index]++;
			} else {
				index++;
			}

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 2;

		int num = 2;

		boolean[] primes = eratosthenes(100);
		int[] nums = new int[100 + 1];

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

			if (nums[index] == 0) {
				num = index;
			} else {
				num = index * index;
			}

			System.out.println(num);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			if (index <= 7 && nums[index] == 0 && str.equals("yes")) {
				nums[index]++;
			} else {
				index++;
			}

			while (!primes[index]) {
				index++;
			}

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 0;

		boolean[] primes = eratosthenes(100);

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

			while (!primes[index]) {
				index++;
			}

			System.out.println(index);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			index++;

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 2;

		int num = 2;

		boolean[] primes = eratosthenes(100);
		int[] nums = new int[100 + 1];

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

			if (nums[index] == 0) {
				num = index;
			} else {
				num = index * index;
			}

			System.out.println(num);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			if (index <= 7 && nums[index] == 0 && str.equals("yes")) {
				nums[index]++;
			} else {
				index++;
			}

			while (!primes[index]) {
				index++;
			}

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 0;

		boolean[] primes = eratosthenes(100);

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

			while (!primes[index]) {
				index++;
			}

			System.out.println(index);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			index++;

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
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.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class C {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter out;

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

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

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

	public static float nextFloat() throws IOException {
		return Float.parseFloat(next());
	}

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

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

		long res = 0;

		int index = 2;

		boolean[] primes = eratosthenes(100);
		int[] nums = new int[100 + 1];

		int last = 2;
		boolean ok = true;

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

			last = index;

			while (!primes[index]) {
				index++;
			}

			System.out.println(index);
			System.out.flush();

			String str = next();

			if (str.equals("yes")) {
				res++;
			}

			if (index > 7 || nums[index] > 0) {
				index++;
			} else {
				nums[index]++;
			}

			if (res > 1) {
				break;
			}

		}

		if (res > 1) {
			System.out.println("composite");
			System.out.flush();
		} else {
			System.out.println("prime");
			System.out.flush();
		}

	}

	static boolean[] eratosthenes(int n) {
		// starting from 2
		boolean[] tab = new boolean[n + 1];
		Arrays.fill(tab, true);
		tab[0] = false;
		tab[1] = false;
		int i = 2;
		while (i <= Math.sqrt(n)) {
			if (tab[i]) {
				for (int j = i * i; j <= n; j += i) {
					tab[j] = false;
				}
			}
			i++;
		}
		return tab;
	}
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Solution{

    ///////////////////////////////////////////////////////////////////////////
    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;

        public FastScanner(InputStream InputStream){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(InputStream));
        }

        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }

        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }

        public BigInteger big() throws IOException{
            if(st.hasMoreTokens())
                return new BigInteger(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return big();
            }
        }

        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }

        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }

        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }

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

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

    }

    ////////////////////////////////////////////////////////////////////
    //      Number Theory

    long pow(long a,long b,long mod){
		if(b == 0)	return 1;
		long t = pow(a,b>>1,mod);
		t = (t * t) % mod;
		if((b & 1) == 1)	t = (t * a);
		if(t >= mod)	t %= mod;
		return t;
	}

    int divisor(long x,long[] a){
        long limit = x;
        int numberOfDivisors = 0;

        for (int i=1; i < limit; ++i) {
            if (x % i == 0) {
                limit = x / i;
                if (limit != i) {
                    numberOfDivisors++;
                }
                numberOfDivisors++;
            }
        }
        return numberOfDivisors;
    }

    void findSubsets(int array[]){
        long numOfSubsets = 1 << array.length;
        for(int i = 0; i < numOfSubsets; i++){
            @SuppressWarnings("unused")
			int pos = array.length - 1;
            int bitmask = i;
            while(bitmask > 0){
                if((bitmask & 1) == 1)
//                    ww.print(array[pos]+" ");
                bitmask >>= 1;
                pos--;
            }
//            ww.println();
        }
    }

    public static long gcd(long a, long b){
        return b == 0 ? a : gcd(b,a%b);
    }

    public static long lcm(int a,int b, int c){
        return lcm(lcm(a,b),c);
    }

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

    public static long invl(long a, long mod) {
        long b = mod;
        long p = 1, q = 0;
        while (b > 0) {
            long c = a / b;
            long d;
            d = a;
            a = b;
            b = d % b;
            d = p;
            p = q;
            q = d - c * q;
        }
        return p < 0 ? p + mod : p;
    }

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

//     FastScanner s = new FastScanner(new File("a.pdf"));
//	 PrintWriter ww = new PrintWriter(new FileWriter("output.txt"));
    static InputStream inputStream = System.in;
    static FastScanner s = new FastScanner(inputStream);
    static OutputStream outputStream = System.out;
    static PrintWriter ww = new PrintWriter(new OutputStreamWriter(outputStream));
//      private static Scanner s = new Scanner(System.in);
    @SuppressWarnings("unused")
    private static int[][] states = { {-1,0} , {1,0} , {0,-1} , {0,1} };

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

    public static void main(String[] args) throws Exception{
        new Solution().solve();
        s.close();
        ww.close();
    }

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

    void print(int x){
    	System.out.println(x);
    	System.out.flush();
    }

    void print(String x){
    	System.out.println(x);
    	System.out.flush();
    }

    void exit(){
    	System.exit(0);
    }

	void solve() throws IOException  {

		Scanner xx = new Scanner(System.in);

		int[] a = {4,9,25,49};
		String x = "";

		for(int i=0;i<a.length;i++){
			print(a[i]);
			x = xx.next();
			if(x.equals("yes")){
				print("composite");
				exit();
			}
		}

		int[] b = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
		int total = 0;

		for(int i=0;i<b.length;i++){
			print(b[i]);
			x = xx.next();
			if(x.equals("yes")) total++;
		}

		if(total > 1) print("composite");
		else print("prime");

		xx.close();
	}

}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Solution{

    ///////////////////////////////////////////////////////////////////////////
    static class FastScanner{
        BufferedReader s;
        StringTokenizer st;

        public FastScanner(InputStream InputStream){
            st = new StringTokenizer("");
            s = new BufferedReader(new InputStreamReader(InputStream));
        }

        public FastScanner(File f) throws FileNotFoundException{
            st = new StringTokenizer("");
            s = new BufferedReader (new FileReader(f));
        }

        public int nextInt() throws IOException{
            if(st.hasMoreTokens())
                return Integer.parseInt(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextInt();
            }
        }

        public BigInteger big() throws IOException{
            if(st.hasMoreTokens())
                return new BigInteger(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return big();
            }
        }

        public double nextDouble() throws IOException{
            if(st.hasMoreTokens())
                return Double.parseDouble(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextDouble();
            }
        }

        public long nextLong() throws IOException{
            if(st.hasMoreTokens())
                return Long.parseLong(st.nextToken());
            else{
                st = new StringTokenizer(s.readLine());
                return nextLong();
            }
        }

        public String nextString() throws IOException{
            if(st.hasMoreTokens())
                return st.nextToken();
            else{
                st = new StringTokenizer(s.readLine());
                return nextString();
            }

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

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

    }

    ////////////////////////////////////////////////////////////////////
    //      Number Theory

    long pow(long a,long b,long mod){
		if(b == 0)	return 1;
		long t = pow(a,b>>1,mod);
		t = (t * t) % mod;
		if((b & 1) == 1)	t = (t * a);
		if(t >= mod)	t %= mod;
		return t;
	}

    int divisor(long x,long[] a){
        long limit = x;
        int numberOfDivisors = 0;

        for (int i=1; i < limit; ++i) {
            if (x % i == 0) {
                limit = x / i;
                if (limit != i) {
                    numberOfDivisors++;
                }
                numberOfDivisors++;
            }
        }
        return numberOfDivisors;
    }

    void findSubsets(int array[]){
        long numOfSubsets = 1 << array.length;
        for(int i = 0; i < numOfSubsets; i++){
            @SuppressWarnings("unused")
			int pos = array.length - 1;
            int bitmask = i;
            while(bitmask > 0){
                if((bitmask & 1) == 1)
//                    ww.print(array[pos]+" ");
                bitmask >>= 1;
                pos--;
            }
//            ww.println();
        }
    }

    public static long gcd(long a, long b){
        return b == 0 ? a : gcd(b,a%b);
    }

    public static long lcm(int a,int b, int c){
        return lcm(lcm(a,b),c);
    }

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

    public static long invl(long a, long mod) {
        long b = mod;
        long p = 1, q = 0;
        while (b > 0) {
            long c = a / b;
            long d;
            d = a;
            a = b;
            b = d % b;
            d = p;
            p = q;
            q = d - c * q;
        }
        return p < 0 ? p + mod : p;
    }

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

//     FastScanner s = new FastScanner(new File("a.pdf"));
//	 PrintWriter ww = new PrintWriter(new FileWriter("output.txt"));
    static InputStream inputStream = System.in;
    static FastScanner s = new FastScanner(inputStream);
    static OutputStream outputStream = System.out;
    static PrintWriter ww = new PrintWriter(new OutputStreamWriter(outputStream));
//      private static Scanner s = new Scanner(System.in);
    @SuppressWarnings("unused")
    private static int[][] states = { {-1,0} , {1,0} , {0,-1} , {0,1} };

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

    public static void main(String[] args) throws Exception{
        new Solution().solve();
        s.close();
        ww.close();
    }

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

    void print(int x){
    	System.out.println(x);
    	System.out.flush();
    }

    void print(String x){
    	System.out.println(x);
    	System.out.flush();
    }

    void exit(){
    	System.exit(0);
    }

	void solve() throws IOException  {

		Scanner xx = new Scanner(System.in);

		print(2);
		String x = xx.next();
		if(x.equals("yes")){
			print("composite");
			exit();
		}

		print(3);
		x = xx.next();
		if(x.equals("yes")){
			print("composite");
			exit();
		}

		for(int i=1;i<=9;i++){
			print(6*i+1);
			x = xx.next();
			if(x.equals("yes")){
				print("composite");
				exit();
			}
			print(6*i-1);
			x = xx.next();
			if(x.equals("yes")){
				print("composite");
				exit();
			}
		}

		print("prime");
		xx.close();

	}

}


import java.util.*;
public class CodeForces{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int count=0;
		int[] primes = new int[]{2, 3, 4, 5, 7,9, 11, 13,16, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49};
		for(int i =0;i<=19;i++){
			System.out.println(primes[i]);
			System.out.flush();
			String response = sc.nextLine();
			if(response.equals("yes"))
				count++;
			if(count==2)
				break;
		}
		if(count==2){
			System.out.println("composite");
			System.out.flush();
		}
		else{
			System.out.println("prime");
			System.out.flush();
		}

	}
}


import java.io.*;

public class Main {
    public static String output(int d, int n) {
        if(n%d == 0)
            return "yes";
        return "no";
    }
    public static void main(String[] args) {
        try {
            BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
            int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 4, 9, 25, 49};
            int numYes = 0;
            for(int i = 0; i < primes.length; i++) {
                System.out.println(primes[i]);
                System.out.flush();
                String s = f.readLine();
                if(s.equals("yes")) {
                    numYes++;
                }
            }
            if(numYes == 0 || numYes == 1)
                System.out.println("prime");
            else
                System.out.println("composite");
            //}
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

}


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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        int[]pow2 = new int[]{2*2,3*3,5*5,7*7};
        int[]p = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};

        boolean composite = false;
        for (Integer i: pow2) {
            System.out.println(i);
            System.out.flush();

            String ans = in.readLine();
            if ("yes".equalsIgnoreCase(ans)) composite = true;
        }

        if (!composite) {
            int divs = 0;
            for (Integer i: p) {
                System.out.println(i);
                System.out.flush();

                String ans = in.readLine();
                if ("yes".equals(ans)) divs++;
            }

            if (divs>1) composite = true;
        }

        System.out.println(composite ? "composite" : "prime");
        System.out.flush();
    }

}


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

public class Main {

	static int mod = (int) 1e9 + 7;
	static int MAX = (int) 1e9;
	static ArrayList<Integer>[] g;
	static int n, m;
	static long k;
	static int[][] a;
	static int nodes = 0;
	static int edges = 0;
	static boolean[][] done;
	static int[][] ans;
	static int[] dp;
	static int curX, curY;
	static int rx, ry, x1, y1, x2, y2;

	public static void main(String[] args) {
		FasterScanner s = new FasterScanner();
		PrintWriter out = new PrintWriter(System.out);

		int test = 1;// s.nextInt();

		testloop: while (test-- > 0) {
			int[] primes = generatePrimes(50);
			int len = primes.length;
			int count = 0;
			int prime = 0;
			int cnt = 0;
			for (int i = 0; i < len; i++) {
				cnt++;
				out.println(primes[i]);
				out.flush();
				String x = s.nextLine();
				if (x.equals("yes")) {
					count++;
					prime = primes[i];
				}
			}
			if (count >= 2) {
				out.println("composite");
				out.flush();
				out.close();
				System.exit(0);
			} else if (count == 0) {
				out.println("prime");
				out.flush();
				out.close();
				System.exit(0);
			} else {
				int i = prime * prime;
				cnt++;
				out.println(i);
				out.flush();
				String x = s.nextLine();
				if (x.equals("yes")) {
					out.println("composite");
					out.flush();
					out.close();
					System.exit(0);
				}
				out.println("prime");
				out.flush();
//				System.out.println(cnt);
				out.close();
				System.exit(0);
			}
		}
		out.close();
	}

	public static class Node implements Comparable<Node> {
		long val;
		int index;

		Node(long val, int index) {
			this.val = val;
			this.index = index;
		}

		@Override
		public int compareTo(Node o) {
			if (this.val != o.val)
				return Long.compare(val, o.val);
			else
				return Integer.compare(this.index, o.index);
		}
	}

	public static int find(int[] a, int val) {
		int left = 0;
		if (val > a[a.length - 1])
			return a.length;
		int right = a.length;

		while (left < right) {

			int mid = (left + right) >> 1;
			// System.out.println("HERE" + left +" " + right +" "+mid);

			if (a[mid] > val) {
				right = mid;
			} else {
				left = mid + 1;
			}
		}
		return right;
	}

	public static void addInTable(Hashtable<Integer, Integer> table, int pos, int val) {
		if (!table.containsKey(pos)) {
			table.put(pos, val);
		} else {
			table.put(pos, table.get(pos) + val);
		}
	}

	static class Pair implements Comparable<Pair> {
		long x;
		long y;

		public int compareTo(Pair o) {
			return Double.compare(this.curDistance(), o.curDistance());
		}

		public double curDistance() {
			return Math.sqrt((x - curX) * (x - curX) + (y - curY) * (y - curY))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance1() {
			return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance2() {
			return Math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance() {
			return 2 * Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}
	}

	static class Component implements Comparable<Component> {
		int id;
		int size;

		Component(int id, int size) {
			this.id = id;
			this.size = size;
		}

		@Override
		public int compareTo(Component o) {
			return size - o.size;
		}
	}

	static class Point {
		int x, y;

		Point(int xx, int yy) {
			x = xx;
			y = yy;
		}
	}

	static void dfs(int x, int y, int rem, int val) {
		if (rem <= 0)
			return;
		rem--;
		done[x][y] = true;
		if (check(x + 1, y) && !done[x + 1][y] && a[x + 1][y] >= val)
			dfs(x + 1, y, rem, val);
		if (check(x - 1, y) && !done[x - 1][y] && a[x - 1][y] >= val)
			dfs(x - 1, y, rem, val);
		if (check(x, y + 1) && !done[x][y + 1] && a[x][y + 1] >= val)
			dfs(x, y + 1, rem, val);
		if (check(x, y - 1) && !done[x][y - 1] && a[x][y - 1] >= val)
			dfs(x, y - 1, rem, val);
	}

	static boolean check(int x, int y) {
		return x >= 0 && y >= 0 && x < n && y < m;
	}

	static class Player implements Comparable<Player> {
		String name;
		int score;

		Player(String n, int v) {
			name = n;
			score = v;
		}

		@Override
		public int compareTo(Player o) {
			return o.score - score;
		}
	}

	static class Edge {
		int t, rev, f;
		long cap;

		public Edge(int t, int rev, long cap) {
			this.t = t;
			this.rev = rev;
			this.cap = cap;
		}
	}

	public static List<Edge>[] createGraph(int nodes) {
		List<Edge>[] graph = new List[nodes];
		for (int i = 0; i < nodes; i++)
			graph[i] = new ArrayList<>();
		return graph;
	}

	public static void addEdge(List<Edge>[] graph, int s, int t, long cap) {
		graph[s].add(new Edge(t, graph[t].size(), cap));
		graph[t].add(new Edge(s, graph[s].size() - 1, 0));
	}

	static boolean dinicBfs(List<Edge>[] graph, int src, int dest, int[] dist) {
		Arrays.fill(dist, -1);
		dist[src] = 0;
		int[] Q = new int[graph.length];
		int sizeQ = 0;
		Q[sizeQ++] = src;
		for (int i = 0; i < sizeQ; i++) {
			int u = Q[i];
			for (Edge e : graph[u]) {
				if (dist[e.t] < 0 && e.f < e.cap) {
					dist[e.t] = dist[u] + 1;
					Q[sizeQ++] = e.t;
				}
			}
		}
		return dist[dest] >= 0;
	}

	static long dinicDfs(List<Edge>[] graph, int[] ptr, int[] dist, int dest, int u, long l) {
		if (u == dest)
			return l;
		for (; ptr[u] < graph[u].size(); ++ptr[u]) {
			Edge e = graph[u].get(ptr[u]);
			if (dist[e.t] == dist[u] + 1 && e.f < e.cap) {
				long df = dinicDfs(graph, ptr, dist, dest, e.t, Math.min(l, e.cap - e.f));
				if (df > 0) {
					e.f += df;
					graph[e.t].get(e.rev).f -= df;
					return df;
				}
			}
		}
		return 0;
	}

	public static long maxFlow(List<Edge>[] graph, int src, int dest) {
		long flow = 0;
		int[] dist = new int[graph.length];
		while (dinicBfs(graph, src, dest, dist)) {
			int[] ptr = new int[graph.length];
			while (true) {
				long df = dinicDfs(graph, ptr, dist, dest, src, Integer.MAX_VALUE);
				if (df == 0)
					break;
				flow += df;
			}
		}
		return flow;
	}

	static int ans(ArrayList<Character>[] l, char a, int n) {
		if (n == 1)
			return 1;
		int sum = 0;
		for (int i = 0; i < l[a - 'a'].size(); i++) {
			sum += ans(l, l[a - 'a'].get(i), n - 1);
		}
		return sum;
	}

	static void dfs1(List<Integer>[] graph, boolean[] used, List<Integer> order, int u) {
		used[u] = true;
		for (int v : graph[u])
			if (!used[v])
				dfs1(graph, used, order, v);
		order.add(u);
	}

	static void dfs2(List<Integer>[] reverseGraph, int[] comp, int u, int color) {
		comp[u] = color;
		for (int v : reverseGraph[u])
			if (comp[v] == -1)
				dfs2(reverseGraph, comp, v, color);
	}

	public static boolean[] solve2Sat(List<Integer>[] graph) {
		int n = graph.length;
		boolean[] used = new boolean[n];
		List<Integer> order = new ArrayList<>();
		for (int i = 0; i < n; ++i)
			if (!used[i])
				dfs1(graph, used, order, i);

		List<Integer>[] reverseGraph = new List[n];
		for (int i = 0; i < n; i++)
			reverseGraph[i] = new ArrayList<>();
		for (int i = 0; i < n; i++)
			for (int j : graph[i])
				reverseGraph[j].add(i);

		int[] comp = new int[n];
		Arrays.fill(comp, -1);
		for (int i = 0, color = 0; i < n; ++i) {
			int u = order.get(n - i - 1);
			if (comp[u] == -1)
				dfs2(reverseGraph, comp, u, color++);
		}

		for (int i = 0; i < n; ++i)
			if (comp[i] == comp[i ^ 1])
				return null;

		boolean[] res = new boolean[n / 2];
		for (int i = 0; i < n; i += 2)
			res[i / 2] = comp[i] > comp[i ^ 1];
		return res;
	}

	public static int[] createSets(int size) {
		int[] p = new int[size];
		for (int i = 0; i < size; i++)
			p[i] = i;
		return p;
	}

	public static int root(int[] p, int x) {
		return x == p[x] ? x : (p[x] = root(p, p[x]));
	}

	public static void unite(int[] p, int a, int b) {
		a = root(p, a);
		b = root(p, b);
		if (a != b)
			p[a] = b;
	}

	public static boolean nextPermutation(int[] p) {
		for (int a = p.length - 2; a >= 0; --a)
			if (p[a] < p[a + 1])
				for (int b = p.length - 1;; --b)
					if (p[b] > p[a]) {
						int t = p[a];
						p[a] = p[b];
						p[b] = t;
						for (++a, b = p.length - 1; a < b; ++a, --b) {
							t = p[a];
							p[a] = p[b];
							p[b] = t;
						}
						return true;
					}
		return false;
	}

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

	static class SegTree {
		int[] val;
		int n;

		SegTree(int n) {
			val = new int[2 * n];
			this.n = n;
		}

		void upd(int p, int l) {
			p += n;
			val[p] = l;
			for (; (p >>= 1) != 0;) {
				val[p] = Math.max(val[2 * p], val[2 * p + 1]);

			}
		}

		int query(int l, int r) { // sum on interval [l, r)
			// System.out.println(l+" "+r);
			int res = 0;
			for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
				if ((l & 1) != 0)
					res = Math.max(res, val[l++]);
				if ((r & 1) != 0)
					res = Math.max(res, val[--r]);
			}
			return res;
		}
	}

	static boolean check(int i, int j, int n) {
		if (i >= 0 && j >= 0 && i < n && j < n)
			return true;
		return false;
	}

	public static int[] generateDivisorTable(int n) {
		int[] divisor = new int[n + 1];
		for (int i = 1; i <= n; i++)
			divisor[i] = i;
		for (int i = 2; i * i <= n; i++)
			if (divisor[i] == i)
				for (int j = i * i; j <= n; j += i)
					divisor[j] = i;
		return divisor;
	}

	public static int[][] matrixMul(int[][] a, int[][] b) {
		int n = a.length;
		int m = a[0].length;
		int k = b[0].length;
		int[][] res = new int[n][k];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < k; j++) {
				for (int p = 0; p < m; p++) {
					res[i][j] = (res[i][j] + (int) ((a[i][p] * 1l * b[p][j]) % mod)) % mod;
				}
			}
		}
		return res;
	}

	public static int[][] matrixPow(int[][] a, int p) {
		if (p == 0) {
			return matrixUnit(a.length);
		} else if (p % 2 == 0) {
			return matrixPow(matrixMul(a, a), p / 2);
		} else {
			return matrixMul(a, matrixPow(a, p - 1));
		}
	}

	public static int[][] matrixUnit(int n) {
		int[][] res = new int[n][n];
		for (int i = 0; i < n; ++i) {
			res[i][i] = 1;
		}
		return res;
	}

	static int[] modInv(int n, int mod) {
		int[] ans = new int[n];
		for (int i = 1; i < n; i++)
			ans[i] = (int) pow(i, mod - 2, mod);
		return ans;
	}

	static int[] primes;

	public static long ncr(int n, int r) {
		if (n < r)
			return 0;
		if (n == r)
			return 1;
		if (r == 0)
			return 1;
		if (r < 0)
			return 0;
		long ans = 1;
		for (int i = 0; i < primes.length; i++) {
			long power = count(n, primes[i]) - count(n - r, primes[i]) - count(r, primes[i]);
			ans *= pow(primes[i], power, mod);
			ans %= mod;
		}
		return ans;
	}

	public static long pow(long x, long n, int mod) {
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p) % mod) {
			if ((n & 1) != 0) {
				res = (int) (res * p % mod);
			}
		}
		return res;
	}

	public static long count(int n, int p) {
		long count = 0;
		long z = p;
		while (z <= n) {
			count += n / z;
			z *= p;
		}
		return count;

	}

	public static int[] generatePrimes(int n) {
		boolean[] prime = new boolean[n + 1];
		Arrays.fill(prime, 2, n + 1, true);
		for (int i = 2; i * i <= n; i++)
			if (prime[i])
				for (int j = i * i; j <= n; j += i)
					prime[j] = false;
		int[] primes = new int[n + 1];
		int cnt = 0;
		for (int i = 0; i < prime.length; i++)
			if (prime[i])
				primes[cnt++] = i;

		return Arrays.copyOf(primes, cnt);
	}

	static class Pairxy implements Comparable<Pairxy> {
		int x;
		int y;

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

		public int compareTo(Pairxy o) {
			return Integer.compare(this.x, o.x);
		}

	}

	public static long C(int n, int r) {
		long ans = 1;
		int x = 1;
		while (x <= r) {
			ans *= n;
			ans /= x;
			x++;
			n--;
		}
		return ans;
	}

	static class DisjointSetsRank {

		int[] p;
		int[] rank;
		int[] size;

		public DisjointSetsRank(int size) {
			p = new int[size];
			this.size = new int[size];
			for (int i = 0; i < size; i++) {
				p[i] = i;
				this.size[i] = 1;
			}
			rank = new int[size];
		}

		public int root(int x) {
			return x == p[x] ? x : (p[x] = root(p[x]));
		}

		public int sameSet(int x, int y) {
			if (root(x) == root(y))
				return 1;
			return 0;

		}

		public int unite(int a, int b) {
			a = root(a);
			b = root(b);
			if (a == b)
				return -1;

			if (rank[a] < rank[b]) {
				p[a] = b;
				size[b] += size[a];
				return a;
			} else {
				p[b] = a;
				size[a] += size[b];
				if (rank[a] == rank[b])
					++rank[a];
				return b;
			}
		}

	}

	static int gcd(long m, long n) {
		long x;
		long y;
		while (m % n != 0) {
			x = n;
			y = m % n;
			m = x;
			n = y;
		}
		return (int) n;
	}

	static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int snumChars;

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

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}


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

public class Main {

	static int mod = (int) 1e9 + 7;
	static int MAX = (int) 1e9;
	static ArrayList<Integer>[] g;
	static int n, m;
	static long k;
	static int[][] a;
	static int nodes = 0;
	static int edges = 0;
	static boolean[][] done;
	static int[][] ans;
	static int[] dp;
	static int curX, curY;
	static int rx, ry, x1, y1, x2, y2;

	public static void main(String[] args) {
		FasterScanner s = new FasterScanner();
		PrintWriter out = new PrintWriter(System.out);

		int test = 1;// s.nextInt();

		testloop: while (test-- > 0) {
			int[] primes = generatePrimes(50);
			int len = primes.length;
			int count = 0;
			int prime = 0;
			for (int i = 0; i < len; i++) {
				// cnt++;
				out.println(primes[i]);
				out.flush();
				String x = s.nextLine();
				if (x.equals("yes")) {
					count++;
					prime = primes[i];
				}
			}
			if (count >= 2) {
				out.println("composite");
				out.flush();
				out.close();
				System.exit(0);
			} else if (count == 0) {
				out.println("prime");
				out.flush();
				out.close();
				System.exit(0);
			} else {
				int i = prime * prime;
				if (i < 100) {
					out.println(i);
					out.flush();
					String x = s.nextLine();
					if (x.equals("yes")) {
						out.println("composite");
						out.flush();
						out.close();
						System.exit(0);
					}
				}
				out.println("prime");
				out.flush();
				out.close();
				System.exit(0);
			}
		}
		out.close();
	}

	public static class Node implements Comparable<Node> {
		long val;
		int index;

		Node(long val, int index) {
			this.val = val;
			this.index = index;
		}

		@Override
		public int compareTo(Node o) {
			if (this.val != o.val)
				return Long.compare(val, o.val);
			else
				return Integer.compare(this.index, o.index);
		}
	}

	public static int find(int[] a, int val) {
		int left = 0;
		if (val > a[a.length - 1])
			return a.length;
		int right = a.length;

		while (left < right) {

			int mid = (left + right) >> 1;
			// System.out.println("HERE" + left +" " + right +" "+mid);

			if (a[mid] > val) {
				right = mid;
			} else {
				left = mid + 1;
			}
		}
		return right;
	}

	public static void addInTable(Hashtable<Integer, Integer> table, int pos, int val) {
		if (!table.containsKey(pos)) {
			table.put(pos, val);
		} else {
			table.put(pos, table.get(pos) + val);
		}
	}

	static class Pair implements Comparable<Pair> {
		long x;
		long y;

		public int compareTo(Pair o) {
			return Double.compare(this.curDistance(), o.curDistance());
		}

		public double curDistance() {
			return Math.sqrt((x - curX) * (x - curX) + (y - curY) * (y - curY))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance1() {
			return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance2() {
			return Math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2))
					- Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}

		public double distance() {
			return 2 * Math.sqrt((x - rx) * (x - rx) + (y - ry) * (y - ry));
		}
	}

	static class Component implements Comparable<Component> {
		int id;
		int size;

		Component(int id, int size) {
			this.id = id;
			this.size = size;
		}

		@Override
		public int compareTo(Component o) {
			return size - o.size;
		}
	}

	static class Point {
		int x, y;

		Point(int xx, int yy) {
			x = xx;
			y = yy;
		}
	}

	static void dfs(int x, int y, int rem, int val) {
		if (rem <= 0)
			return;
		rem--;
		done[x][y] = true;
		if (check(x + 1, y) && !done[x + 1][y] && a[x + 1][y] >= val)
			dfs(x + 1, y, rem, val);
		if (check(x - 1, y) && !done[x - 1][y] && a[x - 1][y] >= val)
			dfs(x - 1, y, rem, val);
		if (check(x, y + 1) && !done[x][y + 1] && a[x][y + 1] >= val)
			dfs(x, y + 1, rem, val);
		if (check(x, y - 1) && !done[x][y - 1] && a[x][y - 1] >= val)
			dfs(x, y - 1, rem, val);
	}

	static boolean check(int x, int y) {
		return x >= 0 && y >= 0 && x < n && y < m;
	}

	static class Player implements Comparable<Player> {
		String name;
		int score;

		Player(String n, int v) {
			name = n;
			score = v;
		}

		@Override
		public int compareTo(Player o) {
			return o.score - score;
		}
	}

	static class Edge {
		int t, rev, f;
		long cap;

		public Edge(int t, int rev, long cap) {
			this.t = t;
			this.rev = rev;
			this.cap = cap;
		}
	}

	public static List<Edge>[] createGraph(int nodes) {
		List<Edge>[] graph = new List[nodes];
		for (int i = 0; i < nodes; i++)
			graph[i] = new ArrayList<>();
		return graph;
	}

	public static void addEdge(List<Edge>[] graph, int s, int t, long cap) {
		graph[s].add(new Edge(t, graph[t].size(), cap));
		graph[t].add(new Edge(s, graph[s].size() - 1, 0));
	}

	static boolean dinicBfs(List<Edge>[] graph, int src, int dest, int[] dist) {
		Arrays.fill(dist, -1);
		dist[src] = 0;
		int[] Q = new int[graph.length];
		int sizeQ = 0;
		Q[sizeQ++] = src;
		for (int i = 0; i < sizeQ; i++) {
			int u = Q[i];
			for (Edge e : graph[u]) {
				if (dist[e.t] < 0 && e.f < e.cap) {
					dist[e.t] = dist[u] + 1;
					Q[sizeQ++] = e.t;
				}
			}
		}
		return dist[dest] >= 0;
	}

	static long dinicDfs(List<Edge>[] graph, int[] ptr, int[] dist, int dest, int u, long l) {
		if (u == dest)
			return l;
		for (; ptr[u] < graph[u].size(); ++ptr[u]) {
			Edge e = graph[u].get(ptr[u]);
			if (dist[e.t] == dist[u] + 1 && e.f < e.cap) {
				long df = dinicDfs(graph, ptr, dist, dest, e.t, Math.min(l, e.cap - e.f));
				if (df > 0) {
					e.f += df;
					graph[e.t].get(e.rev).f -= df;
					return df;
				}
			}
		}
		return 0;
	}

	public static long maxFlow(List<Edge>[] graph, int src, int dest) {
		long flow = 0;
		int[] dist = new int[graph.length];
		while (dinicBfs(graph, src, dest, dist)) {
			int[] ptr = new int[graph.length];
			while (true) {
				long df = dinicDfs(graph, ptr, dist, dest, src, Integer.MAX_VALUE);
				if (df == 0)
					break;
				flow += df;
			}
		}
		return flow;
	}

	static int ans(ArrayList<Character>[] l, char a, int n) {
		if (n == 1)
			return 1;
		int sum = 0;
		for (int i = 0; i < l[a - 'a'].size(); i++) {
			sum += ans(l, l[a - 'a'].get(i), n - 1);
		}
		return sum;
	}

	static void dfs1(List<Integer>[] graph, boolean[] used, List<Integer> order, int u) {
		used[u] = true;
		for (int v : graph[u])
			if (!used[v])
				dfs1(graph, used, order, v);
		order.add(u);
	}

	static void dfs2(List<Integer>[] reverseGraph, int[] comp, int u, int color) {
		comp[u] = color;
		for (int v : reverseGraph[u])
			if (comp[v] == -1)
				dfs2(reverseGraph, comp, v, color);
	}

	public static boolean[] solve2Sat(List<Integer>[] graph) {
		int n = graph.length;
		boolean[] used = new boolean[n];
		List<Integer> order = new ArrayList<>();
		for (int i = 0; i < n; ++i)
			if (!used[i])
				dfs1(graph, used, order, i);

		List<Integer>[] reverseGraph = new List[n];
		for (int i = 0; i < n; i++)
			reverseGraph[i] = new ArrayList<>();
		for (int i = 0; i < n; i++)
			for (int j : graph[i])
				reverseGraph[j].add(i);

		int[] comp = new int[n];
		Arrays.fill(comp, -1);
		for (int i = 0, color = 0; i < n; ++i) {
			int u = order.get(n - i - 1);
			if (comp[u] == -1)
				dfs2(reverseGraph, comp, u, color++);
		}

		for (int i = 0; i < n; ++i)
			if (comp[i] == comp[i ^ 1])
				return null;

		boolean[] res = new boolean[n / 2];
		for (int i = 0; i < n; i += 2)
			res[i / 2] = comp[i] > comp[i ^ 1];
		return res;
	}

	public static int[] createSets(int size) {
		int[] p = new int[size];
		for (int i = 0; i < size; i++)
			p[i] = i;
		return p;
	}

	public static int root(int[] p, int x) {
		return x == p[x] ? x : (p[x] = root(p, p[x]));
	}

	public static void unite(int[] p, int a, int b) {
		a = root(p, a);
		b = root(p, b);
		if (a != b)
			p[a] = b;
	}

	public static boolean nextPermutation(int[] p) {
		for (int a = p.length - 2; a >= 0; --a)
			if (p[a] < p[a + 1])
				for (int b = p.length - 1;; --b)
					if (p[b] > p[a]) {
						int t = p[a];
						p[a] = p[b];
						p[b] = t;
						for (++a, b = p.length - 1; a < b; ++a, --b) {
							t = p[a];
							p[a] = p[b];
							p[b] = t;
						}
						return true;
					}
		return false;
	}

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

	static class SegTree {
		int[] val;
		int n;

		SegTree(int n) {
			val = new int[2 * n];
			this.n = n;
		}

		void upd(int p, int l) {
			p += n;
			val[p] = l;
			for (; (p >>= 1) != 0;) {
				val[p] = Math.max(val[2 * p], val[2 * p + 1]);

			}
		}

		int query(int l, int r) { // sum on interval [l, r)
			// System.out.println(l+" "+r);
			int res = 0;
			for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
				if ((l & 1) != 0)
					res = Math.max(res, val[l++]);
				if ((r & 1) != 0)
					res = Math.max(res, val[--r]);
			}
			return res;
		}
	}

	static boolean check(int i, int j, int n) {
		if (i >= 0 && j >= 0 && i < n && j < n)
			return true;
		return false;
	}

	public static int[] generateDivisorTable(int n) {
		int[] divisor = new int[n + 1];
		for (int i = 1; i <= n; i++)
			divisor[i] = i;
		for (int i = 2; i * i <= n; i++)
			if (divisor[i] == i)
				for (int j = i * i; j <= n; j += i)
					divisor[j] = i;
		return divisor;
	}

	public static int[][] matrixMul(int[][] a, int[][] b) {
		int n = a.length;
		int m = a[0].length;
		int k = b[0].length;
		int[][] res = new int[n][k];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < k; j++) {
				for (int p = 0; p < m; p++) {
					res[i][j] = (res[i][j] + (int) ((a[i][p] * 1l * b[p][j]) % mod)) % mod;
				}
			}
		}
		return res;
	}

	public static int[][] matrixPow(int[][] a, int p) {
		if (p == 0) {
			return matrixUnit(a.length);
		} else if (p % 2 == 0) {
			return matrixPow(matrixMul(a, a), p / 2);
		} else {
			return matrixMul(a, matrixPow(a, p - 1));
		}
	}

	public static int[][] matrixUnit(int n) {
		int[][] res = new int[n][n];
		for (int i = 0; i < n; ++i) {
			res[i][i] = 1;
		}
		return res;
	}

	static int[] modInv(int n, int mod) {
		int[] ans = new int[n];
		for (int i = 1; i < n; i++)
			ans[i] = (int) pow(i, mod - 2, mod);
		return ans;
	}

	static int[] primes;

	public static long ncr(int n, int r) {
		if (n < r)
			return 0;
		if (n == r)
			return 1;
		if (r == 0)
			return 1;
		if (r < 0)
			return 0;
		long ans = 1;
		for (int i = 0; i < primes.length; i++) {
			long power = count(n, primes[i]) - count(n - r, primes[i]) - count(r, primes[i]);
			ans *= pow(primes[i], power, mod);
			ans %= mod;
		}
		return ans;
	}

	public static long pow(long x, long n, int mod) {
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p) % mod) {
			if ((n & 1) != 0) {
				res = (int) (res * p % mod);
			}
		}
		return res;
	}

	public static long count(int n, int p) {
		long count = 0;
		long z = p;
		while (z <= n) {
			count += n / z;
			z *= p;
		}
		return count;

	}

	public static int[] generatePrimes(int n) {
		boolean[] prime = new boolean[n + 1];
		Arrays.fill(prime, 2, n + 1, true);
		for (int i = 2; i * i <= n; i++)
			if (prime[i])
				for (int j = i * i; j <= n; j += i)
					prime[j] = false;
		int[] primes = new int[n + 1];
		int cnt = 0;
		for (int i = 0; i < prime.length; i++)
			if (prime[i])
				primes[cnt++] = i;

		return Arrays.copyOf(primes, cnt);
	}

	static class Pairxy implements Comparable<Pairxy> {
		int x;
		int y;

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

		public int compareTo(Pairxy o) {
			return Integer.compare(this.x, o.x);
		}

	}

	public static long C(int n, int r) {
		long ans = 1;
		int x = 1;
		while (x <= r) {
			ans *= n;
			ans /= x;
			x++;
			n--;
		}
		return ans;
	}

	static class DisjointSetsRank {

		int[] p;
		int[] rank;
		int[] size;

		public DisjointSetsRank(int size) {
			p = new int[size];
			this.size = new int[size];
			for (int i = 0; i < size; i++) {
				p[i] = i;
				this.size[i] = 1;
			}
			rank = new int[size];
		}

		public int root(int x) {
			return x == p[x] ? x : (p[x] = root(p[x]));
		}

		public int sameSet(int x, int y) {
			if (root(x) == root(y))
				return 1;
			return 0;

		}

		public int unite(int a, int b) {
			a = root(a);
			b = root(b);
			if (a == b)
				return -1;

			if (rank[a] < rank[b]) {
				p[a] = b;
				size[b] += size[a];
				return a;
			} else {
				p[b] = a;
				size[a] += size[b];
				if (rank[a] == rank[b])
					++rank[a];
				return b;
			}
		}

	}

	static int gcd(long m, long n) {
		long x;
		long y;
		while (m % n != 0) {
			x = n;
			y = m % n;
			m = x;
			n = y;
		}
		return (int) n;
	}

	static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int snumChars;

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

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class bearprime {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i < 50; i++) {
            boolean p = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    p = false;
                    break;
                }
            }
            if (p) {
                primes.add(i);
            }
        }
        System.out.println(primes);
        int fails = 0;
        boolean prime = true;
        for (int p: primes) {
            System.out.println(p);
            System.out.flush();
            String result = input.next();
            if (result.equals("yes")) {
                fails++;
                if (fails == 2) {
                    prime = false;
                    break;
                }
            }
        }
        if (!prime) {
            System.out.println("composite");
        } else {
            for (int i: new int[]{4, 9, 25, 49}) {
                System.out.println(i);
                System.out.flush();
                String result = input.next();
                if (result.equals("yes")) {
                    prime = false;
                    break;
                }
            }
            System.out.println(prime ? "prime" : "composite");
        }
        System.out.flush();
    }
}


import java.util.Scanner;

public class bearprime {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] primes = new int[]{2, 3, 5, 7, 11};
        boolean prime = true;
        for (int i = 0; i < primes.length; i++) {
            System.out.println(primes[i]);
            System.out.flush();
            String result = input.next();
            if (result.equals("YES")) {
                prime = false;
                break;
            }
        }
        System.out.println(prime ? "prime" : "composite");
        System.out.flush();
    }
}


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class bearprime {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i < 50; i++) {
            boolean p = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    p = false;
                    break;
                }
            }
            if (p) {
                primes.add(i);
            }
        }
        int fails = 0;
        boolean prime = true;
        for (int p: primes) {
            System.out.println(p);
            System.out.flush();
            String result = input.next();
            if (result.equals("yes")) {
                fails++;
                if (fails == 2) {
                    prime = false;
                    break;
                }
            }
        }
        if (!prime) {
            System.out.println("composite");
        } else {
            for (int i: new int[]{4, 9, 25, 49}) {
                System.out.println(i);
                System.out.flush();
                String result = input.next();
                if (result.equals("yes")) {
                    prime = false;
                    break;
                }
            }
            System.out.println(prime ? "prime" : "composite");
        }
        System.out.flush();
    }
}


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

public static void main(String[] args) throws IOException {
	File file = new File("in");
	BufferedReader in;
	if (file.exists()) {
		in = new BufferedReader(new FileReader(file));
	} else {
		in = new BufferedReader(new InputStreamReader(System.in));
	}
	String line, lines[];
	ArrayList<Integer> prime = new ArrayList<Integer>();
	int count = 0;
	for( int i = 2; i < 100; i++ )
	{
		count = 0;
		for( int j = 1; j <= i; j++ )
		{
			if ( i % j == 0) count++;
		}
		if ( count == 2) prime.add(i);
	}
	count = 0;
	String val;
	int p = -1;
	for( int i = 0; i < 15; i++ )
	{
		System.out.println(prime.get(i));
		System.out.flush();
		val = in.readLine();
		if ( val.equals("yes"))
		{
			count++;
			p = prime.get(i);
		}
	}
	if ( count == 0 )
	{
		System.out.println("prime");
		System.out.flush();
	}
	else if ( count >= 2 )
	{
		System.out.println("composite");
		System.out.flush();
	}
	else
	{
		System.out.println(p*p);
		System.out.flush();
		val = in.readLine();
		if ( val.equals("yes"))
		{
			System.out.println("composite");
			System.out.flush();
		}
		else
		{
			System.out.println("prime");
			System.out.flush();
		}

	}

}
public static int[] readInts(String line) {
	String lines[] = line.split("\\s+");
	int[] result = new int[line.length()];
	for (int i = 0; i < lines.length; i++)
		result[i] = Integer.parseInt(lines[i]);
	return result;
}
}


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

public static void main(String[] args) throws IOException {
	File file = new File("in");
	BufferedReader in;
	if (file.exists()) {
		in = new BufferedReader(new FileReader(file));
	} else {
		in = new BufferedReader(new InputStreamReader(System.in));
	}
	String line, lines[];
	ArrayList<Integer> prime = new ArrayList<Integer>();
	int count = 0;
	for( int i = 2; i < 100; i++ )
	{
		count = 0;
		for( int j = 1; j <= i; j++ )
		{
			if ( i % j == 0) count++;
		}
		if ( count == 2) prime.add(i);
	}
	count = 0;
	String val;
	int p = -1;
	for( int i = 0; i < 15; i++ )
	{
		System.out.println(prime.get(i));
		System.out.flush();
		val = in.readLine();
		if ( val.equals("yes"))
		{
			count++;
			p = prime.get(i);
		}
	}
	if ( count == 0 )
	{
		System.out.println("prime");
		System.out.flush();
	}
	else if ( count >= 2 )
	{
		System.out.println("composite");
		System.out.flush();
	}
	else
	{
		if( p*p <= 100 )
		{
			System.out.println(p*p);
			System.out.flush();
			val = in.readLine();
			if ( val.equals("yes"))
			{
				System.out.println("composite");
				System.out.flush();
			}
			else
			{
				System.out.println("prime");
				System.out.flush();
			}
		}
		else
		{
			System.out.println("prime");
			System.out.flush();
		}

	}

}
public static int[] readInts(String line) {
	String lines[] = line.split("\\s+");
	int[] result = new int[line.length()];
	for (int i = 0; i < lines.length; i++)
		result[i] = Integer.parseInt(lines[i]);
	return result;
}
}


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

public static void main(String[] args) throws IOException {
	File file = new File("in");
	BufferedReader in;
	if (file.exists()) {
		in = new BufferedReader(new FileReader(file));
	} else {
		in = new BufferedReader(new InputStreamReader(System.in));
	}
	String line, lines[];
	ArrayList<Integer> prime = new ArrayList<Integer>();
	int count = 0;
	for( int i = 2; i < 100; i++ )
	{
		count = 0;
		for( int j = 1; j <= i; j++ )
		{
			if ( i % j == 0) count++;
		}
		if ( count == 2) prime.add(i);
	}
	count = 0;
	String val;
	for( int i = 0; i < 20; i++ )
	{
		System.out.println(prime.get(i));
		System.out.flush();
		val = in.readLine();
		if ( val.equals("yes")) count++;
	}
	if ( count >= 2 )
		System.out.println("composite");
	else
		System.out.println("prime");
	System.out.flush();
}
public static int[] readInts(String line) {
	String lines[] = line.split("\\s+");
	int[] result = new int[line.length()];
	for (int i = 0; i < lines.length; i++)
		result[i] = Integer.parseInt(lines[i]);
	return result;
}
}


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

public class BearAndPrime100 {

	public static void main(String[] args) {
		InputReader r = new InputReader(System.in);
		int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
				41, 43, 47 };
		int[] twos = new int[] { 4, 8, 16, 32, 64 };
		int[] threes = new int[] { 9, 27, 81 };
		int[] fives = new int[] { 25 };
		int[] sevens = new int[] { 49 };
		int div = 0;
		int divisor = -1;
		for (int i = 0; i < primes.length; i++) {
			System.out.println(primes[i]);
			System.out.flush();
			String response = r.next();
			if (response.compareTo("yes") == 0) {
				div++;
				divisor = primes[i];
			}
		}
		if (div == 0) {
			System.out.println("prime");
			System.out.flush();
			return;
		} else if (div >= 2) {
			System.out.println("composite");
			System.out.flush();
			return;
		}
		if (divisor == 2) {
			for (int i = 0; i < twos.length; i++) {
				System.out.println(twos[i]);
				System.out.flush();
				String response = r.next();
				if (response.compareTo("yes") == 0) {
					System.out.println("composite");
					System.out.flush();
					return;
				}
			}
		} else if (divisor == 3) {
			for (int i = 0; i < threes.length; i++) {
				System.out.println(threes[i]);
				System.out.flush();
				String response = r.next();
				if (response.compareTo("yes") == 0) {
					System.out.println("composite");
					System.out.flush();
					return;
				}
			}
		} else if (divisor == 5) {
			for (int i = 0; i < fives.length; i++) {
				System.out.println(fives[i]);
				System.out.flush();
				String response = r.next();
				if (response.compareTo("yes") == 0) {
					System.out.println("composite");
					System.out.flush();
					return;
				}
			}
		} else if (divisor == 7) {
			for (int i = 0; i < sevens.length; i++) {
				System.out.println(sevens[i]);
				System.out.flush();
				String response = r.next();
				if (response.compareTo("yes") == 0) {
					System.out.println("composite");
					System.out.flush();
					return;
				}
			}
		}
		System.out.println("prime");
		System.out.flush();
	}

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

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

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

		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				return 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.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class BearAndPrime100 {

	public static void main(String[] args) {
		InputReader r = new InputReader(System.in);
		int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
				41, 43, 47, 53, 59 };
		int div = 0;
		for (int i = 0; i < primes.length; i++) {
			System.out.println(primes[i]);
			System.out.flush();
			String response = r.next();
			if (response.compareTo("yes") == 0) {
				div++;
			}
		}
		if (div <= 1) {
			System.out.println("prime");
		} else {
			System.out.println("composite");
		}
		System.out.flush();
	}

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

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

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

		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				return 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.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class BearAndPrime100 {

	public static void main(String[] args) {
		InputReader r = new InputReader(System.in);
		int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
				41, 43, 47, 53, 59 };
		int div = 0;
		for (int i = 0; i < primes.length; i++) {
			System.out.println(i);
			System.out.flush();
			String response = r.next();
			if (response.compareTo("yes") == 0) {
				div++;
			}
		}
		if (div <= 1) {
			System.out.println("prime");
		} else {
			System.out.println("composite");
		}
		System.out.flush();
	}

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

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

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

		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				return 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.*;
import java.lang.*;
import java.io.*;

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,       73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        int x = 0;
        String s="";
        while(c+x < 20)
        {
            System.out.println(a[c]);
            s = br.readLine();
            if(s.equals("yes")){
                count++;
                if(a[c] <= 7){
                    System.out.println(a[c]*a[c]);
                    s = br.readLine();
                    if(s.equals("yes")){
                        count++;
                    }
                    x++;
                }
            }
            c++;
            if(count > 1)
            break;
        }
        if(count <= 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,       73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        int x = 0;
        String s="";
        while(c+x < 20)
        {
            System.out.println(a[c]);
            s = br.readLine();
            if(s.equals("yes")){
                if(a[c] < 50){
                    System.out.println(a[c]*2);
                    s = br.readLine();
                    if(s.equals("yes"))
                    count++;
                    x++;
                }
                count++;
            }
            c++;
            if(count > 1)
            break;
        }
        if(count <= 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,       73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        String s="";
        while(c < 20)
        {
            System.out.println(a[c]);
            s = br.readLine();
            if(s.equals("yes")){
                if(a[c] < 50){
                    System.out.println(a[c]*2);
                    s = br.readLine();
                    if(s.equals("yes"))
                    count++;
                }
                count++;
            }
            c++;
        }
        if(count <= 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,       73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        String s="";
        while(c < 20)
        {
            System.out.println(a[c]);
            s = br.readLine();
            if(s.equals("yes")){
                if(a[c] < 50){
                    System.out.println(a[c]*2);
                    s = br.readLine();
                    if(s.equals("yes"))
                    count++;
                    c++;
                }
                count++;
            }
            c++;
        }
        if(count <= 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        String s="";
        while(c < 20)
        {
            System.out.println(a[c++]);
            s = br.readLine();
            if(s.equals("yes"))
            count++;
        }
        if(count <= 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97};
        int c = 0;
        String s="";
        while(c < 20)
        {
            System.out.println(a[c++]);
            s = br.readLine();
            if(s.equals("yes"))
            break;
        }
        if(c == 20)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


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

public class q3
{
    public static void main (String[] args) throws java.lang.Exception
    {
        PrintWriter pw = new PrintWriter(System.out);
        //BufferedReader br = new BufferedReader(new FileReader("xyz"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97};
        int c = 0;
        int count = 0;
        String s="";
        while(c < 20)
        {
            System.out.println(a[c++]);
            s = br.readLine();
            if(s.equals("yes"))
            count++;
        }
        if(count == 1)
        System.out.println("prime");
        else
        System.out.println("composite");

    }
}


import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;

public class BearAndPrime100 {
    public static void main(String[] args) {
        FasterScanner sc = new FasterScanner();

        boolean[] poss = new boolean[101];
        boolean[] used = new boolean[101];
        Arrays.fill(poss, true);

        for (int t = 0; t < 20; t++) {
        	int num = getFirstUnused(poss, used);
        	if (num < 0) {
        		break;
        	}
        	System.out.println(num);
        	System.out.flush();
        	String resp = sc.nextString();
        	if (resp.equals("yes")) {
        		for (int i = 2; i <= 100; i++) {
        			poss[i] &= (i % num == 0);
        		}
        	} else {
        		for (int i = 2; i <= 100; i++) {
        			poss[i] &= (i % num != 0);
        		}
        	}
        	used[num] = true;
        }
        int ans = getFirst(poss);
        if (isPrime(ans)) {
        	System.out.println("prime");
        } else {
        	System.out.println("composite");
        }
        System.out.flush();
    }

    private static boolean isPrime(int N) {
    	for (int i = 2; i < N; i++) {
    		if (N % i == 0) {
    			return false;
    		}
    	}
    	return true;
    }

    private static int getFirst(boolean[] poss) {
    	for (int i = 2; i <= 100; i++) {
    		if (poss[i]) {
    			return i;
    		}
    	}
    	return -1;
    }

    private static int getFirstUnused(boolean[] poss, boolean[] used) {
    	for (int i = 2; i <= 100; i++) {
    		if (poss[i] && !used[i]) {
    			return i;
    		}
    	}
    	return -1;
    }

	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

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

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public int[] nextIntArray(int n, int offset) {
			int[] arr = new int[n + offset];
			for (int i = 0; i < n; i++) {
				arr[i + offset] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public long[] nextLongArray(int n, int offset) {
			long[] arr = new long[n + offset];
			for (int i = 0; i < n; i++) {
				arr[i + offset] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}


import java.util.Scanner;

public class Main {

    static int[] primes = {11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int cnt = 0, yes = 0;
        String reply;

        for (int i = 2; i <= 10; i++) {
            System.out.println(i);
            System.out.flush();

            reply = in.next();
            if (reply.equals("yes")) {
                cnt++;
                yes = i;
            }
        }

        if (cnt > 1)
            System.out.println("composite");
        else if (cnt == 0)
            System.out.println("prime");
        else {
            int u = 100 / yes, i = 0;
            while (i < primes.length && primes[i] <= u) {
                System.out.println(primes[i]);
                System.out.flush();

                reply = in.next();
                if (reply.equals("yes")) {
                    System.out.println("composite");
                    return;
                }
                i++;
            }

            if (yes == 5 || yes == 7) {
                System.out.println(yes * yes);
                System.out.flush();

                reply = in.next();
                if (reply.equals("yes"))
                    System.out.println("composite");
                else
                    System.out.println("prime");
            } else
                System.out.println("prime");
        }
    }
}


import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        int[] prim = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
        Scanner sc = new Scanner(System.in);
        int div = 0;
        for (int i = 0; i < prim.length; i++) {
            System.out.println(prim[i]);
            System.out.flush();
            String ans = sc.nextLine();
            if (ans.equals("yes")) {
                div++;
                if (div == 2) {
                    System.out.println("composite");
                    return;
                }
            }
        }
        for (int i = 0; i < 4; i++) {
            System.out.println(prim[i] * prim[i]);
            System.out.flush();
            String ans = sc.nextLine();
            if (ans.equals("yes")) {
                div++;
                if (div == 2) {
                    System.out.println("composite");
                    return;
                }
            }
        }
        System.out.println("prime");
    }
}


import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        int[] prim = {2, 3, 5, 7, 11};
        Scanner sc = new Scanner(System.in);
        int div = 0;
        for (int i = 0; i < prim.length; i++) {
            System.out.println(prim[i]);
            System.out.flush();
            String ans = sc.nextLine();
            if (ans.equals("yes")) {
                div++;
                if (div == 2) {
                    System.out.println("composite");
                    return;
                }
            }
        }
        System.out.println("prime");
    }
}


import java.util.Scanner;

public class C {

    public static void main(String[] args) {
        int[] prim = {2, 3, 5, 7, 11};
        Scanner sc = new Scanner(System.in);
        int div = 0;
        for (int i = 0; i < prim.length; i++) {
            System.out.println(prim[i]);
            System.out.flush();
            String ans = sc.nextLine();
            if (ans.equals("yes")) {
                div++;
                if (div == 2) {
                    System.out.println("composite");
                    return;
                }
            }
        }
        for (int i = 0; i < prim.length - 1; i++) {
            System.out.println(prim[i] * prim[i]);
            System.out.flush();
            String ans = sc.nextLine();
            if (ans.equals("yes")) {
                div++;
                if (div == 2) {
                    System.out.println("composite");
                    return;
                }
            }
        }
        System.out.println("prime");
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

// Codeforces Round #356 (Div. 2)
// Bear and Prime 100
public class Problem_680_C {

	private void doSolve(PrintWriter out) {
		Integer[] prime = getPrimes().toArray( new Integer[ 100 ] );
		for (int i = 0; prime[i] < 10; i++) {
			System.out.println( prime[i] );
			if (next().equals("yes")) {
				for (int j = i; prime[i] * prime[j] <= 100; j++) {
					System.out.println( prime[i] * prime[j] );
					if (next().equals("yes")) {
						System.out.print("composite");
						return;
					}
				}
				System.out.println("prime");
				return;
 			}
		}
		System.out.println("prime");
	}

	List<Integer> getPrimes() {
		List<Integer> result = new LinkedList<Integer>();
		int N = 100;
		int[] a = new int[N + 1];
		for (int i = 2; i <= N; i++) {
			if (a[i] == 1) {
				continue;
			}
			for (int j = 2 * i; j <= N; j += i) {
				a[j] = 1;
			}
		}

		int count = 0;
		for (int i = 2; i <= N; i++) {
			if (a[i] == 0) {
				result.add(i);
			}

		}
		return result;
	}

	/* ========================================================= */

    private InputReader inputReader;

    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        Problem_680_C solver = new Problem_680_C();
        solver.solve(1, new InputStreamReader(inputStream), out);
        out.close();
    }

    public int nextInt() {
    	return inputReader.nextInt();
    }

    public String next() {
    	return inputReader.next();
    }

    public void solve(int test, Reader in, PrintWriter out)
    {
    	inputReader = new InputReader(in);
    	doSolve(out);
    	System.out.flush();
    }

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

        public InputReader(Reader reader) {
            this.reader = new BufferedReader(reader, 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());
        }

    }

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.*;

public class R3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        boolean find = false;
        int[] pr = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
        int i = 0;
        int streak = 0;
        System.out.println(pr[i]);
        i++;
        System.out.flush();
        while (!find)
        {
            String str = sc.nextLine();
            if (str.equals("yes"))
            {
                streak++;
                if (streak >=2)
                {
                    System.out.println("composite");
                    System.out.flush();
                    return;
                }
                if (pr[i-1]*pr[i-1] < 100) {
                    System.out.println(pr[i - 1] * pr[i - 1]);
                    System.out.flush();
                    str = sc.nextLine();
                    if (str.equals("yes")) {
                        System.out.println("composite");
                        System.out.flush();
                        return;
                    }
                }
                else
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }
                System.out.println(pr[i]);
                i++;
                System.out.flush();
            }
            else
            {
                if(i <=14){
                    System.out.println(pr[i]);
                    i++;
                    System.out.flush();

                }
                else if (streak == 1)
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }
                else
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }

            }
        }
    }

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.*;

public class R3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        boolean find = false;
        int[] pr = {2,3,5,7,11,13,17,19};
        int i = 0;
        int streak = 0;
        System.out.println(pr[i]);
        i++;
        System.out.flush();
        while (!find)
        {
            String str = sc.nextLine();
            if (str.equals("yes"))
            {
                streak++;
                if (streak >=2)
                {
                    System.out.println("composite");
                    System.out.flush();
                    return;
                }
                System.out.println(pr[i]);
                i++;
                System.out.flush();
            }
            else
            {
                if(i <=7){
                    System.out.println(pr[i]);
                    i++;
                    System.out.flush();

                }
                else
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }

            }
        }
    }

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.*;

public class R3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        boolean find = false;
        int[] pr = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};
        int i = 0;
        int streak = 0;
        System.out.println(pr[i]);
        i++;
        System.out.flush();
        while (!find)
        {
            String str = sc.nextLine();
            if (str.equals("yes"))
            {
                streak++;
                if (streak >=2)
                {
                    System.out.println("composite");
                    System.out.flush();
                    return;
                }
                System.out.println(pr[i-1]*pr[i-1]);
                System.out.flush();
                str = sc.nextLine();
                if (str.equals("yes"))
                {
                    System.out.println("composite");
                    System.out.flush();
                    return;
                }

                System.out.println(pr[i]);
                i++;
                System.out.flush();
            }
            else
            {
                if(i <=14){
                    System.out.println(pr[i]);
                    i++;
                    System.out.flush();

                }
                else if (streak == 1)
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }
                else
                {
                    System.out.println("prime");
                    System.out.flush();
                    return;
                }

            }
        }
    }

}


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

public class Main {
  static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  static InputReader in = new InputReader(System.in);

  public static void main(String[] args) {
    int[] smallPrimes = new int[]{2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};

    int count = 0;
    for (int i : smallPrimes) {
      if (doesDivide(i)) {
        count++;
        if (count > 1) {
          break;
        }
        if (i*i <= 100 && doesDivide(i*i)) {
          count++;
          if (count > 1) {
            break;
          }
        }
      }
    }
    out.println(count > 1 ? "composite" : "prime");
    out.flush();
  }

  public static boolean doesDivide(int i) {
    out.println(i);
    out.flush();
    return in.readString().equals("yes");
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

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

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

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

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

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

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

    public int[] readIntArray(int size) {
      int[] array = new int[size];
      for (int i = 0; i < size; i++)
        array[i] = readInt();
      return array;
    }
  }
}