package finalset;

import java.util.Scanner;
import java.util.StringTokenizer;

/**
 * See description.
 *
 */
abstract class Gate {
	// determine result of p op q
	 abstract boolean process (boolean p, boolean q);
	
	// operate over all entities.
	 boolean[] process (boolean [] p, boolean [] q) {
		boolean [] b = new boolean [p.length];
		
		for (int i = 0; i < b.length; i++) {
			b[i] = process (p[i], q[i]);
		}
		
		return b;
	}
	
	public static Gate factory (String op) {
		if (op.equalsIgnoreCase("AND")) return new AND();
		if (op.equalsIgnoreCase("IMPL")) return new IMPL();
		if (op.equalsIgnoreCase("NAND")) return new NAND();
		if (op.equalsIgnoreCase("NOR")) return new NOR();
		if (op.equalsIgnoreCase("OR")) return new OR();
		if (op.equalsIgnoreCase("XNOR")) return new XNOR();
		if (op.equalsIgnoreCase("XOR")) return new XOR();
		
		return null;
	}
}

class AND extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		return p && q;
	}

}

class IMPL extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		if (!p) return true;
		return q;
	}

}

class NAND extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		if (p && q) return false;
		return true;
	}

}
class NOR extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		if (p) return false;
		if (q) return false;
		
		return true;
	}

}
class OR extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		return p || q;
	}

}

class XNOR extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		if (p == q) return true;
		return false;
	}

}

class XOR extends Gate {

	@Override
	boolean process(boolean p, boolean q) {
		if (p == q) return false;
		return true;
	}
}

public class Problem3 {
	static boolean []p = new boolean [] { false, false, false, false, true, true, true, true }; 
	static boolean []q = new boolean [] { false, false, true, true, false, false, true, true };
	static boolean []r = new boolean [] { false, true, false, true, false, true, false, true }; 

	public static boolean [] select (String var) {

		if (var.equalsIgnoreCase("p")) {
			return p;
		} else if (var.equalsIgnoreCase("q")) {
			return q;
		} else if (var.equalsIgnoreCase("r")) {
			return r;
		}
		
		return null;
	}
	
	public static boolean [] copy (boolean []b) {
		boolean []copy = new boolean [b.length];
		for (int i = 0; i < copy.length; i++) {
			copy[i] = b[i];
		}
		
		return copy;
	}

	public static boolean[] evaluate (String s) {
		StringTokenizer st = new StringTokenizer(s);
		
		
		boolean []lhs;
		boolean []rhs;
		
		// first variable. FILL in table with its value.
		String var = st.nextToken();
		lhs = copy (select (var));
		
		if (!st.hasMoreTokens()) return lhs;
		
		String op = st.nextToken();
		while (true) {
			var = st.nextToken();
			
			// process operation
			Gate gate = Gate.factory (op);
			rhs = gate.process(lhs, select (var));
			
			if (!st.hasMoreTokens()) {
				return rhs;
			}
			
			// move along
			lhs = rhs;
			op = st.nextToken();
		}
	}
	
	public static String out (boolean b) {
		if (b) return "1"; else return "0";
	}
	
	public static void main (String args[]) {
		Scanner sc = new Scanner (System.in);
		String s1 = sc.nextLine();
		
		System.out.println(eval(s1));
	}

	public static String eval(String s1) {
		boolean[] v1 = evaluate(s1);
		
		String output = "p q r E\n";
		for (int i = 0; i < v1.length; i++) { 
			output += out(p[i]) + " " + out(q[i]) + " " + out(r[i]) + " " + 
					out(v1[i]);
			output += "\n";
		}
		
		return output;
	}
}