Den lilla staden där du bor planerar att införa ett nytt system för personnummer (social security number, SSN). Varje medborgare kommer att identifieras med ett femsiffrigt SSN. De första fyra siffrorna anger bas-ID-numret (0000–9999) och den sista siffran är en kontrollsiffra för att upptäcka fel.

För att beräkna kontrollsiffror har staden beslutat att använda en operationstabell. En operationstabell är en $10 \times 10$-tabell med decimalsiffror vars diagonalelement alla är $0$. Nedan visas två exempel på operationstabeller.

Operationstabell 1

Operationstabell 2

Med hjälp av en operationstabell beräknas kontrollsiffran $e$ för ett fyrsiffrigt bas-ID-nummer $abcd$ enligt följande formel. Här betecknar $i \otimes j$ tabellelementet på rad $i$ och kolumn $j$.

$$e = (((0 \otimes a) \otimes b) \otimes c) \otimes d$$

Till exempel beräknas kontrollsiffran $e$ för bas-ID-numret $abcd = 2016$ med hjälp av Operationstabell 1 på följande sätt.

$$\begin{aligned} e &= (((0 \otimes 2) \otimes 0) \otimes 1) \otimes 6 \\ &= ((1 \otimes 0) \otimes 1) \otimes 6 \\ &= (7 \otimes 1) \otimes 6 \\ &= 9 \otimes 6 \\ &= 6 \end{aligned}$$

Alltså är SSN-numret $20166$.

Observera att kontrollsiffran beror på vilken operationstabell som används. Med Operationstabell 2 får vi $e = 3$ för samma bas-ID-nummer $2016$, och hela SSN-numret blir $20163$.

$$\begin{array}{c} \begin{aligned} 2016 & \\ \Downarrow & \; \text{+kontrollsiffra med Operationstabell 2} \\ 20163 & \\ \Downarrow & \; \text{mänskliga fel} \end{aligned} \\[6pt] \boxed{\begin{array}{c} \overbrace{\mathbf{0}0163 \quad \mathbf{1}0163 \quad \dots \quad \mathbf{9}0163 \quad 2\mathbf{1}163 \quad 2\mathbf{2}163 \quad \dots \quad 2016\mathbf{8} \quad 2016\mathbf{9}}^{\text{Ändring av en enskild siffra}} \\[10pt] \overbrace{\mathbf{02}163 \quad 2\mathbf{10}63 \quad 20\mathbf{61}3 \quad 201\mathbf{36}}^{\text{Omkastning av två intilliggande siffror}} \end{array}} \end{array}$$

Syftet med att lägga till kontrollsiffran är att upptäcka mänskliga fel när man skriver eller matar in SSN-nummer. Följande funktion check kan upptäcka vissa mänskliga fel. För ett femsiffrigt tal $abcde$ definieras funktionen check på följande sätt.

$$\operatorname{check}(abcde) = ((((0 \otimes a) \otimes b) \otimes c) \otimes d) \otimes e$$

Denna funktion returnerar $0$ för ett korrekt SSN. Detta beror på att varje diagonalelement i en operationstabell är $0$ och att vi för ett korrekt SSN har $e = (((0 \otimes a) \otimes b) \otimes c) \otimes d$:

$$\operatorname{check}(abcde) = ((((0 \otimes a) \otimes b) \otimes c) \otimes d) \otimes e = e \otimes e = 0.$$

Å andra sidan innebär ett nollskilt värde från check att det angivna numret inte kan vara ett korrekt SSN. Observera att funktionen check, beroende på vilken operationstabell som används, kan returnera $0$ även för ett felaktigt SSN. Vilka typer av fel som upptäcks beror på vilken operationstabell som används; tabellen avgör kvaliteten på feldetekteringen.

Stadsförvaltningen vill upptäcka två typer av vanliga mänskliga fel i sifferföljder: att ändra en enskild siffra och att kasta om två intilliggande siffror, såsom visas i Figur B.1.

En operationstabell är bra om den kan upptäcka alla vanliga fel av de båda typerna på alla SSN-nummer som bildas från de fyrsiffriga bas-ID-numren 0000–9999. Observera att fel i kontrollsiffran, liksom fel i de fyra bas-ID-siffrorna, måste upptäckas. Till exempel är Operationstabell 1 bra. Operationstabell 2 är inte bra eftersom $\operatorname{check}(20613)$ är $0$ för $20613$, vilket är ett nummer som erhålls genom att kasta om den 3:e och den 4:e siffran i ett korrekt SSN $20163$. Faktum är att bland de $10000$ bas-ID-numren klarar Operationstabell 2 inte av att upptäcka ett eller flera vanliga fel för så många som $3439$ bas-ID-nummer.

Givet en operationstabell, avgör hur bra den är genom att räkna antalet bas-ID-nummer för vilka den givna tabellen inte kan upptäcka ett eller flera vanliga fel.

Indata

Indata består av ett enda testfall i följande format.

$$\begin{array}{cccc} x_{00} & x_{01} & \cdots & x_{09} \\ \vdots & & & \\ x_{90} & x_{91} & \cdots & x_{99} \end{array}$$

Indata beskriver en operationstabell där $x_{ij}$ är decimalsiffran på rad $i$ och kolumn $j$. Varje rad i indata motsvarar en rad i tabellen, där elementen skiljs åt av ett enda mellanslag. Diagonalelementen $x_{ii}$ ($i = 0, \ldots, 9$) är alltid $0$.

Utdata

Skriv ut antalet bas-ID-nummer för vilka den givna tabellen inte kan upptäcka ett eller flera vanliga mänskliga fel.

Exempel

Indata 1

0 3 1 7 5 9 8 6 4 2
7 0 9 2 1 5 4 8 6 3
4 2 0 6 8 7 1 3 5 9
1 7 5 0 9 8 3 4 2 6
6 1 2 3 0 4 5 9 7 8
3 6 7 4 2 0 9 5 8 1
5 8 6 9 7 2 0 1 3 4
8 9 4 5 3 6 2 0 1 7
9 4 3 8 6 1 7 2 0 5
2 5 8 1 4 3 6 7 9 0

Utdata 1

0

Indata 2

0 1 2 3 4 5 6 7 8 9
9 0 1 2 3 4 5 6 7 8
8 9 0 1 2 3 4 5 6 7
7 8 9 0 1 2 3 4 5 6
6 7 8 9 0 1 2 3 4 5
5 6 7 8 9 0 1 2 3 4
4 5 6 7 8 9 0 1 2 3
3 4 5 6 7 8 9 0 1 2
2 3 4 5 6 7 8 9 0 1
1 2 3 4 5 6 7 8 9 0

Utdata 2

3439

Indata 3

0 9 8 7 6 5 4 3 2 1
1 0 9 8 7 6 5 4 3 2
2 1 0 9 8 7 6 5 4 3
3 2 1 0 9 8 7 6 5 4
4 3 2 1 0 9 8 7 6 5
5 4 3 2 1 0 9 8 7 6
6 5 4 3 2 1 0 9 8 7
7 6 5 4 3 2 1 0 9 8
8 7 6 5 4 3 2 1 0 9
9 8 7 6 5 4 3 2 1 0

Utdata 3

9995

Indata 4

0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

Utdata 4

10000