description: This is an interactive problem.
  
  ICPC Assiut Community decided to hold a unique chess contest, and you were chosen to control a queen and hunt down the hidden king, while a member of ICPC Assiut Community controls this king.
  
  You compete on an 8×8 chessboard, the rows are numerated from top to bottom, and the columns are numerated left to right, and the cell in row x and column y is denoted as (x, y).
  
  In one turn you can move the queen to any of the squares on the same horizontal line, vertical line, or any of the diagonals. For example, if the queen was on square (4, 5), you can move to (q_1, 5), (4, q_1), (q_1, 9-q_1), or (q_2, q_2+1) where (1 ≤ q_1 ≤ 8, q_1 ≠ 4, 1 ≤ q_2 ≤ 7, q_2 ≠ 4). Note that the queen cannot stay on its current cell. 
  
  <image>
  
  In one turn, the king can move "Right", "Left", "Up", "Down", "Down-Right", "Down-Left", "Up-Left", or "Up-Right" such that he doesn't get out of the board. The king cannot move into a cell that is on the same row, column or diagonal with the queen (including the position of the queen itself). For example, if the king was on square (4, 5), he can move to (4+k_1, 5+k_2) where (-1 ≤ k_1,k_2 ≤ 1, (k_1, k_2) ≠ (0, 0)). 
  
  <image>
  
  At the start of the game, you should place the queen at any location on the board, and this is done once per game. After that the king is secretly placed at any cell different from the queen's location. You do not know the position of the king. Then, the king and the queen take turns with the king moving first. The king moves to one of the possible directions ("Right", "Down", "Up-Left", etc.), and you are only given the direction it moves to. After that, you should move your queen by declaring the square to which your queen will move. The game follows like this until you win the game or run out of moves.
  
  You win if the king has no valid moves. You lose if after 130 moves of the queen the king still has valid moves.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 60) — the number of test cases.
  
  Interaction
  
  In each test case, you should print the queen's starting cell immediately. If you placed the queen at the king's cell, you will win immediately.
  
  After that, you may make at most 130 moves. Each move is made in the format x y, where x and y are two integers (1 ≤ x,y ≤ 8) that denote the new row and column of the queen respectively. Your move should be a valid queen move.
  
  After the initial queen placement and after each move you will receive a string s that represents the direction of the king's move. It will be one of the following: "Right", "Left", "Up", "Down", "Down-Right", "Down-Left", "Up-Left", "Up-Right", or "Done" if you win the game. You should consider "Done" as the end of each test case.
  
  After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
  
    * fflush(stdout) or cout.flush() in C++;
    * System.out.flush() in Java;
    * flush(output) in Pascal;
    * stdout.flush() in Python;
    * see documentation for other languages.
  
  
  
  If at any point you make an invalid query or try to make more than 130 queries for each test case, the game will terminate immediately and you will receive a Wrong Answer verdict.
  
  Example
  
  Input
  
  
  1
  Left
  Right
  Done
  
  Output
  
  
  7 5
  7 6
  7 7
  
  Note
  
  In the example, the hidden king was at (8, 8) at the start. The game follows like this:
  
  <image> <image>
solution: //package round737;
  import java.io.*;
  import java.util.*;
  
  public class E {
  	InputStream is;
  	FastWriter out;
  	String INPUT = "";
  
  	void solve()
  	{
  		for(int T = ni();T > 0;T--)go();
  	}
  
  	void print(int r, int c)
  	{
  		out.println(r + " " + c); out.flush();
  	}
  
  	int[] read()
  	{
  		String s = ns();
  		if(s.contains("Done"))return null;
  		int[] ret = {0, 0};
  		if(s.contains("Down"))ret[0] = 1;
  		if(s.contains("Up"))ret[0] = -1;
  		if(s.contains("Left"))ret[1] = -1;
  		if(s.contains("Right"))ret[1] = 1;
  		return ret;
  	}
  
  	boolean valid(int kr, int kc, int qr, int qc)
  	{
  		if(kr < 1 || kr > 8)return false;
  		if(kc < 1 || kc > 8)return false;
  		if(kr == qr)return false;
  		if(kc == qc)return false;
  		if(kr+kc == qr+qc)return false;
  		if(kr-kc == qr-qc)return false;
  		if(Math.abs(kr-qr) <= 1 &&  Math.abs(kc-qc) <= 1)return false;
  		return true;
  	}
  
  	void go()
  	{
  		int[][] his = new int[200][];
  		int p = 0;
  		print(2, 7);
  		his[p++] = read();
  		if(his[p-1] == null)return;
  		for(int r = 3;r <= 7;r++){
  			print(r, 7);
  			his[p++] = read();
  			if(his[p-1] == null)return;
  		}
  		for(int c = 6;c >= 2;c--){
  			print(7, c);
  			his[p++] = read();
  			if(his[p-1] == null)return;
  		}
  		List<int[]> valids = new ArrayList<>();
  		for(int i = 1;i <= 8;i++){
  			inner:
  			for(int j = 1;j <= 8;j++){
  				int kr = i, kc = j;
  				if(i == 2 && j == 7)continue;
  				for(int h = 0;h <= 5;h++){
  					kr += his[h][0];
  					kc += his[h][1];
  					if(!valid(kr, kc, 2+h, 7))continue inner;
  				}
  				for(int h = 6;h <= 10;h++){
  					kr += his[h][0];
  					kc += his[h][1];
  					if(!valid(kr, kc, 7, 7-(h-5)))continue inner;
  				}
  				valids.add(new int[]{kr, kc});
  			}
  		}
  		int qr = 7, qc = 2;
  		while(!valids.isEmpty()){
  //			for(int[] v : valids){
  //				tr(v);
  //			}
  //			tr();
  			int[] tar = valids.get(0);
  			if(tar[0] > qr + 1){
  				qr = tar[0]-1;
  			}else if(tar[0] < qr - 1){
  				qr = tar[0]+1;
  			}else if(tar[1] < qc - 1){
  				qc = tar[1]+1;
  			}else if(tar[1] > qc - 1){
  				qc = tar[1]-1;
  			}
  			print(qr, qc);
  			his[p++] = read();
  			if(his[p-1] == null)return;
  			List<int[]> nvalids = new ArrayList<>();
  			for(int[] u : valids){
  				u[0] += his[p-1][0];
  				u[1] += his[p-1][1];
  				if(valid(u[0], u[1], qr, qc)){
  					nvalids.add(u);
  				}
  			}
  			valids = nvalids;
  		}
  	}
  	
  	void run() throws Exception
  	{
  		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
  		out = new FastWriter(System.out);
  		
  		long s = System.currentTimeMillis();
  		solve();
  		out.flush();
  		tr(System.currentTimeMillis()-s+"ms");
  	}
  	
  	public static void main(String[] args) throws Exception { new E().run(); }
  	
  	private byte[] inbuf = new byte[1024];
  	public int lenbuf = 0, ptrbuf = 0;
  	
  	private int readByte()
  	{
  		if(lenbuf == -1)throw new InputMismatchException();
  		if(ptrbuf >= lenbuf){
  			ptrbuf = 0;
  			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
  			if(lenbuf <= 0)return -1;
  		}
  		return inbuf[ptrbuf++];
  	}
  	
  	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
  	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
  	
  	private double nd() { return Double.parseDouble(ns()); }
  	private char nc() { return (char)skip(); }
  	
  	private String ns()
  	{
  		int b = skip();
  		StringBuilder sb = new StringBuilder();
  		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
  			sb.appendCodePoint(b);
  			b = readByte();
  		}
  		return sb.toString();
  	}
  	
  	private char[] ns(int n)
  	{
  		char[] buf = new char[n];
  		int b = skip(), p = 0;
  		while(p < n && !(isSpaceChar(b))){
  			buf[p++] = (char)b;
  			b = readByte();
  		}
  		return n == p ? buf : Arrays.copyOf(buf, p);
  	}
  
  	private int[] na(int n)
  	{
  		int[] a = new int[n];
  		for(int i = 0;i < n;i++)a[i] = ni();
  		return a;
  	}
  
  	private long[] nal(int n)
  	{
  		long[] a = new long[n];
  		for(int i = 0;i < n;i++)a[i] = nl();
  		return a;
  	}
  
  	private char[][] nm(int n, int m) {
  		char[][] map = new char[n][];
  		for(int i = 0;i < n;i++)map[i] = ns(m);
  		return map;
  	}
  
  	private int[][] nmi(int n, int m) {
  		int[][] map = new int[n][];
  		for(int i = 0;i < n;i++)map[i] = na(m);
  		return map;
  	}
  
  	private int ni() { return (int)nl(); }
  
  	private long nl()
  	{
  		long num = 0;
  		int b;
  		boolean minus = false;
  		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
  		if(b == '-'){
  			minus = true;
  			b = readByte();
  		}
  
  		while(true){
  			if(b >= '0' && b <= '9'){
  				num = num * 10 + (b - '0');
  			}else{
  				return minus ? -num : num;
  			}
  			b = readByte();
  		}
  	}
  
  	public static class FastWriter
  	{
  		private static final int BUF_SIZE = 1<<13;
  		private final byte[] buf = new byte[BUF_SIZE];
  		private final OutputStream out;
  		private int ptr = 0;
  
  		private FastWriter(){out = null;}
  
  		public FastWriter(OutputStream os)
  		{
  			this.out = os;
  		}
  
  		public FastWriter(String path)
  		{
  			try {
  				this.out = new FileOutputStream(path);
  			} catch (FileNotFoundException e) {
  				throw new RuntimeException("FastWriter");
  			}
  		}
  
  		public FastWriter write(byte b)
  		{
  			buf[ptr++] = b;
  			if(ptr == BUF_SIZE)innerflush();
  			return this;
  		}
  
  		public FastWriter write(char c)
  		{
  			return write((byte)c);
  		}
  
  		public FastWriter write(char[] s)
  		{
  			for(char c : s){
  				buf[ptr++] = (byte)c;
  				if(ptr == BUF_SIZE)innerflush();
  			}
  			return this;
  		}
  
  		public FastWriter write(String s)
  		{
  			s.chars().forEach(c -> {
  				buf[ptr++] = (byte)c;
  				if(ptr == BUF_SIZE)innerflush();
  			});
  			return this;
  		}
  
  		private static int countDigits(int l) {
  			if (l >= 1000000000) return 10;
  			if (l >= 100000000) return 9;
  			if (l >= 10000000) return 8;
  			if (l >= 1000000) return 7;
  			if (l >= 100000) return 6;
  			if (l >= 10000) return 5;
  			if (l >= 1000) return 4;
  			if (l >= 100) return 3;
  			if (l >= 10) return 2;
  			return 1;
  		}
  
  		public FastWriter write(int x)
  		{
  			if(x == Integer.MIN_VALUE){
  				return write((long)x);
  			}
  			if(ptr + 12 >= BUF_SIZE)innerflush();
  			if(x < 0){
  				write((byte)'-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for(int i = ptr + d - 1;i >= ptr;i--){
  				buf[i] = (byte)('0'+x%10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		private static int countDigits(long l) {
  			if (l >= 1000000000000000000L) return 19;
  			if (l >= 100000000000000000L) return 18;
  			if (l >= 10000000000000000L) return 17;
  			if (l >= 1000000000000000L) return 16;
  			if (l >= 100000000000000L) return 15;
  			if (l >= 10000000000000L) return 14;
  			if (l >= 1000000000000L) return 13;
  			if (l >= 100000000000L) return 12;
  			if (l >= 10000000000L) return 11;
  			if (l >= 1000000000L) return 10;
  			if (l >= 100000000L) return 9;
  			if (l >= 10000000L) return 8;
  			if (l >= 1000000L) return 7;
  			if (l >= 100000L) return 6;
  			if (l >= 10000L) return 5;
  			if (l >= 1000L) return 4;
  			if (l >= 100L) return 3;
  			if (l >= 10L) return 2;
  			return 1;
  		}
  
  		public FastWriter write(long x)
  		{
  			if(x == Long.MIN_VALUE){
  				return write("" + x);
  			}
  			if(ptr + 21 >= BUF_SIZE)innerflush();
  			if(x < 0){
  				write((byte)'-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for(int i = ptr + d - 1;i >= ptr;i--){
  				buf[i] = (byte)('0'+x%10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		public FastWriter write(double x, int precision)
  		{
  			if(x < 0){
  				write('-');
  				x = -x;
  			}
  			x += Math.pow(10, -precision)/2;
  			//		if(x < 0){ x = 0; }
  			write((long)x).write(".");
  			x -= (long)x;
  			for(int i = 0;i < precision;i++){
  				x *= 10;
  				write((char)('0'+(int)x));
  				x -= (int)x;
  			}
  			return this;
  		}
  
  		public FastWriter writeln(char c){
  			return write(c).writeln();
  		}
  
  		public FastWriter writeln(int x){
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(long x){
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(double x, int precision){
  			return write(x, precision).writeln();
  		}
  
  		public FastWriter write(int... xs)
  		{
  			boolean first = true;
  			for(int x : xs) {
  				if (!first) write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter write(long... xs)
  		{
  			boolean first = true;
  			for(long x : xs) {
  				if (!first) write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter writeln()
  		{
  			return write((byte)'\n');
  		}
  
  		public FastWriter writeln(int... xs)
  		{
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(long... xs)
  		{
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(char[] line)
  		{
  			return write(line).writeln();
  		}
  
  		public FastWriter writeln(char[]... map)
  		{
  			for(char[] line : map)write(line).writeln();
  			return this;
  		}
  
  		public FastWriter writeln(String s)
  		{
  			return write(s).writeln();
  		}
  
  		private void innerflush()
  		{
  			try {
  				out.write(buf, 0, ptr);
  				ptr = 0;
  			} catch (IOException e) {
  				throw new RuntimeException("innerflush");
  			}
  		}
  
  		public void flush()
  		{
  			innerflush();
  			try {
  				out.flush();
  			} catch (IOException e) {
  				throw new RuntimeException("flush");
  			}
  		}
  
  		public FastWriter print(byte b) { return write(b); }
  		public FastWriter print(char c) { return write(c); }
  		public FastWriter print(char[] s) { return write(s); }
  		public FastWriter print(String s) { return write(s); }
  		public FastWriter print(int x) { return write(x); }
  		public FastWriter print(long x) { return write(x); }
  		public FastWriter print(double x, int precision) { return write(x, precision); }
  		public FastWriter println(char c){ return writeln(c); }
  		public FastWriter println(int x){ return writeln(x); }
  		public FastWriter println(long x){ return writeln(x); }
  		public FastWriter println(double x, int precision){ return writeln(x, precision); }
  		public FastWriter print(int... xs) { return write(xs); }
  		public FastWriter print(long... xs) { return write(xs); }
  		public FastWriter println(int... xs) { return writeln(xs); }
  		public FastWriter println(long... xs) { return writeln(xs); }
  		public FastWriter println(char[] line) { return writeln(line); }
  		public FastWriter println(char[]... map) { return writeln(map); }
  		public FastWriter println(String s) { return writeln(s); }
  		public FastWriter println() { return writeln(); }
  	}
  
  	public void trnz(int... o)
  	{
  		for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
  		System.out.println();
  	}
  
  	// print ids which are 1
  	public void trt(long... o)
  	{
  		Queue<Integer> stands = new ArrayDeque<>();
  		for(int i = 0;i < o.length;i++){
  			for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
  		}
  		System.out.println(stands);
  	}
  
  	public void tf(boolean... r)
  	{
  		for(boolean x : r)System.out.print(x?'#':'.');
  		System.out.println();
  	}
  
  	public void tf(boolean[]... b)
  	{
  		for(boolean[] r : b) {
  			for(boolean x : r)System.out.print(x?'#':'.');
  			System.out.println();
  		}
  		System.out.println();
  	}
  
  	public void tf(long[]... b)
  	{
  		if(INPUT.length() != 0) {
  			for (long[] r : b) {
  				for (long x : r) {
  					for (int i = 0; i < 64; i++) {
  						System.out.print(x << ~i < 0 ? '#' : '.');
  					}
  				}
  				System.out.println();
  			}
  			System.out.println();
  		}
  	}
  
  	public void tf(long... b)
  	{
  		if(INPUT.length() != 0) {
  			for (long x : b) {
  				for (int i = 0; i < 64; i++) {
  					System.out.print(x << ~i < 0 ? '#' : '.');
  				}
  			}
  			System.out.println();
  		}
  	}
  
  	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
  	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
  }
  