This is an interactive problem. In the output section below you will see the information about flushing the output.

Bear Limak thinks of some hidden number — an integer from interval [2, 100]. Your task is to say if the hidden number is prime or composite.

Integer x > 1 is called prime if it has exactly two distinct divisors, 1 and x. If integer x > 1 is not prime, it's called composite.

You can ask up to 20 queries about divisors of the hidden number. In each query you should print an integer from interval [2, 100]. The system will answer "yes" if your integer is a divisor of the hidden number. Otherwise, the answer will be "no".

For example, if the hidden number is 14 then the system will answer "yes" only if you print 2, 7 or 14.

When you are done asking queries, print "prime" or "composite" and terminate your program.

You will get the Wrong Answer verdict if you ask more than 20 queries, or if you print an integer not from the range [2, 100]. Also, you will get the Wrong Answer verdict if the printed answer isn't correct.

You will get the Idleness Limit Exceeded verdict if you don't print anything (but you should) or if you forget about flushing the output (more info below).

Input

After each query you should read one string from the input. It will be "yes" if the printed integer is a divisor of the hidden number, and "no" otherwise.

Output

Up to 20 times you can ask a query — print an integer from interval [2, 100] in one line. You have to both print the end-of-line character and flush the output. After flushing you should read a response from the input.

In any moment you can print the answer "prime" or "composite" (without the quotes). After that, flush the output and terminate your program.

To flush you can use (just after printing an integer and end-of-line): 

  * fflush(stdout) in C++; 
  * System.out.flush() in Java; 
  * stdout.flush() in Python; 
  * flush(output) in Pascal; 
  * See the documentation for other languages. 



Hacking. To hack someone, as the input you should print the hidden number — one integer from the interval [2, 100]. Of course, his/her solution won't be able to read the hidden number from the input.

Examples

Input

yes
no
yes


Output

2
80
5
composite


Input

no
yes
no
no
no


Output

58
59
78
78
2
prime

Note

The hidden number in the first query is 30. In a table below you can see a better form of the provided example of the communication process.

<image>

The hidden number is divisible by both 2 and 5. Thus, it must be composite. Note that it isn't necessary to know the exact value of the hidden number. In this test, the hidden number is 30.

<image>

59 is a divisor of the hidden number. In the interval [2, 100] there is only one number with this divisor. The hidden number must be 59, which is prime. Note that the answer is known even after the second query and you could print it then and terminate. Though, it isn't forbidden to ask unnecessary queries (unless you exceed the limit of 20 queries).

Difficulty: MEDIUM
Tags: Mathematics

Constructive algorithms

Starter code:

Solutions:
import sys
import os
from io import BytesIO, IOBase

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def query(a):
	os.write(1, b'%d\n' % a)
	return str(os.read(0, 100))

def solve(case):
	cnt = 0
	primes = [2, 3, 5, 7]
	div = []
	for i in range(len(primes)):
		ans = query(primes[i])
		if 'yes' in ans:
			div.append(primes[i])
			cnt += 1
	if cnt == 0:
		print('prime')
	elif len(div) == 1:
		i = div[0]
		x = 2
		cnt = 0
		while i ** x < 101:
			if 'yes' in query(i ** x):
				cnt += 1
				break
			x += 1
		new = []
		for i in range(10, 50):
			if isPrime(i):
				new.append(i)
		for i in new:
			if div[0] * i > 100:
				break
			if 'yes' in query(i):
				cnt += 1
		if cnt == 0:
			print('prime')
		else:
			print('composite')
	else:
		print('composite')
solve(1)


import sys, math, cmath, time
start_time = time.time()

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())

def solve():
	a = []
	for i in range(2, 50):
		qw = 1
		for j in range(2, math.ceil(i ** 0.5)):
			if i % j == 0:
				qw = 0
				break
		if qw == 1:
			a.append(i)
	qw = 'prime'
	c = 0
	for i in range(len(a)):
		print(a[i])
		sys.stdout.flush()
		s = insr()
		if s == 'yes':
			c = c + 1
			if c >= 2:
				qw = 'composite'
				break
	print(qw)
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
t = 1
for tt in range(t):
	solve()
if not ONLINE_JUDGE:
	print('Time Elapsed:', time.time() - start_time, 'seconds')
sys.stdout.close()


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve(case):
	cnt = 0
	primes = [2, 3, 5, 7]
	div = []
	for i in range(len(primes)):
		print(primes[i])
		sys.stdout.flush()
		ans = inp()
		if ans == 'yes':
			div.append(primes[i])
			cnt += 1
	if cnt == 0:
		print('prime')
	elif len(div) == 1:
		i = div[0]
		x = 2
		cnt = 0
		while i ** x < 101:
			print(i ** x)
			sys.stdout.flush()
			if inp() == 'yes':
				cnt += 1
				break
			x += 1
		new = []
		for i in range(10, 50):
			if isPrime(i):
				new.append(i)
		for i in new:
			if div[0] * i > 100:
				break
			print(i)
			sys.stdout.flush()
			if inp() == 'yes':
				cnt += 1
		if cnt == 0:
			print('prime')
		else:
			print('composite')
	else:
		print('composite')
testcase(1)


from sys import stdin, stdout
dividers = ['4', '9', '25', '49', '2', '3', '5', '7', '11', '13', '17', '19', '23', '29', '31', '37', '41', '43', '47']
cnt = 0
for v in dividers:
	stdout.write(v + '\n')
	stdout.flush()
	if stdin.readline().rstrip() == 'yes':
		cnt += 1
if cnt > 1:
	stdout.write('composite')
else:
	stdout.write('prime')
stdout.flush()


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 10 ** 9 + 7
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]

def primeN(n):
	prime = [True for i in range(n + 1)]
	prime[0] = False
	prime[1] = False
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return [p for p in range(n + 1) if prime[p]]
primes = primeN(50)
found = 0
for i in primes:
	print(i, flush=True)
	res = input()
	if res == 'yes':
		found += 1
	if i > 7:
		continue
	print(i * i, flush=True)
	res = input()
	if res == 'yes':
		found += 1
if found > 1:
	print('composite', flush=True)
else:
	print('prime', flush=True)
exit()


from sys import stdout, stdin
PS = [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]

def ask_and_yes(num):
	print(num)
	stdout.flush()
	line = stdin.readline().strip()
	return line == 'yes'

def solve():
	first_p = -1
	for p in PS:
		if p >= 53:
			print('prime')
			return
		elif ask_and_yes(p):
			first_p = p
			break
	quo = int(100 / first_p)
	if first_p >= quo:
		print('prime')
		return
	for i in range(len(PS) - 1, -1, -1):
		if PS[i] < quo:
			break
	for j in range(i, -1, -1):
		if PS[j] == first_p:
			break
		elif ask_and_yes(PS[j]):
			print('composite')
			return
	if ask_and_yes(first_p * first_p):
		print('composite')
	else:
		print('prime')
solve()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]

def prime(number):
	if number == 2:
		return True
	if number & 1:
		i = 2
		while i * i <= number:
			if number % i == 0:
				return False
			i += 1
		return True
	return False
arr = []
for i in range(2, 101):
	if prime(i):
		arr.append(i)
		if i * i <= 100:
			arr.append(i * i)
arr.sort()
(low, high) = (0, 24)
c = 0
for i in range(20):
	out(arr[i])
	sys.stdout.flush()
	verdict = data()
	if verdict.lower() == 'yes':
		c += 1
	if c == 2:
		out('composite')
		exit()
out('prime')


import sys

def is_prime(n, primes):
	for p in primes:
		if n % p == 0:
			return False
	else:
		return True

def main():
	primes = [2, 3, 5, 7]
	for i in range(primes[-1] + 2, 49, 2):
		if is_prime(i, primes):
			primes.append(i)
	ndivs = 0
	last_divisor = -1
	for p in primes[:4]:
		print(p)
		sys.stdout.flush()
		ans = sys.stdin.readline().strip() == 'no'
		ndivs += not ans
		if not ans:
			last_divisor = p
		if ndivs >= 2:
			break
	if ndivs > 1:
		print('composite')
	elif ndivs == 0:
		print('prime')
	else:
		print(last_divisor * last_divisor)
		sys.stdout.flush()
		ans = sys.stdin.readline().strip() == 'no'
		if not ans:
			print('composite')
		else:
			for p in primes[4:]:
				print(p)
				sys.stdout.flush()
				ans = sys.stdin.readline().strip() == 'no'
				if not ans:
					print('composite')
					break
			else:
				print('prime')
	sys.stdout.flush()
main()