10
4 108 114
5 30 155
8 193 197
9 71 169
2 163 166
8 120 144
8 22 151
4 21 166
2 46 127
8 38 51
 20
9 142 172
7 132 256
8 245 315
9 496 496
3 345 362
8 13 162
5 342 470
9 16 488
9 467 482
4 471 478
10 92 224
6 228 261
9 54 167
2 402 409
5 9 10
7 225 360
3 438 483
6 252 342
3 491 493
6 296 367
 1
8 1234567890123 123456789012345

0
3
0
1
3
0
5
16
9
1
 0
0
0
0
4
6
13
7
0
0
1
2
3
0
0
2
12
9
1
4
 774752389568

#include <bits/stdc++.h>
using namespace std;
template <class htpe, class cmp>
using heap = priority_queue<htpe, vector<htpe>, cmp>;
template <class htpe>
using min_heap = heap<htpe, greater<htpe> >;
template <class htpe>
using max_heap = heap<htpe, less<htpe> >;
const int INF = 1791791791;
const long long INFLL = 1791791791791791791ll;
template <int input_buf_size, int output_buf_size>
class FastIO {
  char cbuf[input_buf_size + 1];
  int icur = 0;
  inline bool go_to_next_token() {
    while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
    while (cbuf[icur] == 0) {
      icur = 0;
      if (fgets(cbuf, sizeof(cbuf), stdin) != cbuf) return false;
      while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
    }
    return true;
  }

 public:
  string readString() {
    assert(go_to_next_token());
    string ans;
    while (cbuf[icur] != ' ' && cbuf[icur] != '\n' && cbuf[icur] != 0)
      ans.push_back(cbuf[icur++]);
    ans.shrink_to_fit();
    return ans;
  }
  template <class int_type>
  int_type readInt() {
    assert(go_to_next_token());
    int_type x = 0;
    bool m = cbuf[icur] == '-';
    if (m) icur++;
    while ('0' <= cbuf[icur] && cbuf[icur] <= '9') {
      x *= 10;
      x += (cbuf[icur] - '0');
      icur++;
    }
    if (m) x = -x;
    return x;
  }
  bool seekEof() { return !go_to_next_token(); }

 private:
  char obuf[output_buf_size + 1];
  int ocur = 0;
  inline void write_string(const char *str, size_t sz = 0) {
    if (sz == 0) sz = strlen(str);
    if (ocur + sz > output_buf_size) {
      fputs(obuf, stdout);
      fputs(str, stdout);
      ocur = 0;
      obuf[0] = 0;
      return;
    }
    strcpy(obuf + ocur, str);
    ocur += sz;
    obuf[ocur] = 0;
  }

 public:
  template <class int_type>
  void writeInt(int_type x, bool sp = true) {
    char buf[21];
    int c = 0;
    if (x < 0) {
      buf[c++] = '-';
      x = -x;
    }
    int s = c;
    if (x == 0) {
      buf[c++] = '0';
    }
    while (x > 0) {
      buf[c++] = (x % 10) + '0';
      x /= 10;
    }
    for (int i = 0; 2 * i < c - s; i++) {
      swap(buf[s + i], buf[c - 1 - i]);
    }
    buf[c] = 0;
    write_string(buf, c);
    if (sp) write_string(" ", 1);
  }
  void writeString(string s, bool space = true) {
    write_string(s.c_str(), s.size());
    if (space) write_string(" ", 1);
  }
  void writeEndl() { write_string("\n", 1); }
  void flush() {
    fputs(obuf, stdout);
    ocur = 0;
    obuf[0] = 0;
  }

 private:
  bool lflush;

 public:
  FastIO(bool local_flush) {
    obuf[0] = 0;
    lflush = local_flush;
  }
  ~FastIO() { fputs(obuf, stdout); }
};
FastIO<10000000, 10000000> IO(true);
const int maxb = 11;
const int maxlen = 100;
long long dp[maxb][maxlen][1 << maxb];
long long count(int b, long long mx) {
  if (mx == 0) return 1;
  vector<int> digs;
  long long cur = mx;
  while (cur > 0) {
    digs.push_back(cur % b);
    cur /= b;
  }
  reverse((digs).begin(), (digs).end());
  long long ans = 0;
  for (int i = 0; i < ((int)(digs.size())); ++i) ans += dp[b][i][0];
  int cmask = 0;
  for (int i = 0; i < ((int)(digs.size())); ++i) {
    for (int dig = (int)(i == 0); dig < ((int)(digs[i])); ++dig) {
      ans += dp[b][digs.size() - 1 - i][cmask ^ (1 << digs[i])];
    }
    cmask ^= (1 << digs[i]);
  }
  return ans;
}
int main() {
  for (int b = (int)(2); b < ((int)(maxb)); ++b) {
    dp[b][0][0] = 1;
    long double val = 1;
    for (long long len = 1; len < maxlen && val < INFLL; len++, val *= b) {
      for (int mask = 0; mask < ((int)(1 << b)); ++mask) {
        for (int dig = (int)(len == 1); dig < ((int)(b)); ++dig) {
          dp[b][len][mask] += dp[b][len - 1][mask ^ (1 << dig)];
        }
      }
    }
  }
  int q = IO.readInt<int>();
  for (int _ = 0; _ < ((int)(q)); ++_) {
    int b = IO.readInt<int>();
    long long l = IO.readInt<long long>();
    long long r = IO.readInt<long long>();
    IO.writeInt(count(b, r) - count(b, l - 1));
    IO.writeEndl();
  }
  return 0;
}
