```go
package main

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

const INF int64 = 9000000000000000000

var comb [][]int64

func addCap(a, b int64) int64 {
	if a >= INF-b {
		return INF
	}
	return a + b
}

func mulCap(a, b int64) int64 {
	if a == 0 || b == 0 {
		return 0
	}
	if a > INF/b {
		return INF
	}
	return a * b
}

func buildComb(N int) {
	comb = make([][]int64, N+1)
	for i := 0; i <= N; i++ {
		comb[i] = make([]int64, N+1)
		comb[i][0] = 1
		comb[i][i] = 1
		for j := 1; j < i; j++ {
			comb[i][j] = addCap(comb[i-1][j-1], comb[i-1][j])
		}
	}
}

func buildDPAllLengths(caps []int, N int) []int64 {
	dp := make([]int64, N+1)
	dp[0] = 1
	for d := 0; d < 16; d++ {
		newdp := make([]int64, N+1)
		limit := caps[d]
		for s := 0; s <= N; s++ {
			if dp[s] == 0 {
				continue
			}
			maxUse := limit
			if maxUse > N-s {
				maxUse = N - s
			}
			for use := 0; use <= maxUse; use++ {
				val := mulCap(dp[s], comb[s+use][use])
				newdp[s+use] = addCap(newdp[s+use], val)
			}
		}
		dp = newdp
	}
	return dp
}

func countWithCaps(caps []int, length int) int64 {
	if length < 0 {
		return 0
	}
	dp := make([]int64, length+1)
	dp[0] = 1
	for d := 0; d < 16; d++ {
		newdp := make([]int64, length+1)
		limit := caps[d]
		for s := 0; s <= length; s++ {
			if dp[s] == 0 {
				continue
			}
			maxUse := limit
			if maxUse > length-s {
				maxUse = length - s
			}
			for use := 0; use <= maxUse; use++ {
				val := mulCap(dp[s], comb[s+use][use])
				newdp[s+use] = addCap(newdp[s+use], val)
			}
		}
		dp = newdp
	}
	return dp[length]
}

func toHexDigit(d int) byte {
	if d < 10 {
		return byte('0' + d)
	}
	return byte('a' + (d - 10))
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var kInput int64
	var t int
	if _, err := fmt.Fscan(in, &kInput, &t); err != nil {
		return
	}

	Lmax := 16 * t
	buildComb(Lmax)

	capsLower := make([]int, 16)
	for i := 0; i < 16; i++ {
		capsLower[i] = t
	}
	capsLower[0] = t - 1
	dpLower := buildDPAllLengths(capsLower, Lmax-1)

	var totalSoFar int64 = 0
	L := 1
	for L = 1; L <= Lmax; L++ {
		cnt := mulCap(15, dpLower[L-1])
		if addCap(totalSoFar, cnt) < kInput {
			totalSoFar = addCap(totalSoFar, cnt)
		} else {
			break
		}
	}

	k := kInput - totalSoFar

	res := make([]byte, 0, L)
	caps := make([]int, 16)
	for i := 0; i < 16; i++ {
		caps[i] = t
	}

	cntPerDigit := dpLower[L-1]
	var idx int64 = 0
	if cntPerDigit > 0 {
		if k-1 >= 0 {
			idx = (k - 1) / cntPerDigit
		}
	}
	if idx > 14 {
		idx = 14
	}
	firstDigit := int(1 + idx)
	res = append(res, toHexDigit(firstDigit))
	caps[firstDigit]--
	k -= idx * cntPerDigit

	for pos := 1; pos < L; pos++ {
		rem := L - pos
		countPerCap := make([]int, t+1)
		for d := 0; d < 16; d++ {
			if caps[d] > 0 {
				countPerCap[caps[d]]++
			}
		}
		cntForCap := make([]int64, t+1)
		for v := 1; v <= t; v++ {
			if countPerCap[v] > 0 {
				tmp := make([]int, 16)
				copy(tmp, caps)
				for j := 0; j < 16; j++ {
					if tmp[j] == v {
						tmp[j]--
						break
					}
				}
				cntForCap[v] = countWithCaps(tmp, rem-1)
			}
		}
		for d := 0; d < 16; d++ {
			if caps[d] == 0 {
				continue
			}
			v := caps[d]
			cnt := cntForCap[v]
			if k > cnt {
				k -= cnt
			} else {
				res = append(res, toHexDigit(d))
				caps[d]--
				break
			}
		}
	}

	fmt.Println(string(res))
}
```