Problem: You are given a positive integer n. In one move, you can increase n by one (i.e. make n := n + 1). Your task is to find the minimum number of moves you need to perform in order to make the sum of digits of n be less than or equal to s.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.

The only line of the test case contains two integers n and s (1 ≤ n ≤ 10^{18}; 1 ≤ s ≤ 162).

Output

For each test case, print the answer: the minimum number of moves you need to perform in order to make the sum of digits of n be less than or equal to s.

Example

Input


5
2 1
1 1
500 4
217871987498122 10
100000000000000001 1


Output


8
0
500
2128012501878
899999999999999999

Solution (in PYTHON3):

Solution:
import sys
import math

# Constants
mod = 998244353

# Program Settings
cases = True


# Functions Settings
dynamic_factorial = False



# Pre-defined function
# Begin

# Testcase handler
def main(test_case = False):
    n = int(input()) if test_case else 1
    for _ in range(n):
        test()

# Binary method of power
def fast_pow(a:int, b:int):
    res = 1
    while b > 0:
        if b & 1:
            res *= a
        a *= a
        b >>= 1
    return res

# Combination of 2
def c2(n):
    return n * (n-1) // 2

# Get the list form of input
def get():
    return list(map(int, input().split()))

# Number of 1s in binary form
def bits(n: int):
    return list(bin(n)).count('1')

# For interactive problems
def flush():
    sys.stdout.flush()

# Print array and split it with space
def parr(arr):
    print(*arr, sep=' ')

# GCD (int a, int b)
# Return: value of GCD(a, b)
def gcd(a, b):
    while b:
        if b % a == 0:
            break
        tmp = a
        a = b % a
        b = tmp
    return a

# Extended GCD (int a, int b)
# Return: array of [GCD(a, b), [x0, y0]]
# Where a * x0 + b * y0 = 1
# If GCD(a, b) != 1 then return False
def ext_gcd(a: int, b: int):
    if (b == 0):
        return [a, [1, 0]]
 
    res = ext_gcd(b, a % b)
    g = res[0]
    if g != 1:
        return False
    x1 = res[1][0]
    y1 = res[1][1]
    x = y1
    y = x1 - y1 * (a // b)
 
    return [g, [x, y]]

# Get all different values of array a with their count
def get_set(a):
    res = {}
    for x in a:
        if x in res:
            res[x] += 1
        else:
            res[x] = 1
    return res

# Factorial
fact = {0: 1}
def factorial(n):
    if dynamic_factorial:
        if n not in fact:
            fact[n] = factorial(n-1) * n
        return fact[n]
    else:
        res = 1
        while n > 0:
            res = (res * n) % mod
            n -= 1
        return res

# Sum of array
def sum_of(a):
    res = 0
    for x in a:
        res = (res + x) % mod
    return res

# Prod of array
def prod_of(a):
    res = 1
    for x in a:
        res = (res * x) % mod
    return res

# End

def test():
    n, s = get()
    print(solve(n, s))

# Problem functions
def digit_sum(n):
    result = 0
    while n > 0:
        result += n % 10
        n //= 10
    return result

def solve(n, s):
    d = digit_sum(n)
    if d <= s:
        return 0
    else:
        last_digit = n % 10
        return 10 - last_digit + 10 * solve(n // 10 + 1, s)
        # elif d < s:
        #     if d + 9 - last_digit >= s:
        #         return s - d
        #     else:
        #         return 9-last_digit + 10 * solve(n // 10, s - 9)
    print('OUT')


main(cases)