```go
package main

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

const MaxK = 18

type Transform struct {
	out [10]uint8
	add [10]uint64
}

var identity Transform
var singleTrans [10]Transform
var full [MaxK + 1][10][2]Transform

func compose(a, b Transform) Transform {
	var r Transform
	for i := 0; i < 10; i++ {
		mid := a.out[i]
		r.out[i] = b.out[mid]
		r.add[i] = a.add[i] + b.add[mid]
	}
	return r
}

func makeSingle(m int) Transform {
	if m == 0 {
		return identity
	}
	t := identity
	for b := 0; b < 10; b++ {
		if b > 0 && m <= b {
			t.out[b] = uint8(10 - m)
			t.add[b] = 2
		} else {
			t.out[b] = uint8(10 + b - m)
			t.add[b] = 1
		}
	}
	return t
}

func build(limit uint64) Transform {
	s := strconv.FormatUint(limit, 10)
	digits := make([]int, len(s))
	for i := 0; i < len(s); i++ {
		digits[i] = int(s[i] - '0')
	}

	var dfs func(pos, p, started int) Transform
	dfs = func(pos, p, started int) Transform {
		if pos == len(digits) {
			if started == 1 {
				return singleTrans[p]
			}
			return identity
		}
		rem := len(digits) - pos - 1
		lim := digits[pos]
		res := identity
		for d := lim; d >= 0; d-- {
			ns := started
			if d > 0 {
				ns = 1
			}
			np := p
			if ns == 1 {
				if d > np {
					np = d
				}
			} else {
				np = 0
			}
			var block Transform
			if d == lim {
				block = dfs(pos+1, np, ns)
			} else {
				block = full[rem][np][ns]
			}
			res = compose(res, block)
		}
		return res
	}

	return dfs(0, 0, 0)
}

func main() {
	for i := 0; i < 10; i++ {
		identity.out[i] = uint8(i)
	}
	for i := 0; i < 10; i++ {
		singleTrans[i] = makeSingle(i)
	}
	for p := 0; p < 10; p++ {
		full[0][p][0] = identity
		full[0][p][1] = singleTrans[p]
	}
	for k := 1; k <= MaxK; k++ {
		for p := 0; p < 10; p++ {
			for st := 0; st < 2; st++ {
				res := identity
				for d := 9; d >= 0; d-- {
					ns := st
					if d > 0 {
						ns = 1
					}
					np := p
					if ns == 1 {
						if d > np {
							np = d
						}
					} else {
						np = 0
					}
					res = compose(res, full[k-1][np][ns])
				}
				full[k][p][st] = res
			}
		}
	}

	in := bufio.NewReader(os.Stdin)
	var s string
	fmt.Fscan(in, &s)
	n, _ := strconv.ParseUint(s, 10, 64)

	if n == 0 {
		fmt.Println(0)
		return
	}

	a := n / 10
	b := int(n % 10)
	tr := build(a)
	ans := tr.add[b]
	if tr.out[b] > 0 {
		ans++
	}

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprint(out, ans)
	out.Flush()
}
```