```go
package main

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

func sumDigitsUpTo(n int64) int64 {
	if n <= 0 {
		return 0
	}

	var dfs func(pos int, tight bool, started bool, sum int) int64
	digits := make([]int, 0, 19)
	{
		x := n
		for x > 0 {
			digits = append(digits, int(x%10))
			x /= 10
		}
		for i, j := 0, len(digits)-1; i < j; i, j = i+1, j-1 {
			digits[i], digits[j] = digits[j], digits[i]
		}
	}

	mem := make([][]int64, len(digits)+1)
	for i := range mem {
		mem[i] = make([]int64, 2*9*19+1)
		for j := range mem[i] {
			mem[i][j] = -1
		}
	}

	var dp func(idx int, tight bool, started bool, sum int) (int64, int64)
	dp = func(idx int, tight bool, started bool, sum int) (int64, int64) {
		if idx == len(digits) {
			if started {
				return 1, int64(sum)
			}
			return 0, 0
		}
		if !tight {
			key := sum
			if started {
				key += 9 * 19
			}
			if mem[idx][key] != -1 {
				cnt := mem[idx][key] >> 32
				su := int64(uint64(mem[idx][key]) & ((1 << 32) - 1))
				if su&(1<<31) != 0 {
					su = su - (1 << 32)
				}
				return cnt, su
			}
		}

		limit := 9
		if tight {
			limit = digits[idx]
		}
		var cntTotal int64
		var sumTotal int64
		for dig := 0; dig <= limit; dig++ {
			ntight := tight && (dig == limit)
			nstarted := started || dig != 0
			add := 0
			if nstarted {
				add = dig
			}
			cnt, su := dp(idx+1, ntight, nstarted, sum+add)
			cntTotal += cnt
			sumTotal += su
		}

		if !tight {
			key := sum
			if started {
				key += 9 * 19
			}
			cnt := cntTotal
			su := sumTotal
			lo := int64(uint32(su))
			mem[idx][key] = (cnt << 32) | lo
		}

		return cntTotal, sumTotal
	}

	_ = dfs
	_, res := dp(0, true, false, 0)
	return res
}

func sumDigitsRange(l, r int64) int64 {
	if r < l {
		return 0
	}
	return sumDigitsUpTo(r) - sumDigitsUpTo(l-1)
}

func pow10i(d int) int64 {
	res := int64(1)
	for i := 0; i < d; i++ {
		res *= 10
	}
	return res
}

func blockDigitsSum(d int64) int64 {
	if d <= 0 {
		return 0
	}
	D := int(d)
	a := pow10i(D - 1)
	b := pow10i(D) - 1
	return sumDigitsRange(a, b)
}

func solveK(k int64) int64 {
	var ans int64
	var d int64 = 1
	for {
		a := pow10i(int(d - 1))
		b := pow10i(int(d)) - 1
		cnt := b - a + 1
		totalDigits := cnt * d
		if k >= totalDigits {
			ans += blockDigitsSum(d)
			k -= totalDigits
			d++
			continue
		}
		fullNums := k / d
		rem := k % d
		if fullNums > 0 {
			last := a + fullNums - 1
			ans += sumDigitsRange(a, last)
		}
		if rem > 0 {
			x := a + fullNums
			s := fmt.Sprintf("%d", x)
			for i := int64(0); i < rem; i++ {
				ans += int64(s[i] - '0')
			}
		}
		break
	}
	return ans
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var k int64
		fmt.Fscan(in, &k)
		fmt.Fprintln(out, solveK(k))
	}
}
```