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.util.*;
import java.io.*;
import java.math.*;

public class Main
{
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        
        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        String next() {
            while(st == null && !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
    
	public static void main(String[] args) throws Exception {
		PrintWriter pw = new PrintWriter(System.out);
		Scanner s = new Scanner(System.in);
		
		int t = s.nextInt();
		while(t--!=0) {
		    long n = s.nextLong();
		    long ss = s.nextLong();
		    
		    long num = 0;
		    long c9 = ss/9;
		    String st = "";
		    while(c9--!=0) {
		        st += "9";
		    }
		    if(ss%9 != 0) {
		        long v = (ss%9);
		        st = v + st;
		    }
		    num = Long.parseLong(st);
		    //pw.println(num + " " + n);
		    
		    long ans = 0;
		    if(n <= num) {
		        long org = n;
		        long sum = 0;
		        while(n!=0) {
		            sum += n%10;
		            n /= 10;
		            //pw.println(n);
		        }
		        
		        if(sum <= ss) {
		            ans = 0;
		        }else {
		            ans = num - org;
		        }
		    }else {
		        long org = n;
		        long sum = 0;
		        while(n!=0) {
		            sum += n%10;
		            n /= 10;
		            //pw.println(n);
		        }
		        
		        if(sum <= ss) {
		            ans = 0;
		            //pw.println(sum + "in" + org + " " + ss);
		        }else {
		            n = org;
		            long v = 10;
		            while(sum > ss) {
		                long v1 = v - n%v;
		                n += v1;
		                long n_ = n;
		                sum = 0;
		                while(n_!=0) {
		                    sum += n_%10;
		                    n_ /= 10;
		                }
		                v *= 10;
		            }
		            //pw.println(n + "n" + org);
		            ans = n - org;
		            if(sum > ss) {
		                ans += num - 1;
		            }
		        }
		        
		    }
		    pw.println(ans);
		}
		pw.flush();
	}
}