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·10^5) — 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 x_{i} 0 ≤ x_{i} ≤ 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
& 1
& 3
& 5

Output
1
& 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.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'import os\nimport sys\nfrom io import BytesIO, IOBase\n \nBUFSIZE = 8192\n \n \nclass FastIO(IOBase):\n    newlines = 0\n \n    def __init__(self, file):\n        self._fd = file.fileno()\n        self.buffer = BytesIO()\n        self.writable = "x" in file.mode or "r" not in file.mode\n        self.write = self.buffer.write if self.writable else None\n \n    def read(self):\n        while True:\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n            if not b:\n                break\n            ptr = self.buffer.tell()\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n        self.newlines = 0\n        return self.buffer.read()\n \n    def readline(self):\n        while self.newlines == 0:\n            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n            self.newlines = b.count(b"\\n") + (not b)\n            ptr = self.buffer.tell()\n            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n        self.newlines -= 1\n        return self.buffer.readline()\n \n    def flush(self):\n        if self.writable:\n            os.write(self._fd, self.buffer.getvalue())\n            self.buffer.truncate(0), self.buffer.seek(0)\n \n \nclass IOWrapper(IOBase):\n    def __init__(self, file):\n        self.buffer = FastIO(file)\n        self.flush = self.buffer.flush\n        self.writable = self.buffer.writable\n        self.write = lambda s: self.buffer.write(s.encode("ascii"))\n        self.read = lambda: self.buffer.read().decode("ascii")\n        self.readline = lambda: self.buffer.readline().decode("ascii")\n \n \nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip("\\r\\n")\n######################################\na=int(input())\nbits=[\'r\' for i in range(10)]\ntemp=[\'r\' for i in range(10)]\nfor i in range(a):\n    x,y=input().split()\n    y=int(y)\n    n=bin(y)\n    n=n[2:]\n    ans=\'\'\n    for i in range(10-len(n)):\n        ans+=\'0\'\n    ans=ans+n\n    \n    if(x==\'|\'):\n        \n        for i in range(len(bits)):\n            if(ans[i]==\'1\'):\n                temp[i]=\'1\'\n            \n    if(x==\'&\'):\n        for i in range(len(bits)):\n            if(ans[i]==\'0\'):\n                temp[i]=\'0\'\n    if(x==\'^\'):\n        for i in range(len(bits)):\n            if((temp[i]==\'0\' and ans[i]==\'1\') or (temp[i]==\'1\' and ans[i]==\'0\')):\n                temp[i]=\'1\'\n            elif(temp[i]==ans[i] and (temp[i]==\'0\' or temp[i]==\'1\')):\n                temp[i]=\'0\'\n            else:\n                if(ans[i]==\'1\'):\n                    if(temp[i]==\'r\'):\n                        temp[i]=\'rb\'\n                    else:\n                        temp[i]=\'r\'\n\n\nad=[\'0\' for i in range(10)]\nxor=[\'0\' for i in range(10)]\nnd=[\'1\' for i in range(10)]\n\nfor i in range(len(temp)):\n    if(temp[i]==\'1\'):\n        ad[i]=\'1\'\n        nd[i]=\'1\'\n        xor[i]=\'0\'\n    elif(temp[i]==\'0\'):\n        nd[i]=\'0\'\n        ad[i]=\'0\'\n        xor[i]=\'1\'\n    elif(temp[i]==\'rb\'):\n        xor[i]=\'1\'\n        ad[i]=\'0\'\n        nd[i]=\'1\'\n    else:\n        xor[i]=\'0\'\n        ad[i]=\'0\'\n        nd[i]=\'1\'\n\nad=int(\'\'.join(map(str,ad)),2)\nnd=int(\'\'.join(map(str,nd)),2)\nxor=int(\'\'.join(map(str,xor)),2)\nprint(3)\nprint(\'^\',xor)\nprint(\'&\',nd)\nprint(\'|\',ad)\n                \n        \n            \n            \n            \n        \n    \n\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 24007