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.
The first line contains an integer *n* (1 ≤ *n* ≤ 5·10<sup class="upper-index">5</sup>) — the number of lines.

Next *n* lines contain commands. A command consists of a character that represents the operation ("&amp;", "|" or "^" for AND, OR or XOR respectively), and the constant *x*<sub class="lower-index">*i*</sub> 0 ≤ *x*<sub class="lower-index">*i*</sub> ≤ 1023.
You can read about bitwise operations in [https://en.wikipedia.org/wiki/Bitwise_operation](https://en.wikipedia.org/wiki/Bitwise_operation).

Second sample:

Let *x* be an input of the Petya's program. It's output is ((*x*&amp;1)&amp;3)&amp;5 = *x*&amp;(1&amp;3&amp;5) = *x*&amp;1. So these two programs always give the same outputs.
3
| 3
^ 2
| 1
2
| 3
^ 2
3
& 1
& 3
& 5
1
& 1
3
^ 1
^ 2
^ 3
0
2
| 999
^ 689
2
| 999
^ 689
3
& 242
^ 506
^ 522
2
| 781
^ 253
2
| 56
^ 875
2
| 56
^ 875
3
^ 125
^ 377
& 1019
2
| 4
^ 260
1
& 123
1
& 123
1
| 123
1
| 123
1
^ 123
1
^ 123
10
^ 218
& 150
| 935
& 61
| 588
& 897
| 411
| 584
^ 800
| 704
2
| 1023
^ 260
10
^ 160
& 1021
& 510
^ 470
& 1022
& 251
& 760
& 1016
| 772
| 515
2
| 775
^ 112
1
& 0
1
& 0
1
| 0
0
1
^ 0
0
1
& 1023
0
1
| 1023
1
| 1023
1
^ 1023
1
^ 1023
#include<stdio.h>
#include<iostream>
#include <stdlib.h>
#include <time.h>
#include<string.h>
#include<math.h>
#include<stack>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#define ll long long
#define maxn 0x3f3f3f3f
#define inf 0x3f3f3f3f3f3f3f3f
#define mdd 998244353
using namespace std;
long long i,j,m,n,mapp[20],a[200100],b[200100],c[200100],t,x,y,z,k,l,r,p,pp,num,ans,sum,key,cnt,flag,minn,maxx,d[50],pre[200100];
char zz;
double xa[5],ya[5],xb[5],yb[5],ee[5],ff;
//string ;
//vector<long long>v[200100];
//map<ll,ll>mp;
//priority_queue<ll,vector<ll>,greater<ll> >s;

struct qq{ll xx,yy,zz,dd;};
queue<qq>s;

bool cmp(ll u,ll v){
	ll x=abs(u),y=abs(v);
	if(x!=y)return x<y;
	else return u<v;
}

int main(){
	scanf("%lld",&n);
	memset(mapp,inf,sizeof mapp);
	for(i=0,z=0,y=0,z=0;i<n;i++){
		scanf("%c",&zz);
		scanf("%c%lld",&zz,&m);
		if(zz=='|'){
			t=0;
			while(m){
				p=m%2;
				if(p==1){
					mapp[t]=1;d[t]=0;
				}
				t++;
				m/=2;
			}
		}
		else if(zz=='&'){
			t=0;
			while(m){
				p=m%2;
				if(p==0){
					mapp[t]=0;d[t]=0;
				}
				t++;
				m/=2;
			}
		}
		else if(zz=='^'){
			t=0;
			while(m){
				p=m%2;
				if(mapp[t]<inf&&p==1)mapp[t]^=1;
				else if(p==1)d[t]^=1;
				t++;
				m/=2;
			}
		}
	}
	x=0;y=0;z=0;
	for(i=9;i>=0;i--){
		if(mapp[i]==0)y++;
		else if(mapp[i]==1)x++;
		else if(d[i]==1)z++;
		if(i>0){
			x*=2;y=y*2;z*=2;
		}
	}
	
	if(y==0)printf("4\n| %lld\n| %lld\n^ %lld\n^ %lld",x,y,y,z);
	else{
		t=1;k=0;
		while(y>0){
			p=y%2;
			p^=1;
			k+=t*p;
			t*=2;
			y/=2;
		}
	}printf("3\n| %lld\n& %lld\n^ %lld",x,k,z);

	
	
}
		   				 	 	  	       		 	 	 	