Problem: This is an interactive problem.

Vasya and Petya are going to play the following game: Petya has some positive integer number a. After that Vasya should guess this number using the following questions. He can say a pair of non-negative integer numbers (x, y). Petya will answer him: 

  * "x", if (x mod a) ≥ (y mod a). 
  * "y", if (x mod a) < (y mod a). 



We define (x mod a) as a remainder of division x by a.

Vasya should guess the number a using no more, than 60 questions.

It's guaranteed that Petya has a number, that satisfies the inequality 1 ≤ a ≤ 10^9.

Help Vasya playing this game and write a program, that will guess the number a.

Interaction

Your program should play several games.

Before the start of any game your program should read the string: 

  * "start" (without quotes) — the start of the new game. 
  * "mistake" (without quotes) — in the previous game, you found the wrong answer. Your program should terminate after reading this string and it will get verdict "Wrong answer". 
  * "end" (without quotes) — all games finished. Your program should terminate after reading this string. 



After reading the string "start" (without quotes) the new game starts. 

At the beginning, your program should ask several questions about pairs of non-negative integer numbers (x, y). You can only ask the numbers, that satisfy the inequalities 0 ≤ x, y ≤ 2 ⋅ 10^9. To ask a question print "? x y" (without quotes). As the answer, you should read one symbol: 

  * "x" (without quotes), if (x mod a) ≥ (y mod a). 
  * "y" (without quotes), if (x mod a) < (y mod a). 
  * "e" (without quotes) — you asked more than 60 questions. Your program should terminate after reading this string and it will get verdict "Wrong answer". 



After your program asked several questions your program should print the answer in form "! a" (without quotes). You should print the number a satisfying the inequalities 1 ≤ a ≤ 10^9. It's guaranteed that Petya's number a satisfied this condition. After that, the current game will finish.

We recall that your program can't ask more than 60 questions during one game.

If your program doesn't terminate after reading "mistake" (without quotes), "end" (without quotes) or "e" (without quotes), it can get any verdict, because it will continue reading from closed input. Also, if your program prints answer or question in the incorrect format it can get any verdict, too. Be careful.

Don't forget to flush the output after printing questions and answers.

To flush the output, you can use: 

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



It's guaranteed that you should play at least 1 and no more than 100 games.

Hacks:

In hacks, you can use only one game. To hack a solution with Petya's number a (1 ≤ a ≤ 10^9) in the first line you should write a single number 1 and in the second line you should write a single number a.

Example

Input


start
x
x
start
x
x
y
start
x
x
y
y
end


Output


? 0 0
? 10 1
! 1
? 0 0
? 3 4
? 2 5
! 2
? 2 4
? 2 5
? 3 10
? 9 1
! 3

Note

In the first test, you should play 3 games with Petya's numbers 1, 2 and 3.

In the first game, Petya will answer "x" (without quotes) to any question, because (x mod 1) = 0 for any integer x. 

In the second game, if you will ask pair (0, 0), the answer will be "x" (without quotes), because (0 mod 2) ≥ (0 mod 2). But if you will ask pair (2, 5), the answer will be "y" (without quotes), because (2 mod 2) < (5 mod 2), because (2 mod 2) = 0 and (5 mod 2) = 1.

Solution (in JAVA):

Solution:
	                                                    import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.TreeMap;


	                 
	                 
	                 
	                 
	                 
	                public class Solution2 implements Runnable
	                {
	                    static final long MAX = 464897L;
	                    static class InputReader
	                    {
	                        private InputStream stream;
	                        private byte[] buf = new byte[1024];
	                        private int curChar;
	                        private int numChars;
	                        private SpaceCharFilter filter;
	                        private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	                 
	                        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 String nextLine()
	                        {
	                            String str = "";
	                            try
	                            {
	                                str = br.readLine();
	                            }
	                            catch (IOException e)
	                            {
	                                e.printStackTrace();
	                            }
	                            return str;
	                        }
	                        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 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 double nextDouble() 
	                        {
	                            int c = read();
	                            while (isSpaceChar(c))
	                                c = read();
	                            int sgn = 1;
	                            if (c == '-') 
	                            {
	                                sgn = -1;
	                                c = read();
	                            }
	                            double res = 0;
	                            while (!isSpaceChar(c) && c != '.') 
	                            {
	                                if (c == 'e' || c == 'E')
	                                    return res * Math.pow(10, nextInt());
	                                if (c < '0' || c > '9')
	                                    throw new InputMismatchException();
	                                res *= 10;
	                                res += c - '0';
	                                c = read();
	                            }
	                            if (c == '.') 
	                            {
	                                c = read();
	                                double m = 1;
	                                while (!isSpaceChar(c)) 
	                                {
	                                    if (c == 'e' || c == 'E')
	                                        return res * Math.pow(10, nextInt());
	                                    if (c < '0' || c > '9')
	                                        throw new InputMismatchException();
	                                    m /= 10;
	                                    res += (c - '0') * m;
	                                    c = read();
	                                }
	                            }
	                            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 String next() 
	                        {
	                            return readString();
	                        }
	                        
	                        public interface SpaceCharFilter 
	                        {
	                            public boolean isSpaceChar(int ch);
	                        }
	                    }
	                     
	                    public static void main(String args[]) throws Exception
	                    {
	                        new Thread(null, new Solution2(),"Solution2",1<<26).start();
	                    }   
	                    static long gcd(long a, long b) 
	                    { 
	                      if (b == 0) 
	                        return a; 
	                      return gcd(b, a % b);  
	                    } 
	                    static long lcm(long a,long b) {
	                        return (a*b)/gcd(a,b);
	                    }
	                    int maxn = 1000005;
	                    long MOD = 998244353;
	                    long prime = 29;
	                    ArrayList<Integer> adj[];
	                    TreeMap<Long,Long> tmap = new TreeMap();
	                    int[] val;
	                    int[] ans;
	                    public void run() 
	                    {
	                        InputReader sc = new InputReader(System.in);
	                        PrintWriter w = new PrintWriter(System.out);
	                        boolean flag = false;
	                        int l = 0;
                    		int r = 1;
                    		int mid = (l + r)/2;
	                        while(true) {
	                        	String s = sc.next();
	                        	if(s.equals("end")) {
	                        		break;
	                        	}
	                        	else if(s.equals("start")) {
	                        		
	                        		System.out.println("? 0 1");
	                        		flag = true;
	                        		System.out.flush();
	                        		l = 0;
	                        		r = 1;
	                        		
	                        	}else if(flag){
	                        		if(s.equals("y") && flag) {
	                        			int temp = r;
	                        			r = r * 2;
	                        			l = temp;
	                        			System.out.println("? " + l + " " + r);
	                        			System.out.flush();
	                        		}else {
	                        			flag = false;
	                        			mid = (l + r)/2;
	                        			if(l + 1 == r) {
	                        				System.out.println("! " + (l + 1));
	                        				System.out.flush();
	                        				continue;
	                        			}
	                        			System.out.println("? " + l + " " + mid);
	                        			System.out.flush();
	                        			continue;
	                        		}
	                        	}else {
	                        		if(s.equals("y")) {
	                        			l = mid;
	                        		}else {
	                        			r = mid;
	                        		}
	                        		mid = (l + r)/2;
	                        		if(l + 1 == r) {
                        				System.out.println("! " + (l + 1));
                        				System.out.flush();
                        				continue;
                        			}
                        			System.out.println("? " + l + " " + mid);
                        			System.out.flush();
	                        	}
	                        }
	                        
	                        w.close();
	                    } 
	                    String forward(String s) {
	                    	char[] ch = s.toCharArray();
	                    	char[] toSend = new char[s.length()];
	                    	int x = 0;
	                    	for(int i = 0;i < ch.length;i+=2) {
	                    		toSend[x] = ch[i];
	                    		x++;
	                    	}
	                    	int y = ch.length-1;
	                    	for(int i = 1;i < ch.length;i+=2) {
	                    		toSend[y] = ch[i];
	                    		y--;
	                    	}
	                    	return String.valueOf(toSend);
	                    }
	                    String formed(String s) {
	                    	char[] ch = s.toCharArray();
	                    	char[] toSend = new char[s.length()];
	                    	int x = ch.length-1;
	                    	int y = 0;
	                    	for(int i = 0;i < ch.length/2;i++) {
	                    		toSend[y] = ch[i];
	                    		if(i+1<ch.length) {
	                    			toSend[y+1] = ch[x];
	                    			x--;
	                    		}
	                    		y+=2;	
	                    	}
	                    	return String.valueOf(toSend);
	                    }
	                    long ans(long r,long v) {
	                    	if(r == 0) {
	                    		return 0L;
	                    	}
	                    	int[] prefix = new int[64];
                        	for(long i = 0;i <= 63;i++) {
                        		if((v>>i&1L) != 0) {
                        			if(i == 0) {
                        				prefix[(int) i] = 1;
                        			}else {
                        				prefix[(int) i] = prefix[(int) (i-1)] + 1;
                        			}
                        		}else {
                        			if(i == 0) {
                        				continue;
                        			}
                        			prefix[(int) i] = prefix[(int) (i-1)];
                        		}
                        	}
                        	
                        	long ans = 0;
                        	for(long i = 63;i > 0;i--) {
                        		if((v>>i & 1L) != 0) {
                        			if((r>>i&1L) == 0) {
                        				return ans;
                        			}
                        		}
                        		else if(((r>>i)&1L) != 0) {
                        			r = r - (1L<<i);
                        			long cnt = prefix[(int) (i-1)];
                        			long todd = i - cnt;
                        			ans += pow2[(int) todd];
                        			r = r + (1L<<i);
                        		}
                        		
                        	}
                        	return ans+1;
	                    }
	                    long[] pow2 = new long[64];
	                    void pre() {
	                    	pow2[0] = 1;
	                    	for(int i = 1;i <= 63;i++) {
	                    		pow2[i] = pow2[i-1] * 2;
	                    	}
	                    }
	                    ArrayList<Integer> merge(int key,ArrayList<Integer> a,ArrayList<Integer> b){
	                		ArrayList<Integer> c = new ArrayList();
	                		int i = 0;
	                		int j = 0;
	                		while(i < a.size() && j < b.size()){
	                			if(a.get(i) <= b.get(j)){
	                				c.add(a.get(i));
	                				i++;
	                			}else{
	                				c.add(b.get(j));
	                				j++;
	                			}
	                		}
	                		while(i < a.size()){
	                			c.add(a.get(i));
	                			i++;
	                		}
	                		while(j < b.size()){
	                			c.add(b.get(j));
	                			j++;
	                		}
	                		
	                		ArrayList<Integer> toreturn = new ArrayList();
	                		for(int l = 0;l < c.size();l+=2) {
	                			toreturn.add(c.get(l));
	                		}
	                		if(c.size() % 2 != 0) {
	                			toreturn.remove(toreturn.size()-1);
	                		}
	                		ans[c.get(c.size()-1)] = key;
	                		return toreturn;
	                	}
	                    static class SegTreeLazy{
	                		long[] segTree;
	                		long[] lazy;
	                		public SegTreeLazy(int n){
	                			segTree = new long[4*n];
	                			lazy = new long[4*n];
	                		}
	                		void build(int l,int r,int pos,int[] arr) {
	                			if(l == r) {
	                				segTree[pos] = arr[l];
	                				return;
	                			}
	                			int mid = (l + r)/2;
	                			build(l, mid, 2*pos+1, arr);
	                			build(mid+1, r, 2*pos+2, arr);
	                			segTree[pos] = segTree[2*pos+1] + segTree[2*pos+2];
	                		}
	                		void update(int l,int r,int start,int end,int pos,long val) {
	                			
	                			if(lazy[pos] != 0) {
	                				segTree[pos] += (r - l + 1) * lazy[pos];
	                				if(l != r) {
	                					lazy[2*pos+1] += lazy[pos];
	                					lazy[2*pos+2] += lazy[pos];
	                				}
	                				lazy[pos] = 0;
	                			}
	                			if(l > r || l > end || r < start) {
	                				return;
	                			}
	                			if(l >= start && r <= end) {
	                				segTree[pos] += (r - l + 1) * val;
	                				if(l != r) {
	                					lazy[2*pos+1] += val;
	                					lazy[2*pos+2] += val;
	                				}
	                				return;
	                			}
	                			int mid = (l + r)/2;
	                			update(l, mid, start, end, 2*pos+1, val);
	                			update(mid+1, r, start, end, 2*pos+2, val);
	                			segTree[pos] = segTree[2*pos+1] + segTree[2*pos+2];
	                		}
	                		long query(int l,int r,int start,int end,int pos) {
	                			if(lazy[pos] != 0) {
	                				segTree[pos] += (r - l + 1) * lazy[pos];
	                				if(l != r) {
	                					lazy[2*pos+1] += lazy[pos];
	                					lazy[2*pos+2] += lazy[pos];
	                				}
	                				lazy[pos] = 0;
	                			}
	                			if(l > r || l > end || r < start) {
	                				return 0;
	                			}
	                			if(l >= start && r <= end) {
	                				return segTree[pos];
	                			}
	                			int mid = (l + r)/2;
	                			long p1 = query(l, mid, start, end, 2*pos+1);
	                			long p2 = query(mid+1, r, start, end, 2*pos+2);
	                			return p1 + p2;
	                		}
	                	}
	                	
	                    static long power(long a,long b,long mod) {
                            long ans = 1;
                            a = a % mod;
                            while(b != 0) {
                                if(b % 2 == 1) {
                                    ans = (ans * a) % mod;
                                }
                                a = (a * a) % mod;
                                b = b/2;
                            }
                            return ans;
                        }
	                    class Pair implements Comparable<Pair>{
	                        int a;
	                        int b;
	                        int c;
	                        Pair(int a,int b,int c){
	                            this.b = b;
	                            this.a = a;
	                            this.c = c;
	                        }
	                        public boolean equals(Object o) {
	                            Pair p = (Pair)o;
	                            return this.a == p.a && this.b == this.b;
	                        }
	                        public int hashCode(){
	                            return Long.hashCode(a)*27 + Long.hashCode(b)*31;
	                        }
	                        public int compareTo(Pair p) {
	                            return Long.compare(this.a,p.a);
	                        }
	                    }
	                    
	                }