Problem: 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:

  1. it prints 0, and adds 4 to its value, so the current value is 4, and the output is 0; 
  2. it prints 4, and adds 4 to its value, so the current value is 8, and the output is 04; 
  3. it prints 8, and adds 4 to its value, so the current value is 12, and the output is 048; 
  4. it prints 2, and adds 2 to its value, so the current value is 14, and the output is 0482; 
  5. 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 ≤ 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 ≤ |s| ≤ 2 ⋅ 10^6, s_i ∈ \{0 - 9\}) — the remaining data you have. It's guaranteed that s_1 = 0.

Output

Print a 10 × 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.

Solution (in JAVA):

Solution:
import java.io.*;
import java.math.*;
import java.util.*;
import java.lang.*;

public class Main implements Runnable {
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new Main(), "Main", 1 << 26).start();
    }

    static long gcd(long a, long b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    static int gcd(int a, int b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    static long modPow(long a, long p, long m) {
        if (a == 1) return 1;
        long ans = 1;
        while (p > 0) {
            if (p % 2 == 1) ans = (ans * a) % m;
            a = (a * a) % m;
            p >>= 1;
        }
        return ans;
    }

    static long modInv(long a, long m) {
        return modPow(a, m - 2, m);
    }


    static class Radix {


        static int getMax(int arr[], int n)
        {
            int mx = arr[0];
            for (int i = 1; i < n; i++)
                if (arr[i] > mx)
                    mx = arr[i];
            return mx;
        }

        static void countSort(int arr[], int n, int exp)
        {
            int output[] = new int[n];
            int i;
            int count[] = new int[10];
            Arrays.fill(count,0);

            for (i = 0; i < n; i++)
                count[ (arr[i]/exp)%10 ]++;

            for (i = 1; i < 10; i++)
                count[i] += count[i - 1];

            for (i = n - 1; i >= 0; i--)
            {
                output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
                count[ (arr[i]/exp)%10 ]--;
            }

            for (i = 0; i < n; i++)
                arr[i] = output[i];
        }

        static void radixsort(int arr[], int n)
        {
            int m = getMax(arr, n);

            for (int exp = 1; m/exp > 0; exp *= 10)
                countSort(arr, n, exp);
        }

    }

    class DSU{
        int par[],size[],connectedComponent;
        DSU(int n){
            par=new int[n];
            size=new int[n];
            for (int i = 0; i <n ; i++) {
                size[i]=1;
                par[i]=i;
            }
            connectedComponent=n;
        }
        int root(int n){
            if(n==par[n])return n;
            return par[n]=root(par[n]);
        }
        boolean union(int u,int v){
            return f_union(root(u),root(v));
        }
        boolean f_union(int u,int v){
            if(u==v)return false;
            if(size[u]>size[v]){
                size[u]+=size[v];
                par[v]=u;
            }
            else{
                size[v]+=size[u];
                par[u]=v;
            }
            connectedComponent--;
            return true;
        }
        DSU clone_DSU(){
            DSU t=new DSU(par.length);
            t.connectedComponent=connectedComponent;
            for (int i = 0; i <par.length ; i++) {
                t.par[i]=par[i];
                t.size[i]=size[i];
            }
            return t;
        }
    }


    class segmentTree{
        long query(int cur,int l,int r,int start,int end,long tree[],long a[],long []lazy){
            if(l>end || r<start)return 0;
            if(lazy[cur]!=0){
                tree[cur]+=lazy[cur];
                if(l!=r){
                    lazy[2*cur+1]+=lazy[cur];
                    lazy[2*cur+2]+=lazy[cur];
                }
                lazy[cur]=0;
            }
            if(l>=start && r<=end)return tree[cur];
            int mid=(l+r)>>1;
            long p1=query(2*cur+1,l,mid,start,end,tree,a,lazy);
            long p2=query(2*cur+2,mid+1,r,start,end,tree,a,lazy);
            return p1+p2;
        }

        void build(int cur,int l,int r,long tree[],long a[]){
            if(l==r){
                tree[cur]=a[l];
                return;
            }
            int mid=(l+r)>>1;
            build(2*cur+1,l,mid,tree,a);
            build(2*cur+2,mid+1,r,tree,a);
            tree[cur]=tree[2*cur+1]+tree[2*cur+2];
        }

        void update(int cur,int start,int end,long val,int l,int r,long tree[],long a[],long []lazy){
            if(l>end || r<start)return;
            if(lazy[cur]!=0){
                tree[cur]+=(r-l+1)*lazy[cur];
                if(l!=r){
                    lazy[2*cur+1]+=lazy[cur];
                    lazy[2*cur+2]+=lazy[cur];
                }
                lazy[cur]=0;
            }
            if(l>=start && r<=end){
                tree[cur] += (r-l+1)*val;
                if(l != r) {
                    lazy[cur*2+1] += val;
                    lazy[cur*2+2] +=val;
                }
                return;
            }
            int mid=(l+r)>>1;
            update(2*cur+1,start,end,val,l,mid,tree,a,lazy);
            update(2*cur+2,start,end,val,mid+1,r,tree,a,lazy);
            tree[cur]=tree[2*cur+1]+tree[2*cur+2];
        }
    }


    public void run() {
        InputReader sc = new InputReader(System.in);
        // Scanner sc=new Scanner(System.in);
        //  Random sc=new Random();
        PrintWriter out = new PrintWriter(System.out);

        int pre[][][]=new int[10][10][10];
        for (int i = 0; i <10 ; i++) {
            for (int j = 0; j <10 ; j++) {
                Arrays.fill(pre[i][j],-1);
            }
        }
        for (int i = 0; i <10 ; i++) {
            for (int j = i; j <10 ; j++) {
                Queue<Node> q=new LinkedList<>();
                q.add(new Node(i,j,0));
                HashSet<Integer> vis=new HashSet<>();
                vis.add(0);
                pre[i][j][0]=0;
                while (!q.isEmpty()){
                    Node v=q.remove();
                    if(!vis.contains((v.sum+i)%10)){
                        pre[i][j][(v.sum+i)%10]=pre[i][j][v.sum]+1;
                        vis.add((v.sum+i)%10);
                        q.add(new Node(i,j,(v.sum+i)%10));
                    }
                    if(!vis.contains((v.sum+j)%10)){
                        pre[i][j][(v.sum+j)%10]=pre[i][j][v.sum]+1;
                        vis.add((v.sum+j)%10);
                        q.add(new Node(i,j,(v.sum+j)%10));
                    }
                }
            }
        }

        for (int i = 0; i <10 ; i++) {
            for (int j = i; j <10 ; j++) {
                pre[j][i]=pre[i][j];
            }
        }

        for (int i = 1; i <10 ; i++) {
            for (int j = 1; j <10 ; j++) {
                pre[i][j][0]=Integer.MAX_VALUE/2;
                for (int k = 0; k <=10 ; k++) {
                    for (int l = 0; l <=10 ; l++) {
                        if(k==0 && l==0)continue;
                        if((i*k+l*j)%10==0){
                            pre[i][j][0]=Math.min(pre[i][j][0],k+l);
                        }
                    }
                }
            }
        }


     /*   for (int i = 0; i <10 ; i++) {
            for (int j = 0; j <10 ; j++) {
                out.println(i+" "+j);
                for (int k = 0; k <10 ; k++) {
                    out.print(pre[i][j][k] + " ");
                }
                out.println();
            }
        }*/
    // out.println(pre[1][1][1]);
        long fans[][]=new long[10][10];
        char a[]=sc.next().toCharArray();
        int n=a.length;
        for (int i = 0; i <10 ; i++) {
            for (int j = i; j <10 ; j++) {
                int x=i;
                int y=j;
                long ans=0;
                int last=0;
                int flag=0;
                for (int k = 1; k < n; k++) {
                    if(last>a[k]-'0'){
                        if(pre[i][j][(10-(last-(a[k]-'0')))%10]>0){
                            ans+=pre[i][j][(10-(last-(a[k]-'0')))%10]-1;
                         //   out.print(pre[i][j][(10-(last-(a[k]-'0')))%10]+" ");
                        }
                        else if(pre[i][j][(10-(last-(a[k]-'0')))%10]==0);
                        else{
                          //  out.print(-1+" ");
                            fans[i][j]=-1;
                          //  out.println();
                            flag=1;
                            break;
                        }
                    }
                    else{
                        if(pre[i][j][(-last+(a[k]-'0'))%10]>0){
                            ans+=pre[i][j][(-last+(a[k]-'0'))%10]-1;
                           // out.print(pre[i][j][(-last+(a[k]-'0'))%10]+" ");
                        }
                        else if(pre[i][j][(-last+(a[k]-'0'))%10]==0);
                        else{
                            fans[i][j]=-1;
                          //  out.println();
                            flag=1;
                            break;
                        }
                    }
                    last=a[k]-'0';
                }
                if(flag==0){
                   // out.print((ans)+" ");
                    fans[i][j]=ans;
                  //  out.println();
                }


            }
           // out.println();
        }

        for (int i = 0; i <10 ; i++) {
            for (int j = 0; j <10 ; j++) {
                fans[j][i]=fans[i][j];
            }
        }
        for (int i = 0; i <10 ; i++) {
            for (int j = 0; j < 10; j++) {
                out.print(fans[i][j]+" ");
            }
            out.println();
        }
        out.close();
    }

    class Node{
        int x,y,sum,d=0;

        public Node(int x, int y, int sum) {
            this.x = x;
            this.y = y;
            this.sum = sum;
        }
    }

}