Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.

In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.

Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.

Input

The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.

Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.

Output

Output an integer k (0 ≤ k ≤ 5) — the length of your program.

Next k lines must contain commands in the same format as in the input.

Examples

Input

3
| 3
^ 2
| 1


Output

2
| 3
^ 2


Input

3
&amp; 1
&amp; 3
&amp; 5


Output

1
&amp; 1


Input

3
^ 1
^ 2
^ 3


Output

0

Note

You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.

Second sample:

Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
import java.util.*;
import java.io.*;

/**
 * 26-Oct-2017
 * 8:33:52 PM
 * @author HulkBuster
 * 
 */
public class CF879 {
public static int mod = (int) (1e9 + 7);
public static InputReader in;
public static PrintWriter out;

public static void solve() throws FileNotFoundException {

	in = new InputReader(System.in);
	out = new PrintWriter(System.out);
	
	int and[] = new int[10];
	int xor[] = new int[10];
	int or[] = new int[10];
	int c[] = new int[10];
	int d[] = new int[10];
	int two[] = new int[10];
	for(int i=0;i<10;i++)
	{
		d[i] = 1;
		and[i] = 1;
		two[i] = (int)Math.pow(2, i);
	}
	int n = in.ni();
	
	
	for(int i=0;i<n;i++){
		
		String s = in.nextLine();
		String ar[] = s.split(" ");
		int x = Integer.parseInt(ar[1]);
		if(ar[0].equals("|")){
			for(int j=0;j<10;j++)
			{
				int y = (x>>j)%2;
				c[j] = c[j]|y;
				d[j] = d[j]|y;
			}
		}
		else if(ar[0].equals("^")){
			for(int j=0;j<10;j++)
			{
				int y = (x>>j)%2;
				c[j] = c[j]^y;
				d[j] = d[j]^y;
			}
		}
		else{
			for(int j=0;j<10;j++)
			{
				int y = (x>>j)%2;
				c[j] = c[j]&y;
				d[j] = d[j]&y;
			}
		}
	}
	for(int i=0;i<10;i++){
		if(c[i]==0&&d[i]==0)
			and[i] =0;
		else if(c[i]==1&&d[i]==1)
			or[i]=1;
		else if(c[i]==1&&d[i]==0)
			xor[i]=1;
	}
	int aa=0,bb=0,cc=0;
	for(int i=0;i<10;i++){
		aa = aa+and[i]*((int)Math.pow(2, i));
		bb = bb+or[i]*((int)Math.pow(2, i));
		cc = cc+xor[i]*((int)Math.pow(2, i));
	}
	out.println(3+"\n"+"| "+bb+"\n"+"& "+aa+"\n"+"^ "+cc);
	out.close();
}

public static void main(String[] args) {
	new Thread(null, new Runnable() {
		public void run() {
			try {
				solve();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}, "1", 1 << 26).start();
}

static class Pair implements Comparable<Pair> {

	int x, y, i;

	Pair(int x, int y, int i) {
		this.x = x;
		this.y = y;
		this.i = i;
	}

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int compareTo(Pair o) {
		if (this.x != o.x)
			return Integer.compare(this.x, o.x);
		else
			return Integer.compare(this.y, o.y);
		//return 0;
	}

	public boolean equals(Object o) {
		if (o instanceof Pair) {
			Pair p = (Pair) o;
			return p.x == x && p.y == y && p.i == i;
		}
		return false;
	}

	public int hashCode() {
		return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
	}

}

public static long add(long a, long b) {
	long x = (a + b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static long sub(long a, long b) {
	long x = (a - b);
	while (x < 0)
		x += mod;
	return x;
}

public static long mul(long a, long b) {
	long x = (a * b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static boolean isPal(String s) {
	for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
		if (s.charAt(i) != s.charAt(j))
			return false;
	}
	return true;
}

public static String rev(String s) {
	StringBuilder sb = new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

public static long gcd(long x, long y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static int gcd(int x, int y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

static int modInverse(int a, int m) {
	int m0 = m, t, q;
	int x0 = 0, x1 = 1;
	if (m == 1)
		return 0;
	while (a > 1) {
		// q is quotient
		q = a / m;
		t = m;
		// m is remainder now, process same as
		// Euclid's algo
		m = a % m;
		a = t;
		t = x0;
		x0 = x1 - q * x0;
		x1 = t;
	}
	// Make x1 positive
	if (x1 < 0)
		x1 += m0;
	return x1;
}

public static long gcdExtended(long a, long b, long[] x) {

	if (a == 0) {
		x[0] = 0;
		x[1] = 1;
		return b;
	}
	long[] y = new long[2];
	long gcd = gcdExtended(b % a, a, y);

	x[0] = y[1] - (b / a) * y[0];
	x[1] = y[0];

	return gcd;
}

public static long mulmod(long a, long b, long m) {
	if (m <= 1000000009)
		return a * b % m;

	long res = 0;
	while (a > 0) {
		if ((a & 1) != 0) {
			res += b;
			if (res >= m)
				res -= m;
		}
		a >>= 1;
		b <<= 1;
		if (b >= m)
			b -= m;
	}
	return res;
}

public static int abs(int a, int b) {
	return (int) Math.abs(a - b);
}

public static long abs(long a, long b) {
	return (long) Math.abs(a - b);
}

public static int max(int a, int b) {
	if (a > b)
		return a;
	else
		return b;
}

public static int min(int a, int b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long max(long a, long b) {
	if (a > b)
		return a;
	else
		return b;
}

public static long min(long a, long b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long pow(long n, long p, long m) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		if (result >= m)
			result %= m;
		p >>= 1;
		n *= n;
		if (n >= m)
			n %= m;
	}
	return result;
}

public static long pow(long n, long p) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		p >>= 1;
		n *= n;
	}
	return result;
}

public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

static class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int snext() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int ni() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nl() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nIArr(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	public long[] nLArr(int n) {
		long a[] = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	public String readString() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = snext();
		while (isSpaceChar(c))
			c = snext();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}
}
