#include <fstream>
#include <vector>
#include <iostream>
#include <map>

using namespace std;

uint64_t N, K;

vector<uint64_t> divs;
vector<uint64_t> solution;
map<pair<uint64_t, uint64_t>, uint64_t> possibilitiesMap;
map<pair<uint64_t, uint64_t>, uint64_t>::iterator iter;

uint64_t possibilities(uint64_t lowerLimit, uint64_t number)
{
    if (lowerLimit > number)
        return 0;
    if (lowerLimit == number) {
        pair<uint64_t, uint64_t> localPair(lowerLimit, number);
        iter = possibilitiesMap.find(localPair);
        if (iter == possibilitiesMap.end())
        {
            possibilitiesMap.insert(pair<pair<uint64_t, uint64_t>, uint64_t>(localPair, 1));
        }
        return 1;
    }

    uint64_t contor = 0;
    for (uint64_t i = 0; i < divs.size(); i++)
    {
        if (divs[i] >= lowerLimit && number % divs[i] == 0)
        {
            contor += possibilities(divs[i], number / divs[i]);
        }
    }
    contor += possibilities(number, number);

    pair<uint64_t, uint64_t> localPair(lowerLimit, number);
    possibilitiesMap.insert(pair<pair<uint64_t, uint64_t>, uint64_t>(localPair, contor));

    return contor;
}

int main()
{
    ifstream fin("desc.in");
    fin >> N >> K;
    fin.close();

    for(uint64_t i = 2; i <= N; i++)
    {
        if (N % i == 0)
            divs.push_back(i);
    }

    ofstream fout("desc.out");
    fout << possibilities(2, N) << "\n";

    uint64_t index = 0;
    bool solutionFound = 0;

    while (!solutionFound && K > 0)
    {
        //Get next digit;
        uint64_t divizor = divs[index];

        if (N % divizor != 0)
        {
            index++;
        }
        else
        {
            if (N == divizor)
            {
                solution.push_back(N);
                solutionFound = 1;
            }
            else {
                pair<uint64_t, uint64_t> localPair(divizor, N / divizor);
                iter = possibilitiesMap.find(localPair);
                uint64_t poss = iter->second;

                if (poss < K) {
                    K -= poss;
                    index++;

                    if (K == 0) {
                        solutionFound = 1;
                    }
                } else {
                    solution.push_back(divizor);
                    N /= divizor;
                }
            }
        }
    }

    for( uint64_t i = 0; i < solution.size(); i++)
    {
        fout << solution[i] << " ";
    }
    fout.close();
}