use proconio::input;

const N: usize = 81181819;
const K: usize = 9;
const M: usize = 8 * K;

fn main() {
    let solver = Solver::new();

    input! { t: usize }
    for _ in 0..t {
        input! { n: usize }
        let ans = solver.solve(N - n);
        println!("{}", ans.len());
        println!(
            "{}",
            ans.iter()
                .map(ToString::to_string)
                .collect::<Vec<_>>()
                .join("\n")
        );
    }
}

struct Solver {
    table: Vec<Option<Vec<usize>>>,
}

impl Solver {
    fn new() -> Self {
        let mut table = vec![None; M + 1];
        table[0] = Some(vec![]);
        for i in 1..=M {
            for d in [8, 1] {
                if i >= d {
                    if let Some(v) = &table[i - d] {
                        if v.len() >= K {
                            continue;
                        }
                        let mut v = v.clone();
                        v.push(d);
                        table[i] = Some(v);
                        break;
                    }
                }
            }
        }
        Self { table }
    }

    fn solve(&self, n: usize) -> Vec<usize> {
        for k in 1..10 {
            let ans = self.search(n, k);
            if let Some(ans) = ans {
                return ans;
            }
        }
        unreachable!()
    }

    fn search(&self, n: usize, k: usize) -> Option<Vec<usize>> {
        for (i, v) in self.table.iter().enumerate() {
            if n < i {
                break;
            }
            if let Some(v) = v {
                if v.len() > k {
                    continue;
                }

                if i == n {
                    assert!(v.len() <= k);
                    let mut v = v.clone();
                    v.resize(k, 0);
                    return Some(v);
                }

                if (n - i) % 10 == 0 {
                    if let Some(mut w) = self.search((n - i) / 10, k) {
                        assert_eq!(w.len(), k);

                        for a in &mut w {
                            *a *= 10;
                        }

                        for (a, b) in w.iter_mut().zip(v) {
                            *a += b;
                        }

                        return Some(w);
                    }
                }
            }
        }
        None
    }
}