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

Solution:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

public class D {
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        int tt = sc.nextInt();
        while (tt-- > 0){
            long n = sc.nextLong();
            int s = sc.nextInt();
            int[] arr = charArrayToIntArray(String.valueOf(n).toCharArray());
            int len = arr.length;
            //long ans = 0L;

            for(int i = len - 1; i >= 0; --i){
                int digitSum = (int) sum(arr);
                if(digitSum <= s)
                    break;
               /* while(arr[i] < 10){
                    ++arr[i];
                    //ans += Math.pow(10, len - i);
                    //cans += Math.pow(10, len - i);;
                }*/
                //if(arr[i] == 0) continue;
                arr[i] = 0;
                if(!addOne(arr, i - 1)){
                    arr = findHigherOneAndZeros(len);
                    break;
                }
            }

            long finalNum = 0L;
            for (int j : arr) {
                finalNum *= 10;
                finalNum += j;
            }
            //System.out.print(finalNum +" - " + n +" : ");
            System.out.println(finalNum - n);
        }
    }

    private static int[] findHigherOneAndZeros(int len) {
        int[] arr = new int[len + 1];
        arr[0] = 1;
        return arr;
    }

    private static boolean addOne(int[] arr, int idx) {
        for(int i = idx; i >= 0; --i){
            ++arr[i];
            if(arr[i] < 10) return true;
            arr[i] = 0;
        }
        return false;
    }

    private static long sum(int...arr){
        long sum = 0L;
        for(int a : arr)
            sum += a;
        return sum;
    }
    private static int[] charArrayToIntArray(char[] chArr){
        int n = chArr.length;
        int[] arr = new int[n];
        for(int i = 0; i < n; ++i)
            arr[i] = chArr[i] - '0';

        return arr;
    }
    private static class FastReader {
        private final BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] readArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextInt();

            return arr;
        }

        List<Integer> readList(int n) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; ++i)
                list.add(nextInt());
            return list;
        }

        long[] readLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextLong();

            return arr;
        }

        double[] readDoubleArray(int n) {
            double[] arr = new double[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextDouble();
            return arr;
        }
    }
}