#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

// Hàm tính giai thừa
long long fact(int n) {
    long long res = 1;
    for (int i = 2; i <= n; ++i) {
        if (res > 1e18 / i) return -1; // Tràn số
        res *= i;
    }
    return res;
}

// Hàm phân tích N thành tích các giai thừa
// Sử dụng đệ quy/quy hoạch động
// Trả về vector chứa các giai thừa nếu thành công, rỗng nếu thất bại
vector<int> solve(int n) {
    // Tạo mảng các giai thừa có thể dùng
    vector<long long> facts;
    for (int i = 1; ; ++i) {
        long long f = fact(i);
        if (f == -1 || f > n) break;
        facts.push_back(f);
    }

    // Chuyển facts sang dạng int (sau khi kiểm tra)
    vector<int> f_ints;
    for (long long x : facts) f_ints.push_back((int)x);

    // DP: dp[i] là bitmask các giai thừa dùng được để tạo ra i (hoặc similar)
    // Do số lượng giai thừa nhỏ (max ~20), có thể dùng DP theo tổng
    // Nhưng tổng N có thể lớn. 
    // Phân tích N thành thừa số nguyên tố trước.

    // Thay vào đó, dùng phương pháp gom nhóm thừa số nguyên tố.
    // 1 giai thừa k! chứa các thừa số nguyên tố từ 2 đến k.
    // Ta cần gom các thừa số nguyên tố của N thành các tập hợp tương ứng vs k!.

    // Gợi ý từ Solution 1:
    // Phân tích N thành thừa số nguyên tố.
    // Sau đó thử các factorial từ lớn đến nhỏ.

    map<int, int> prime_counts;
    int temp = n;
    for (int i = 2; i * i <= temp; ++i) {
        while (temp % i == 0) {
            prime_counts[i]++;
            temp /= i;
        }
    }
    if (temp > 1) prime_counts[temp]++;

    vector<int> result;
    // Thử các factorial từ lớn nhất có thể
    // Số factorial lớn nhất: 20! ~ 2.4e18, nhưng N max là 10^18?
    // Solution 1 dùng N=300, có lẽ là limit của số giai thừa.

    // Ta thử tìm các factorial greedily
    for (int k = 20; k >= 2; --k) {
        long long f = fact(k);
        if (f == -1) continue;
        if (f > n) continue;

        // Kiểm tra xem f có thể chia hết cho các thừa số hiện tại không
        // Bằng cách kiểm tra xem các thừa số của f có sẵn trong prime_counts không
        map<int, int> f_primes;
        int temp_f = f;
        for (int i = 2; i * i <= temp_f; ++i) {
            while (temp_f % i == 0) {
                f_primes[i]++;
                temp_f /= i;
            }
        }
        if (temp_f > 1) f_primes[temp_f]++;

        bool can_use = true;
        for (auto &[p, c] : f_primes) {
            if (prime_counts[p] < c) {
                can_use = false;
                break;
            }
        }

        if (can_use) {
            // Dùng factorial này
            result.push_back(k);
            for (auto &[p, c] : f_primes) {
                prime_counts[p] -= c;
            }
            // Quay lại thử từ đầu (hoặc tiếp tục greedily)
            // Greedy từ lớn xuống nhỏ thường hiệu quả với bài toán này.
            // Nhưng Solution 1 dường như dùng backtracking.
            // Để đơn giản, ta thử greedily trước. Nếu fail thì thử lại.
            // Nhưng thực tế, greedy từ lớn xuống nhỏ là optimal cho bài này).
            // Tuy nhiên, để chắc chắn, ta reset vòng lặp sau khi dùng 1 factorial.
            k = 21; // Reset về 21 để lặp lại từ đầu với k--
        }
    }

    // Kiểm tra còn thừa số nào không
    for (auto &[p, c] : prime_counts) {
        if (c > 0) return {}; 
    }

    return result;
}

int main() {
    int n;
    cin >> n;
    vector<int> res = solve(n);
    if (res.empty()) cout << "NO";
    else {
        sort(res.begin(), res.end()); // Có thể cần sort
        for (int x : res) cout << x << " ";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<long long> facts;
vector<int> result;
bool found = false;

void precompute() {
    long long f = 1;
    for (int i = 1; ; ++i) {
        f *= i;
        if (f > 1000000000000000000LL) break; // Giới hạn
        facts.push_back(f);
    }
}

// Phân tích n thành thừa số nguyên tố
// Đếm số lượng mỗi nguyên tố
void getPrimeCounts(long long n, vector<int>& counts) {
    for (int i = 2; i * i <= n; ++i) {
        while (n % i == 0) {
            counts[i]++;
            n /= i;
        }
    }
    if (n > 1) counts[n]++;
}

void backtrack(int idx, long long current_val, vector<int>& prime_counts, vector<int>& current_factors) {
    if (found) return;
    if (current_val == 0) {
        // Kiểm tra xem có thừa số nguyên tố nào sót lại không
        for (int c : prime_counts) if (c > 0) return;
        result = current_factors;
        found = true;
        return;
    }

    if (idx < 0) return;

    // Thử dùng facts[idx]
    // Tính thừa số nguyên tố của facts[idx]
    long long f = facts[idx];
    vector<int> f_counts(100, 0); // Kích thước đủ lớn
    getPrimeCounts(f, f_counts);

    // Kiểm tra có dùng được không
    bool can_use = true;
    for (int i = 0; i < 100; ++i) {
        if (f_counts[i] > prime_counts[i]) {
            can_use = false;
            break;
        }
    }

    if (can_use) {
        // Dùng
        for (int i = 0; i < 100; ++i) prime_counts[i] -= f_counts[i];
        current_factors.push_back(idx + 1); // index 0 la 1!, index 1 la 2!
        backtrack(idx - 1, current_val / f, prime_counts, current_factors);
        current_factors.pop_back();
        for (int i = 0; i < 100; ++i) prime_counts[i] += f_counts[i];
    }

    // Thử không dùng
    backtrack(idx - 1, current_val, prime_counts, current_factors);
}

int main() {
    precompute();
    long long n;
    cin >> n;
    vector<int> prime_counts(100, 0);
    getPrimeCounts(n, prime_counts);
    vector<int> current_factors;
    found = false;
    backtrack(facts.size() - 1, n, prime_counts, current_factors);
    if (found) {
        sort(result.begin(), result.end());
        for (int x : result) cout << x << " ";
    } else {
        cout << "NO";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

// Sử dụng map để lưu trữ thừa số nguyên tố
// Hàm phân tích số thành thừa số nguyên tố
void factorize(long long n, map<long long, int>& factors) {
    for (long long i = 2; i * i <= n; ++i) {
        while (n % i == 0) {
            factors[i]++;
            n /= i;
        }
    }
    if (n > 1) factors[n]++;
}

// Kiểm tra xem factorial k! có thể tạo từ các thừa số hiện có không
bool canTake(int k, map<long long, int>& current_factors) {
    long long f = 1;
    for (int i = 2; i <= k; ++i) f *= i;

    map<long long, int> fact_factors;
    factorize(f, fact_factors);

    for (auto &[p, c] : fact_factors) {
        if (current_factors[p] < c) return false;
    }
    return true;
}

void subtractFactors(int k, map<long long, int>& current_factors) {
    long long f = 1;
    for (int i = 2; i <= k; ++i) f *= i;

    map<long long, int> fact_factors;
    factorize(f, fact_factors);

    for (auto &[p, c] : fact_factors) {
        current_factors[p] -= c;
    }
}

int main() {
    long long n;
    cin >> n;

    map<long long, int> current_factors;
    factorize(n, current_factors);

    vector<int> result;

    // Thử greedily từ factorial lớn nhất (20) về nhỏ
    // Nhưng cẩn thận: greedy đôi khi sai.
    // Ví dụ: N = 2! * 3! * 4! (tức là tổng các thừa số)
    // Giả sử N có thừa số là 2^a * 3^b * ...
    // greedy từ lớn xuống nhỏ thường đúng với bài toán chia nhóm này.

    bool changed = true;
    while (changed) {
        changed = false;
        for (int k = 20; k >= 2; --k) {
            if (canTake(k, current_factors)) {
                result.push_back(k);
                subtractFactors(k, current_factors);
                changed = true;
                break; // Chỉ lấy 1 lần mỗi vòng lặp, sau đó reset
            }
        }
    }

    // Kiểm tra còn thừa số không
    for (auto &[p, c] : current_factors) {
        if (c > 0) {
            cout << "NO";
            return 0;
        }
    }

    sort(result.begin(), result.end());
    for (int x : result) cout << x << " ";

    return 0;
}