import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

    public void solve() throws Exception {
        int n = sc.nextInt();
        ArrayList<Integer> divlist = new ArrayList<>();
        for (int i = 1; i * i <= n; i++) {
            if (n % i == 0) {
                divlist.add(i);
                if (i * i != n) {
                    divlist.add(n / i);
                }
            }
        }

        int cnt = divlist.size();
        int[] divisors = new int[cnt];
        for (int i = 0; i < cnt; i++) {
            divisors[i] = divlist.get(i);
        }
        Arrays.sort(divisors);

        int[][] dp = new int[cnt][cnt];
        int[][] fromi = new int[cnt][cnt];
        int[][] fromj = new int[cnt][cnt];
        int[][] factj = new int[cnt][cnt];
        for (int i = 0; i < cnt; i++) {
            Arrays.fill(fromi[i], -1);
            Arrays.fill(fromj[i], -1);
        }
        Arrays.fill(dp[0], 1);
        Arrays.fill(factj[0], 0);

        for (int i = 1; i < cnt; i++) {
            for (int j = 0; j < cnt; j++) {
                if (j > 0) {
                    dp[i][j] = dp[i][j - 1];
                    fromi[i][j] = fromi[i][j - 1];
                    fromj[i][j] = fromj[i][j - 1];
                    factj[i][j] = factj[i][j - 1];
                }
                if (divisors[i] % divisors[j] != 0) {
                    continue;
                }
                int previ = Arrays.binarySearch(divisors, divisors[i] / divisors[j]);
                int prevj = j - 1;
                if (prevj >= 0 && prevj < j && dp[previ][prevj] != 0 && dp[previ][prevj] + 1 > dp[i][j]) {
                    dp[i][j] = dp[previ][prevj] + 1;
                    fromi[i][j] = previ;
                    fromj[i][j] = prevj;
                    factj[i][j] = j;
                }
            }
        }

        int bestj = 0;
        for (int i = 0; i < cnt; i++) {
            if (dp[cnt - 1][i] > dp[cnt - 1][bestj]) {
                bestj = i;
            }
        }

        int curi = cnt - 1;
        int curj = bestj;
        out.println(dp[curi][curj]);
        do {
            curj = factj[curi][curj];
            out.print(divisors[curj] + " ");
            int temp = fromi[curi][curj];
            curj = fromj[curi][curj];
            curi = temp;
        } while (curi != -1);
        out.println();
    }

    final String filename = "proddiff";

    static Throwable uncaught;

    BufferedReader in;
    FastScanner sc;
    PrintWriter out;

    @Override
    public void run() {
        try {
            in = new BufferedReader(new FileReader(filename + ".in"));
            out = new PrintWriter(new FileWriter(filename + ".out"));
            sc = new FastScanner(in);
            solve();
        } catch (Throwable uncaught) {
            Solution.uncaught = uncaught;
        } finally {
            out.close();
        }
    }

    public static void main(String[] args) throws Throwable {
        Thread thread = new Thread(null, new Solution(), "", (1 << 26));
        thread.start();
        thread.join();
        if (Solution.uncaught != null) {
            throw Solution.uncaught;
        }
    }

}

class FastScanner {

    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }

}