import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.regex.Pattern;
	
class Crossword {
	static class Operation {
		private static final Pattern SOLO_LETRAS = Pattern.compile("^[A-Za-z]+$");
		ArrayList<String> parameters;
		String result;
		
		public Operation(ArrayList<String> parameters, String result) {
			this.parameters = parameters;
			this.result = result;
		}

		@Override
		public String toString() {
			return "Operation [" + parameters + ", =" + result + "]";
		}
		
		public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
			int ammount = 0;
			final String REGEX = "^((-)?[0-9]+)|([-+x/])$";
			for (String str : parameters) {
				if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
					ammount++;
				}
			}
			if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
				ammount++;
			}
			return ammount;
		}

		public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
			if(result.matches("[A-Z]+")) {
				int resultUnknown = Integer.parseInt(this.parameters.get(0));
				for(int operador=1;operador<this.parameters.size();operador+=2) {
					switch(this.parameters.get(operador)) {
						case "+":
							resultUnknown+=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "-":
							resultUnknown-=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "*":
							resultUnknown*=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "/":
							resultUnknown/=Integer.parseInt(this.parameters.get(operador+1));
							break;
						default: 
							throw new IllegalArgumentException("Comando desconocido: ");
							
					}
				}
				solvedUnkowns.put(result, resultUnknown);
			}else if(containsVariable(this.parameters)){
				int resultUnknown =  Integer.parseInt(result);
				String result;
				int route=1;
				while(!this.parameters.get(route).matches("[A-Z]+")) {
					switch(this.parameters.get(route+1)) {
					case "-":
						resultUnknown+=Integer.parseInt(this.parameters.get(route-1));
						break;
					case "+":
						resultUnknown-=Integer.parseInt(this.parameters.get(route-1));
						break;
					case "/":
						resultUnknown*=Integer.parseInt(this.parameters.get(route-1));
						break;
					case "*":
						resultUnknown/=Integer.parseInt(this.parameters.get(route-1));
						break;
					}
					route+=2;
				}
				result=this.parameters.get(route);
				route+=2;
				while(route<this.parameters.size()) {
					switch(this.parameters.get(route)) {
					case "-":
						resultUnknown+=Integer.parseInt(this.parameters.get(route+1));
						break;
					case "+":
						resultUnknown-=Integer.parseInt(this.parameters.get(route+1));
						break;
					case "/":
						resultUnknown*=Integer.parseInt(this.parameters.get(route+1));
						break;
					case "*":
						resultUnknown/=Integer.parseInt(this.parameters.get(route+1));
						break;
					default: 
						throw new IllegalArgumentException("Comando desconocido: ");
					}
					route+=2;
				}
				
				solvedUnkowns.put(result, resultUnknown);
			}else {
				throw new IllegalArgumentException("Ninguna parte contiene una variable");
			}
			
		}
		
	    public static Boolean containsVariable(ArrayList<String> array) {
	        return array.stream()
	                .anyMatch(palabra -> SOLO_LETRAS.matcher(palabra).matches());
	    }
	}
	
	public static HashMap<String, Integer> solve(String[][] board) {
		
		HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
		LinkedList<Operation> operations = new LinkedList<Crossword.Operation>();
		
		for (int row = 0; row < board.length; row += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int col = 0; col < board[row].length; col++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row][col+1]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		
		for (int col = 0; col < board[0].length; col += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int row = 0; row < board.length; row++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row+1][col]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		System.out.println("lista" + operations.toString());
		int cont = 0;
		while (0 < operations.size()) {
			Operation op = operations.pollFirst();
			switch (op.unknownAmmount(solvedUnkowns)) {
			case 0:
				// not doing anything, just removing it from the queue
				cont = 0;
				break;
			case 1:
				op.calculateUnkown(solvedUnkowns);
				cont = 0;
				break;
			default:
				operations.addLast(op);
				cont++;
				break;
			}
			if (operations.size() <= cont) {
				return solvedUnkowns;
			}
		}
		
		return solvedUnkowns;
	}
}