import static java.lang.Math.acos;
import static java.lang.Math.cos;
import static java.lang.Math.sin;

import java.io.*;
import java.math.BigInteger;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;

public class C {

	public String expr;
	public int index;

	public double getValue() {
		current = -1;
		next();
		return expression();
	}

	private int current;
	private char token;

	/** Returns next token, but if end of expression has been reached 'Z'+1 is returned */
	private void next() {
		token = current+1 < expr.length() ? expr.charAt(++current) : (char)0;
	}

	/** Skips current token */
	private void skip(char t) {
		assert token == t;
		next();
	}

	// operand = operand | -operand | '(' expression ')'
	private double operand() {
		if ('0' <= token && token <= '9') {
			double result = 0;
			int x = 1;
			boolean point = false;
			while (('0' <= token && token <= '9') || (token == '.')) {
				if (token == '.')
					point = true;
				if (point) {
					x /= 10;
					result += (token - '0')*x;
				}
				else
					result = result * 10 + (token -'0');
				skip(token);
			}
			return result;
		}
		if (token == '(') {
			skip('(');
			double result = expression();
			skip(')');
			return result;
		}
		int stream = token - 'A';
		int number = 0;
		boolean negative = false;
		skip(token);
		skip('[');
		if (token == '-') {
			skip('-');
			negative = true;
		}
		while ('0' <= token && token <= '9') {
			number = number * 10 + (token -'0');
			skip(token);
		}
		skip(']');
		if (negative)
			number = -number;

		if (index + number < 0)
			return 0;
		if (index + number >= samples)
			return 0;

		return val[stream][index+number];
	}

	// factor = operand | operand '^' factor
	private double factor() {
		return operand();
	}

	// term = factor | term '*' factor | term '/' factor
	private double term() {
		double result = factor();
		for(;;) {
			if (token == '*') {
				skip('*');
				result *= factor();
			}
			else
				return result;
		}
	}

	// expression = term | expression '+' term | expression '-' term
	private double expression() {
		double result = term();
		for (;;) {
			if (token == '+') {
				skip('+');
				result += term();
			}
			else
				if (token == '-') {
					skip('-');
					result -= term();
				}
				else
					return result;
		}
	}


	boolean[] known;
	List<Integer>[] depends;
	int streams, samples;
	int[][] val;
	String[] expression;

	void doIt() throws Exception {
		BufferedReader in = new BufferedReader(new FileReader("C.in"));
		PrintStream out = new PrintStream("C.out");

		int T = Integer.parseInt(in.readLine());

		for (int testCase = 0; testCase < T; testCase++) {
			streams = Integer.parseInt(in.readLine());
			samples = Integer.parseInt(in.readLine());

			known = new boolean[26];
			boolean[] knownAlready = new boolean[26];
			boolean[] have = new boolean[26];
			depends = new ArrayList[26];
			expression = new String[26];

			val = new int[26][samples];

			int countKnowns = 0;

			for (int i = 0; i < 26; i++) {
				Arrays.fill(val[i], Integer.MAX_VALUE);
				depends[i] = new ArrayList<Integer>();
			}

			for (int i = 0; i < 26; i++) expression[i] = "";

			for (int i = 0; i < streams; i++) {
				String s = in.readLine();
				System.out.println(s);
				int stream = s.charAt(0) - 'A';
				have[stream] = true;
				if (s.indexOf('=') > -1) {
					expression[stream] = "";
					StringTokenizer str = new StringTokenizer(s);
					str.nextToken();
					str.nextToken();
					while (str.hasMoreTokens())
						expression[stream] += str.nextToken();

					System.out.println(expression[stream]);
					for (char c = 'A'; c <= 'Z'; c++)
						if (s.indexOf(c, 2) > -1)
							depends[stream].add((int)(c - 'A'));
				}
				else {
					countKnowns++;
					knownAlready[i] = known[i] = true;
					StringTokenizer str = new StringTokenizer(s);
					str.nextToken();
					str.nextToken();
					for (int j = 0; j < samples; j++)
						val[stream][j] = Integer.parseInt(str.nextToken());
				}
			}

			while (true) {
				int stream = -1;
				for (int i = 0; i < 26 && stream == -1; i++) {
					System.out.println(i + "\t" + known[i] + "\t" + depends[i]);
					if (!known[i] && have[i]) {
						boolean ok = true;
						for (int j : depends[i])
							if (!known[j]) {
								ok = false;
								break;
							}
						if (ok)
							stream = i;
					}
				}
				System.out.println(stream);
				if (stream == -1)
					break;

				for (int i = 0; i < samples; i++) {
					index = i;
					System.out.println(expr = expression[stream]);
					val[stream][i] = (int) Math.round(getValue());
				}
				known[stream] = true;
			}

			out.println("DATA SET #" + (testCase+1));
			for (int i = 0; i < 26; i++)
				if (!knownAlready[i] && known[i]) {
					out.print((i+'A') + " %");
					for (int j = 0; j < samples; j++)
						out.print(" " + val[i][j]);
					out.println();
				}
		}

		out.close();
	}

	public static void main(String[] args) throws Exception {
		new C().doIt();
	}
}



Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -65
	at C.operand(C.java:84)
	at C.factor(C.java:89)
	at C.term(C.java:94)
	at C.expression(C.java:107)
	at C.getValue(C.java:20)
	at C.doIt(C.java:208)
	at C.main(C.java:227)
A % 10 20 30 20 10
B = A[0] + A[-1]
A[0]+A[-1]
C = 0.5 * ( A[0] + B[0] )
0.5*(A[0]+B[0])
0	true	[]
1	false	[0]
1
A[0]+A[-1]
A[0]+A[-1]
A[0]+A[-1]
A[0]+A[-1]
A[0]+A[-1]
0	true	[]
1	true	[0]
2	false	[0, 1]
2
0.5*(A[0]+B[0])
0.5*(A[0]+B[0])
0.5*(A[0]+B[0])
0.5*(A[0]+B[0])
0.5*(A[0]+B[0])
0	true	[]
1	true	[0]
2	true	[0, 1]
3	false	[]
4	false	[]
5	false	[]
6	false	[]
7	false	[]
8	false	[]
9	false	[]
10	false	[]
11	false	[]
12	false	[]
13	false	[]
14	false	[]
15	false	[]
16	false	[]
17	false	[]
18	false	[]
19	false	[]
20	false	[]
21	false	[]
22	false	[]
23	false	[]
24	false	[]
25	false	[]
-1
Z = 0.5 * Y[0] + 0.5 * B[0]
0.5*Y[0]+0.5*B[0]
Y % 50 10 50 10 50
B % 10 50 10 50 15
0	false	[]
1	true	[]
2	true	[]
3	false	[]
4	false	[]
5	false	[]
6	false	[]
7	false	[]
8	false	[]
9	false	[]
10	false	[]
11	false	[]
12	false	[]
13	false	[]
14	false	[]
15	false	[]
16	false	[]
17	false	[]
18	false	[]
19	false	[]
20	false	[]
21	false	[]
22	false	[]
23	false	[]
24	false	[]
24