/*------------------------------------------------------------
TEAM29
A
230
Target: Java6; Platform: Win32; Comment: Java (JDK 6)
------------------------------------------------------------*/
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Random;
import java.util.concurrent.atomic.AtomicReference;


public class Solution {
	private static final int TIME_LIMIT = 2900;
	private static final boolean DEBUG = false;
	
	long curWhite = 0x000000000000FFFFL;
	long curBlack = 0xFFFF000000000000L;
		
//	State makeMove(Move m) {
//		if (m.tx != m.fx + 1 || Math.abs(m.ty - m.fy) > 1 ||
//				m.ty == m.fy && get(black, m.tx, m.ty) ||
//				!get(white, m.fx, m.fy) || get(white, m.tx, m.ty)) {
//			throw new AssertionError();
//		}
//		return new State(set(clear(white, m.fx, m.fy), m.tx, m.ty), clear(black, m.tx, m.ty)).flip();
//	}

	public boolean win(long white, long black) {
		return black == 0 || (white & 0xFF00000000000000L) != 0;
	}

	public boolean lose(long white, long black) {
		return white == 0 || (black & 0x00000000000000FFL) != 0;
	}
	
	static class Move {
		int fx, fy, tx, ty;
		
		Move(int fx, int fy, int tx, int ty) {
			this.fx = fx;
			this.fy = fy;
			this.tx = tx;
			this.ty = ty;
		}
		
		Move flip() {
			return new Move(7 - fx, 7 - fy, 7 - tx, 7 - ty);
		}

		public String toString() {
			return "" + (char)(fy + 'a') + (char)(fx + '1') + (char)(ty + 'a') + (char)(tx + '1');
		}
	}
	
	final long movableToLeft = 0x7F7F7F7F7F7F7F7FL;
	final long movableToRight = 0xFEFEFEFEFEFEFEFEL;
	private Move bestMove;
	
	final int MINF = -1000000000;
	final int INF = 1000000000;
	final int MIN_MAX_DEPTH = 5;
	
	private Move anyMove;
	final int[] Y_MOVES = {0, -1, 1};
	
	private int alphaBeta(long white, long black, int alpha, int beta, int depth, int maxDepth, boolean setBest) {
		if (lose(white, black)) {
			return Math.max(alpha, MINF + 1 + depth);
		}
		if (win(white, black)) {
			return Math.min(beta, INF - 1 - depth);
		}
		if (depth == maxDepth) {
			return Math.min(Math.max(fitness(white, black), alpha), beta);
		}
		long iter = white;
		while (iter != 0 && currentThread.get() != null) {
			int pos = 63 - Long.numberOfLeadingZeros(iter);
			int x = pos >> 3;
			int y = pos & 7;
			iter ^= 1L << pos;
			for (int dy : Y_MOVES) {
				int ny = y + dy;
				int nx = x + 1;
				if (ny >= 0 && ny < 8 && !get(white, nx, ny) && (dy != 0 || !get(black, nx, y))) {
					if (setBest) {
						anyMove = new Move(x, y, nx, ny);
					}
					long newWhite = clear(set(white, nx, ny), x, y);
					long newBlack = clear(black, nx, ny);
					int val = -alphaBeta(Long.reverse(newBlack), Long.reverse(newWhite), -beta, -alpha, depth + 1, maxDepth, false);
					if (val > alpha) {
						alpha = val;
						if (setBest) {
							bestMove = new Move(x, y, nx, ny);
						}
						if (alpha >= beta) {
							return alpha;
						}
					}
				}
			}
		}
		return alpha;
	}
	
	final int[] coeffAttack = {17, 22, 31, 32, 39, 44, 1000, 0};
	final int[] coeff = new int[8];
	private int fitnessInvokes;
	{
		for (int i = 0; i < 8; ++i) {
			coeff[i] = coeffAttack[i];
		}
	}
	
	Random rnd = new Random();
	boolean inSubAlpha = false;
	
	private int fitness(long white, long black) {
		int res = 0;
		long iter = white;
		while (iter != 0) {
			int pos = 63 - Long.numberOfLeadingZeros(iter);
			int x = pos >> 3;
			int y = pos & 7;
			long mask = ((7 << y) >> 1) & 0xFF;
			boolean underAttack = (black & (mask << (8 * (x + 1)))) != 0;
			iter ^= 1L << pos;
			res += (underAttack ? coeffAttack : coeff)[x];
		}
		iter = black;
		while (iter != 0) {
			int pos = 63 - Long.numberOfLeadingZeros(iter);
			int x = pos >> 3;
			int y = pos & 7;
			iter ^= 1L << pos;
			long mask = ((7 << y) >> 1) & 0xFF;
			boolean underAttack = (white & (mask << (8 * (x - 1)))) != 0;
			res -= (underAttack ? coeffAttack : coeff)[7 - x];
		}
//		if (rnd.nextInt(100000) == 0 && !inSubAlpha) {
//			inSubAlpha = true;
//			int val = alphaBeta(white, black, MINF, INF, 0, 5, false);
//			if (currentThread.get() != null) {
//				System.err.println(black + " " +white + " " + val);
//			}
//			inSubAlpha = false;
//		}
		return res;
	}

	private Move bestMove(long white, long black) {
		currentThread.set(new Thread() {
			@Override
			public void run() {
				try {
					Thread.sleep(TIME_LIMIT);
				} catch (InterruptedException e) {
				}
				currentThread.compareAndSet(this, null);
			}
		});
		anyMove = null;
		currentThread.get().start();
		Move curMove = null;
		fitnessInvokes = 0;
		for (int maxDepth = MIN_MAX_DEPTH; currentThread.get() != null; maxDepth++) {
			bestMove = null;
			alphaBeta(white, black, MINF, INF, 0, maxDepth, true);
			if (currentThread.get() != null) {
				curMove = bestMove;
			}
		}
		if (curMove == null) {
			curMove = anyMove;
		}
		Thread th = currentThread.get();
		if (th != null) {
			th.interrupt();
		}
		return curMove;
	}

	boolean weAreWhite = false;
	boolean firstMove = true;
	
	final AtomicReference<Thread> currentThread = new AtomicReference<Thread>();

	private boolean solve() throws IOException {
		String move = in.readLine();
		if (move.equals("Start")) {
			weAreWhite = true;
			if (DEBUG) {
				System.setErr(new PrintStream(new FileOutputStream("logWhite.log"), true));
			}
		} else if (move.equals("Quit")) {
			return false;
		} else {
			Move m = parseMove(move);
			if (weAreWhite) {
				m = m.flip();
			}
			makeCurMove(m);
		}
		if (!weAreWhite && firstMove) {
			if (DEBUG) {
				System.setErr(new PrintStream(new FileOutputStream("logBlack.log"), true));
			}
		}
		firstMove = false;
		Move m = bestMove(curWhite, curBlack);
		makeCurMove(m);
		if (!weAreWhite) {
			m = m.flip();
		}
		print(m.toString());
		return true;
	}

	private void makeCurMove(Move m) {
		long newWhite = clear(set(curWhite, m.tx, m.ty), m.fx, m.fy);
		long newBlack = clear(curBlack, m.tx, m.ty);
		curWhite = Long.reverse(newBlack);
		curBlack = Long.reverse(newWhite);
	}

	private Move parseMove(String move) {
		return new Move(move.charAt(1) - '1', move.charAt(0) - 'a', move.charAt(3) - '1', move.charAt(2) - 'a');
	}

	static long set(long val, int pos) {
		return val | (1L << pos);
	}
	
	static long clear(long val, int pos) {
		return val & (~(1L << pos));
	}
	
	static long set(long val, int x, int y) {
		return set(val, 8 * x + y);
	}
	
	static long clear(long val, int x, int y) {
		return clear(val, 8 * x + y);
	}
	
	static boolean get(long val, int pos) {
		return (val & (1L << pos)) != 0;
	}
	
	static boolean get(long val, int x, int y) {
		return get(val, 8 * x + y);
	}

	private BufferedReader in;
	private PrintWriter out;

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		
		if (!in.readLine().equals("Name")) {
			throw new AssertionError();
		}
		print("Eat More");
		
		while (solve());
		System.exit(0);
	}

	private void print(String str) {
		out.println(str);
		out.flush();
	}
	
	public static void main(String[] args) throws IOException {
		new Solution().run();
	}
	
}
