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
'''input
3
& 1
& 3
& 5
'''
'''
Author : dhanyaabhirami
Great things never come from comfort zones
'''
from collections import defaultdict as dd
from collections import Counter as ccd
from itertools import  permutations as pp
from itertools import combinations as cc
from random import randint as rd
from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq as hq
import math

mod=pow(10,9) +7
def inp(flag=0):
    if flag==0:
        return list(map(int,input().strip().split(' ')))
    else:
        return int(input())

# Code credits
# assert(debug()==true)

# for _ in range(int(input())):
#     n=inp(1)
    
n=int(input())
a=0
b=1023
for i in range(n):
    c,k= input().strip().split(' ')
    k=int(k)
    if (c=='|'):
            a|=k
            b|=k        
    elif (c=='^'):
        a^=k
        b^=k
    elif (c=='&'):
        a&=k
        b&=k
        
OR = 0
XOR = 0
for i in range(10):
    x=1<<i
    if a&x and b&x:
        XOR|=x
        OR|=x
    if ~a&x and b&x:
        XOR|=x
    if ~a&x and ~b&x:
        OR|=x
print('2')
print('|',OR)
print('^',XOR)