1
& 0
 1
^ 123
 10
^ 218
& 150
| 935
& 61
| 588
& 897
| 411
| 584
^ 800
| 704
 3
& 1
& 3
& 5
 1
| 123
 1
^ 0
 1
| 1023
 3
& 242
^ 506
^ 522
 10
^ 160
& 1021
& 510
^ 470
& 1022
& 251
& 760
& 1016
| 772
| 515
 1
& 1023
 1
| 0
 2
| 56
^ 875
 1
^ 1023
 2
| 999
^ 689
 3
^ 125
^ 377
& 1019
 1
& 123

3
& 0
| 0
^ 0
 3
& 1023
| 0
^ 123
 3
& 763
| 763
^ 0
 3
& 1
| 0
^ 0
 3
& 1023
| 123
^ 0
 3
& 1023
| 0
^ 0
 3
& 1023
| 1023
^ 0
 3
& 1010
| 768
^ 240
 2
| 775
^ 112
 3
& 1023
| 0
^ 0
 3
& 1023
| 0
^ 0
 3
& 983
| 16
^ 835
 3
& 1023
| 0
^ 1023
 3
& 350
| 326
^ 16
 3
& 1019
| 0
^ 256
 3
& 123
| 0
^ 0

import java.util.*;
import java.io.*;
import java.lang.Math.*;

public class MainA
{
	static int mod = (int) 1e9 + 7;
	
	public static void main(String[] args) throws java.lang.Exception
	{
		InputReader in = new InputReader(System.in);
		PrintWriter out=new PrintWriter(System.out);
		int n=in.nextInt();
		int visited[]=new int[10];
		Arrays.fill(visited,-1);
		for(int i=0;i<n;i++)
		{
			String s[]=in.nextLine().split(" ");
			int var=Integer.parseInt(s[1]);
			int  bin[]=new int[10];
		    int v = 0;
		    while(var > 0)
		    {
		    	bin[v++] = var%2;
		        var = var/2;
		    }
			if(s[0].charAt(0)=='|')
			{
				for(int j=v-1;j>=0;j--)
				{
					if(bin[j]==1)visited[j]=1;
					
				}
				//for(int j=9;j>=0;j--)out.print(visited[j]+" ");
				//out.println();
			}
			else if(s[0].charAt(0)=='&')
			{
				for(int j=9;j>=0;j--)
				{
					if(bin[j]==0)visited[j]=0;
				}
				//for(int j=9;j>=0;j--)out.print(visited[j]+" ");
				//out.println();
				//debug(i,visited);
			}
			else 
			{
				//out.println("jjjjjj");
				for(int j=v-1;j>=0;j--)
				{
					if(bin[j]==0)
					{
			
					}
					else 
					{
						if(visited[j]==-1)
						{
							visited[j]=-2;
						}
						else if(visited[j]==-2)
						{
							visited[j]=-1;
						}
						else
						{
							if(visited[j]==1)visited[j]=0;
							else visited[j]=1;
						}
					}
					
				}
			}
			
		}
		//debug(visited);
		int flag=0;
		for(int i=0;i<10;i++)
		{
			if(visited[i]==-1 || visited[i]==-2)
			{
				flag=1;
				break;
			}
		}
		if(flag==1)
		{
			int ans1=0;
			int ans2=0;
			int ans3=0;
			for(int i=0;i<10;i++)
			{
				if(visited[i]==1)
				{
					ans1+=Math.pow(2, i);
					ans2+=Math.pow(2, i);
				}
				else if(visited[i]==0)
				{
					
				}
				else if(visited[i]==-1)
				{
					ans1+=Math.pow(2, i);
				}
				else if(visited[i]==-2)
				{
					ans1+=Math.pow(2, i);
					ans3+=Math.pow(2, i);
				}
			}
			out.println(3);
			out.println("& "+ans1);
			out.println("| "+ans2);
			out.println("^ "+ans3);
			
		}
		else{
		int ans=0;
		for(int i=0;i<10;i++)
		{
			if(visited[i]==1)
			ans+=Math.pow(2,i);
		}
		
		out.println(2);
		out.println("& "+ans);
		out.println("| "+ans);}
		
		out.close();
	}

	public static class Trie
	{
		Trie []children = new Trie[26];
		int value;
		int leve;
		
		Trie()
		{
			value=1;
			for (int i = 0; i < 26; i++)
				children[i] = null;
		}
		
		public static void insert(Trie root,String key)
	    {
	        int length = key.length();
	        int index;
	      
	        Trie pCrawl = root;
	        int k=1;
	        for (int level = length-1; level >=0; level--)
	        {
	            index = key.charAt(level) - 'a';
	            if (pCrawl.children[index] == null)
	                pCrawl.children[index] = new Trie();
	            else
	            {
	            	pCrawl.children[index].value++;
	            }
	            pCrawl.children[index].leve=k++;
	            pCrawl = pCrawl.children[index];
	        }
	      
	    }
		
		public static void dfs(Trie root,int len[])
		{
			for(int i=0;i<26;i++)
			{
				if(root.children[i]!=null)
				{
					int level=root.children[i].leve;
					int value=root.children[i].value;
					len[level-1]=Math.max(len[level-1],value);
					dfs(root.children[i],len);
				}
			}
		}
	}
	public static long add(long a,long b)
	{
		return (a+b)%mod;
	}
	public static long mul(long a,long b)
	{
		return (a*b)%mod;
	}
	
	public static long sub(long a,long b)
	{
		return (a-b+mod)%mod;
	}
	static class Pairs implements Comparable<Pairs>
	{
		int x;
		int y;
		
		
		Pairs(int a, int b)
		{
			x = a;
			y = b;
			
		}

		@Override
		public boolean equals(Object o)
		{
			Pairs other=(Pairs)o;
			return x==other.x && y==other.y;
		}
		@Override
		public int compareTo(Pairs o)
		{
			// TODO Auto-generated method stub
			return Integer.compare(x,o.x);
		}
		@Override
		public int hashCode()
		{
			return  Objects.hash(x,y);
		}

	}

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

	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 (y == 0)
			return x;
		if (x % y == 0)
			return y;
		else
			return gcd(y, x % y);
	}

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

	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 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[][] mul(long a[][], long b[][])
	{
		long c[][] = new long[2][2];
		c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0];
		c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1];
		c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0];
		c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1];

		return c;
	}

	public static long[][] pow(long n[][], long p, long m)
	{
		long result[][] = new long[2][2];
		result[0][0] = 1;
		result[0][1] = 0;
		result[1][0] = 0;
		result[1][1] = 1;

		if (p == 0)
			return result;
		if (p == 1)
			return n;
		while (p != 0)
		{
			if (p % 2 == 1)
				result = mul(result, n);
			//System.out.println(result[0][0]);
			for (int i = 0; i < 2; i++)
			{
				for (int j = 0; j < 2; j++)
				{
					if (result[i][j] >= m)
						result[i][j] %= m;
				}
			}

			p >>= 1;
			n = mul(n, n);
			// System.out.println(1+" "+n[0][0]+" "+n[0][1]+" "+n[1][0]+" "+n[1][1]);
			for (int i = 0; i < 2; i++) 
			{
				for (int j = 0; j < 2; j++)
				{
					if (n[i][j] >= m)
						n[i][j] %= m;
				}
			}
		}
		return result;
	}
	public static long pow(long n,long p, long m)
	{
		long result=1;
		if(p==0)return 1;
		if(p==1)return n%m;
		while(p!=0)
		{
			if(p%2==1)result=(result*n)%m;
			p >>=1;
			n=(n*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;
	}

	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 nextInt()
		{
			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 nextLong()
		{
			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[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

		public long[] nextLongArray(int n)
		{
			long a[] = new long[n];
			for (int i = 0; i < n; i++) 
			{
				a[i] = nextInt();
			}
			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);
		}
	}
}