#include <bits/stdc++.h>
using namespace std;

#define fs first
#define sc second
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()

template <typename T> struct XorShift {
  XorShift() : latte(uniform_int_distribution<T>(0, numeric_limits<T>::max())) {}
  XorShift(T l, T r) : latte(uniform_int_distribution<T>(l, r)) {}

  struct generator {
    generator() : w(rd()) {}

    using result_type = unsigned int;
    random_device rd;
    result_type x = 123456789u, y = 362436069u, z = 521288629u, w, t;

    static constexpr result_type min() {
      return 0u;
    }
    static constexpr result_type max() {
      return numeric_limits<result_type>::max();
    }
    result_type operator()() {
      t = x ^ (x << 11), x = y, y = z, z = w;
      return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
    }
  } malta;
  uniform_int_distribution<T> latte;

  T operator()() {
    return latte(malta);
  }
};

using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;

template <class Uint, class BinOp> bool is_prime_impl(const Uint &n, const Uint *witness, BinOp modmul) {
  if (n == 2) return true;
  if (n < 2 || n % 2 == 0) return false;
  const Uint m = n - 1, d = m / (m & -m);
  auto modpow = [&](Uint a, Uint b) {
    Uint res = 1;
    for (; b; b /= 2) {
      if (b & 1) res = modmul(res, a);
      a = modmul(a, a);
    }
    return res;
  };
  auto suspect = [&](Uint a, Uint t) {
    a = modpow(a, t);
    while (t != n - 1 && a != 1 && a != n - 1) {
      a = modmul(a, a);
      t = modmul(t, 2);
    }
    return a == n - 1 || t % 2 == 1;
  };
  for (const Uint *w = witness; *w; w++) {
    if (*w % n != 0 && !suspect(*w, d)) return false;
  }
  return true;
}

bool is_prime(const u128 &n) {
  constexpr u128 witness[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022, 0};
  auto modmul = [&](u128 a, u128 b) { return a * b % n; };
  return is_prime_impl<u128>(n, witness, modmul);
}

long long multMod(long long a, long long b, long long m) {
  long long res = 0;
  a %= m;
  while (b) {
    if (b & 1) {
      res = (res + a) % m;
    }
    a = (a * 2) % m;
    b = b / 2;
  }
  return res;
}

long long PollardRho(long long num, long long c) {
  long long x, y, p;
  x = p = 1LL;
  long long next = 2, i = 1;
  while (p == 1) {
    ++i;
    if (i == next) {
      y = x;
      next *= 2;
    }
    x = (multMod(x, x, num) + c) % num;
    if (y == x) return PollardRho(num, c + 1);
    p = __gcd(num, llabs(x - y));
  }
  return p;
}

vector<long long> prime_factor(long long n) {
  vector<long long> a;
  for (int i = 1;; ++i) {
    if (is_prime(n)) {
      a.push_back(n);
      break;
    }
    int d = PollardRho(n, i);
    a.push_back(d);
    n /= d;
  }

  vector<long long> res;
  for (int i = 0; i < a.size(); ++i) {
    if (is_prime(a[i])) {
      res.push_back(a[i]);
    } else {
      vector<long long> po = prime_factor(a[i]);
      for (int j = 0; j < po.size(); ++j) {
        res.push_back(po[j]);
      }
      // for (int j = 2; j * j <= a[i]; ++j) {
      //   while (a[i] % j == 0) {
      //     res.push_back(j);
      //     a[i] /= j;
      //   }
      // }
    }
  }

  sort(all(res));

  return res;
}

signed main() {
  XorShift<long long> rd;

  // int q;
  // cin >> q;
  //
  // while (q--) {
  long long n;
  cin >> n;

  vector<long long> ans = prime_factor(n);
  cout << n << ": ";
  for (int i = 0; i < ans.size(); ++i) {
    cout << ans[i] << (i + 1 == ans.size() ? "\n" : " ");
  }
  // }
}

Measured memory_bytes: 3196