import java.math.BigInteger;
import java.util.Scanner;

public class Solution {
	
	public static void main(String args[])
	{
		Scanner in = new Scanner(System.in);    
        String n = in.nextLine();
        int N = Integer.parseInt(n);
        for(int i = 0; i< N; i++)
        {
        	String NK = in.nextLine();
        	long Nn = Long.parseLong((NK.split(" ")[0]));
        	long Kk = Long.parseLong((NK.split(" ")[1]));
        	
        	long Nnn = Nn - Kk;
        	Nnn = Nnn + 1;
        	if(Nn == 1 && Kk == 1)
        		System.out.println("1");
        	else if(Nn<=Kk)
        		System.out.println("0");
        	else if(Kk > Nn/2 + 1)
        		System.out.println("0");
        	else
        		System.out.println(combinations(Nnn, Kk,100003L ));
        	
        }
	}
	
	public static BigInteger factorial(BigInteger n) {
	    BigInteger result = BigInteger.ONE;

	    while (!n.equals(BigInteger.ZERO)) {
	        result = result.multiply(n);
	        n = n.subtract(BigInteger.ONE);
	    }

	    return result;
	}
	
	public static int  factorial(int n) {
	    int result = 1;

	    while (!(n==0)) {
	        result = ((result% 100003) * (n% 100003)) ;
	        n = n -1;
	    }

	    return result;
	}

	
	static int facmod(int n, int m) 
	{
	    int f = 1;
	    for(int i =2; i<=n; i++)
	    {
	        f = f * i;
	        if(f > m) 
	        {
	            f = f % m;
	        }
	    }
	    return f;
	}


	public static BigInteger nCr(BigInteger bigInteger, BigInteger kk){
		
		
	    return factorial(bigInteger).divide(factorial(bigInteger.subtract(kk)).multiply(factorial(kk)));
	}
	
	static long fast_pow(long  base, long  n,long  M)
	{
	    if(n==0)
	       return 1;
	    if(n==1)
	    return base;
	    long halfn=fast_pow(base,n/2,M);
	    if(n%2==0)
	        return ( halfn * halfn ) % M;
	    else
	        return ( ( ( halfn * halfn ) % M ) * base ) % M;
	}
	
	

	static long findMMI_fermat(long n,long M)
	{
	    return fast_pow(n,M-2,M);
	}
	
	static long calc(int n, int r)
	{
	    
	    
	    int i=1;
	    int MOD=100003;
	    
	    while(true)
	    {
	        
	        
	        long  numerator,denominator,mmi_denominator,ans;
	        //I declared these variable as long long so that there is no need to use explicit typecasting
	        numerator=facmod(n, MOD);
	        //working
	        
	        System.out.println(numerator);
	        denominator=(facmod(r, MOD)*facmod(n-r, MOD));
	        
	        ans=(numerator/denominator);
	        return ans;
	    }
	}
	
	static long modPow(long a, long x, long p) {
	    //calculates a^x mod p in logarithmic time.
	    long res = 1;
	    while(x > 0) {
	        if( x % 2 != 0) {
	            res = (res * a) % p;
	        }
	        a = (a * a) % p;
	        x /= 2;
	    }
	    return res;
	}

	static long modInverse(long a, long p) {
	    //calculates the modular multiplicative of a mod m.
	    //(assuming p is prime).
	    return modPow(a, p-2, p);
	}
	static long modBinomial(long n, long k, long p) {
		// calculates C(n,k) mod p (assuming p is prime).

	    long numerator = 1; // n * (n-1) * ... * (n-k+1)
	    for (int i=0; i<k; i++) {
	        numerator = (numerator * (n-i) ) % p;
	    }

	    long denominator = 1; // k!
	    for (int i=1; i<=k; i++) {
	        denominator = (denominator * i) % p;
	    }

	    // numerator / denominator mod p.
	    return ( numerator* modInverse(denominator,p) ) % p;
	}
	
	static int get_degree( long n,  long p) { // returns the degree with which p is in n!
		  int degree_num = 0;
		  long  u = p;
		  long  temp = n;
		  while (u <= temp) {
		    degree_num += temp/u;
		    u *= p;
		  }
		  return degree_num;
		}

		static  long combinations(long n, long k,  long p) {
		  int num_degree = get_degree(n,p) - get_degree(n- k,p);
		  int den_degree = get_degree(k,p);
		  if (num_degree > den_degree) {
		    return 0;
		  }
		  long  res = 1;
		  for ( long i = n; i > n- k; --i) {
		    long  ti = i;
		    while(ti % p == 0) {
		      ti /= p;
		    }
		    res = (res *ti)%p;
		  }
		  for ( long i = 1; i <= k; ++i) {
		    long  ti = i;
		    while(ti % p == 0) {
		      ti /= p;
		    }
		    res = (res * degree(ti, p-2, p))%p;
		  }
		  return res;
		}
		
		 static long degree(long  a, long k,  long p) {
			  long res = 1;
			  long  cur = a;

			  while (k!=0) {
			    if (k%2!=0) {
			      res = (res * cur)%p;
			    }
			    k /= 2;
			    cur = (cur * cur) % p;
			  }
			  return res;
			}

}