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.
	
	
	 
	    	        			/*
	 * Author- Priyam Vora
	 * BTech 2nd Year DAIICT
	 */
	     
	     
	        		    import java.awt.Checkbox;
	import java.awt.Point;
	import java.awt.event.PaintEvent;
	import java.io.*;
	        		    import java.math.*;
	        		    import java.util.*;
	import java.util.Map.Entry;
import java.util.concurrent.PriorityBlockingQueue;

import javax.print.attribute.SetOfIntegerSyntax;
	import javax.swing.plaf.FontUIResource;
	    	     
	        		    public class Main{
	        		  	private static InputStream stream;
	        		    	private static byte[] buf = new byte[1024];
	        		    	private static int curChar;
	        		    	private static int numChars;
	        		    	private static SpaceCharFilter filter;
	        		    	private static PrintWriter pw;
	        		    	private static long count = 0,mod=1000000007;
	        		    //	private static TreeSet<Integer> ts=new TreeSet[200000];
	public final static int INF = (int) 1E9;
	
	public static void main(String args[]) {
    	
		InputReader(System.in);
		pw = new PrintWriter(System.out); 
	    new Thread(null ,new Runnable(){
	       public void run(){
	           try{
	        		
	               solve();

	               pw.close();
	           } catch(Exception e){
	               e.printStackTrace();
	           }
	       }
	   },"1",1<<26).start();
	   	   }
	    static StringBuilder sb;
	    public static void test() throws IOException{
	    	 sb=new StringBuilder();
	    	int t=nextInt();
	    	while(t-->0){
	    		
	    		solve();
	    		//pw.println();
	    		//sb.append("\n");
	    	}
	    //	pw.println(sb);
	    }
	    public static long pow(long n, long p,long mod) {
			if(p==0)
				return 1;
			if(p==1)
				return n%mod;
			if(p%2==0){
				long temp=pow(n, p/2,mod);
			return (temp*temp)%mod;
			}else{
				 	long temp=pow(n,p/2,mod);
				 	temp=(temp*temp)%mod;
				 	return(temp*n)%mod;
				 	
			}
		}
	    public static long pow(long n, long p) {
			if(p==0)
				return 1;
			if(p==1)
				return n;
			if(p%2==0){
				long temp=pow(n, p/2);
			return (temp*temp);
			}else{
				 	long temp=pow(n,p/2);
				 	temp=(temp*temp);
				 	return(temp*n);
				 	
			}
		}
	    public static void Merge(long a[],int p,int r){
	        if(p<r){
	            int q = (p+r)/2;
	            Merge(a,p,q);
	            Merge(a,q+1,r);
	            Merge_Array(a,p,q,r);
	        }
	    }
	    public static void Merge_Array(long a[],int p,int q,int r){
	       long b[] = new long[q-p+1];
	        long c[] = new long[r-q];
	        for(int i=0;i<b.length;i++)
	            b[i] = a[p+i];
	        for(int i=0;i<c.length;i++)
	            c[i] = a[q+i+1];
	        int i = 0,j = 0;
	        for(int k=p;k<=r;k++){
	            if(i==b.length){
	                a[k] = c[j];
	                j++;
	            }
	            else if(j==c.length){
	                a[k] = b[i];
	                i++;
	            }
	            else if(b[i]<c[j]){
	                a[k] = b[i];
	                i++;
	            }
	            else{
	                a[k] = c[j];
	                j++;
	            }
	        }
	    }
	    
	  
		public static long gcd(long x, long y) {
			if (x == 0)
				return y;
			else
				return gcd( y % x,x);
		}	
		
		public static boolean isPrime(int n) {
			if (n <= 1)
				return false;
			if (n <= 3)
				return true;
	 
			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;
		}
		
	        static LinkedList<Integer> adj[];
	        static boolean Visited[];
	        static HashSet<Integer> exc;
	        static long oddsum[]=new long[1000001];
	        static long co=0,ans=0;
	    
	    	private static void buildgraph(int n){
	    		adj=new LinkedList[n+1];
	    		Visited=new boolean[n+1];
	    		levl=new int[n+1];
	    		
	    		for(int i=0;i<=n;i++){
	    			adj[i]=new LinkedList<Integer>();
	    		
	    		}
	
	
	    	}
	      
	       
	        static int[] levl;
	        static int[] eat;
	        static int n,m;
	        static int price[];
	        //ind frog crab
	    
	        
	        static long d,x,y;
			static long modInverse(long A, long M)
			{
			extendedEuclid(A,M);
			return (x%M+M)%M;    //x may be negative
			}
			static void extendedEuclid(long A, long B) {
			if(B == 0) {
			d = A;
			x = 1;
			y = 0;
			}
			else {
			extendedEuclid(B, A%B);
			long temp = x;
			x = y;
			y = temp - (A/B)*y;
			}
			}
	        static double distance(int x1,int y1,int x2,int y2){
	        	return Math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
	        }
	        static double area(int x1, int y1, int x2, int y2, int x3, int y3)
	        {
	           return Math.abs((x1*(y2-y3) + x2*(y3-y1)+ x3*(y1-y2))/2.0);
	        }
	        static boolean isInside(int x1, int y1, int x2, int y2, int x3, int y3, int x, int y)
	        {   
	           double A = area (x1, y1, x2, y2, x3, y3);
	         
	           double A1 = area (x, y, x2, y2, x3, y3);
	         
	           double A2 = area (x1, y1, x, y, x3, y3);
	         
	           double A3 = area (x1, y1, x2, y2, x, y);
	           
	          return (A == A1 + A2 + A3);
	        }
	      
			static int col[];
	    public static boolean isVowel(char c){
	    	if(c=='a' || c=='e'||c=='i' || c=='o' || c=='u')
	    		return true;
	    	return false;
	    }
	static Stack<Integer> st[];
	static Queue<Integer> q[];
	static long cost[],startt[],endt[];    
	public static void solve() throws IOException{
		int n=nextInt();
		
		ArrayList<Integer> ar2=new ArrayList<Integer>();
		ArrayList<Integer> ar3=new ArrayList<Integer>();
		ArrayList<Integer> ar4 = new ArrayList<Integer>();
		
		String[] s=new String[n];
		
		
		int t1=0;
		int t2=0;
		int t3=0;
		int t4=0;
		
		for(int i=0;i<n;i++)
			s[i]=nextLine();
		for(int i =0;i<10;i++) {
			long num1=(1<<i);
			long num2=0;
			for(int j=0;j<n;j++) {
				String[] tmp=s[j].split(" ");
				long x = Integer.parseInt(tmp[1]);
				if(tmp[0].charAt(0)=='|') {
					num1|=x;
					num2|=x;
				}else if(tmp[0].charAt(0)=='&') {
					num1&=x;
					num2&=x;
				}else {
					num1^=x;
					num2^=x;
				}
			}
			if((num1&(1<<i))!=0 && (num2&(1<<i))==0){
				
				t1++;
			}
			else if((num1&(1<<i))!=0 && (num2&(1<<i))!=0) {
				t2++;
				ar2.add(i);
			}
			else if((num1&(1<<i))==0 && (num2&(1<<i))!=0) {
				t3++;
				ar3.add(i);
			}
			else {
				t4++;
				ar4.add(i);
			}
		}
		long count=0;
		if(t2!=0) 
			count++;
		if(t3!=0) 
			count++;
		if(t4!=0) 
			count++;
        
		pw.println(count);
        if(t2!=0) {
        	int num=0;
        	for(int x:ar2) {
        		num|=(1<<x);
        	}
        	pw.println("| "+(num));
        }
        if(t3!=0) {
        	int num=0;
        	for(int x:ar3) {
        		num|=(1<<x);
        	}
        	pw.println("^ "+(num));
        }
        if(t4!=0) {
        	
        	long num=1023;
        	
        	for(int x:ar4) {
        		num^=(1<<x);
        	}
           	pw.println("& "+(num));
        }
}
		
	public static boolean check(int v,int u){
		if(startt[v]<startt[u] && endt[v]>endt[u]){
			return true;
		}
		return false;
	}
	
    
 
	static int no_vert=0,timer=1;
	
	private static void dfs(int s){
		Visited[s]=true;
		startt[s]=timer++;
		
		no_vert++;
		for(int x:adj[s]){
			if(!Visited[x]){
			
				dfs(x);
			}
			
		}
		endt[s]=timer++;
	}
	
	
	    private static boolean Check(int x,int y,int n){
			if(x>=0 && x<n && y>=0 && y<n)
				return true;
			return false;
		}
	    
	    static long dp[],dp2[];
	    static ArrayList<Integer> pri[],pri2[];
	  private static void dfs(int curr,int par,int co){
		 Visited[curr]=true;
		 for(int x:adj[curr]){
			 if(!Visited[x]){
				 dfs(x,curr,co);
			 }
		 }
		 if(col[curr]==0){
			 dp[curr]++;
		 }else{
			 dp[curr]--;
		 }
		 if(dp[curr]>0){
			 pri[par].add(curr);
		 dp[par]+=dp[curr];
		 }
	  }
	  private static void dfs3(int curr,int par,int co){
			 Visited[curr]=true;
			 for(int x:adj[curr]){
				 if(!Visited[x]){
					 dfs3(x,curr,co);
				 }
			 }
			 if(col[curr]==1){
				 dp2[curr]++;
			 }else{
				 dp2[curr]--;
			 }
			 if(dp2[curr]>0){
				 pri2[par].add(curr);
			 dp2[par]+=dp2[curr];
			 }
		  }
	    public static String reverseString(String s) {
			StringBuilder sb = new StringBuilder(s);
			sb.reverse();
			return (sb.toString());
		}
	    
	  /*  
	   private static void BFS(int sou){
	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(sou);
	    	Visited[sou]=true;
	    	levl[sou]=0;
	    	while(!q.isEmpty()){
	    		int top=q.poll();
	    		
	    		for(int i:adj[top]){
	    			//pw.println(i+" "+top);
				if(!Visited[i])
				{
					
					q.add(i);
					levl[i]=levl[top]+1;
				}
				
				Visited[i]=true;
				
				}
			}
		}*/
		
	
	
	
	    		      static int indeg[];
	    		   /* private static void kahn(int n){
	    		    	
	    		    	PriorityQueue<Integer> q=new PriorityQueue<Integer>();
	    				for(int i=1;i<=n;i++){
	    					if(indeg[i]==0){
	    						q.add(i);
	    					}
	    				}
	    				while(!q.isEmpty()){
	    					int top=q.poll();
	    					st.push(top);
	    					for(Node i:adj[top]){
	    						indeg[i.to]--;
	    						if(indeg[i.to]==0){
	    							q.add(i.to);
	    						}
	    					}
	    				}
	    		    }
	    		        
	    		        static int state=1;
	    		        static long no_exc=0,no_vert=0;
	    		      static Stack<Integer> st;
	    		      static HashSet<Integer> inset;
	    		     /*   private static void topo(int curr){
	    		        	
	    		        	Visited[curr]=true;
	    		        	inset.add(curr);
	    		        	for(int x:adj[curr]){
	    		        		if(adj[x].contains(curr) || inset.contains(x)){
	    		        			state=0;
	    		        			return;
	    		        		}
	    		        		if(state==0)
	    		        			return;
	    		        		
	    		        	}
	    		        	st.push(curr);
	    		        	
	    		        	inset.remove(curr);
	    		        }*/
	    		        static HashSet<Integer> hs;
	    		       
	    		     
	    		     	static boolean prime[];
						static int spf[];
						public static void sieve(int n){
							prime=new boolean[n+1];
							spf=new int[n+1];
							
							Arrays.fill(spf, 1);
							Arrays.fill(prime, true);
						prime[1]=false;
							spf[2]=2;
							
						for(int i=4;i<=n;i+=2){
							spf[i]=2;
						}
						for(int i=3;i<=n;i+=2){
							if(prime[i]){
								spf[i]=i;
								for(int j=2*i;j<=n;j+=i){
									
									prime[j]=false;
								if(spf[j]==1){
									spf[j]=i;
								}
								}
							}
						}
						
							
						}
	    		     	
	    		    	// To Get Input
	// Some Buffer Methods
	 
	    		     	public static void sort(long a[]){
	    		     		Merge(a, 0, a.length-1);
	    		     	}
	    		    	public static void InputReader(InputStream stream1) {
	    		    		stream = stream1;
	    		    	}
	 
	    		    	private static boolean isWhitespace(int c) {
	    		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    		    	}
	 
	    		    	private static boolean isEndOfLine(int c) {
	    		    		return c == '\n' || c == '\r' || c == -1;
	    		    	}
	 
	    		    	private static int read() {
	    		    		if (numChars == -1)
	    		    			throw new InputMismatchException();
	    		    		if (curChar >= numChars) {
	    		    			curChar = 0;
	    		    			try {
	    		    				numChars = stream.read(buf);
	    		    			} catch (IOException e) {
	    		    				throw new InputMismatchException();
	    		    			}
	    		    			if (numChars <= 0)
	    		    				return -1;
	    		    		}
	    		    		return buf[curChar++];
	    		    	}
	 
	    		    	private static int nextInt() {
	    		    		int c = read();
	    		    		while (isSpaceChar(c))
	    		    			c = read();
	    		    		int sgn = 1;
	    		    		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
	    		    			c = read();
	    		    		} while (!isSpaceChar(c));
	    		    		return res * sgn;
	    		    	}
	 
	    		    	private static long nextLong() {
	    		    		int c = read();
	    		    		while (isSpaceChar(c))
	    		    			c = read();
	    		    		int sgn = 1;
	    		    		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
	    		    			c = read();
	    		    		} while (!isSpaceChar(c));
	    		    		return res * sgn;
	    		    	}
	 
	    		    	private static String nextToken() {
	    		    		int c = read();
	    		    		while (isSpaceChar(c))
	    		    			c = read();
	    		    		StringBuilder res = new StringBuilder();
	    		    		do {
	    		    			res.appendCodePoint(c);
	    		    			c = read();
	    		    		} while (!isSpaceChar(c));
	    		    		return res.toString();
	    		    	}
	 
	    		    	private static String nextLine() {
	    		    		int c = read();
	    		    		while (isSpaceChar(c))
	    		    			c = read();
	    		    		StringBuilder res = new StringBuilder();
	    		    		do {
	    		    			res.appendCodePoint(c);
	    		    			c = read();
	    		    		} while (!isEndOfLine(c));
	    		    		return res.toString();
	    		    	}
	 
	    		    	private static int[] nextIntArray(int n) {
	    		    		int[] arr = new int[n];
	    		    		for (int i = 0; i < n; i++) {
	    		    			arr[i] = nextInt();
	    		    		}
	    		    		return arr;
	    		    	}
	 
	    		    	private static long[][] next2dArray(int n, int m) {
	    		    		long[][] arr = new long[n][m];
	    		    		for (int i = 0; i < n; i++) {
	    		    			for (int j = 0; j < m; j++) {
	    		    				arr[i][j] = nextLong();
	    		    			}
	    		    		}
	    		    		return arr;
	    		    	}
	    		    	private static char[][] nextCharArray(int n,int m){
	    		    		char [][]c=new char[n][m];
	    		    		for(int i=0;i<n;i++){
	    		    			String s[]=nextLine().split(" ");
	    		    			for(int j=0;j<s.length;j++){
	    		    				c[i][j]=s[j].charAt(0);
	    		    			}
	    		    		}
	    		    		return c;
	    		    	}
	 
	    		    	private static long[] nextLongArray(int n) {
	    		    		long[] arr = new long[n];
	    		    		for (int i = 0; i < n; i++) {
	    		    			arr[i] = nextLong();
	    		    		}
	    		    		return arr;
	    		    	}
	 
	    		    	private static void pArray(int[] arr) {
	    		    		for (int i = 0; i < arr.length; i++) {
	    		    			pw.print(arr[i] + " ");
	    		    		}
	    		    		pw.println();
	    		    		return;
	    		    	}
	 
	    		    	private static void pArray(long[] arr) {
	    		    		for (int i = 0; i < arr.length; i++) {
	    		    			pw.print(arr[i] + " ");
	    		    		}
	    		    		pw.println();
	    		    		return;
	    		    	}
	 
	    		    	private static void pArray(boolean[] arr) {
	    		    		for (int i = 0; i < arr.length; i++) {
	    		    			pw.print(arr[i] + " ");
	    		    		}
	    		    		pw.println();
	    		    		return;
	    		    	}
	 
	    		    	private static boolean isSpaceChar(int c) {
	    		    		if (filter != null)
	    		    			return filter.isSpaceChar(c);
	    		    		return isWhitespace(c);
	    		    	}
	 
	    		    	private interface SpaceCharFilter {
	    		    		public boolean isSpaceChar(int ch);
	    		    	}
	    		    	
	
	}
	    		    
	    		        class Node{
	    		    	int to;
	    		    	long dist;
	    		    	Node(int to,long dist){
	    		    		this.to=to;
	    		    		this.dist=dist;
	    		    	}
	    		    	
	    		    }
	    		
	class Dsu{
	private int rank[], parent[] ,n;
	long str[],si[],larg[];
	long max=0;
	int cnt=0;
	private static int[] parent1;
	Dsu(int size){
		this.n=size+1;
		rank=new int[n];
		cnt=n-1;
		//parent=new int[n];
	    		    		    		parent=new int[n];
	    		    		    		str=new long[n];
	    		    		    		si=new long[n];
	    		    		
	    		    		    		larg=new long[n];
	    		    		    		makeSet();
	    		    		
	    		    		    	}
	    		    		    	
	    		    		    	void makeSet(){
	    		    		    		for(int i=0;i<n;i++){
	    		    		    			parent[i]=i;
	    		    		    			si[i]=1;
	    		    		    		}
	    		    		    	}
	    		    		    	
	    		    		    	int find(int x){
	    		    		    		if(parent[x]!=x){
	    		    		    			
	    		    		    			parent[x]=find(parent[x]);
	    		    		    		}
	    		    		    		return parent[x];
	    		    		    	}
	    		    		    	
	    		    		    	void join(int ind,long val){
	    		    		    		if(str[ind]==0){
	    		    		    			str[ind]=val;
	    		    		    			larg[ind]=val;
	    		    		    			max=Math.max(max, str[ind]);
	    		    		    		}
	    		    		    		int prev_ind=(ind-1);
	    		    		    		int next_ind=(ind+1);
	    		    		    		if(prev_ind>0 && larg[prev_ind]!=0){
	    		    		    			union(prev_ind,ind);
	    		    		    		}
	    		    		    		if(next_ind<n && larg[next_ind]!=0){
	    		    		    			union(next_ind,ind);
	    		    		    		}
	    		    		    		
	    		    		    	}
	    		    		    
	    		    		    	
	    		    		    	boolean union(int x,int y){
	    		    		    		int xRoot=find(x);
	    		    		    		int yRoot=find(y);
	    		    		    
	    		    		    	
	    		    		    		if(xRoot==yRoot)
	    		    		    			return false;
	    		    		    		if(rank[xRoot]<rank[yRoot]){
	    		    		    		parent[xRoot]=yRoot;
	    		    		    		
	    		    		    		larg[yRoot]=Math.max(larg[xRoot], larg[yRoot]);
	    		    		    		
	    		    		    		si[yRoot]+=si[xRoot];
	    		    		    		str[yRoot]=larg[yRoot]*si[yRoot];
	    		    		    			max=Math.max(str[yRoot], max);
	    		    		    		}else if(rank[yRoot]<rank[xRoot]){
	    		    		    			parent[yRoot]=xRoot;
	     
	    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);
	        		    		    		
	        		    		    		si[xRoot]+=si[yRoot];
	        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
	    			    		    		max=Math.max(str[xRoot], max);
	    		    		    		}else{
	    		    		    			parent[yRoot]=xRoot;
	    		    		    			rank[xRoot]++;
	     
	    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);
	        		    		    		
	        		    		    		si[xRoot]+=si[yRoot];
	        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
	    			    		    		max=Math.max(str[xRoot], max);
	    		    		    		
	    		    		    		}
	    		    		    		cnt--;
	    		    		    		return true;
	    		    		    	}
	    	
	    		    		     
	    		    		    }
	class Pair implements Comparable<Pair>{
		long dist,fuel,w;
		Pair(long dist,long fuel){
			this.dist=dist;
			this.fuel=fuel;
		}
	
		@Override
		public int compareTo(Pair o) {
			// TODO Auto-generated method stub
			
			return (int)(o.dist-dist);
		}
	}
	  
								
