#include <bits/stdc++.h>
using namespace std;
int mod = 7340033;
namespace FFT {
using ld = long double;
const ld PI = acos(-1.0);
struct comp {
  ld a, b;
  comp(ld a = 0, ld b = 0) : a(a), b(b) {}
  inline comp operator+(const comp &c) const { return comp(a + c.a, b + c.b); }
  inline comp operator-(const comp &c) const { return comp(a - c.a, b - c.b); }
  inline comp operator*(const comp &c) const {
    return comp(a * c.a - b * c.b, a * c.b + b * c.a);
  }
  inline comp operator/(const ld &c) const { return comp(a / c, b / c); }
  inline comp conj() { return comp(a, -b); }
};
void fft(vector<comp> &p, bool inv = 0) {
  int n = (int)p.size(), i = 0;
  for (int j = 1; j < n - 1; ++j) {
    for (int k = n >> 1; k > (i ^= k); k >>= 1)
      ;
    if (j < i) swap(p[i], p[j]);
  }
  for (int l = 1, m; (m = l << 1) <= n; l <<= 1) {
    ld ang = 2 * PI / m;
    comp wn = comp(cos(ang), (inv ? 1. : -1.) * sin(ang)), w;
    for (int i = 0, j, k; i < n; i += m) {
      for (w = comp(1, 0), j = i, k = i + l; j < k; ++j, w = w * wn) {
        comp t = w * p[j + l];
        p[j + l] = p[j] - t;
        p[j] = p[j] + t;
      }
    }
  }
  if (inv)
    for (int i = 0; i < n; ++i) p[i] = p[i] / ld(n);
}
template <typename T>
vector<T> multiply(const vector<T> &A, const vector<T> &B) {
  int n = (int)B.size(), m = (int)B.size(), t = n + m - 1, sz = 1;
  while (sz < t) sz <<= 1;
  vector<comp> x(sz), y(sz), z(sz);
  for (int i = 0; i < sz; i++) {
    x[i] = i < n ? comp(A[i], 0) : comp(0, 0);
    y[i] = i < m ? comp(B[i], 0) : comp(0, 0);
  }
  fft(x), fft(y);
  for (int i = 0; i < sz; i++) z[i] = x[i] * y[i];
  fft(z, 1);
  vector<T> ret(sz);
  for (int i = 0; i < sz; i++) ret[i] = z[i].a + 0.5;
  return ret;
}
vector<int> multiply(vector<int> &A, vector<int> &B, const int mod) {
  int mask = sqrt(mod), shift = 15;
  while ((1 << shift) < mask) shift++;
  mask = (1 << shift) - 1;
  int n = (int)A.size(), m = (int)B.size(), t = n + m - 1, sz = 1;
  while (sz < t) sz <<= 1;
  vector<comp> a(sz), b(sz), c(sz), d(sz);
  for (int i = 0; i < sz; i++) {
    a[i] = i < n ? comp(A[i] & mask, A[i] >> shift) : comp(0, 0);
    b[i] = i < m ? comp(B[i] & mask, B[i] >> shift) : comp(0, 0);
  }
  fft(a);
  fft(b);
  comp c0, c1, d0, d1, aj, bj, m1(0.5, 0), m2(0, -0.5);
  for (int i = 0, j = 0; i < sz; i++, --j < 0 && (j += sz)) {
    aj = a[j].conj(), bj = b[j].conj();
    c0 = (a[i] + aj) * m1;
    c1 = (a[i] - aj) * m2;
    d0 = (b[i] + bj) * m1;
    d1 = (b[i] - bj) * m2;
    c[i] = c0 * d0 + comp(0, 1) * c1 * d1;
    d[i] = c0 * d1 + d0 * c1;
  }
  fft(c, 1);
  fft(d, 1);
  vector<int> ret(sz);
  int64_t a0, a1, a2;
  for (int i = 0; i < sz; i++) {
    a0 = c[i].a + 0.5, a1 = d[i].a + 0.5;
    a2 = c[i].b + 0.5;
    ret[i] = (a0 + (a1 % mod << shift) + (a2 % mod << 2 * shift)) % mod;
  }
  return ret;
}
}  // namespace FFT
int dp[32][3002];
vector<int> a;
int main() {
  int i, j, k, l, m, n;
  dp[0][0] = 1;
  for (int i = 1; i <= 30; i++) {
    a = vector<int>(dp[i - 1], dp[i - 1] + 1001);
    a = FFT::multiply(a, a, mod);
    a.resize(1001);
    a = FFT::multiply(a, a, mod);
    for (int j = 1000; j > 0; j--) {
      dp[i][j] = a[j - 1];
    }
    dp[i][0] = 1;
  }
  int ts;
  cin >> ts;
  while (ts--) {
    scanf("%d%d", &n, &k);
    m = 0;
    while (n > 1 && n % 2 == 1) {
      m++;
      n = n / 2;
    }
    printf("%d\n", dp[m][k]);
  }
}
