111111
 100009
 10011
 1000000
 8
 10201
 102030
 908172
 123456
 415
 900000
 21
 909090
 314159
 999999
 909823
 987654
 1453
 1435
 98
 10
 2
 1

1
111111
 9
100001 1 1 1 1 1 1 1 1
 1
10011
 1
1000000
 8
1 1 1 1 1 1 1 1
 2
10101 100
 3
101010 1010 10
 9
101111 101011 101010 101010 101010 101010 101010 101000 100000
 6
111111 11111 1111 111 11 1
 5
111 101 101 101 1
 9
100000 100000 100000 100000 100000 100000 100000 100000 100000
 2
11 10
 9
101010 101010 101010 101010 101010 101010 101010 101010 101010
 9
111111 101011 101011 1011 11 1 1 1 1
 9
111111 111111 111111 111111 111111 111111 111111 111111 111111
 9
101111 101111 101101 101100 101100 101100 101100 101100 101000
 9
111111 111111 111111 111111 111110 111100 111000 110000 100000
 5
1111 111 111 110 10
 5
1111 111 111 101 1
 9
11 11 11 11 11 11 11 11 10
 1
10
 2
1 1
 1
1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class B {

    public void solve() throws IOException {
        String input;
        while ( ( input = B.readln() ) != null ) {
            int num = Integer.parseInt( input.trim() );

            BinSummer summer = new BinSummer( num );
            System.out.println( summer.getBinCount() );

            for ( int i = 0; i < summer.breakdown.size(); ++i ) {
                if ( i > 0 ) {
                    System.out.print( " " );
                }
                System.out.print( summer.breakdown.get( i ) );
            }

            System.out.println();
        }
    }

    private static class BinSummer {
        private int[] num;
        private List<String> breakdown = new ArrayList<String>();

        public BinSummer( int num ) {
            init( num );
        }

        public int getBinCount() {
            calc();
            return breakdown.size();
        }

        private void calc() {
            while ( !allZ() ) {
                int[] curB = new int[ num.length ];

                for ( int i = num.length - 1; i >= 0; --i ) {
                    if ( num[i] > 0 ) {
                        curB[i] = 1;
                        num[i] -= 1;
                    }
                }

                addBin( curB );
            }
        }

        private void addBin( int[] b ) {
            StringBuilder buffer = new StringBuilder( b.length );

            for ( int d : b ) {
                buffer.append( d );
            }

            breakdown.add( buffer.toString() );
        }

        private boolean allZ() {
            for ( int n : num ) {
                if ( n > 0 ) {
                    return false;
                }
            }

            return true;
        }

        private void init( int dec ) {
            num = new int[ mag( dec ) ];

            int idx = num.length - 1;
            while ( dec > 0 ) {
                num[idx--] = dec % 10;
                dec /= 10;
            }
        }

        private int mag( int num ) {
            int len = 0;

            while ( num > 0 ) {
                num /= 10;
                ++len;
            }

            return len;
        }
    }

    private static BufferedReader br = new BufferedReader( new InputStreamReader( System.in ), 65536 );

    static String readln() throws IOException {
        return br.readLine();
    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader( InputStream stream ) {
            reader = new BufferedReader( new InputStreamReader( stream ) );
            tokenizer = null;
        }

        public String next() {
            while ( tokenizer == null || !tokenizer.hasMoreTokens() ) {
                try {
                    tokenizer = new StringTokenizer( reader.readLine() );
                } catch ( Throwable e ) {
                    return null;
                }

            }

            return tokenizer.nextToken();
        }

        public int nextInt() {
            String next = next();

            if ( next == null ) {
                return -1;
            }

            return Integer.parseInt( next );
        }
    }

    public static void main( String args[] ) {
        B solver = new B();

        try {
            solver.solve();
        } catch ( Throwable t ) {
            t.printStackTrace();
        }
    }

}
