import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    
    public static void abort(String s) {
        System.err.println(s);
        System.exit(0);
    }
    
    private static int modPartialFactorial(int n, int r, int m) {
        // calculates n*(n-1)*(n-2)*...(n-k) mod m (for n < m)
        long fact = 1;
        r = n-r;
        for (; n > r; n--) {
            fact = (fact*n)%m;
        }
        return (int) fact;
    }
    
    /*
    private static int modFactorial(int n, int m) {
        // calculates n! mod m (for n < m)
        long fact = 1;
        while ((n--)>0) {
            fact = (fact*n)%m;
        }
        return (int) fact;
    }
    */
    
    private static int modPow(long n, int p, int m) {
        // calculates n^p mod m
        if (n < 2) return (int) n;
        long ret = 1;
        while (p > 0) {
            // if p is odd we'll need an extra factor of this n
            if (p%2 != 0)
                ret = (ret*n) % m;
            // n^p = (n^2)^(p/2)
            n = (n*n) % m;
            p /= 2;
            //System.out.println("Result = "+n+"^"+p+"+"+ret);
        }
        return (int) ret;
    }
    
    /*
    private static BigInteger bigIntBinomCoeffMod(long ln, long lk, BigInteger bigP) {
        if (lk > ln-lk) lk = ln-lk;
        BigInteger b = new BigInteger("1");
        BigInteger n = BigInteger.valueOf(ln);
        BigInteger k = BigInteger.valueOf(lk);
        BigInteger i = BigInteger.ONE;
        while (i.compareTo(k) <= 0) {
            b = b.multiply(n.subtract(i).add(BigInteger.ONE)).divide(i);
            i = i.add(BigInteger.ONE);
        }
        return b.mod(bigP);
    }
    */
    
    private static int nCrModM(int n, int r, int m) {
        if (n == r) return 1;
        if (n < r) return 0;
        
        if (n-r < r) r = n-r;
        // nCr = n!/((n-r)!r!)
        // a/b mod m = ((a mod m) * (b^-1 mod m)) mod m
        // b^-1 mod m = b^(m-2) mod m for prime m
        
        // a mod m = n!/(n-r)! mod m
        int numer = modPartialFactorial(n, r, m);
        // b^-1 mod m = r!^(m-2) mod m
        int denom = modPow(modPartialFactorial(r, r, m), m-2, m);
        long ret = (long)numer*(long)denom;
        
        //System.out.println("n["+n+"], r["+r+"], m["+m+"]");
        //System.out.println("numer["+numer+"]*denom["+denom+"] mod m = ret["+ret+"], mod m = "+ret%m);
        
        return (int) (ret % m);
    }
    
    public static int binomCoeffMod(long A, long B, int P) {
        final long P2 = (long) Math.pow(P, 2);
        int n2 = (int) (A/P2);
        int n1 = (int) ((A-n2*P2)/P);
        int n0 = (int) (A-n2*P2-n1*P);
        int k2 = (int) (B/P2);
        int k1 = (int) ((B-k2*P2)/P);
        int k0 = (int) (B-k2*P2-k1*P);
        
        //System.out.println("A["+A+"]=n2["+n2+"]*P^2 + n1["+n1+"]*P + n0["+n0+"]");
        //System.out.println("B["+B+"]=k2["+k2+"]*P^2 + k1["+k1+"]*P + k0["+k0+"]");

        int b2 = nCrModM(n2, k2, P);
        int b1 = nCrModM(n1, k1, P);
        int b0 = nCrModM(n0, k0, P);
        
        /*
        System.out.println("n2["+n2+"]Ck2["+k2+"] = "+b2);
        System.out.println("n1["+n1+"]Ck1["+k1+"] = "+b1);
        System.out.println("n0["+n0+"]Ck0["+k0+"] = "+b0);
        */
        
        long b = (b2*b1)%P;
        b = (b*b0)%P;
        return (int) b;
    }
    
    public static int waysMod(long N, long K, int P) {
        //if (K*2-1 > N) return 0;
        //if (K*2-1 == N) return 1;
        return binomCoeffMod(N-K+1, K, P);
    }

    public static void main(String[] args) throws Exception {
        final int P = 100003;
        Scanner kbReader = new Scanner(System.in);
        int T = kbReader.nextInt();
        while((T--)>0) {
            long N = kbReader.nextLong();
            long K = kbReader.nextLong();
            int w = waysMod(N, K, P);
            if (w < 0) {
                throw new Exception("negative answer!");
            }
            System.out.println(w);
        }
    }
}