package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var canonical []int64

	for m := 1; m <= 9; m++ {
		val := int64(0)
		for i := 0; i < m; i++ {
			val = val*10 + 9
		}
		canonical = append(canonical, val)
	}

	for k := 0; k <= 9; k++ {
		for d := 1; d <= 8; d++ {
			if k+1 <= 9 {
				val := int64(d)
				for i := 0; i < k; i++ {
					val = val*10 + 9
				}
				canonical = append(canonical, val)
			}
		}
	}

	for L := 2; L <= 9; L++ {
		for k := 0; k <= 1; k++ {
			lenP := L - 1 - k
			if lenP < 1 {
				continue
			}
			for d := 0; d <= 8; d++ {
				for c1 := 1; c1 <= 9; c1++ {
					for m0 := 0; m0 <= lenP-1; m0++ {
						R := lenP - 1 - m0
						var genSeq func(length int, minVal int, current []int)
						genSeq = func(length int, minVal int, current []int) {
							if length == 0 {
								val := int64(c1)
								for i := 0; i < m0; i++ {
									val = val * 10
								}
								for _, digit := range current {
									val = val*10 + int64(digit)
								}
								
								if val == 90 && d != 0 {
									return
								}
								
								val = val*10 + int64(d)
								for i := 0; i < k; i++ {
									val = val*10 + 9
								}
								canonical = append(canonical, val)
								return
							}
							for v := minVal; v <= 9; v++ {
								next := make([]int, len(current)+1)
								copy(next, current)
								next[len(current)] = v
								genSeq(length-1, v, next)
							}
						}
						genSeq(R, c1, nil)
					}
				}
			}
		}
	}

	sort.Slice(canonical, func(i, j int) bool {
		return canonical[i] < canonical[j]
	})

	unique := make([]int64, 0, len(canonical))
	if len(canonical) > 0 {
		unique = append(unique, canonical[0])
		for i := 1; i < len(canonical); i++ {
			if canonical[i] != canonical[i-1] {
				unique = append(unique, canonical[i])
			}
		}
	}
	canonical = unique

	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		var n int64
		fmt.Fscan(reader, &n)

		count := sort.Search(len(canonical), func(j int) bool {
			return canonical[j] > n
		})
		fmt.Fprintln(writer, count)
	}
}