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:
//package competitveprogramming;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
  
public class er110b
{
    //By shwetank_verma
	static void BFS(ArrayList<Integer>[] adj, int src,
            long dist[], long paths[], int n)
{
  boolean[] visited = new boolean[n];
  for (int i = 0; i < n; i++)
      visited[i] = false;
  dist[src] = 0;
  paths[src] = 1;

  Queue<Integer> q = new LinkedList<>();
  q.add(src);
  visited[src] = true;
  while (!q.isEmpty())
  {
      int curr = q.peek();
      q.poll();

      for (int x : adj[curr])
      {

          if (visited[x] == false)
          {
              q.add(x);
              visited[x] = true;
          }
          if (dist[x] > dist[curr] + 1)
          {
              dist[x] = dist[curr] + 1;
              dist[x]=dist[x]%mod;
              paths[x] = paths[curr]%mod;
          }
          else if (dist[x] == dist[curr] + 1)
              paths[x] += paths[curr];
      }
  }
}
	static long findShortestPaths(ArrayList<Integer> adj[],
            int s, int n)
	{
		long[] dist = new long[n], paths = new long[n];

		for (int i = 0; i < n; i++)
			dist[i] = Integer.MAX_VALUE;

		for (int i = 0; i < n; i++)
			paths[i] = 0;

		BFS(adj, s, dist, paths, n);

		return paths[n-1]%mod;
}
	static void addEdge(ArrayList<Integer> adj[],
            int u, int v)
	{
		adj[u].add(v);
		adj[v].add(u);
	}
	static int sum(long n) {
		String str=""+n;
		int res=0;
		char ch[]=str.toCharArray();
		for(char c:ch)
			res+=c-48;
		return res;
	}
	public static void main(String[] args)
    {
        FastReader sc=new FastReader();
        try{
           
                int t=1;
                t=sc.nextInt();
                while(t-->0){
                	long n=sc.nextLong();
                	int s=sc.nextInt();
                	long ans=0;
                	if(sum(n)<=s)
                	{
                		System.out.println(0);
                	}
                	else {
                		String ss=""+n;
                		long p=1;
                		for(int i=0;i<ss.length();i++) {
                			long d=(n/p)%10;
                			long val=p*((10-d)%10);
                			n+=val;
                			ans+=val;
                			if(sum(n)<=s)
                				break;
                			p=p*10;
                		}
                		System.out.println(ans);
                	}
                }
           
            
        }catch(Exception e){
            return;
        }
    }

static void ruffleSort(long[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			long oi=r.nextInt(n), temp=a[i];
			a[i]=a[(int)oi];
			a[(int)oi]=temp;
		}
		Arrays.sort(a);
	}
static void ruffleSort(int[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			int oi=r.nextInt(n), temp=a[i];
			a[i]=a[oi];
			a[oi]=temp;
		}
		Arrays.sort(a);
	}

    static class FastReader
    {
        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;
        }
    }
    static int mod=1000000007;
    static boolean primes[]=new boolean[1000007];
    static ArrayList<Integer> b=new ArrayList<>();
    static boolean seive(int n){
        Arrays.fill(primes,true);
        primes[0]=primes[1]=false;
        for(int i=2;i*i<=n;i++){
            if(primes[i]==true){
                for(int p=i*i;p<=n;p+=i){
                    primes[p]=false;
                }
            }
        }
        if(n<1000007){
        	for(int i=2;i<=n;i++) {
        		if(primes[i])
        			b.add(i);
        	}
            return primes[n];
        }
        return false;
        
    }
    static int gcd(int a,int b){
        if(b==0)
        return a;
        return gcd(b,a%b);
    }
    static long GCD(long a,long b){
        if(b==0)
        return a;
        return GCD(b,a%b);
    }
    static ArrayList<Integer> segseive(int l,int r){
    	
    	ArrayList<Integer> isprime=new ArrayList<Integer>();
    	boolean p[]=new boolean[r-l+1];
    	Arrays.fill(p, true);
        
    	for(int i=0;b.get(i)*b.get(i)<=r;i++) {
    		int currprime=b.get(i);
    		int base=(l/currprime)*currprime;
    		if(base<l) {
    			base+=currprime;
    		}
    		for(int j=base;j<=r;j+=currprime) {
    			p[j-l]=false;
    		}
    		
    		
    		if(base==currprime) {
    			p[base-l]=true;
    		}
    		
    	}
    	for(int i=0;i<=r-l;i++) {
    		if(p[i])
    			isprime.add(i+l);
    	}
    	return isprime;
    }
      static int LowerBound(int a[], int x) { // x is the target value or key
  int l=-1,r=a.length;
  while(l+1<r) {
    int m=(l+r)>>>1;
    if(a[m]>=x) r=m;
    else l=m;
  }
  return r;
}
static int UpperBound(int a[], int x) {// x is the key or target value
    int l=-1,r=a.length;
    while(l+1<r) {
       int m=(l+r)>>>1;
       if(a[m]<=x) l=m;
       else r=m;
    }
    return l+1;
 }

  
     
}