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.awt.List;
    		import java.io.*;
    		import java.util.*;
     
    		
    		
    		
    		
    		/*
    		 * 
    		 * daiict
    		 *
    		 * 
    		 * 
    		 */
    		
    		
    		public class prac {
    			FastScanner in;
    			PrintWriter out;
    		
    			static ArrayList[] adj;
    			
    			static int n;
    			static int m;
    			
    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static long[] arr;
    			static long[] brr;
    			static int[][] ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    		
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
    			
    		
    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    	
    			static class Pair implements Comparable<Pair>
    		    {
    				long x;long y;
    				
    		        Pair(long l, long m) {
    		          
    		        	this.x = l;
    		            this.y = m;
    		          
    		        }
    		        
    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }
    		        
    		        public String toString(){
    		        	return x + " " + y;
    		        }
    		        
    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;
    		        		
    		        		return this.x == a.x;
    		        	}
    		        	
    		        	return false;
    		        }
    		        
    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }
    		    
    		    }
    		    
    			
    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}
    	
    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.max(seg[i<<1],seg[i<<1|1]);
    				}
     
    			public static void modify(int p, int i,long val,int n) {  // set value at position p
    					if(i == 1){
    						long temp = val;
    						val = seg[p+n] - arr[p] + val;
    						arr[p] = temp;
    					}else{
    						val = Math.min(val, p) + arr[p];
    						brr[p] = val;
    					}
    					
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.max(seg[p],seg[p^1]);
    				}
     
    				long query(int l, int r,int n) {  // max on interval [l, r)
    				  long res = Integer.MIN_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (int)Math.max(res,seg[l++]);
    				    if ((r&1) == 1) res = (int)Math.max(res,seg[--r]);
    				  }
    				  return res;
    				}
    				
    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}
    			
    			public static int read(int idx){
    				int sum = 0;
    				
    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}
    				
    				return sum;
    			}
     
    		    void solve() throws NumberFormatException, IOException {
    		 
    		    	Scanner in = new Scanner(System.in);
    		    	StringBuilder sb = new StringBuilder();
    		  
    		    	LinkedList<Integer> q = new LinkedList();
    		    	
    		    	int n = in.nextInt();
    		    	in.nextLine();
    		    	
    		    	char arr[] = new char[n];
    		    	int brr[] = new int[n];
    		    	
    		    	for(int i = 0;i<n;i++){
    		    		String s[] = in.nextLine().split(" ");
    		    		
    		    		arr[i] = s[0].charAt(0);
    		    		brr[i] = Integer.parseInt(s[1]);
    		    		
    		    	}
    		    	
    		    	char and0[] = "1111111111".toCharArray();
    	
    		    	char or[] = "0000000000".toCharArray();
    		    	char xor[] = "0000000000".toCharArray();
    		    	
    		    	
    		    	for(int i = 0;i<10;i++){
    		    		int c = call(i,0,arr,brr);
    		    		int d = call(i,1,arr,brr);
    		    		//out.println(c + " " +d);
    		    		
    		    		if(c == 0 && d == 0){
    		    			and0[10-i-1] = '0';
    		    		}else if(c == 1 && d == 1){
    		    			or[10-i-1] = '1';
    		    		}else if(c == 0 && d == 1){
    		    			xor[10-i-1] = '0';
    		    		}else if(c == 1 && d == 0){
    		    			xor[10-i-1] = '1';
    		    		}
    		    		
    		    	}
    		    	
    		    	//out.println(String.copyValueOf(and0));
    		    	int and = goo(and0);
    		    	int orr = goo(or);
    		    	int xorr = goo(xor);
    		    	
    		    	out.println(3);
    		    	
    		    	out.println("& "+and);
    		    	out.println("| "+orr);
    		    	out.println("^ "+xorr);
    		    	
    		    	
    		    	
    		    }
    		    
    		    public static int goo(char arr[]){
    		    	
    		    	int ans = 0;
    		    	
    		    	for(int i = 0;i<10;i++){
    		    		if(arr[i] == '1'){
    		    			ans += (1<<(10-i-1));
    		    		}
    		    	}
    		    	
    		    	
    		    	return ans;
    		    }
    		    
    		    public static int call(int i, int d,char arr[],int brr[]){
    		    	
    		    	int ans = d;
    		    	
    		    	for(int j = 0;j<arr.length;j++){
    		    		if(arr[j] == '&'){
    		    			ans = ans & ((brr[j]>>i)&1);
    		    		}else if(arr[j] == '|'){
    		    			ans = ans | ((brr[j]>>i)&1);
    		    		}else{
    		    			ans = ans ^ ((brr[j]>>i)&1);
    		    		}
    		    	}
    		    	
    		    	return ans;
    		    	
    		    }
    		    
    		    
    		    /**
    		     * 
    		     * @param a
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return the smallest index i which a[i] >= value in range [left, right) if exists, otherwise return -1
    		     */
    		    int ff(long[] a, int left, int right, int value) {
    		        int low = left;
    		        int high = right;
    		        while (low != high) {
    		            int mid = (low + high) / 2;
    		            if (a[mid] < value) {
    		                low = mid + 1;
    		            } else {
    		                high = mid;
    		            }
    		        }
    		        if (low == right) {
    		            return low;
    		        }
    		        return low;
    		    } 
    		   
    		    /**
    		     * 
    		     * @param a
    		     * @param left
    		     * @param right
    		     * @param value
    		     * @return greatest index i which a[i] <= value in range [left, right) if exists, otherwise return a number out of [left, right)
    		     */
    		    int ffff(long[] a, int left, int right, int value) {
    		        while (left != right) {
    		            int mid = (left + right) >> 1;
    		            if (a[mid] <= value) {
    		                left = mid + 1;
    		            } else {
    		                right = mid;
    		            }
    		        }
    		        if (left < 0) {
    		            left *= -1;
    		        }
    		        return --left;
    		    }
	    
    		   
    		  
    		
    		    public static String reverse(String s){
    		    	
    		    	String ans = "";
    		    	
    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}
    		    	
    		    	return ans;
    		    	
    		    }
    			
    			
    		    
    		 
    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }
    			
    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;
    				
    				}
    				return r;
    			}
    			
    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}
    			
    			
    			
    			
    			public static boolean isPrime(int n) {
    				// Corner cases
    				if (n <= 1)
    					return false;
    				if (n <= 3)
    					return true;
    		 
    				// This is checked so that we can skip 
    				// middle five numbers in below loop
    				if (n % 2 == 0 || n % 3 == 0)
    					return false;
    		 
    				for (int i = 5; i * i <= n; i = i + 6)
    					if (n % i == 0 || n % (i + 2) == 0)
    						return false;
    		 
    				return true;
    			}
    			
    		
    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);
    		
    				solve();
    		
    				out.close();
    			}
    		
    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;
    		
    				public FastScanner() {
    					br = new BufferedReader(new InputStreamReader(System.in));
    				}
    		
    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}
    		
    				int nextInt() {
    					return Integer.parseInt(next());
    				}
    		
    				long nextLong() {
    					return Long.parseLong(next());
    				}
    		
    				double nextDouble() {
    					return Double.parseDouble(next());
    				}
    			}
    			
    			
    			
    			
    		 
    		
    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}
    		
    		
    		
    		
    		