import java.io.*;
import java.util.*;

/**
 * Created by Karolina_2 on 2015-04-12.
 */
public class Solver {

    List<String[]> constraints = new ArrayList<>();

    static Stack stack;
    Solver(){
        stack = new Stack();
    }

    public void readFromFile(File file){
        try {
            Scanner scanner = new Scanner(new FileReader(file));
            String[] variables = scanner.nextLine().split(" ");
            List<String> vars = Arrays.asList(variables);
            List<List<Integer>> domains = new ArrayList<>();
            Map<String, List<Integer>> domainsMap = new LinkedHashMap<>();
            //List<String[]> constraints = new ArrayList<>();
            /*for(int i = 0; i < variables.length; i++){
                String[] domainString = scanner.nextLine().split(" ");
                List<Integer> domain = new ArrayList<>();
                for(int j = 0; j < domainString.length; j++){
                    domain.add(Integer.parseInt(domainString[j]));
                }
                domains.add(domain);
            }*/
            for(int i = 0; i < variables.length; i++){
                String[] domainString = scanner.nextLine().split(" ");
                List<Integer> domain = new ArrayList<>();
                for(int j = 0; j < domainString.length; j++){
                    domain.add(Integer.parseInt(domainString[j]));
                }
                domainsMap.put(variables[i], domain);
            }
            int[] values = new int[variables.length];
            List<Integer> vals = new ArrayList<>();
            Map<String, Integer> mapa = new LinkedHashMap<>();
            for(int i = 0; i < variables.length; i++){
                mapa.put("x" + (i+1), -1);
            }
            System.out.println("Rozmiar mapy: " + mapa.size());
            int w = 0;
            for(String str : domainsMap.keySet()){
                if(domainsMap.get(str).size() == 1){
                    values[w] = domainsMap.get(str).get(0);
                }
                else{
                    values[w] = -1;
                }
                w++;
            }
            for(int i = 0; i < values.length; i++){
                if(values[i] != -1){
                    mapa.replace("x" + (i+1), values[i]);
                }
            }
            /*for(String x : mapa.keySet()){
                System.out.println("Element: " + (x+1) + " " + mapa.get(x));

            }*/
            for(int i = 0; i < domains.size(); i++){
                vals.add(-1);
            }
            System.out.println(vals.size());
            for(int i = 0; i < domains.size(); i++){
                if(domains.get(i).size() == 1){
                    vals.set(i, domains.get(i).get(0));
                }
                else{
                    vals.set(i, -1);
                }
            }
            System.out.println();
            for(int val : vals){
                System.out.print(val + " ");
            }
            System.out.println();
            for(String var : vars){
                System.out.print(var + " ");
            }
            List<String> constraint = new ArrayList<>();
            while(scanner.hasNext()){
                constraint.add(scanner.nextLine());
            }
            for(String string : constraint){
                String[] strings = string.split(" ");
                constraints.add(strings);
            }

                //res = (String)stack.peek();
                //System.out.println(res);
            System.out.println(constraints.size());
            System.out.println(domains.size());
            System.out.println(variables.length);
            //this.checkCorrectness(constraints, mapa);
            System.out.print(this.backtracking(mapa, domainsMap));
            for(String var : mapa.keySet()){
                System.out.println("Wartosc: " + mapa.get(var));
            }
        }catch(IOException err){
            err.printStackTrace();
        }
    }

    private boolean checkCorrectness(List<String[]> constraints, Map<String, Integer> map, String var, int val){
        //przejezdzac po kazdym ograniczeniu i sprawdzac, czy spelnione
        Map<String, Integer> mapa = new LinkedHashMap<>(map);
        mapa.put(var, val);
        boolean czySpelnione = true;
        for(String[] string : constraints) {
            if(czySpelnione) {
                String res = "";
                for (String string2 : string) {
                    if (string2.startsWith("x")) {
                        int x = mapa.get(string2);
                        stack.push(x);
                    } else if (isNumber(string2)) {
                        //int x = Integer.parseInt(string2);
                        //if(x != -1)
                            stack.push(string2);
                    } else if (string2.equals("-") || string2.equals("+") || string2.equals("*") || string2.equals("/")) {
                        /*String st1 = (String) stack.pop();
                        String st2 = (String) stack.pop();*/
                        int x = (int)stack.pop();
                        int y = (int)stack.pop();
                        int result;
                        if(x != -1 && y != -1) {
                            result = x + y;
                            //String result = st2 + string2 + st1;
                            stack.push(result);
                        }
                    }else if(string2.equals("==")) {
                        //System.out.println(result);
                        System.out.println("Stack size: " + stack.size());
                        if(stack.size() >= 2)
                            czySpelnione = Integer.parseInt((String) stack.pop()) == (int) stack.pop();
                        System.out.println(czySpelnione);
                    }else if(string2.equals("<>")){
                        if(stack.size() >= 2)
                            czySpelnione = Integer.parseInt((String) stack.pop()) != (int) stack.pop();
                        System.out.println(czySpelnione);
                    } else if (string2.equals("||")) {
                        int st;
                        if(!stack.empty()) {
                            st = (int) stack.pop();
                            //String result = "|" + st + "|";
                            int result = Math.abs(st);
                            System.out.print(result);
                            stack.push(result);
                        }
                        //System.out.println(result);
                    } else if (string2.equals("rozne")) {
                        //List<String> rozne = new ArrayList<>();
                        //System.out.print(this.czySaRozne(stack));
                        czySpelnione = this.czySaRozne(stack);
                        //System.out.println(czySpelnione);
                        //while (!stack.isEmpty()) {
                        //  rozne.add((String) stack.pop());
                        //}
                    /*for (int i = 0; i < rozne.size() - 1; i++) {
                        for (int j = 0; j < rozne.size() - 1; j++) {
                            if (i != j && i < j) {
                                String resu = rozne.get(i) + " != " + rozne.get(j);
                                //System.out.println(resu);
                                stack.push(resu);
                            }
                        }
                    }*/
                    }
                }
                stack.clear();
            }
        }
        /*for(String[] cons : constraints){
            for(String con : cons){
                System.out.print(con);
            }
            System.out.println();
        }
        for(String var : variables){
            System.out.print(var + " ");
        }
        for(int i : values){
            System.out.print(i + " ");
        }*/

        return czySpelnione;
    }

    static boolean isNumber(String string){
        if(string.isEmpty()) return false;
        for(int i = 0; i < string.length(); i++){
            if(!Character.isDigit(string.charAt(i))){
                return false;
            }
        }
        return true;
    }

    private boolean czySaRozne(Stack stack){
        //System.out.print(stack.pop());
        int num = stack.size() - 1;
        int[] values = new int[num];
        //int size = stack.size();
        for(int i = 0; i < num; i++) {
            int var = (int)stack.pop();
            values[i] = var;
        }
        for(int i = 0; i < values.length; i++){
            for(int j = 0; j < values.length; j++){
                if(i != j && values[i] != -1 && values[j] != j){
                    if(values[i] == values[j]){
                        return false;
                    }
                }
            }
        }
        return true;
    }

    private boolean backtrack(Map<String, Integer> map, Map<String, List<Integer>> domain, Map<String, List<Integer>> copy){
        if(!map.containsValue(-1)) {
            return true;
        }
        String var = this.chooseVar(map);
        //System.out.print(var);
        List<Integer> varDomain = new ArrayList<>();
        //Map<String, List<Integer>> copyOfDomain = this.copyMap(domain);
        for(int i = 0; i < domain.get(var).size(); i++){

            //System.out.print("Poprawnosc: " + this.checkCorrectness(constraints, map, var, domain.get(var).get(i)));
            if(this.checkCorrectness(constraints, map, var, domain.get(var).get(i))) {
                map.replace(var, domain.get(var).get(i));
                varDomain.add(domain.get(var).get(i));
                copy.replace(var, varDomain);
                //copyOfDomain.replace(var, varDomain);
                if (backtrack(map, domain, copy)) {
                    //jesli trzeba wszystkie rozwiazania, to dodawac do kolekcji, a nie zwracac true
                    return true;
                }
                else map.replace(var, -1);

                //else
                //  map.replace(var, -1);
            }
        }
        return false;
    }

    private boolean backtracking(Map<String, Integer> map, Map<String, List<Integer>> domain){
        //File file = new File("")
        if(!map.containsValue(-1)) {
            return true;
            //if(this.checkCorrectness(constraints, map)) {
              //  return map;
            //}
             //else{
               // System.out.println("Nie znaleziono poprawnego rozwiązania!");
                //return new HashMap<String, Integer>();
            //}
            //return map;
        }
        Map<String, List<Integer>> copyOfDomain = this.copyMap(domain);
        backtrack(map, domain, copyOfDomain);
        /*String var = this.chooseVariable(domain);
        System.out.print(var);
        List<Integer> varDomain = new ArrayList<>();
        //Map<String, List<Integer>> copyOfDomain = this.copyMap(domain);
        for(int i = 0; i < domain.get(var).size(); i++){
            map.replace(var, domain.get(var).get(i));
            System.out.print("Poprawnosc: " + this.checkCorrectness(constraints, map));
            if(this.checkCorrectness(constraints, map)) {
                varDomain.add(domain.get(var).get(i));
                domain.replace(var, varDomain);
                //copyOfDomain.replace(var, varDomain);
                if (backtracking(map, domain)) {
                    return true;
                }
                else map.replace(var, -1);

                //else
                  //  map.replace(var, -1);
            }
        }*/
        return false;
    }

    private Map<String, List<Integer>> copyMap(Map<String, List<Integer>> original){
        Map<String, List<Integer>> resultMap = new LinkedHashMap<>();
        for(Map.Entry<String, List<Integer>> entry : original.entrySet()){
            resultMap.put(entry.getKey(), new ArrayList<>(entry.getValue()));
        }
        return resultMap;
    }

    private String chooseVariable(Map<String, List<Integer>> domain){
        int size = 999;
        String result = "";
        for(String var : domain.keySet()){
            if(domain.get(var).size() < size && domain.get(var).size() != 1){
                size = domain.get(var).size();
                result = var;
            }
        }
        return result;
    }

    private String chooseVar(Map<String, Integer> map){
        for(String var : map.keySet()){
            if(map.get(var) == -1){
                return var;
            }
        }
        return "";
    }

    public static void main(String[] args){
        Solver solver = new Solver();
        solver.readFromFile(new File("sudoku.txt"));
    }
}

//sudoku 10x10?