Meliodas and Ban are fighting over chocolates. Meliodas has $X$ chocolates, while Ban has $Y$. Whoever has lesser number of chocolates eats as many chocolates as he has from the other's collection. This eatfest war continues till either they have the same number of chocolates, or atleast one of them is left with no chocolates.

Can you help Elizabeth predict the total no of chocolates they'll be left with at the end of their war?

-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow. 
- Each testcase contains of a single line of input, which contains two integers $X, Y$, the no of chocolates Meliodas and Ban have, respectively. 

-----Output:-----
For each testcase, output in a single line the no of chocolates that remain after Ban and Meliodas stop fighting.

-----Constraints-----
- $1 \leq T \leq 100000$
- $0 \leq X,Y \leq 10^9$

-----Sample Input:-----
3

5 3

10 10

4 8  

-----Sample Output:-----
2

20

8  

-----EXPLANATION:-----
Denoting Meliodas as $M$, Ban as $B$.
Testcase 1:
$M$=5, $B$=3

Ban eates 3 chocolates of Meliodas.
$M$=2, $B$=3

Meliodas eats 2 chocolates of Ban.
$M$=2, $B$=1

Ban eates 1 chocolate of Meliodas.
$M$=1, $B$=1

Since they have the same no of candies, they stop quarreling.

Total candies left: 2  
Testcase 2:
$M$=10, $B$=10

Since both of them had the same candies to begin with, there was no point in fighting.

Total candies left: 20  
Testcase 3:
$M$=4, $B$=8

Meliodas eats 4 chocolates of Ban.
$M$=4, $B$=4

Since they have the same no of candies, they stop quarreling.

Total candies left: 8

```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 = 't=int(input())\nfor _ in range(t):\n a,b=list(map(int,input().split()))\n while a!=0 and b!=0 and a!=b:\n  if(a>b):\n   a=a%b\n  else:\n   b=b%a\n if(a==0 or b==0):\n  print((a+b)*2)\n elif(a==b):\n  print(a+b)\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 13111