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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        int t;
        t = in.nextInt();
        while (t > 0) {
            solver.call(in,out);
            t--;
        }

        out.close();
    }

    static class TaskA {
        public void call(InputReader in, PrintWriter out) {
            long n;
            n = in.nextLong();
            int s , sum =0 , a=0;
            s = in.nextInt();
            ArrayList<Long> arrayList = new ArrayList<>();
            ArrayList<Integer> arrayList1 = new ArrayList<>();

            while(n!=0){
                arrayList.add(n%10);
                n = n/10;
            }

            Long[] arr = new Long[arrayList.size()];

            for (int i = 0 , j =arrayList.size()-1; i < arrayList.size() ; i++ , j--) {
                arr[i] = arrayList.get(j);
            }

            for (int i = 0; i <arr.length ; i++) {
                sum+=arr[i];
                if(sum<s)
                    a++;
            }

            if(sum<=s){
                out.print(0);
            }
            else{
                if (arrayList.get(0) != 0) {
                    arrayList1.add((int) (10 - arrayList.get(0)));
                    sum = 1;
                } else {
                    arrayList1.add(0);
                    sum = 0;
                }
                for (int i = 1; i < arrayList.size() - a; i++) {
                    if (sum == 0) {
                        if (arrayList.get(i) != 0) {
                            arrayList1.add((int) (10 - arrayList.get(i)));
                            sum++;
                        } else
                            arrayList1.add(0);
                    } else {
                        arrayList1.add((int) (9 - arrayList.get(i)));
                    }

                }
            }
            a = 0 ;
            for (int i = arrayList1.size() - 1; i >= 0; i--) {
                if(arrayList1.get(i)==0)
                    a++;
                else
                    break;
            }
            for (int i = (arrayList1.size() - 1 )- a; i >= 0; i--) {
                out.print(arrayList1.get(i));
            }
            out.println();
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong(){
            return Long.parseLong(next());
        }

    }
}