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>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
void _R(T &x) {
  cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
  _R(head);
  R(tail...);
}
template <class T>
void _W(const T &x) {
  cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
  for (auto i = x.begin(); i != x.end(); _W(*i++)) {
    if (i != x.cbegin()) putchar(' ');
  }
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
  _W(head);
  putchar(sizeof...(tail) ? ' ' : '\n');
  W(tail...);
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
  sort(begin(v), end(v), f);
  v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
inline T bit(T x, int i) {
  return (x >> i) & 1;
}
template <class T>
inline bool chkmax(T &a, const T &b) {
  return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
  return b < a ? a = b, true : false;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
inline int two(int x) { return 1 << x; }
const int L = 70;
int l, dig[L];
int64_t dp[11][L][2][1 << 10];
int64_t go(int b, int pos, bool any, int msk) {
  if (pos == -1) return msk == 0;
  int64_t &memo = dp[b][pos][any][msk];
  if (memo != -1) return memo;
  int64_t ans = 0;
  int u = (any ? b - 1 : dig[pos]);
  for (int i = (0); i <= int(u); i++)
    ans += go(b, pos - 1, any || i < u, msk ^ two(i));
  return memo = ans;
}
void conv(int b, int64_t n) {
  l = 0;
  while (n) {
    dig[l++] = n % b;
    n /= b;
  }
}
int64_t solve(int b, int64_t n) {
  if (n == 0) return 0;
  conv(b, n);
  int64_t ans = 0;
  for (int i = 0; i < int(l); i++) {
    int u = (i == l - 1 ? dig[i] : b - 1);
    for (int j = (1); j <= int(u); j++) {
      int64_t now = go(b, i - 1, (i < l - 1 || j < u), two(j));
      ans += now;
    }
  }
  return ans;
}
int main() {
  memset(dp, -1, sizeof(dp));
  int q;
  R(q);
  while (q--) {
    int b;
    int64_t lb, rb;
    R(b, lb, rb);
    auto ans = solve(b, rb) - solve(b, lb - 1);
    W(ans);
  }
  return 0;
}
