Suppose you have a special $x$-$y$-counter. This counter can store some value as a decimal number; at first, the counter has value $0$. 

The counter performs the following algorithm: it prints its lowest digit and, after that, adds either $x$ or $y$ to its value. So all sequences this counter generates are starting from $0$. For example, a $4$-$2$-counter can act as follows:  it prints $0$, and adds $4$ to its value, so the current value is $4$, and the output is $0$;  it prints $4$, and adds $4$ to its value, so the current value is $8$, and the output is $04$;  it prints $8$, and adds $4$ to its value, so the current value is $12$, and the output is $048$;  it prints $2$, and adds $2$ to its value, so the current value is $14$, and the output is $0482$;  it prints $4$, and adds $4$ to its value, so the current value is $18$, and the output is $04824$. 

This is only one of the possible outputs; for example, the same counter could generate $0246802468024$ as the output, if we chose to add $2$ during each step.

You wrote down a printed sequence from one of such $x$-$y$-counters. But the sequence was corrupted and several elements from the sequence could be erased.

Now you'd like to recover data you've lost, but you don't even know the type of the counter you used. You have a decimal string $s$ — the remaining data of the sequence. 

For all $0 \le x, y < 10$, calculate the minimum number of digits you have to insert in the string $s$ to make it a possible output of the $x$-$y$-counter. Note that you can't change the order of digits in string $s$ or erase any of them; only insertions are allowed.


-----Input-----

The first line contains a single string $s$ ($1 \le |s| \le 2 \cdot 10^6$, $s_i \in \{\text{0} - \text{9}\}$) — the remaining data you have. It's guaranteed that $s_1 = 0$.


-----Output-----

Print a $10 \times 10$ matrix, where the $j$-th integer ($0$-indexed) on the $i$-th line ($0$-indexed too) is equal to the minimum number of digits you have to insert in the string $s$ to make it a possible output of the $i$-$j$-counter, or $-1$ if there is no way to do so.


-----Example-----
Input
0840

Output
-1 17 7 7 7 -1 2 17 2 7 
17 17 7 5 5 5 2 7 2 7 
7 7 7 4 3 7 1 7 2 5 
7 5 4 7 3 3 2 5 2 3 
7 5 3 3 7 7 1 7 2 7 
-1 5 7 3 7 -1 2 9 2 7 
2 2 1 2 1 2 2 2 0 1 
17 7 7 5 7 9 2 17 2 3 
2 2 2 2 2 2 0 2 2 2 
7 7 5 3 7 7 1 3 2 7 



-----Note-----

Let's take, for example, $4$-$3$-counter. One of the possible outcomes the counter could print is $0(4)8(1)4(7)0$ (lost elements are in the brackets).

One of the possible outcomes a $2$-$3$-counter could print is $0(35)8(1)4(7)0$.

The $6$-$8$-counter could print exactly the string $0840$.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Dynamic programming

Complete search

Shortest paths


Solutions:
import sys
from collections import defaultdict
input = sys.stdin.readline
import math

def main():
	s = input().rstrip()
	opt = [[[[math.inf for _ in range(10)] for _ in range(10)] for _ in range(10)] for _ in range(10)]
	pairs = [[0 for _ in range(10)] for _ in range(10)]
	for x in range(10):
		for y in range(10):
			for a in range(10):
				for cntx in range(10):
					for cnty in range(10):
						dig = (a + cntx * x + cnty * y) % 10
						if cntx + cnty > 0:
							opt[x][y][a][dig] = min(opt[x][y][a][dig], cntx + cnty)
	for i in range(1, len(s)):
		pairs[int(s[i - 1])][int(s[i])] += 1
	res = [[0 for _ in range(10)] for _ in range(10)]
	for x in range(10):
		for y in range(10):
			for p1 in range(10):
				for p2 in range(10):
					p = pairs[p1][p2]
					if p > 0:
						if opt[x][y][p1][p2] == math.inf:
							res[x][y] = -1
						elif res[x][y] != -1:
							res[x][y] += p * (opt[x][y][p1][p2] - 1)
	for x in range(10):
		print(*res[x])

def __starting_point():
	main()
__starting_point()


s = input()
pairs = {a + b: 0 for a in '0123456789' for b in '0123456789'}
for (a, b) in zip(s, s[1:]):
	pairs[a + b] += 1

def solve(x, y, i, j):
	ans = 20
	for a in range(10):
		for b in range(10):
			if (i + a * x + b * y + x) % 10 == j:
				ans = min(ans, a + b)
			if (i + a * x + b * y + y) % 10 == j:
				ans = min(ans, a + b)
	if ans == 20:
		return -1
	return ans
for x in range(10):
	row = []
	for y in range(10):
		ans = 0
		for i in range(10):
			for j in range(10):
				s = f'{i}{j}'
				if pairs[s] > 0:
					tmp = solve(x, y, i, j)
					ans += tmp * pairs[s]
					if tmp == -1:
						ans = -1
						break
			else:
				continue
			break
		row.append(ans)
	print(*row)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def main():
	vals = [int(k) for k in input()]
	n = len(vals)
	store = [[[[-1 for s in range(10)] for i in range(10)] for j in range(10)] for k in range(10)]
	for p1 in range(10):
		for p2 in range(10):
			for num1 in range(10):
				for num2 in range(num1, 10):
					minans = 99999
					for coef1 in range(11):
						for coef2 in range(11):
							if (p1 + coef1 * num1 + coef2 * num2) % 10 == p2 and (coef1 > 0 or coef2 > 0):
								minans = min(minans, max(coef1 + coef2 - 1, 0))
					if minans != 99999:
						store[p1][p2][num1][num2] = minans
						store[p1][p2][num2][num1] = minans
	ans = [[-1 for s in range(10)] for j in range(10)]
	for num1 in range(10):
		for num2 in range(num1, 10):
			count = 0
			broke = False
			for i in range(n - 1):
				if store[vals[i]][vals[i + 1]][num1][num2] != -1:
					count += store[vals[i]][vals[i + 1]][num1][num2]
				else:
					broke = True
					break
			if broke == False:
				ans[num1][num2] = count
				ans[num2][num1] = count
	for i in range(10):
		print(*ans[i])
main()


import sys
input = sys.stdin.readline
s = list(map(int, input().strip()))
a = len(s)
ans = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for _ in range(10)]
h = [[[1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [1, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, -1, 1, -1, 2, -1, 3, -1, 4, -1], [1, 7, 4, 1, 8, 5, 2, 9, 6, 3], [1, -1, 3, -1, 1, -1, 4, -1, 2, -1], [1, -1, -1, -1, -1, 1, -1, -1, -1, -1], [1, -1, 2, -1, 4, -1, 1, -1, 3, -1], [1, 3, 6, 9, 2, 5, 8, 1, 4, 7], [1, -1, 4, -1, 3, -1, 2, -1, 1, -1], [1, 9, 8, 7, 6, 5, 4, 3, 2, 1]], [[1, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 1, 2, 3, 4, 5, 6, 7, 8, 9], [5, 1, 1, 2, 2, 3, 3, 4, 4, 5], [4, 1, 2, 1, 2, 3, 2, 3, 4, 3], [4, 1, 2, 3, 1, 2, 3, 4, 2, 3], [2, 1, 2, 3, 4, 1, 2, 3, 4, 5], [5, 1, 2, 3, 4, 5, 1, 2, 3, 4], [4, 1, 2, 3, 2, 3, 4, 1, 2, 3], [3, 1, 2, 3, 3, 4, 2, 3, 1, 2], [2, 1, 2, 3, 4, 5, 4, 3, 2, 1]], [[1, -1, 1, -1, 2, -1, 3, -1, 4, -1], [5, 1, 1, 2, 2, 3, 3, 4, 4, 5], [5, -1, 1, -1, 2, -1, 3, -1, 4, -1], [4, 4, 1, 1, 2, 2, 2, 3, 3, 3], [3, -1, 1, -1, 1, -1, 2, -1, 2, -1], [2, 4, 1, 5, 2, 1, 3, 2, 4, 3], [3, -1, 1, -1, 2, -1, 1, -1, 2, -1], [5, 3, 1, 4, 2, 5, 3, 1, 4, 2], [2, -1, 1, -1, 2, -1, 2, -1, 1, -1], [3, 2, 1, 3, 2, 4, 3, 3, 2, 1]], [[1, 7, 4, 1, 8, 5, 2, 9, 6, 3], [4, 1, 2, 1, 2, 3, 2, 3, 4, 3], [4, 4, 1, 1, 2, 2, 2, 3, 3, 3], [10, 7, 4, 1, 8, 5, 2, 9, 6, 3], [3, 3, 3, 1, 1, 4, 2, 2, 2, 3], [2, 3, 4, 1, 4, 1, 2, 5, 2, 3], [5, 4, 2, 1, 4, 3, 1, 5, 3, 2], [2, 3, 4, 1, 2, 5, 2, 1, 4, 3], [5, 2, 4, 1, 3, 5, 2, 4, 1, 3], [4, 3, 2, 1, 4, 3, 2, 3, 2, 1]], [[1, -1, 3, -1, 1, -1, 4, -1, 2, -1], [4, 1, 2, 3, 1, 2, 3, 4, 2, 3], [3, -1, 1, -1, 1, -1, 2, -1, 2, -1], [3, 3, 3, 1, 1, 4, 2, 2, 2, 3], [5, -1, 3, -1, 1, -1, 4, -1, 2, -1], [2, 5, 3, 3, 1, 1, 4, 4, 2, 2], [2, -1, 2, -1, 1, -1, 1, -1, 2, -1], [5, 2, 3, 5, 1, 3, 4, 1, 2, 4], [3, -1, 2, -1, 1, -1, 2, -1, 1, -1], [5, 4, 3, 2, 1, 5, 4, 3, 2, 1]], [[1, -1, -1, -1, -1, 1, -1, -1, -1, -1], [2, 1, 2, 3, 4, 1, 2, 3, 4, 5], [2, 4, 1, 5, 2, 1, 3, 2, 4, 3], [2, 3, 4, 1, 4, 1, 2, 5, 2, 3], [2, 5, 3, 3, 1, 1, 4, 4, 2, 2], [2, -1, -1, -1, -1, 1, -1, -1, -1, -1], [2, 2, 2, 4, 4, 1, 1, 3, 3, 5], [2, 3, 2, 5, 2, 1, 4, 1, 4, 3], [2, 3, 4, 2, 3, 1, 2, 5, 1, 4], [2, 5, 4, 3, 2, 1, 4, 3, 2, 1]], [[1, -1, 2, -1, 4, -1, 1, -1, 3, -1], [5, 1, 2, 3, 4, 5, 1, 2, 3, 4], [3, -1, 1, -1, 2, -1, 1, -1, 2, -1], [5, 4, 2, 1, 4, 3, 1, 5, 3, 2], [2, -1, 2, -1, 1, -1, 1, -1, 2, -1], [2, 2, 2, 4, 4, 1, 1, 3, 3, 5], [5, -1, 2, -1, 4, -1, 1, -1, 3, -1], [3, 3, 2, 2, 2, 4, 1, 1, 3, 3], [3, -1, 2, -1, 2, -1, 1, -1, 1, -1], [4, 3, 2, 4, 3, 2, 1, 3, 2, 1]], [[1, 3, 6, 9, 2, 5, 8, 1, 4, 7], [4, 1, 2, 3, 2, 3, 4, 1, 2, 3], [5, 3, 1, 4, 2, 5, 3, 1, 4, 2], [2, 3, 4, 1, 2, 5, 2, 1, 4, 3], [5, 2, 3, 5, 1, 3, 4, 1, 2, 4], [2, 3, 2, 5, 2, 1, 4, 1, 4, 3], [3, 3, 2, 2, 2, 4, 1, 1, 3, 3], [10, 3, 6, 9, 2, 5, 8, 1, 4, 7], [4, 3, 3, 3, 2, 2, 2, 1, 1, 4], [4, 3, 4, 3, 2, 3, 2, 1, 2, 1]], [[1, -1, 4, -1, 3, -1, 2, -1, 1, -1], [3, 1, 2, 3, 3, 4, 2, 3, 1, 2], [2, -1, 1, -1, 2, -1, 2, -1, 1, -1], [5, 2, 4, 1, 3, 5, 2, 4, 1, 3], [3, -1, 2, -1, 1, -1, 2, -1, 1, -1], [2, 3, 4, 2, 3, 1, 2, 5, 1, 4], [3, -1, 2, -1, 2, -1, 1, -1, 1, -1], [4, 3, 3, 3, 2, 2, 2, 1, 1, 4], [5, -1, 4, -1, 3, -1, 2, -1, 1, -1], [5, 5, 4, 4, 3, 3, 2, 2, 1, 1]], [[1, 9, 8, 7, 6, 5, 4, 3, 2, 1], [2, 1, 2, 3, 4, 5, 4, 3, 2, 1], [3, 2, 1, 3, 2, 4, 3, 3, 2, 1], [4, 3, 2, 1, 4, 3, 2, 3, 2, 1], [5, 4, 3, 2, 1, 5, 4, 3, 2, 1], [2, 5, 4, 3, 2, 1, 4, 3, 2, 1], [4, 3, 2, 4, 3, 2, 1, 3, 2, 1], [4, 3, 4, 3, 2, 3, 2, 1, 2, 1], [5, 5, 4, 4, 3, 3, 2, 2, 1, 1], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]]]
for i in range(10):
	for j in range(i, 10):
		cnt = 0
		flag = True
		l = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
		for m in range(a - 1):
			diff = s[m + 1] - s[m]
			if diff < 0:
				diff += 10
			l[diff] += 1
		for p in range(10):
			if l[p] != 0:
				temp = h[i][j][p]
				if temp == -1:
					flag = False
					break
				else:
					cnt += (temp - 1) * l[p]
		if flag:
			ans[i][j] = ans[j][i] = cnt
		else:
			ans[i][j] = ans[j][i] = -1
for x in ans:
	print(*x)


from collections import *
s = input()
c = Counter(((ord(y) - ord(x)) % 10 for (x, y) in zip(s, s[1:])))
r = [0] * 100
for i in range(100):
	a = [-1] * 11
	q = [10]
	while q:
		x = q.pop(0)
		for j in (i // 10, i % 10):
			y = (x + j) % 10
			if a[y] < 0:
				a[y] = a[x] + 1
				q += (y,)
	for x in c:
		r[i] = -(r[i] < 0 or a[x] < 0 or -r[i] - c[x] * a[x])
print(*r)


import sys
s = sys.stdin.readline().strip()
if s[0] != '0':
	s = '0' + s
ans = [[[10 ** 9 for i in range(0, 10)] for j in range(0, 10)] for k in range(0, 10)]
for n in range(0, 20):
	for i in range(0, 10):
		for j in range(0, 10):
			for k in range(0, 10):
				if k == i or k == j:
					ans[i][j][k] = 1
				else:
					ans[i][j][k] = min([ans[i][j][k], 1 + ans[i][j][(k - i + 10) % 10], 1 + ans[i][j][(k - j + 10) % 10]])
x = [0] * 10
for i in range(0, len(s) - 1):
	x[(int(s[i + 1]) - int(s[i]) + 10) % 10] = x[(int(s[i + 1]) - int(s[i]) + 10) % 10] + 1
for i in range(0, 10):
	ans2 = [0] * 10
	for j in range(0, 10):
		for k in range(0, 10):
			ans2[j] = ans2[j] + (ans[i][j][k] - 1) * x[k]
		if ans2[j] >= 10 ** 8:
			ans2[j] = -1
	print(' '.join(list(map(str, ans2))))


from itertools import product

def main():
	(a, cnt, res, hbb) = (48, [-1] + [0] * 18, {}, [])
	for b in map(ord, input()):
		cnt[b - a] += 1
		a = b
	for i in range(9, 0, -1):
		cnt[i] += cnt.pop()
	cnt = [z for z in enumerate(cnt) if z[1]]
	for a in range(10):
		dist = [0] * 10
		for t in range(1, 11):
			x = a * t % 10
			if dist[x]:
				break
			dist[x] = t
		ha = [*(z for z in enumerate(dist) if z[1]), (0, 0)]
		hbb.append(ha)
		for (b, hb) in enumerate(hbb):
			dist = [99999999] * 10
			for ((x, t), (y, u)) in product(ha, hb):
				x = (x + y) % 10
				t += u
				if 0 < t <= dist[x]:
					dist[x] = t - 1
			t = sum((c * dist[x] for (x, c) in cnt))
			res[a, b] = res[b, a] = t if t < 99999999 else -1
	for a in range(10):
		print(*[res[a, b] for b in range(10)])
main()


from sys import stdin, stdout
from itertools import accumulate
s = input()

def computeGCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
record = {}
for x in range(10):
	for y in range(10):
		for d in range(10):
			m = 9999
			if (x == 0 or y == 0) and d == 0:
				record[x, y, d] = 0
			elif x == 0 and y == 0 and (d != 0):
				record[x, y, d] = -1
			else:
				for k in range(10):
					d_tmp = d + 10 * k
					if x == 0:
						if d_tmp % y == 0:
							record[x, y, d] = d_tmp // y - 1
							break
					elif y == 0:
						if d_tmp % x == 0:
							record[x, y, d] = d_tmp // x - 1
							break
					else:
						for a in range(d_tmp // x + 1):
							for b in range(d_tmp // y + 1):
								if x * a + y * b == d_tmp and d_tmp != 0:
									m = min(m, a + b - 1)
				if (x, y, d) not in record:
					if m == 9999:
						m = -1
					record[x, y, d] = m
data = [[0] * 10 for _ in range(10)]
len_s = len(s)
s = list(s)
freq = [0] * 10
for i in range(len_s - 1):
	A = s[i]
	B = s[i + 1]
	d = ord(B) - ord(A)
	if d < 0:
		d += 10
	freq[d] += 1
for x in range(10):
	for y in range(10):
		for d in range(10):
			if freq[d] == 0:
				data[x][y] += 0
			elif record[x, y, d] == -1:
				data[x][y] = -10000000
			else:
				data[x][y] += freq[d] * record[x, y, d]
for x in range(10):
	for y in range(10):
		if data[x][y] < 0:
			print(-1, end=' ')
		else:
			print(data[x][y], end=' ')
	print('', end='\n')


from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations
import sys
import bisect
sys.setrecursionlimit(10 ** 6)

def SI():
	return input().split()

def MI():
	return map(int, input().split())

def I():
	return int(input())

def LI():
	return [int(i) for i in input().split()]
YN = ['Yes', 'No']
YNeos = 'YNeos'
GYN = ['Yes', 'trumpet']
mo = 10 ** 9 + 7
imp = 'IMPOSSIBLE'
s = list(input())
di = defaultdict(int)
for i in range(len(s) - 1):
	di[int(s[i]), int(s[i + 1])] += 1
mp = [[[[0] * 10 for i in range(10)] for j in range(10)] for k in range(10)]
for h in range(10):
	for w in range(10):
		for x in range(10):
			for y in range(10):
				zm = 10 ** 3
				for nx in range(11):
					for ny in range(11):
						if nx + ny == 0:
							continue
						if (x * nx + y * ny - (w - h)) % 10 == 0:
							zm = min(zm, nx + ny - 1)
				if zm < 30:
					zz = zm
				else:
					zz = -1
				mp[h][w][x][y] = zz
ans = [[0] * 10 for i in range(10)]
for x in range(10):
	for y in range(10):
		for i in di.items():
			if mp[i[0][0]][i[0][1]][x][y] == -1:
				ans[x][y] = -1
				break
			ans[x][y] += mp[i[0][0]][i[0][1]][x][y] * i[1]
for j in range(10):
	print(*ans[j])


from collections import *
a = []
for i in range(100):
	b = [-1] * 10
	l = [0]
	k = 0
	while l:
		m = []
		for x in l:
			for j in (i // 10, i % 10):
				y = (x + j) % 10
				if b[y] < 0:
					b[y] = k
					m += (y,)
		l = m
		k += 1
	a += (b,)
s = (*map(int, input()),)
c = Counter(((y - x) % 10 for (x, y) in zip(s, s[1:])))
r = [0] * 100
for x in c:
	for i in range(100):
		if r[i] >= 0:
			d = a[i][x]
			r[i] = d if d < 0 else r[i] + c[x] * d
print(*r)


def findMoves(x, y, p, q):
	res = 21
	for i in range(11):
		for j in range(11):
			if i > 0 or j > 0:
				if (x + i * p + j * q) % 10 == y:
					res = min(i + j - 1, res)
	if res == 21:
		return -1
	return res

def calc(p, q):
	ans = 0
	for i in range(10):
		for j in range(10):
			if count[i][j] > 0:
				moves = findMoves(i, j, p, q)
				if moves == -1:
					return -1
				else:
					ans += moves * count[i][j]
	return ans
s = str(input())
n = len(s)
count = [[0] * 10 for i in range(10)]
for i in range(n - 1):
	j = int(s[i])
	k = int(s[i + 1])
	count[j][k] += 1
answer = [[0] * 10 for i in range(10)]
for i in range(10):
	for j in range(10):
		answer[i][j] = calc(i, j)
	print(' '.join((str(x) for x in answer[i])))


inf = 1000000000
string = input()
s = []
for i in range(string.__len__()):
	s.append(int(string[i]))
cf = [[0] * 10 for i in range(10)]
for i in range(1, s.__len__()):
	cf[s[i - 1]][s[i]] += 1
for x in range(10):
	for y in range(10):
		ds = [[inf + 7] * 10 for i in range(10)]
		for v in range(10):
			for cx in range(10):
				for cy in range(10):
					if cx + cy == 0:
						continue
					to = (v + cx * x + cy * y) % 10
					ds[v][to] = min(ds[v][to], cx + cy)
		res = 0
		for v in range(10):
			for to in range(10):
				if ds[v][to] > inf and cf[v][to] > 0:
					res = -1
					break
				res += (ds[v][to] - 1) * cf[v][to]
			if res == -1:
				break
		print(res, end=' ')
	print()


s = list(map(int, input()))
ans = [[0] * 10 for i in range(10)]
for i in range(10):
	for j in range(i + 1):
		arr = [1000] * 10
		for i1 in range(10):
			for j1 in range(i1 == 0, 10):
				st = (i * i1 + j * j1) % 10
				arr[st] = min(arr[st], i1 + j1 - 1)
		for e in range(1, len(s)):
			cur = (s[e] - s[e - 1]) % 10
			if arr[cur] != 1000:
				ans[i][j] += arr[cur]
			else:
				ans[i][j] = -1
				break
		ans[j][i] = ans[i][j]
for i in ans:
	print(*i)


n = input()
cache = {}

def solve(a, b, c):
	if a == b == 0:
		if c == 0:
			return 1
		else:
			return None
	if a > b:
		(a, b) = (b, a)
	if (a, b, c) in cache:
		return cache[a, b, c]
	for i in range(b + 1):
		j = -1
		while True:
			j += 1
			x = c + i * 10 - a * j
			if x < 0:
				break
			if x % b == 0:
				y = x // b
				if y == 0 and a == 0:
					y = 1
				v = cache.get((a, b, c))
				if j + y > 0 and (v is None or j + y < v):
					cache[a, b, c] = j + y
			if a == 0:
				break
	cache.setdefault((a, b, c), None)
	return cache.get((a, b, c))
x = 0
table = {}
for y in n[1:]:
	y = int(y)
	z = (10 + y - x) % 10
	x = y
	ti = table.get(z, 0)
	ti += 1
	table[z] = ti
for i in range(10):
	for j in range(10):
		s = 0
		for (z, ti) in table.items():
			k = solve(i, j, z)
			if k is None:
				print(f'{-1:>10}', end='')
				break
			else:
				s += k * ti
		else:
			print(f'{s - len(n) + 1:>10}', end='')
	print()


from sys import stdin
from sys import setrecursionlimit as SRL
SRL(10 ** 7)
rd = stdin.readline
rrd = lambda : list(map(int, rd().strip().split()))
s = str(rd().strip())
ans = [[0] * 11 for _j in range(11)]
ddp = [[[100000] * 11 for _k in range(11)] for kk in range(11)]
tt = [0] * 11
for i in range(10):
	for j in range(10):
		for u in range(11):
			for v in range(11):
				if u == 0 and v == 0:
					continue
				k = (i * u + j * v) % 10
				ddp[i][j][k] = min(ddp[i][j][k], max(0, u + v - 1))
pre = 0
for i in range(1, len(s)):
	t = (int(s[i]) + 10 - pre) % 10
	tt[t] += 1
	pre = int(s[i])
for i in range(10):
	asi = ''
	for j in range(10):
		for k in range(11):
			if tt[k] and ddp[i][j][k] >= 80000:
				ans[i][j] = -1
				break
			ans[i][j] += tt[k] * ddp[i][j][k]
		asi = asi + str(ans[i][j]) + ' '
	print(asi)


s = input()
mp = [0] * 10
for i in range(1, len(s)):
	x = (int(s[i]) - int(s[i - 1]) + 10) % 10
	mp[x] += 1

def tab(a, b):
	tb = [1000] * 10
	for i in range(10):
		for j in range(10):
			if i == 0 and j == 0:
				continue
			x = (a * i + b * j) % 10
			tb[x] = min(tb[x], i + j)
	return tb
for x in range(10):
	for y in range(10):
		tb = tab(x, y)
		ans = 0
		for t in range(10):
			if mp[t] > 0 and tb[t] == 1000:
				print(-1, end=' ')
				break
			ans += mp[t] * (tb[t] - 1)
		else:
			print(ans, end=' ')
	print()


import sys
d = [int(i) for i in input()]
data = [(d[i + 1] - d[i]) % 10 for i in range(len(d) - 1)]
cnt = [0] * 10
for d in data:
	cnt[d] += 1
for i in range(10):
	for j in range(10):
		row = [32] * 10
		for a in range(10):
			for b in range(10):
				val = (a * i + b * j) % 10
				s = a + b
				if s > 0 and s < row[val]:
					row[val] = s
		for k in range(10):
			if row[k] == 32:
				row[k] = -1
			else:
				row[k] -= 1
		ans = 0
		for c in range(10):
			inc = row[c]
			if inc == -1 and cnt[c] > 0:
				ans = -1
				break
			ans += inc * cnt[c]
		sys.stdout.write(str(ans) + ' ')
	sys.stdout.write('\n')


import sys
input = lambda : sys.stdin.readline().strip()
s = input()
num = {}
for i in range(10):
	num[i] = 0
for i in range(len(s) - 1):
	num[(int(s[i + 1]) - int(s[i])) % 10] += 1
for x in range(10):
	for y in range(10):
		d = {}
		for i in range(10):
			d[i] = sys.maxsize
		for i in range(10):
			for j in range(10):
				if i + j == 0:
					continue
				cur = (i * x + j * y) % 10
				d[cur] = min(d[cur], i + j)
		ans = 0
		for i in range(10):
			if d[i] == sys.maxsize and num[i] > 0:
				break
			ans += num[i] * (d[i] - 1)
		else:
			print(ans, end=' ')
			continue
		print(-1, end=' ')
	print()


from collections import deque
from functools import lru_cache

@lru_cache(maxsize=None)
def helper(a, b):
	m = {}
	queue = deque([(0, 0)])
	while queue:
		(cur, cnt) = queue[0]
		queue.popleft()
		cura = (cur + a) % 10
		curb = (cur + b) % 10
		if cura not in m:
			m[cura] = cnt + 1
			queue.append((cura, cnt + 1))
		if curb not in m:
			m[curb] = cnt + 1
			queue.append((curb, cnt + 1))
	return m
s = list(map(int, input()))
ans = [[0] * 10 for i in range(10)]
for i in range(10):
	for j in range(i, 10):
		m = helper(min(i, j), max(i, j))
		cnt = 0
		for k in range(len(s) - 1):
			dis = ((s[k + 1] - s[k]) % 10 + 10) % 10
			if cnt == -1 or dis not in m:
				cnt = -1
			else:
				cnt += m[dis] - 1
		ans[i][j] = cnt
		ans[j][i] = cnt
for i in range(10):
	print(' '.join(map(str, ans[i])))


from collections import *
s = (*map(int, input()),)
c = Counter(((y - x) % 10 for (x, y) in zip(s, s[1:])))
r = [0] * 100
for i in range(100):
	a = [-1] * 11
	q = [10]
	while q:
		x = q.pop(0)
		for j in (i // 10, i % 10):
			y = (x + j) % 10
			if a[y] < 0:
				a[y] = a[x] + 1
				q += (y,)
	for x in c:
		if r[i] >= 0:
			r[i] = -1 if a[x] < 0 else r[i] + c[x] * a[x]
print(*r)


import sys
from collections import Counter
input = sys.stdin.readline
t = str(input())[:-1]
if len(t) == 1:
	for i in range(10):
		print(*[0] * 10)
else:
	diff = [(int(t[k + 1]) - int(t[k])) % 10 for k in range(len(t) - 1)]
	cnt = Counter(diff)
	arr = [[0 for _ in range(10)] for _ in range(10)]
	for x in range(10):
		for y in range(10):
			d = {}
			for i in range(10):
				for j in range(10):
					if i + j != 0:
						d[(x * i + y * j) % 10] = min(i + j - 1, d.get((x * i + y * j) % 10, i + j - 1))
			for el in cnt.keys():
				if el not in d:
					arr[x][y] = -1
					break
				else:
					arr[x][y] += d[el] * cnt[el]
	for i in range(10):
		print(*arr[i])


def naiveSolve(n):
	return

def floyd_warshall(n, edges):
	dist = [[inf for i in range(n)] for j in range(n)]
	for (u, v, d) in edges:
		dist[u][v] = d
	for k in range(n):
		for i in range(n):
			for j in range(n):
				if dist[i][k] + dist[k][j] < dist[i][j]:
					dist[i][j] = dist[i][k] + dist[k][j]
	return dist

def generateMinSteps(x, y):
	edges = []
	for i in range(10):
		edges.append([i, (i + x) % 10, 1])
		if y != x:
			edges.append([i, (i + y) % 10, 1])
	dist = floyd_warshall(10, edges)
	return dist

def getMinStep(arr, x, y):
	dist = generateMinSteps(x, y)
	n = len(arr)
	ans = 0
	for i in range(n - 1):
		ans += dist[arr[i]][arr[i + 1]]
	ans -= n - 1
	if ans == inf:
		ans = -1
	return ans

def main():
	arr = [ord(x) - 48 for x in input()]
	ans = [[-1 for _ in range(10)] for __ in range(10)]
	for i in range(10):
		for j in range(i, 10):
			ans[i][j] = getMinStep(arr, i, j)
			ans[j][i] = ans[i][j]
	multiLineArrayOfArraysPrint(ans)
	return
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]

def makeArr(defaultValFactory, dimensionArr):
	dv = defaultValFactory
	da = dimensionArr
	if len(da) == 1:
		return [dv() for _ in range(da[0])]
	else:
		return [makeArr(dv, da[1:]) for _ in range(da[0])]

def queryInteractive(l, r):
	print('? {} {}'.format(l, r))
	sys.stdout.flush()
	return int(input())

def answerInteractive(x):
	print('! {}'.format(x))
	sys.stdout.flush()
inf = float('inf')
MOD = 10 ** 9 + 7
from math import gcd, floor, ceil
for _abc in range(1):
	main()


def f(x, y, d):
	while d <= 0:
		d += 10
	ans = 10000
	for i in range(10):
		for j in range(10):
			if (i * x + j * y) % 10 == d % 10 and i + j > 0:
				ans = min(ans, i + j)
	if ans == 10000:
		return -1
	return max(ans - 1, 0)
arr = [0] * 10
for i in range(10):
	arr[i] = [0] * 10
for i in range(10):
	for j in range(10):
		arr[i][j] = [0] * 10
for x in range(10):
	for y in range(10):
		for d in range(10):
			arr[x][y][d] = f(x, y, d)
s = input()
b = []
for i in range(len(s) - 1):
	b.append(int(s[i + 1]) - int(s[i]))
bb = [0] * 10
for i in b:
	bb[i] += 1
ans = [0] * 10
for i in range(10):
	ans[i] = [0] * 10
for x in range(10):
	for y in range(10):
		for d in range(10):
			t = arr[x][y][d]
			if t == -1 and bb[d] != 0:
				ans[x][y] = -1
				break
			ans[x][y] += t * bb[d]
for x in range(10):
	for y in range(10):
		print(ans[x][y], end=' ')
	print()
print()


def cover(t, x, y):
	tar = []
	for xc in range(100):
		for yc in range(100):
			if xc == 0 and yc == 0:
				continue
			if (xc * x + yc * y) % 10 == t:
				tar.append(xc + yc)
	if tar:
		return min(tar) - 1
	else:
		return -2
d = {(0, 0, 0): 0, (0, 0, 1): 0, (0, 0, 2): 0, (0, 0, 3): 0, (0, 0, 4): 0, (0, 0, 5): 0, (0, 0, 6): 0, (0, 0, 7): 0, (0, 0, 8): 0, (0, 0, 9): 0, (0, 1, 0): 0, (0, 1, 1): 9, (0, 1, 2): 4, (0, 1, 3): 3, (0, 1, 4): 3, (0, 1, 5): 1, (0, 1, 6): 4, (0, 1, 7): 3, (0, 1, 8): 2, (0, 1, 9): 1, (0, 2, 0): 0, (0, 2, 1): 4, (0, 2, 2): 4, (0, 2, 3): 3, (0, 2, 4): 2, (0, 2, 5): 1, (0, 2, 6): 2, (0, 2, 7): 4, (0, 2, 8): 1, (0, 2, 9): 2, (0, 3, 0): 0, (0, 3, 1): 3, (0, 3, 2): 3, (0, 3, 3): 9, (0, 3, 4): 2, (0, 3, 5): 1, (0, 3, 6): 4, (0, 3, 7): 1, (0, 3, 8): 4, (0, 3, 9): 3, (0, 4, 0): 0, (0, 4, 1): 3, (0, 4, 2): 2, (0, 4, 3): 2, (0, 4, 4): 4, (0, 4, 5): 1, (0, 4, 6): 1, (0, 4, 7): 4, (0, 4, 8): 2, (0, 4, 9): 4, (0, 5, 0): 0, (0, 5, 1): 1, (0, 5, 2): 1, (0, 5, 3): 1, (0, 5, 4): 1, (0, 5, 5): 1, (0, 5, 6): 1, (0, 5, 7): 1, (0, 5, 8): 1, (0, 5, 9): 1, (0, 6, 0): 0, (0, 6, 1): 4, (0, 6, 2): 2, (0, 6, 3): 4, (0, 6, 4): 1, (0, 6, 5): 1, (0, 6, 6): 4, (0, 6, 7): 2, (0, 6, 8): 2, (0, 6, 9): 3, (0, 7, 0): 0, (0, 7, 1): 3, (0, 7, 2): 4, (0, 7, 3): 1, (0, 7, 4): 4, (0, 7, 5): 1, (0, 7, 6): 2, (0, 7, 7): 9, (0, 7, 8): 3, (0, 7, 9): 3, (0, 8, 0): 0, (0, 8, 1): 2, (0, 8, 2): 1, (0, 8, 3): 4, (0, 8, 4): 2, (0, 8, 5): 1, (0, 8, 6): 2, (0, 8, 7): 3, (0, 8, 8): 4, (0, 8, 9): 4, (0, 9, 0): 0, (0, 9, 1): 1, (0, 9, 2): 2, (0, 9, 3): 3, (0, 9, 4): 4, (0, 9, 5): 1, (0, 9, 6): 3, (0, 9, 7): 3, (0, 9, 8): 4, (0, 9, 9): 9, (1, 0, 0): -2, (1, 0, 1): 0, (1, 0, 2): -2, (1, 0, 3): 6, (1, 0, 4): -2, (1, 0, 5): -2, (1, 0, 6): -2, (1, 0, 7): 2, (1, 0, 8): -2, (1, 0, 9): 8, (1, 1, 0): 0, (1, 1, 1): 0, (1, 1, 2): 0, (1, 1, 3): 0, (1, 1, 4): 0, (1, 1, 5): 0, (1, 1, 6): 0, (1, 1, 7): 0, (1, 1, 8): 0, (1, 1, 9): 0, (1, 2, 0): -2, (1, 2, 1): 0, (1, 2, 2): -2, (1, 2, 3): 3, (1, 2, 4): -2, (1, 2, 5): 3, (1, 2, 6): -2, (1, 2, 7): 2, (1, 2, 8): -2, (1, 2, 9): 1, (1, 3, 0): 6, (1, 3, 1): 0, (1, 3, 2): 3, (1, 3, 3): 6, (1, 3, 4): 2, (1, 3, 5): 2, (1, 3, 6): 3, (1, 3, 7): 2, (1, 3, 8): 1, (1, 3, 9): 2, (1, 4, 0): -2, (1, 4, 1): 0, (1, 4, 2): -2, (1, 4, 3): 2, (1, 4, 4): -2, (1, 4, 5): 4, (1, 4, 6): -2, (1, 4, 7): 1, (1, 4, 8): -2, (1, 4, 9): 3, (1, 5, 0): -2, (1, 5, 1): 0, (1, 5, 2): 3, (1, 5, 3): 2, (1, 5, 4): 4, (1, 5, 5): -2, (1, 5, 6): 1, (1, 5, 7): 2, (1, 5, 8): 2, (1, 5, 9): 4, (1, 6, 0): -2, (1, 6, 1): 0, (1, 6, 2): -2, (1, 6, 3): 3, (1, 6, 4): -2, (1, 6, 5): 1, (1, 6, 6): -2, (1, 6, 7): 2, (1, 6, 8): -2, (1, 6, 9): 2, (1, 7, 0): 2, (1, 7, 1): 0, (1, 7, 2): 2, (1, 7, 3): 2, (1, 7, 4): 1, (1, 7, 5): 2, (1, 7, 6): 2, (1, 7, 7): 2, (1, 7, 8): 2, (1, 7, 9): 2, (1, 8, 0): -2, (1, 8, 1): 0, (1, 8, 2): -2, (1, 8, 3): 1, (1, 8, 4): -2, (1, 8, 5): 2, (1, 8, 6): -2, (1, 8, 7): 2, (1, 8, 8): -2, (1, 8, 9): 4, (1, 9, 0): 8, (1, 9, 1): 0, (1, 9, 2): 1, (1, 9, 3): 2, (1, 9, 4): 3, (1, 9, 5): 4, (1, 9, 6): 2, (1, 9, 7): 2, (1, 9, 8): 4, (1, 9, 9): 8, (2, 0, 0): -2, (2, 0, 1): 1, (2, 0, 2): 0, (2, 0, 3): 3, (2, 0, 4): 2, (2, 0, 5): -2, (2, 0, 6): 1, (2, 0, 7): 5, (2, 0, 8): 3, (2, 0, 9): 7, (2, 1, 0): 1, (2, 1, 1): 1, (2, 1, 2): 0, (2, 1, 3): 1, (2, 1, 4): 1, (2, 1, 5): 1, (2, 1, 6): 1, (2, 1, 7): 1, (2, 1, 8): 1, (2, 1, 9): 1, (2, 2, 0): 0, (2, 2, 1): 0, (2, 2, 2): 0, (2, 2, 3): 0, (2, 2, 4): 0, (2, 2, 5): 0, (2, 2, 6): 0, (2, 2, 7): 0, (2, 2, 8): 0, (2, 2, 9): 0, (2, 3, 0): 3, (2, 3, 1): 1, (2, 3, 2): 0, (2, 3, 3): 3, (2, 3, 4): 2, (2, 3, 5): 3, (2, 3, 6): 1, (2, 3, 7): 3, (2, 3, 8): 3, (2, 3, 9): 1, (2, 4, 0): 2, (2, 4, 1): 1, (2, 4, 2): 0, (2, 4, 3): 2, (2, 4, 4): 2, (2, 4, 5): 2, (2, 4, 6): 1, (2, 4, 7): 2, (2, 4, 8): 1, (2, 4, 9): 2, (2, 5, 0): -2, (2, 5, 1): 1, (2, 5, 2): 0, (2, 5, 3): 3, (2, 5, 4): 2, (2, 5, 5): -2, (2, 5, 6): 1, (2, 5, 7): 1, (2, 5, 8): 3, (2, 5, 9): 3, (2, 6, 0): 1, (2, 6, 1): 1, (2, 6, 2): 0, (2, 6, 3): 1, (2, 6, 4): 1, (2, 6, 5): 1, (2, 6, 6): 1, (2, 6, 7): 1, (2, 6, 8): 1, (2, 6, 9): 1, (2, 7, 0): 5, (2, 7, 1): 1, (2, 7, 2): 0, (2, 7, 3): 3, (2, 7, 4): 2, (2, 7, 5): 1, (2, 7, 6): 1, (2, 7, 7): 5, (2, 7, 8): 2, (2, 7, 9): 3, (2, 8, 0): 3, (2, 8, 1): 1, (2, 8, 2): 0, (2, 8, 3): 3, (2, 8, 4): 1, (2, 8, 5): 3, (2, 8, 6): 1, (2, 8, 7): 2, (2, 8, 8): 3, (2, 8, 9): 3, (2, 9, 0): 7, (2, 9, 1): 1, (2, 9, 2): 0, (2, 9, 3): 1, (2, 9, 4): 2, (2, 9, 5): 3, (2, 9, 6): 1, (2, 9, 7): 3, (2, 9, 8): 3, (2, 9, 9): 7, (3, 0, 0): -2, (3, 0, 1): 2, (3, 0, 2): -2, (3, 0, 3): 0, (3, 0, 4): -2, (3, 0, 5): -2, (3, 0, 6): -2, (3, 0, 7): 8, (3, 0, 8): -2, (3, 0, 9): 6, (3, 1, 0): 2, (3, 1, 1): 2, (3, 1, 2): 1, (3, 1, 3): 0, (3, 1, 4): 2, (3, 1, 5): 2, (3, 1, 6): 2, (3, 1, 7): 2, (3, 1, 8): 2, (3, 1, 9): 2, (3, 2, 0): -2, (3, 2, 1): 1, (3, 2, 2): -2, (3, 2, 3): 0, (3, 2, 4): -2, (3, 2, 5): 4, (3, 2, 6): -2, (3, 2, 7): 3, (3, 2, 8): -2, (3, 2, 9): 2, (3, 3, 0): 0, (3, 3, 1): 0, (3, 3, 2): 0, (3, 3, 3): 0, (3, 3, 4): 0, (3, 3, 5): 0, (3, 3, 6): 0, (3, 3, 7): 0, (3, 3, 8): 0, (3, 3, 9): 0, (3, 4, 0): -2, (3, 4, 1): 2, (3, 4, 2): -2, (3, 4, 3): 0, (3, 4, 4): -2, (3, 4, 5): 2, (3, 4, 6): -2, (3, 4, 7): 4, (3, 4, 8): -2, (3, 4, 9): 1, (3, 5, 0): -2, (3, 5, 1): 2, (3, 5, 2): 4, (3, 5, 3): 0, (3, 5, 4): 2, (3, 5, 5): -2, (3, 5, 6): 3, (3, 5, 7): 4, (3, 5, 8): 1, (3, 5, 9): 2, (3, 6, 0): -2, (3, 6, 1): 2, (3, 6, 2): -2, (3, 6, 3): 0, (3, 6, 4): -2, (3, 6, 5): 3, (3, 6, 6): -2, (3, 6, 7): 1, (3, 6, 8): -2, (3, 6, 9): 3, (3, 7, 0): 8, (3, 7, 1): 2, (3, 7, 2): 3, (3, 7, 3): 0, (3, 7, 4): 4, (3, 7, 5): 4, (3, 7, 6): 1, (3, 7, 7): 8, (3, 7, 8): 2, (3, 7, 9): 2, (3, 8, 0): -2, (3, 8, 1): 2, (3, 8, 2): -2, (3, 8, 3): 0, (3, 8, 4): -2, (3, 8, 5): 1, (3, 8, 6): -2, (3, 8, 7): 2, (3, 8, 8): -2, (3, 8, 9): 3, (3, 9, 0): 6, (3, 9, 1): 2, (3, 9, 2): 2, (3, 9, 3): 0, (3, 9, 4): 1, (3, 9, 5): 2, (3, 9, 6): 3, (3, 9, 7): 2, (3, 9, 8): 3, (3, 9, 9): 6, (4, 0, 0): -2, (4, 0, 1): 3, (4, 0, 2): 1, (4, 0, 3): 7, (4, 0, 4): 0, (4, 0, 5): -2, (4, 0, 6): 3, (4, 0, 7): 1, (4, 0, 8): 2, (4, 0, 9): 5, (4, 1, 0): 3, (4, 1, 1): 3, (4, 1, 2): 1, (4, 1, 3): 1, (4, 1, 4): 0, (4, 1, 5): 3, (4, 1, 6): 3, (4, 1, 7): 1, (4, 1, 8): 2, (4, 1, 9): 3, (4, 2, 0): 1, (4, 2, 1): 1, (4, 2, 2): 1, (4, 2, 3): 1, (4, 2, 4): 0, (4, 2, 5): 1, (4, 2, 6): 1, (4, 2, 7): 1, (4, 2, 8): 1, (4, 2, 9): 1, (4, 3, 0): 7, (4, 3, 1): 1, (4, 3, 2): 1, (4, 3, 3): 7, (4, 3, 4): 0, (4, 3, 5): 3, (4, 3, 6): 3, (4, 3, 7): 1, (4, 3, 8): 2, (4, 3, 9): 3, (4, 4, 0): 0, (4, 4, 1): 0, (4, 4, 2): 0, (4, 4, 3): 0, (4, 4, 4): 0, (4, 4, 5): 0, (4, 4, 6): 0, (4, 4, 7): 0, (4, 4, 8): 0, (4, 4, 9): 0, (4, 5, 0): -2, (4, 5, 1): 3, (4, 5, 2): 1, (4, 5, 3): 3, (4, 5, 4): 0, (4, 5, 5): -2, (4, 5, 6): 3, (4, 5, 7): 1, (4, 5, 8): 2, (4, 5, 9): 1, (4, 6, 0): 3, (4, 6, 1): 3, (4, 6, 2): 1, (4, 6, 3): 3, (4, 6, 4): 0, (4, 6, 5): 3, (4, 6, 6): 3, (4, 6, 7): 1, (4, 6, 8): 1, (4, 6, 9): 2, (4, 7, 0): 1, (4, 7, 1): 1, (4, 7, 2): 1, (4, 7, 3): 1, (4, 7, 4): 0, (4, 7, 5): 1, (4, 7, 6): 1, (4, 7, 7): 1, (4, 7, 8): 1, (4, 7, 9): 1, (4, 8, 0): 2, (4, 8, 1): 2, (4, 8, 2): 1, (4, 8, 3): 2, (4, 8, 4): 0, (4, 8, 5): 2, (4, 8, 6): 1, (4, 8, 7): 1, (4, 8, 8): 2, (4, 8, 9): 2, (4, 9, 0): 5, (4, 9, 1): 3, (4, 9, 2): 1, (4, 9, 3): 3, (4, 9, 4): 0, (4, 9, 5): 1, (4, 9, 6): 2, (4, 9, 7): 1, (4, 9, 8): 2, (4, 9, 9): 5, (5, 0, 0): -2, (5, 0, 1): 4, (5, 0, 2): -2, (5, 0, 3): 4, (5, 0, 4): -2, (5, 0, 5): 0, (5, 0, 6): -2, (5, 0, 7): 4, (5, 0, 8): -2, (5, 0, 9): 4, (5, 1, 0): 4, (5, 1, 1): 4, (5, 1, 2): 2, (5, 1, 3): 2, (5, 1, 4): 1, (5, 1, 5): 0, (5, 1, 6): 4, (5, 1, 7): 2, (5, 1, 8): 3, (5, 1, 9): 4, (5, 2, 0): -2, (5, 2, 1): 2, (5, 2, 2): -2, (5, 2, 3): 1, (5, 2, 4): -2, (5, 2, 5): 0, (5, 2, 6): -2, (5, 2, 7): 4, (5, 2, 8): -2, (5, 2, 9): 3, (5, 3, 0): 4, (5, 3, 1): 2, (5, 3, 2): 1, (5, 3, 3): 4, (5, 3, 4): 3, (5, 3, 5): 0, (5, 3, 6): 2, (5, 3, 7): 4, (5, 3, 8): 4, (5, 3, 9): 2, (5, 4, 0): -2, (5, 4, 1): 1, (5, 4, 2): -2, (5, 4, 3): 3, (5, 4, 4): -2, (5, 4, 5): 0, (5, 4, 6): -2, (5, 4, 7): 2, (5, 4, 8): -2, (5, 4, 9): 4, (5, 5, 0): 0, (5, 5, 1): 0, (5, 5, 2): 0, (5, 5, 3): 0, (5, 5, 4): 0, (5, 5, 5): 0, (5, 5, 6): 0, (5, 5, 7): 0, (5, 5, 8): 0, (5, 5, 9): 0, (5, 6, 0): -2, (5, 6, 1): 4, (5, 6, 2): -2, (5, 6, 3): 2, (5, 6, 4): -2, (5, 6, 5): 0, (5, 6, 6): -2, (5, 6, 7): 3, (5, 6, 8): -2, (5, 6, 9): 1, (5, 7, 0): 4, (5, 7, 1): 2, (5, 7, 2): 4, (5, 7, 3): 4, (5, 7, 4): 2, (5, 7, 5): 0, (5, 7, 6): 3, (5, 7, 7): 4, (5, 7, 8): 1, (5, 7, 9): 2, (5, 8, 0): -2, (5, 8, 1): 3, (5, 8, 2): -2, (5, 8, 3): 4, (5, 8, 4): -2, (5, 8, 5): 0, (5, 8, 6): -2, (5, 8, 7): 1, (5, 8, 8): -2, (5, 8, 9): 2, (5, 9, 0): 4, (5, 9, 1): 4, (5, 9, 2): 3, (5, 9, 3): 2, (5, 9, 4): 4, (5, 9, 5): 0, (5, 9, 6): 1, (5, 9, 7): 2, (5, 9, 8): 2, (5, 9, 9): 4, (6, 0, 0): -2, (6, 0, 1): 5, (6, 0, 2): 2, (6, 0, 3): 1, (6, 0, 4): 3, (6, 0, 5): -2, (6, 0, 6): 0, (6, 0, 7): 7, (6, 0, 8): 1, (6, 0, 9): 3, (6, 1, 0): 5, (6, 1, 1): 5, (6, 1, 2): 2, (6, 1, 3): 1, (6, 1, 4): 2, (6, 1, 5): 1, (6, 1, 6): 0, (6, 1, 7): 3, (6, 1, 8): 1, (6, 1, 9): 3, (6, 2, 0): 2, (6, 2, 1): 2, (6, 2, 2): 2, (6, 2, 3): 1, (6, 2, 4): 1, (6, 2, 5): 2, (6, 2, 6): 0, (6, 2, 7): 2, (6, 2, 8): 1, (6, 2, 9): 2, (6, 3, 0): 1, (6, 3, 1): 1, (6, 3, 2): 1, (6, 3, 3): 1, (6, 3, 4): 1, (6, 3, 5): 1, (6, 3, 6): 0, (6, 3, 7): 1, (6, 3, 8): 1, (6, 3, 9): 1, (6, 4, 0): 3, (6, 4, 1): 2, (6, 4, 2): 1, (6, 4, 3): 1, (6, 4, 4): 3, (6, 4, 5): 3, (6, 4, 6): 0, (6, 4, 7): 3, (6, 4, 8): 1, (6, 4, 9): 3, (6, 5, 0): -2, (6, 5, 1): 1, (6, 5, 2): 2, (6, 5, 3): 1, (6, 5, 4): 3, (6, 5, 5): -2, (6, 5, 6): 0, (6, 5, 7): 3, (6, 5, 8): 1, (6, 5, 9): 3, (6, 6, 0): 0, (6, 6, 1): 0, (6, 6, 2): 0, (6, 6, 3): 0, (6, 6, 4): 0, (6, 6, 5): 0, (6, 6, 6): 0, (6, 6, 7): 0, (6, 6, 8): 0, (6, 6, 9): 0, (6, 7, 0): 7, (6, 7, 1): 3, (6, 7, 2): 2, (6, 7, 3): 1, (6, 7, 4): 3, (6, 7, 5): 3, (6, 7, 6): 0, (6, 7, 7): 7, (6, 7, 8): 1, (6, 7, 9): 1, (6, 8, 0): 1, (6, 8, 1): 1, (6, 8, 2): 1, (6, 8, 3): 1, (6, 8, 4): 1, (6, 8, 5): 1, (6, 8, 6): 0, (6, 8, 7): 1, (6, 8, 8): 1, (6, 8, 9): 1, (6, 9, 0): 3, (6, 9, 1): 3, (6, 9, 2): 2, (6, 9, 3): 1, (6, 9, 4): 3, (6, 9, 5): 3, (6, 9, 6): 0, (6, 9, 7): 1, (6, 9, 8): 1, (6, 9, 9): 3, (7, 0, 0): -2, (7, 0, 1): 6, (7, 0, 2): -2, (7, 0, 3): 8, (7, 0, 4): -2, (7, 0, 5): -2, (7, 0, 6): -2, (7, 0, 7): 0, (7, 0, 8): -2, (7, 0, 9): 2, (7, 1, 0): 6, (7, 1, 1): 6, (7, 1, 2): 3, (7, 1, 3): 2, (7, 1, 4): 3, (7, 1, 5): 2, (7, 1, 6): 1, (7, 1, 7): 0, (7, 1, 8): 2, (7, 1, 9): 2, (7, 2, 0): -2, (7, 2, 1): 3, (7, 2, 2): -2, (7, 2, 3): 2, (7, 2, 4): -2, (7, 2, 5): 1, (7, 2, 6): -2, (7, 2, 7): 0, (7, 2, 8): -2, (7, 2, 9): 2, (7, 3, 0): 8, (7, 3, 1): 2, (7, 3, 2): 2, (7, 3, 3): 8, (7, 3, 4): 1, (7, 3, 5): 4, (7, 3, 6): 4, (7, 3, 7): 0, (7, 3, 8): 3, (7, 3, 9): 2, (7, 4, 0): -2, (7, 4, 1): 3, (7, 4, 2): -2, (7, 4, 3): 1, (7, 4, 4): -2, (7, 4, 5): 3, (7, 4, 6): -2, (7, 4, 7): 0, (7, 4, 8): -2, (7, 4, 9): 2, (7, 5, 0): -2, (7, 5, 1): 2, (7, 5, 2): 1, (7, 5, 3): 4, (7, 5, 4): 3, (7, 5, 5): -2, (7, 5, 6): 2, (7, 5, 7): 0, (7, 5, 8): 4, (7, 5, 9): 2, (7, 6, 0): -2, (7, 6, 1): 1, (7, 6, 2): -2, (7, 6, 3): 4, (7, 6, 4): -2, (7, 6, 5): 2, (7, 6, 6): -2, (7, 6, 7): 0, (7, 6, 8): -2, (7, 6, 9): 2, (7, 7, 0): 0, (7, 7, 1): 0, (7, 7, 2): 0, (7, 7, 3): 0, (7, 7, 4): 0, (7, 7, 5): 0, (7, 7, 6): 0, (7, 7, 7): 0, (7, 7, 8): 0, (7, 7, 9): 0, (7, 8, 0): -2, (7, 8, 1): 2, (7, 8, 2): -2, (7, 8, 3): 3, (7, 8, 4): -2, (7, 8, 5): 4, (7, 8, 6): -2, (7, 8, 7): 0, (7, 8, 8): -2, (7, 8, 9): 1, (7, 9, 0): 2, (7, 9, 1): 2, (7, 9, 2): 2, (7, 9, 3): 2, (7, 9, 4): 2, (7, 9, 5): 2, (7, 9, 6): 2, (7, 9, 7): 0, (7, 9, 8): 1, (7, 9, 9): 2, (8, 0, 0): -2, (8, 0, 1): 7, (8, 0, 2): 3, (8, 0, 3): 5, (8, 0, 4): 1, (8, 0, 5): -2, (8, 0, 6): 2, (8, 0, 7): 3, (8, 0, 8): 0, (8, 0, 9): 1, (8, 1, 0): 7, (8, 1, 1): 7, (8, 1, 2): 3, (8, 1, 3): 3, (8, 1, 4): 1, (8, 1, 5): 3, (8, 1, 6): 2, (8, 1, 7): 1, (8, 1, 8): 0, (8, 1, 9): 1, (8, 2, 0): 3, (8, 2, 1): 3, (8, 2, 2): 3, (8, 2, 3): 2, (8, 2, 4): 1, (8, 2, 5): 3, (8, 2, 6): 1, (8, 2, 7): 3, (8, 2, 8): 0, (8, 2, 9): 1, (8, 3, 0): 5, (8, 3, 1): 3, (8, 3, 2): 2, (8, 3, 3): 5, (8, 3, 4): 1, (8, 3, 5): 1, (8, 3, 6): 2, (8, 3, 7): 3, (8, 3, 8): 0, (8, 3, 9): 1, (8, 4, 0): 1, (8, 4, 1): 1, (8, 4, 2): 1, (8, 4, 3): 1, (8, 4, 4): 1, (8, 4, 5): 1, (8, 4, 6): 1, (8, 4, 7): 1, (8, 4, 8): 0, (8, 4, 9): 1, (8, 5, 0): -2, (8, 5, 1): 3, (8, 5, 2): 3, (8, 5, 3): 1, (8, 5, 4): 1, (8, 5, 5): -2, (8, 5, 6): 2, (8, 5, 7): 3, (8, 5, 8): 0, (8, 5, 9): 1, (8, 6, 0): 2, (8, 6, 1): 2, (8, 6, 2): 1, (8, 6, 3): 2, (8, 6, 4): 1, (8, 6, 5): 2, (8, 6, 6): 2, (8, 6, 7): 2, (8, 6, 8): 0, (8, 6, 9): 1, (8, 7, 0): 3, (8, 7, 1): 1, (8, 7, 2): 3, (8, 7, 3): 3, (8, 7, 4): 1, (8, 7, 5): 3, (8, 7, 6): 2, (8, 7, 7): 3, (8, 7, 8): 0, (8, 7, 9): 1, (8, 8, 0): 0, (8, 8, 1): 0, (8, 8, 2): 0, (8, 8, 3): 0, (8, 8, 4): 0, (8, 8, 5): 0, (8, 8, 6): 0, (8, 8, 7): 0, (8, 8, 8): 0, (8, 8, 9): 0, (8, 9, 0): 1, (8, 9, 1): 1, (8, 9, 2): 1, (8, 9, 3): 1, (8, 9, 4): 1, (8, 9, 5): 1, (8, 9, 6): 1, (8, 9, 7): 1, (8, 9, 8): 0, (8, 9, 9): 1, (9, 0, 0): -2, (9, 0, 1): 8, (9, 0, 2): -2, (9, 0, 3): 2, (9, 0, 4): -2, (9, 0, 5): -2, (9, 0, 6): -2, (9, 0, 7): 6, (9, 0, 8): -2, (9, 0, 9): 0, (9, 1, 0): 8, (9, 1, 1): 8, (9, 1, 2): 4, (9, 1, 3): 2, (9, 1, 4): 2, (9, 1, 5): 4, (9, 1, 6): 3, (9, 1, 7): 2, (9, 1, 8): 1, (9, 1, 9): 0, (9, 2, 0): -2, (9, 2, 1): 4, (9, 2, 2): -2, (9, 2, 3): 2, (9, 2, 4): -2, (9, 2, 5): 2, (9, 2, 6): -2, (9, 2, 7): 1, (9, 2, 8): -2, (9, 2, 9): 0, (9, 3, 0): 2, (9, 3, 1): 2, (9, 3, 2): 2, (9, 3, 3): 2, (9, 3, 4): 2, (9, 3, 5): 2, (9, 3, 6): 1, (9, 3, 7): 2, (9, 3, 8): 2, (9, 3, 9): 0, (9, 4, 0): -2, (9, 4, 1): 2, (9, 4, 2): -2, (9, 4, 3): 2, (9, 4, 4): -2, (9, 4, 5): 1, (9, 4, 6): -2, (9, 4, 7): 3, (9, 4, 8): -2, (9, 4, 9): 0, (9, 5, 0): -2, (9, 5, 1): 4, (9, 5, 2): 2, (9, 5, 3): 2, (9, 5, 4): 1, (9, 5, 5): -2, (9, 5, 6): 4, (9, 5, 7): 2, (9, 5, 8): 3, (9, 5, 9): 0, (9, 6, 0): -2, (9, 6, 1): 3, (9, 6, 2): -2, (9, 6, 3): 1, (9, 6, 4): -2, (9, 6, 5): 4, (9, 6, 6): -2, (9, 6, 7): 2, (9, 6, 8): -2, (9, 6, 9): 0, (9, 7, 0): 6, (9, 7, 1): 2, (9, 7, 2): 1, (9, 7, 3): 2, (9, 7, 4): 3, (9, 7, 5): 2, (9, 7, 6): 2, (9, 7, 7): 6, (9, 7, 8): 3, (9, 7, 9): 0, (9, 8, 0): -2, (9, 8, 1): 1, (9, 8, 2): -2, (9, 8, 3): 2, (9, 8, 4): -2, (9, 8, 5): 3, (9, 8, 6): -2, (9, 8, 7): 3, (9, 8, 8): -2, (9, 8, 9): 0, (9, 9, 0): 0, (9, 9, 1): 0, (9, 9, 2): 0, (9, 9, 3): 0, (9, 9, 4): 0, (9, 9, 5): 0, (9, 9, 6): 0, (9, 9, 7): 0, (9, 9, 8): 0, (9, 9, 9): 0}
s = [int(x) for x in input()]
if s[0] != 0:
	for _ in range(10):
		print('-1 ' * 10)
	exit()
a = []
for i in range(1, len(s)):
	a.append((s[i] - s[i - 1]) % 10)
counts = [0] * 10
for x in a:
	counts[x] += 1
for i in range(10):
	for j in range(10):
		skip = False
		count = 0
		for x in range(10):
			if counts[x]:
				tr = d[x, i, j]
				if tr == -2:
					print(-1, end=' ')
					skip = True
					break
				else:
					count += tr * counts[x]
		if skip:
			continue
		print(count, end=' ')
	print()


import sys
input = sys.stdin.readline
from collections import deque

def main():
	S = list(input().rstrip())
	P = [0] * 10
	for i in range(len(S) - 1):
		P[(int(S[i + 1]) - int(S[i])) % 10] += 1
	ans = [[0] * 10 for _ in range(10)]
	for x in range(10):
		for y in range(10):
			Score = [-1] * 10
			Score[x] = 0
			Score[y] = 0
			q = deque()
			q.appendleft(x)
			q.appendleft(y)
			while q:
				a = q.pop()
				Ns = [(a + x) % 10, (a + y) % 10]
				for n in Ns:
					if Score[n] == -1:
						Score[n] = Score[a] + 1
						q.appendleft(n)
			now = 0
			for num in range(10):
				if P[num] > 0 and Score[num] == -1:
					now = -1
					break
				now += P[num] * Score[num]
			ans[x][y] = now
	for y in range(10):
		print(*ans[y])
main()


s = input()

def floyd_warshall(n, A):
	dist = [[float('inf') for i in range(n)] for j in range(n)]
	for i in range(n):
		for j in range(n):
			if A[i][j]:
				dist[i][j] = A[i][j]
	for k in range(n):
		for i in range(n):
			for j in range(n):
				if dist[i][k] + dist[k][j] < dist[i][j]:
					dist[i][j] = dist[i][k] + dist[k][j]
	return dist
cp = {}
for ii in range(len(s) - 1):
	p = int(s[ii])
	q = int(s[ii + 1])
	try:
		cp[p, q] += 1
	except:
		cp[p, q] = 1
for i in range(10):
	res = []
	for j in range(10):
		adj = [[] for i in range(10)]
		adj = [[0] * 10 for i in range(10)]
		for ii in range(10):
			adj[ii][ii] = 0
			adj[ii][(ii + i) % 10] = 1
			adj[ii][(ii + j) % 10] = 1
		dist = floyd_warshall(10, adj)
		tot = 0
		tot = 0
		st = True
		for ii in cp:
			ii = tuple(ii)
			p = ii[0]
			q = ii[1]
			x = dist[p][q]
			if x == float('inf'):
				st = False
				break
			tot += (x - 1) * cp[ii]
		if not st:
			res.append(-1)
		else:
			res.append(tot)
	print(*res)


st = list(input())
counts = []
for i in range(0, 10):
	counts.append(0)
for i in range(1, len(st)):
	counts[(int(st[i]) - int(st[i - 1]) + 10) % 10] += 1
for x in range(0, 10):
	st = ''
	for y in range(0, 10):
		s = 0
		f = False
		for i in range(0, 10):
			if counts[i] == 0:
				continue
			j = 0
			c = 100000000000
			ff = False
			f = False
			while j < 10:
				k = 0
				while k < 10:
					if j == 0 and k == 0:
						k += 1
						continue
					if (x * j + y * k) % 10 == i:
						c = min(c, j + k)
						ff = True
					k += 1
				j += 1
			if ff:
				s += counts[i] * (max(1, c) - 1)
				f = True
			if not f:
				s = -1
				break
		st += str(s)
		if y != 9:
			st += ' '
	print(st)


bigger = 1000000000000000000000000000
s = input()
cf = [[0 for _ in range(10)] for __ in range(10)]
ans = []
for i in range(1, len(s)):
	cf[int(s[i - 1])][int(s[i])] += 1
for x in range(10):
	line = []
	for y in range(10):
		ds = [[bigger + 7 for _ in range(10)] for __ in range(10)]
		for v in range(10):
			for cx in range(10):
				for cy in range(10):
					if cx + cy == 0:
						continue
					to = (v + cx * x + cy * y) % 10
					ds[v][to] = min(ds[v][to], cx + cy)
		res = 0
		for v in range(10):
			for to in range(10):
				if ds[v][to] > bigger and cf[v][to] > 0:
					res = -1
					break
				res += (ds[v][to] - 1) * cf[v][to]
			if res == -1:
				break
		line.append(res)
	ans.append(line)
for line in ans:
	print(*line)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def prod(a, mod=10 ** 9 + 7):
	ans = 1
	for each in a:
		ans = ans * each % mod
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
from math import inf
dp = [inf] * 10000

def convert(i, j, k, l):
	return i * 1000 + j * 100 + k * 10 + l

def convert2(x):
	l = x % 10
	k = (x - l) % 100 // 10
	j = (x - l - k * 10) % 1000 // 100
	i = x // 1000
	return (i, j, k, l)
for i in range(10):
	for j in range(10):
		for k in range(10):
			for l in range(10):
				for m in range(10):
					if l == m == 0:
						continue
					oof = (k + i * l + j * m) % 10
					c = convert(i, j, k, oof)
					dp[c] = min(dp[c], l + m)
for _ in range(int(input()) if not True else 1):
	s = input()
	di = {}
	for i in range(len(s) - 1):
		st = (int(s[i]), int(s[i + 1]))
		if st not in di:
			di[st] = 0
		di[st] += 1
	ans = [[0] * 10 for i in range(10)]
	for st in di:
		for i in range(10):
			for j in range(10):
				if ans[i][j] == -1:
					continue
				dx = dp[convert(i, j, st[0], st[1])]
				if dx == inf:
					ans[i][j] = -1
					continue
				ans[i][j] += (dx - 1) * di[st] if dx != 0 else 0
	for each in ans:
		print(*each)


from collections import *
s = input()
c = Counter(((ord(y) - ord(x)) % 10 for (x, y) in zip(s, s[1:])))
for i in range(100):
	a = [-1] * 10
	for j in range(1, 11):
		for k in range(j + 1):
			x = ((j - k) * (i // 10) + k * (i % 10)) % 10
			if a[x] == -1:
				a[x] = j - 1
	z = 0
	for x in c:
		if a[x] == -1:
			z = -1
			break
		else:
			z += a[x] * c[x]
	print(z)


s = input().strip()
from collections import Counter
C = Counter()
for i in range(1, len(s)):
	if int(s[i]) >= int(s[i - 1]):
		C[int(s[i]) - int(s[i - 1])] += 1
	else:
		C[int(s[i]) + 10 - int(s[i - 1])] += 1
NEED = [[[10000] * 10 for i in range(10)] for j in range(10)]
for i in range(10):
	for j in range(10):
		for k in range(13):
			for l in range(13):
				if k + l == 0:
					continue
				NEED[i][j][(i * k + j * l) % 10] = min(k + l, NEED[i][j][(i * k + j * l) % 10])
for i in range(10):
	for j in range(10):
		ANS = 0
		for c in C:
			if NEED[i][j][c] == 10000:
				ANS = -1
				break
			else:
				ANS += (NEED[i][j][c] - 1) * C[c]
		print(ANS, end=' ')
	print()


def floyd_warshall(cost):
	n = len(cost)
	dist = cost[:]
	for k in range(n):
		for i in range(n):
			for j in range(n):
				if dist[i][j] > dist[i][k] + dist[k][j]:
					dist[i][j] = dist[i][k] + dist[k][j]
	return dist

def insert_matrix(x, y):
	cost = [[0 for i in range(10)] for j in range(10)]
	for i in range(10):
		for j in range(10):
			if (i + x) % 10 == j or (i + y) % 10 == j:
				cost[i][j] = 1
			else:
				cost[i][j] = 100
	dist = floyd_warshall(cost)
	for i in range(10):
		for j in range(10):
			if dist[i][j] >= 100:
				dist[i][j] = -1
			else:
				dist[i][j] -= 1
	return dist

def solve_one(x, y, transitions):
	mat = insert_matrix(x, y)
	result = 0
	for i in range(10):
		for j in range(10):
			if mat[i][j] * transitions[i][j] < 0:
				return -1
			result += mat[i][j] * transitions[i][j]
	return result

def solve(S):
	transitions = [[0 for i in range(10)] for j in range(10)]
	for i in range(1, len(S)):
		transitions[int(S[i - 1])][int(S[i])] += 1
	result = [[0 for i in range(10)] for j in range(10)]
	for x in range(10):
		for y in range(10):
			result[x][y] = solve_one(x, y, transitions)
	return result
result = solve(input())
for x in range(10):
	for y in range(10):
		print(result[x][y], end=' ')
	print()


S = input()
T = [[0] * 10 for i in range(10)]
for i in range(1, len(S)):
	T[int(S[i - 1])][int(S[i])] += 1
C = [[[[0 for i in range(10)] for j in range(10)] for k in range(10)] for l in range(10)]
for i in range(10):
	for j in range(10):
		for k in range(10):
			for l in range(10):
				min_val = 1000
				for a1 in range(11):
					for a2 in range(11):
						if a1 != 0 or a2 != 0:
							if j == (a1 * k + a2 * l + i) % 10:
								min_val = min(min_val, a1 + a2)
				if min_val == 1000:
					min_val = -10 ** 10
				C[i][j][k][l] = min_val - 1
ans = [[0] * 10 for i in range(10)]
for k in range(10):
	for l in range(10):
		a = 0
		for i in range(10):
			for j in range(10):
				a += C[i][j][k][l] * T[i][j]
		if a < 0:
			a = -1
		ans[k][l] = a
for a in ans:
	print(*a)


s = input()
inf = 1061109567
ans = []
for i in range(10):
	ans.append([-1] * 10)
for i in range(10):
	for j in range(i, 10):
		dist = [0] * 10
		for k in range(10):
			dist[k] = [inf] * 10
		for k in range(10):
			dist[k][(k + i) % 10] = 1
			dist[k][(k + j) % 10] = 1
		for k in range(10):
			for ii in range(10):
				for jj in range(10):
					dist[ii][jj] = min(dist[ii][jj], dist[ii][k] + dist[k][jj])
		p = 0
		cnt = 0
		for k in range(1, len(s)):
			if dist[p][ord(s[k]) - 48] == inf:
				ans[i][j] = ans[j][i] = -1
				break
			cnt += dist[p][ord(s[k]) - 48] - 1
			p = ord(s[k]) - 48
		else:
			ans[i][j] = ans[j][i] = cnt
for arr in ans:
	for a in arr:
		print(a, end=' ')
	print()


def main():
	import sys
	input = sys.stdin.readline
	S = input().rstrip('\n')
	A = [int(s) for s in S]
	N = len(A)
	cnt = [[0] * 10 for _ in range(10)]
	for i in range(N - 1):
		cnt[A[i]][A[i + 1]] += 1
	ans = [[0] * 10 for _ in range(10)]
	for i in range(10):
		for j in range(10):
			if i <= j:
				for k in range(10):
					for l in range(10):
						if cnt[k][l]:
							d = (l - k) % 10
							c = 100
							for m in range(11):
								for n in range(11):
									if m == n == 0:
										continue
									if (i * m + j * n) % 10 == d:
										c = min(c, m + n)
							if c == 100:
								ans[i][j] = -1
							elif ans[i][j] >= 0:
								ans[i][j] += (c - 1) * cnt[k][l]
			else:
				ans[i][j] = ans[j][i]
	for i in range(10):
		print(*ans[i])
main()


a = []
for i in range(100):
	b = [-1] * 10
	l = [0]
	k = 0
	while l:
		m = []
		k += 1
		for x in l:
			for j in (i // 10, i % 10):
				y = (x + j) % 10
				if b[y] < 0:
					b[y] = k
					m += (y,)
		l = m
	a += (b,)
r = [0] * 100
s = (*map(int, input()),)
for (x, y) in zip(s, s[1:]):
	for i in range(100):
		if r[i] >= 0:
			d = a[i][(y - x) % 10]
			if d < 0:
				r[i] = -1
			else:
				r[i] += d - 1
print(*r)


from collections import deque
s = input()
dist = dict()
for x in range(10):
	for y in range(10):
		for a in range(10):
			for b in range(a, 10):
				vis = [-1 for i in range(10)]
				vis[x] = 0
				q = deque()
				q.append(x)
				while len(q) > 0:
					f = q.popleft()
					if f == y and vis[y] != 0:
						dist[(x, y), (a, b)] = vis[y]
						break
					anxt = (f + a) % 10
					if vis[anxt] == -1 or (vis[anxt] == 0 and anxt == y):
						q.append(anxt)
						vis[anxt] = vis[f] + 1
					bnxt = (f + b) % 10
					if vis[bnxt] == -1 or (vis[bnxt] == 0 and bnxt == y):
						q.append(bnxt)
						vis[bnxt] = vis[f] + 1
ans = [[0 for i in range(10)] for j in range(10)]
cnt = dict()
for i in range(len(s) - 1):
	x = int(s[i])
	y = int(s[i + 1])
	if not (x, y) in cnt:
		cnt[x, y] = 0
	cnt[x, y] += 1
for a in range(10):
	for b in range(a, 10):
		for ckey in cnt:
			key = (ckey, (a, b))
			if not key in dist:
				ans[a][b] = -1
				break
			else:
				ans[a][b] += (dist[key] - 1) * cnt[ckey]
		ans[b][a] = ans[a][b]
for i in range(10):
	print(' '.join(map(str, ans[i])))


from itertools import product

def helper(a):
	l = [0] * 10
	for t in range(1, 11):
		x = a * t % 10
		if l[x]:
			break
		l[x] = t
	return [*((x, t) for (x, t) in enumerate(l) if t), (0, 0)]

def main():
	(a, cnt) = (48, [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
	for b in map(ord, input()):
		cnt[(b - a) % 10] += 1
		a = b
	(inf, res, hbb) = (10 ** 9, {}, [])
	for a in range(10):
		ha = helper(a)
		hbb.append(ha)
		for (b, hb) in enumerate(hbb):
			dist = [inf] * 10
			for ((x, t), (y, u)) in product(ha, hb):
				x = (x + y) % 10
				t += u
				if 0 < t <= dist[x]:
					dist[x] = t - 1
			r = sum((c * d for (c, d) in zip(cnt, dist)))
			res[a, b] = res[b, a] = r if r < inf else -1
	for a in range(10):
		print(*[res[a, b] for b in range(10)])
main()


s = input()
df = [0] * 10
ss = zip(s, s[1:])
for (f, s) in ss:
	df[(ord(s) - ord(f)) % 10] += 1
result = [[0] * 10 for _ in range(10)]
for i in range(10):
	for j in range(10):
		for k in range(10):
			if df[k] == 0:
				continue
			v = -1
			for u in range(1, 11):
				for x in range(0, u + 1):
					if (i * x + j * (u - x)) % 10 == k:
						v = u
						break
				if v != -1:
					break
			if v == -1:
				result[i][j] = -1
				break
			result[i][j] += (v - 1) * df[k]
for i in range(10):
	print(' '.join(map(str, result[i])))


adj = [[[1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000], [1, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 4, 1000000000000000000000000000000], [1, 7, 4, 1, 8, 5, 2, 9, 6, 3], [1, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000], [1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 3, 1000000000000000000000000000000], [1, 3, 6, 9, 2, 5, 8, 1, 4, 7], [1, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [1, 9, 8, 7, 6, 5, 4, 3, 2, 1]], [[1, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 1, 2, 3, 4, 5, 6, 7, 8, 9], [5, 1, 1, 2, 2, 3, 3, 4, 4, 5], [4, 1, 2, 1, 2, 3, 2, 3, 4, 3], [4, 1, 2, 3, 1, 2, 3, 4, 2, 3], [2, 1, 2, 3, 4, 1, 2, 3, 4, 5], [5, 1, 2, 3, 4, 5, 1, 2, 3, 4], [4, 1, 2, 3, 2, 3, 4, 1, 2, 3], [3, 1, 2, 3, 3, 4, 2, 3, 1, 2], [2, 1, 2, 3, 4, 5, 4, 3, 2, 1]], [[1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 4, 1000000000000000000000000000000], [5, 1, 1, 2, 2, 3, 3, 4, 4, 5], [5, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 4, 1000000000000000000000000000000], [4, 4, 1, 1, 2, 2, 2, 3, 3, 3], [3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [2, 4, 1, 5, 2, 1, 3, 2, 4, 3], [3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [5, 3, 1, 4, 2, 5, 3, 1, 4, 2], [2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [3, 2, 1, 3, 2, 4, 3, 3, 2, 1]], [[1, 7, 4, 1, 8, 5, 2, 9, 6, 3], [4, 1, 2, 1, 2, 3, 2, 3, 4, 3], [4, 4, 1, 1, 2, 2, 2, 3, 3, 3], [10, 7, 4, 1, 8, 5, 2, 9, 6, 3], [3, 3, 3, 1, 1, 4, 2, 2, 2, 3], [2, 3, 4, 1, 4, 1, 2, 5, 2, 3], [5, 4, 2, 1, 4, 3, 1, 5, 3, 2], [2, 3, 4, 1, 2, 5, 2, 1, 4, 3], [5, 2, 4, 1, 3, 5, 2, 4, 1, 3], [4, 3, 2, 1, 4, 3, 2, 3, 2, 1]], [[1, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [4, 1, 2, 3, 1, 2, 3, 4, 2, 3], [3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [3, 3, 3, 1, 1, 4, 2, 2, 2, 3], [5, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [2, 5, 3, 3, 1, 1, 4, 4, 2, 2], [2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [5, 2, 3, 5, 1, 3, 4, 1, 2, 4], [3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [5, 4, 3, 2, 1, 5, 4, 3, 2, 1]], [[1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000], [2, 1, 2, 3, 4, 1, 2, 3, 4, 5], [2, 4, 1, 5, 2, 1, 3, 2, 4, 3], [2, 3, 4, 1, 4, 1, 2, 5, 2, 3], [2, 5, 3, 3, 1, 1, 4, 4, 2, 2], [2, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000], [2, 2, 2, 4, 4, 1, 1, 3, 3, 5], [2, 3, 2, 5, 2, 1, 4, 1, 4, 3], [2, 3, 4, 2, 3, 1, 2, 5, 1, 4], [2, 5, 4, 3, 2, 1, 4, 3, 2, 1]], [[1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 3, 1000000000000000000000000000000], [5, 1, 2, 3, 4, 5, 1, 2, 3, 4], [3, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [5, 4, 2, 1, 4, 3, 1, 5, 3, 2], [2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000], [2, 2, 2, 4, 4, 1, 1, 3, 3, 5], [5, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 3, 1000000000000000000000000000000], [3, 3, 2, 2, 2, 4, 1, 1, 3, 3], [3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [4, 3, 2, 4, 3, 2, 1, 3, 2, 1]], [[1, 3, 6, 9, 2, 5, 8, 1, 4, 7], [4, 1, 2, 3, 2, 3, 4, 1, 2, 3], [5, 3, 1, 4, 2, 5, 3, 1, 4, 2], [2, 3, 4, 1, 2, 5, 2, 1, 4, 3], [5, 2, 3, 5, 1, 3, 4, 1, 2, 4], [2, 3, 2, 5, 2, 1, 4, 1, 4, 3], [3, 3, 2, 2, 2, 4, 1, 1, 3, 3], [10, 3, 6, 9, 2, 5, 8, 1, 4, 7], [4, 3, 3, 3, 2, 2, 2, 1, 1, 4], [4, 3, 4, 3, 2, 3, 2, 1, 2, 1]], [[1, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [3, 1, 2, 3, 3, 4, 2, 3, 1, 2], [2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [5, 2, 4, 1, 3, 5, 2, 4, 1, 3], [3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [2, 3, 4, 2, 3, 1, 2, 5, 1, 4], [3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [4, 3, 3, 3, 2, 2, 2, 1, 1, 4], [5, 1000000000000000000000000000000, 4, 1000000000000000000000000000000, 3, 1000000000000000000000000000000, 2, 1000000000000000000000000000000, 1, 1000000000000000000000000000000], [5, 5, 4, 4, 3, 3, 2, 2, 1, 1]], [[1, 9, 8, 7, 6, 5, 4, 3, 2, 1], [2, 1, 2, 3, 4, 5, 4, 3, 2, 1], [3, 2, 1, 3, 2, 4, 3, 3, 2, 1], [4, 3, 2, 1, 4, 3, 2, 3, 2, 1], [5, 4, 3, 2, 1, 5, 4, 3, 2, 1], [2, 5, 4, 3, 2, 1, 4, 3, 2, 1], [4, 3, 2, 4, 3, 2, 1, 3, 2, 1], [4, 3, 4, 3, 2, 3, 2, 1, 2, 1], [5, 5, 4, 4, 3, 3, 2, 2, 1, 1], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]]]
s = input()
n = len(s)
gaps = [0 for _ in range(10)]
for i in range(n - 1):
	gaps[(int(s[i + 1]) - int(s[i])) % 10] += 1
ans = [[0 for _ in range(10)] for _ in range(10)]
for i in range(10):
	for j in range(10):
		if i > j:
			ans[i][j] = ans[j][i]
			continue
		for g in range(10):
			ans[i][j] += (adj[i][j][g] - 1) * gaps[g]
		if ans[i][j] > 10 ** 20:
			ans[i][j] = -1
for i in range(10):
	print(*ans[i])