package task2;

public abstract class Type {
    public abstract String toString(Node[] a);
    public abstract Boolean calculate (Node[] a, Boolean val);

}


package task2;

public class Value extends Type {

    @Override
    public String toString(Node[] a) {
        return "x";
    }

    @Override
    public Boolean calculate(Node[] a, Boolean val) {
        return val;
    }
}


package task2;

public class OR extends Type {
    private static final Object OR = new OR();

    public static Node execute(Node v, Node v1) {
        return new Node(v, v1, (Type) OR);
    }

    @Override
    public String toString(Node[] a) {
        return "("+a[0]+"|"+a[1]+")";
    }

    @Override
    public Boolean calculate(Node[] a, Boolean val) {
        return a[0].calculate(val)|a[1].calculate(val);
    }
}




package task2;

public class NOT extends Type{

    private static final Object NOT = new NOT();

    public static Node execute(Node v) {
        return new Node(v, (Type) NOT);
    }

    @Override
    public String toString(Node[] a) {
        return "(~"+a[0]+")";
    }

    @Override
    public Boolean calculate(Node[] a, Boolean val) {
        return !a[0].calculate(val);
    }
}


package task2;

public class AND extends Type{


    private static final Object AND = new AND();


    public static Node execute(Node v, Node v1) {
        return new Node(v, v1, (Type) AND);
    }

    @Override
    public String toString(Node[] a) {
        return "("+a[0]+"&"+a[1]+")";
    }

    @Override
    public Boolean calculate(Node[] a, Boolean val) {
        return a[0].calculate(val)&a[1].calculate(val);
    }
}



package task2;

public interface Expr<T> {
    void flush ();
    T evaluate (T a);
}


package task2;

import java.util.Arrays;

public class Node {
    private static final Object Value = new Value();
    Node[] x;
    Type t;
    Node () {
        x=Arrays.copyOf(new Node[0], 0);
        this.t=(Type) Value;
    }
    Node (Node a, Type t) {
        x=Arrays.copyOf(new Node[1], 1);
        x[0]=a;
        this.t=t;
    }
    Node (Node a, Node b, Type t) {
        x=Arrays.copyOf(new Node[2], 2);
        x[0]=a;
        x[1]=b;
        this.t=t;
    }

    @Override
    public String toString() {
        return t.toString(x);
    }

    public Boolean calculate(Boolean a) {
        return t.calculate(x, a);
    }
}



package task2;

public class BoolExpr implements Expr<Boolean> {

    protected Node v;

    public BoolExpr() {
        this.v=new Node();
    }

    public BoolExpr(Node v) {
        this.v = v;
    }

    public BoolExpr and (BoolExpr x) {
        return new BoolExpr(AND.execute(v, x.v));
    }

    public BoolExpr or (BoolExpr x) {
        return new BoolExpr(OR.execute(v, x.v));
    }

    public BoolExpr not () {
        return new BoolExpr(NOT.execute(v));
    }

    @Override
    public void flush() {
        System.out.println(v);
    }

    @Override
    public Boolean evaluate(Boolean a) {
        return v.calculate(a);
    }
}



import task2.BoolExpr;

public class Main {
    static public void main (String[] argv) {
        BoolExpr a,b,c;

        a = new BoolExpr();
        b = new BoolExpr();
        c = new BoolExpr();



        c = a.and(b); // a \land b
        c = c.or(b.not()); // c \lor \not b

        c.flush();
        Boolean T = true;
        System.out.println(c.evaluate(T));

    }
}