In order to celebrate Twice's 5th anniversary, Tzuyu and Sana decided to play a game.

Tzuyu gave Sana two integers $a$ and $b$ and a really important quest.

In order to complete the quest, Sana has to output the smallest possible value of ($a \oplus x$) + ($b \oplus x$) for any given $x$, where $\oplus$ denotes the bitwise XOR operation. 


-----Input-----

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^{4}$). Description of the test cases follows.

The only line of each test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^{9}$).


-----Output-----

For each testcase, output the smallest possible value of the given expression.


-----Example-----
Input
6
6 12
4 9
59 832
28 14
4925 2912
1 1

Output
10
13
891
18
6237
0



-----Note-----

For the first test case Sana can choose $x=4$ and the value will be ($6 \oplus 4$) + ($12 \oplus 4$) = $2 + 8$ = $10$. It can be shown that this is the smallest possible value.

```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 = '"""\n    Author: Sagar Pandey\n\n"""\n# ---------------------------------------------------Import Libraries---------------------------------------------------\nimport sys\nimport os\nfrom math import sqrt, log, log2, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial\nfrom copy import copy, deepcopy\nfrom sys import stdin, stdout\nfrom collections import Counter, defaultdict, deque\nfrom itertools import permutations\nimport heapq\nfrom bisect import bisect_left as bl\n# If the element is already present in the list,\n# the left most position where element has to be inserted is returned.\nfrom bisect import bisect_right as br\nfrom bisect import bisect\n\n# If the element is already present in the list,\n# the right most position where element has to be inserted is r\n\n# ---------------------------------------------------Global Variables---------------------------------------------------\n# sys.setrecursionlimit(100000000)\nmod = 1000000007\n# ---------------------------------------------------Helper Functions---------------------------------------------------\niinp = lambda: int(sys.stdin.readline())\ninp = lambda: sys.stdin.readline().strip()\nstrl = lambda: list(inp().strip().split(" "))\nintl = lambda: list(map(int, inp().split(" ")))\nmint = lambda: list(map(int, inp().split()))\nflol = lambda: list(map(float, inp().split(" ")))\nflush = lambda: stdout.flush()\n\n\ndef permute(nums):\n    def fun(arr, nums, cur, v):\n        if len(cur) == len(nums):\n            arr.append(cur.copy())\n        i = 0\n        while i < len(nums):\n            if v[i]:\n                i += 1\n                continue\n            else:\n                cur.append(nums[i])\n                v[i] = 1\n                fun(arr, nums, cur, v)\n                cur.pop()\n                v[i] = 0\n                i += 1\n            # while i<len(nums) and nums[i]==nums[i-1]:i+=1    # Uncomment for unique permutations\n        return arr\n\n    res = []\n    nums.sort()\n    v = [0] * len(nums)\n    return fun(res, nums, [], v)\n\n\ndef subsets(res, index, arr, cur):\n    res.append(cur.copy())\n    for i in range(index, len(arr)):\n        cur.append(arr[i])\n        subsets(res, i + 1, arr, cur)\n        cur.pop()\n    return res\n\n\ndef sieve(N):\n    root = int(sqrt(N))\n    primes = [1] * (N + 1)\n    primes[0], primes[1] = 0, 0\n    for i in range(2, root + 1):\n        if primes[i]:\n            for j in range(i * i, N + 1, i):\n                primes[j] = 0\n    return primes\n\n\ndef bs(arr, l, r, x):\n    if x < arr[0] or x > arr[len(arr) - 1]:\n        return -1\n    while l <= r:\n        mid = l + (r - l) // 2\n        if arr[mid] == x:\n            return mid\n        elif arr[mid] < x:\n            l = mid + 1\n        else:\n            r = mid - 1\n    return -1\n\n\ndef isPrime(n):\n    if n <= 1: return False\n    if n <= 3: return True\n    if n % 2 == 0 or n % 3 == 0: return False\n    p = int(sqrt(n))\n    for i in range(5, p + 1, 6):\n        if n % i == 0 or n % (i + 2) == 0:\n            return False\n    return True\n\n\n# -------------------------------------------------------Functions------------------------------------------------------\n\ndef solve():\n    a,b=mint()\n    print(a^b)\n\n\n# -------------------------------------------------------Main Code------------------------------------------------------\nfor _ in range(iinp()):\n    solve()\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 178368