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

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using namespace std;

#include <random>
template< class T>
T pow_ (T x, uint64_t n, uint64_t M){
    T u = 1;
    if(n > 0){
        u = pow_(x, n/2, M);
        if (n % 2 == 0) u = (u*u) % M;
        else u = (((u * u)% M) * x) % M;
    }
    return u;
};

bool suspect(__uint128_t a, uint64_t s, uint64_t d, uint64_t n){
    __uint128_t x = pow_(a, d, n);
    if (x == 1) return true;
    for (int r = 0; r < s; ++r) {
        if(x == n-1) return true;
        x = x * x % n;
    }
    return false;
}

template<class T>
bool miller_rabin(T m){
    uint64_t n = m;
    if (n <= 1 || (n > 2 && n % 2 == 0)) return false;
    uint64_t d = n - 1, s = 0;
    while (!(d&1)) {++s; d >>= 1;}
    static const uint64_t v[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
    for (auto &&p : v) {
        if(p >= n) break;
        if(!suspect(p, s, d, n)) return false;
    }
    return true;
}

vector<int> get_prime(int n) {
    if(n <= 1) return vector<int>{};
    vector<bool> prime(static_cast<unsigned int>(n + 1), true);
    vector<int> res;
    prime[0] = false; prime[1] = false;
    for(int i = 2; i * i <= n; i++){
        if(prime[i]) for(int j = i << 1; j <= n; j += i) prime[j] = false;
    }
    for (int i = 2; i <= n; ++i) {
        if(prime[i]) res.emplace_back(i);
    }
    return res;
}
const auto p = get_prime(100000);

ll phollad_rho(ll n){
    random_device rng;
    ll a = rng() % n;
    while (a == 0 || a == n  - 2) a = rng() % n;

    uint64_t y = static_cast<uint64_t>(rng() % n), r = 1, q = 11, x, g, ys = y;
    do {
        x = y;
        for (int i = 0; i < r; ++i) {
            y = static_cast<uint64_t>((__uint128_t)y * y % n);
            y += a;
            if(y < a) y += (UINT64_MAX-n) + 1;
            y %= n;
        }
        uint64_t k = 0;
        do {
            for (int i = 0; i < ((r-k > 1000) ? 1000 : r-k); ++i) {
                ys = y;
                y = static_cast<uint64_t>((__uint128_t)y * y % n);
                y += a;
                if(y < a) y += (UINT64_MAX-n) + 1;
                y %= n;
                q = static_cast<uint64_t>((__uint128_t)q * (x > y ? x - y : y - x) % n);
            }
            g = __gcd(q, static_cast<uint64_t>(n));
            k += 1000;
        }while(k < r && g == 1);
        r <<= 1;
    }while (g == 1);
    if(g == n){
        do{
            ys = ys * ys % n;
            ys += a;
            if(ys < a) y += (UINT64_MAX-n) + 1;
            ys %= n;
            g = __gcd((x > ys ? x - ys : ys - x), static_cast<uint64_t>(n));
        }while(g == 1);
    }
    return g;
}

vector<ll> prime_factor(ll n, int d = 0){
    vector<ll> a, res;
    if(!d) for (auto &&i : p) {
            while (n % i == 0){
                res.emplace_back(i);
                n /= i;
            }
        }
    while(n != 1){
        if(miller_rabin(n)){
            a.emplace_back(n);
            break;
        }
        ll x = phollad_rho(n);
        n /= x;
        a.emplace_back(x);
    }

    for (auto &&i : a) {
        if (miller_rabin(i)) {
            res.emplace_back(i);
        } else {
            vector<ll> b = prime_factor(i, d + 1);
            for (auto &&j : b) res.emplace_back(j);
        }
    }
    return res;
}

int main() {
    ll n;
    cin >> n;
    cout << n << ":";
    for (auto &&a : prime_factor(n)) {
        cout << " " << a;
    }
    cout << "\n";
    return 0;
}



Measured memory_bytes: 3268