A positive (strictly greater than zero) integer is called round if it is of the form d00...0. In other words, a positive integer is round if all its digits except the leftmost (most significant) are equal to zero. In particular, all numbers from 1 to 9 (inclusive) are round.

For example, the following numbers are round: 4000, 1, 9, 800, 90. The following numbers are not round: 110, 707, 222, 1001.

You are given a positive integer n (1 ≤ n ≤ 10^4). Represent the number n as a sum of round numbers using the minimum number of summands (addends). In other words, you need to represent the given number n as a sum of the least number of terms, each of which is a round number.

Input

The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.

Each test case is a line containing an integer n (1 ≤ n ≤ 10^4).

Output

Print t answers to the test cases. Each answer must begin with an integer k — the minimum number of summands. Next, k terms must follow, each of which is a round number, and their sum is n. The terms can be printed in any order. If there are several answers, print any of them.

Example

Input


5
5009
7
9876
10000
10


Output


2
5000 9
1
7 
4
800 70 6 9000 
1
10000 
1
10 
import java.io.*; 
import java.util.*; 
import java.math.*; 
public class Su_of_Round_Numbers 
{ 
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
    public static long binary(long x)
    {
        long left=0;
        long right=1000000;
        long ans=0;

        while(left<=right)
        {
            long mid=(left+right)/2;

            long temp=mid*(3*mid+1)/2;
            if(temp<=x)
            {
                ans=temp;
                left=mid+1;
            }
            else
            {
                right=mid-1;
            }
        }
        return ans;
    }
    public static void main(String[] args) 
    { 
        FastReader sc=new FastReader(); 
        
        PrintWriter pw=new PrintWriter(System.out);
 
        int t1=sc.nextInt();
 
        m:while(t1-->0)
        {
            char a[]=sc.nextLine().toCharArray();
            ArrayList<Integer> ans=new ArrayList<>();
            int n=a.length;
            for(int i=0;i<n;i++)
            {
                if(a[i]!='0')
                {
                    int temp=(int)Math.pow(10,n-i-1);
                    temp*=Integer.parseInt(""+a[i]);
                    ans.add(temp);
                }
            }

            pw.println(ans.size());
            for(int x:ans)
                pw.print(x+" ");
            pw.println();
        }
        pw.flush();
        
    } 
}   