class Solution {
public:
    vector<int> best;
    int min_diff = INT_MAX;

    vector<int> get_divisors(long long x) {
        vector<int> res;
        for (long long i = 1; i * i <= x; ++i) {
            if (x % i == 0) {
                res.push_back(i);
                if (i != x / i) res.push_back(x / i);
            }
        }
        sort(res.begin(), res.end());
        return res;
    }

    bool can_choose(long long d, int left, long long rem) {
        long long pow = 1;
        for (int i = 0; i < left; ++i) {
            if (pow > numeric_limits<long long>::max() / d) {
                return false;
            }
            pow *= d;
            if (pow > rem) {
                return false;
            }
        }
        return true;
    }

    void dfs(long long rem, int left, int last_min, vector<int>& curr) {
        if (left == 1) {
            if (rem >= last_min) {
                curr.push_back(rem);
                int diff = curr.back() - curr[0];
                if (diff < min_diff) {
                    min_diff = diff;
                    best = curr;
                }
                curr.pop_back();
            }
            return;
        }
        vector<int> divs = get_divisors(rem);
        for (int d : divs) {
            if (d >= last_min) {
                if (can_choose(d, left, rem)) {
                    curr.push_back(d);
                    dfs(rem / d, left - 1, d, curr);
                    curr.pop_back();
                }
            }
        }
    }

    vector<int> minDifference(int n, int k) {
        int sulmariton = n;
        vector<int> curr;
        dfs(n, k, 1, curr);
        return best;
    }
};