#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

vector<long> global_mod;
long mod = 100003;

long mod_factorial(long p) {
  long k = global_mod.back();
  long result = 1;
  while (true) {
    if (p % 2 ==1) {
      result = (result*k) % mod;
    }
    k = (k*k) % mod;
    p = p/2;
    if (p==0) {
      break;
    }
  }
  return result;
}

void compute_global_mod() {
  global_mod.resize(mod, 0);
  for (long i=1; i<mod; ++i) {
    if (i==1) {
      global_mod[i] = 1;
    } else {
      global_mod[i] = (global_mod[i-1]*i) % mod;
    }
  }
}

long factor_of_mod(long s, long e) {
//  cout << s << ", " << e << endl;
  long result = 0;
  long next = s + (mod-s%mod);
  if (next <= e) {
    if ((e-next+1) % mod > next % mod) {
      result += (e-next+1) / mod +1;
    } else {
      result += (e-next+1) / mod;
    }
  }
  next = s + (mod*mod-s%(mod*mod));
  if (next <= e) {
    if ((e-s+1) % (mod*mod) > next % (mod*mod)) {
      result += (e-next+1) / (mod*mod) +1;
    } else {
      result += (e-next+1) / (mod*mod);
    }  
  }
//  cout << result << endl;
  return result;
}

long compute_modulo(long s, long e) {
//  cout << s << ", " << e << endl;
  long result = 1;
  while (s % mod != 0) {
    result = (result * (s % mod)) % mod;
    if (s == e) {
      break;
    }
    ++s;
  }
//  cout << "int: " << result << endl;
  result = (result * mod_factorial((e-s+1)/mod)) % mod;
  if (e % mod != 0 && s < e) {
    result = (result * global_mod[e % mod]) % mod;
  }
  long mod_s;
  long mod_e;
  if (s % mod == 0) {
    mod_s = s/mod;
  } else {
    mod_s = s/mod+1;
  }
  mod_e = e/mod;
  if (mod_s <= mod_e) {
    result = (result * compute_modulo(mod_s, mod_e))%mod;
  }
//  cout << mod_s << ", " << mod_e << endl;
//  cout << result << endl;
  return result;
}

long extended_euclidean(long m, long n) {
  long mmax = m > n ? m : n;
  long mmin = m > n ? n : m;
  long r;
  long s0 = 1;
  long s1 = 0;
  long t0 = 0;
  long t1 = 1;
  long s_tmp, t_tmp;
  while (true) {
    r = mmax % mmin;
    if (r==0) {
      break;
    }
    s_tmp = s0-s1*(mmax/mmin);
    t_tmp = t0-t1*(mmax/mmin);
    s0 = s1;
    s1 = s_tmp;
    t0 = t1;
    t1 = t_tmp;
//    cout << mmax/mmin << ":" << s1 << ", " << t1 << endl;
    mmax = mmin;
    mmin = r;
  }
//  cout << s1 << " * " <<  (m>n ? m:n) << " + " << t1 << " * " << (m>n ? n:m) << endl;
  return m > n ? s1 : t1;
}

long N_choose_K(long N, long K) {
  if (K == 0 || K == N) {
    return 1;
  }
  K = (K > N-K) ? N-K : K;
  long result = 1;
  long div = 1;
  int c = factor_of_mod(1, K);
  div *= compute_modulo(1, K);
//  cout << c << endl;
  c -= factor_of_mod(N-K+1, N);
  result *= compute_modulo(N-K+1, N);
//  cout << c << endl;
//  cout << result << " " << div << endl;
  if (c < 0) {
    return 0;
  } else {
//    cout << extended_euclidean(div, mod) << endl;
    result = (extended_euclidean(div, mod)*result) % mod;
    return result >= 0 ? result : result + mod;
  }
}

int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
  int T;
  cin >> T;
  long N, K;
  long tmp;
  compute_global_mod();
  for (int i=0; i<T; ++i) {
    cin >> N >> K;
    if ((N-K)-K+1 < 0) {
      cout << 0 << endl;
      continue;
    } else {
      tmp = (N-K)-K+1;
      cout << N_choose_K(tmp+K, tmp) << endl;
    }
  }
  return 0;
}