package main

import (
	"io"
	"os"
	"strconv"
)

type Precomp struct {
	free [][]uint64
	cum  []uint64
}

func countUpTo(n uint64, b int, pc *Precomp) uint64 {
	if n == 0 {
		return 0
	}
	var digits [64]int
	m := 0
	base := uint64(b)
	for n > 0 {
		digits[m] = int(n % base)
		n /= base
		m++
	}
	ans := pc.cum[m-1]
	mask := 0
	for pos := m - 1; pos >= 0; pos-- {
		cur := digits[pos]
		start := 0
		if pos == m-1 {
			start = 1
		}
		for d := start; d < cur; d++ {
			ans += pc.free[pos][mask^(1<<d)]
		}
		mask ^= 1 << cur
	}
	if mask == 0 {
		ans++
	}
	return ans
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextUint := func() uint64 {
		for idx < len(data) && data[idx] <= ' ' {
			idx++
		}
		var v uint64
		for idx < len(data) && data[idx] > ' ' {
			v = v*10 + uint64(data[idx]-'0')
			idx++
		}
		return v
	}

	const maxN uint64 = 1000000000000000000

	var pcs [11]Precomp
	for b := 2; b <= 10; b++ {
		digits := 0
		for x := maxN; x > 0; x /= uint64(b) {
			digits++
		}
		states := 1 << b
		free := make([][]uint64, digits+1)
		for i := 0; i <= digits; i++ {
			free[i] = make([]uint64, states)
		}
		free[0][0] = 1
		for l := 0; l < digits; l++ {
			cur := free[l]
			nxt := free[l+1]
			for mask, val := range cur {
				if val == 0 {
					continue
				}
				for d := 0; d < b; d++ {
					nxt[mask^(1<<d)] += val
				}
			}
		}
		cum := make([]uint64, digits+1)
		for l := 1; l <= digits; l++ {
			var cnt uint64
			for d := 1; d < b; d++ {
				cnt += free[l-1][1<<d]
			}
			cum[l] = cum[l-1] + cnt
		}
		pcs[b] = Precomp{free: free, cum: cum}
	}

	q := int(nextUint())
	out := make([]byte, 0, q*24)
	for i := 0; i < q; i++ {
		b := int(nextUint())
		l := nextUint()
		r := nextUint()
		ans := countUpTo(r, b, &pcs[b]) - countUpTo(l-1, b, &pcs[b])
		out = strconv.AppendUint(out, ans, 10)
		out = append(out, '\n')
	}
	os.Stdout.Write(out)
}