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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
long long m, k, T, y, g;
unsigned long long res, n;
bool d(long long N) {
  long long x = 0;
  while (N > 0) {
    x += N % 10;
    N /= 10;
  }
  if (x > k)
    return true;
  else
    return false;
}
int main() {
  scanf("%lld", &T);
  while (T--) {
    scanf("%lld%lld", &n, &k);
    if (!d(n)) {
      cout << 0 << endl;
      continue;
    }
    res = 0;
    while (d(n)) {
      g = 10;
      if (n % g != 0) {
        res += g - n % g;
        n += g - n % g;
      } else {
        g = 100;
        if (n % g != 0) {
          y = g - n % g;
          res += y;
          n += y;
        } else {
          g = 1000;
          if (n % g != 0) {
            y = g - n % g;
            res += y;
            n += y;
          } else {
            g = 10000;
            if (n % g != 0) {
              y = g - n % g;
              res += y;
              n += y;
            } else {
              g = 100000;
              if (n % g != 0) {
                y = g - n % g;
                res += y;
                n += y;
              } else {
                g = 1000000;
                if (n % g != 0) {
                  y = g - n % g;
                  res += y;
                  n += y;
                } else {
                  g = 10000000;
                  if (n % g != 0) {
                    y = g - n % g;
                    res += y;
                    n += y;
                  } else {
                    g = 100000000;
                    if (n % g != 0) {
                      y = g - n % g;
                      res += y;
                      n += y;
                    } else {
                      g = 1000000000;
                      if (n % g != 0) {
                        y = g - n % g;
                        res += y;
                        n += y;
                      } else {
                        g = 10000000000;
                        if (n % g != 0) {
                          y = g - n % g;
                          res += y;
                          n += y;
                        } else {
                          g = 100000000000;
                          if (n % g != 0) {
                            y = g - n % g;
                            res += y;
                            n += y;
                          } else {
                            g = 1000000000000;
                            if (n % g != 0) {
                              y = g - n % g;
                              res += y;
                              n += y;
                            } else {
                              g = 10000000000000;
                              if (n % g != 0) {
                                y = g - n % g;
                                res += y;
                                n += y;
                              } else {
                                g = 10000000000000;
                                if (n % g != 0) {
                                  y = g - n % g;
                                  res += y;
                                  n += y;
                                } else {
                                  g = 100000000000000;
                                  if (n % g != 0) {
                                    y = g - n % g;
                                    res += y;
                                    n += y;
                                  } else {
                                    g = 1000000000000000;
                                    if (n % g != 0) {
                                      y = g - n % g;
                                      res += y;
                                      n += y;
                                    } else {
                                      g = 10000000000000000;
                                      if (n % g != 0) {
                                        y = g - n % g;
                                        res += y;
                                        n += y;
                                      } else {
                                        g = 100000000000000000;
                                        y = g - n % g;
                                        res += y;
                                        n += y;
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    cout << res << endl;
    ;
  }
  return 0;
}