#include <stdio.h>
#include <assert.h>
#include <vector>
#include <algorithm>
#define getchar getchar_unlocked
#define putchar putchar_unlocked
using namespace std;
using i64 = long long;
using i128 = __int128;
using u64 = unsigned long long;
using u128 = __uint128_t;

u128 rd()
{
    u128 k = 0;
    char c = getchar();
    while (c < '0' || c > '9')
        c = getchar();
    while (c >= '0' && c <= '9')
    {
        k = (k << 1) + (k << 3) + (c ^ 48);
        c = getchar();
    }
    return k;
}

void wr(u128 x)
{
    if (x > 9)
        wr(x / 10);
    putchar(x % 10 + '0');
}

const u128 MSB128 = ((u128)0x8000000000000000ull) << 64;
struct u256
{
    u128 lo, hi;
    u256() {}
    u256(u128 lo, u128 hi) : lo(lo), hi(hi) {}
};
const u256 ten = u256(10, 0);
struct u512
{
    u256 lo, hi;
    u512() {}
    u512(u256 lo, u256 hi) : lo(lo), hi(hi) {}
};

// return a < b ? -1 : a == b ? 0 : 1
int cmp256(u256 a, u256 b)
{
    if (a.hi == b.hi && a.lo == b.lo)
        return 0;
    else if ((a.hi > b.hi) || ((a.hi == b.hi) && (a.lo > b.lo)))
        return 1;
    else
        return -1;
}

void shl256(u256 &a)
{
    a.hi <<= 1;
    a.hi |= ((a.lo & MSB128) ? 1 : 0);
    a.lo <<= 1;
}

void shl512(u512 &a)
{
    shl256(a.hi);
    a.hi.lo |= ((a.lo.hi & MSB128) ? 1 : 0);
    shl256(a.lo);
}

void shr256(u256 &a)
{
    a.lo >>= 1;
    a.lo |= ((a.hi & 1) ? MSB128 : 0);
    a.hi >>= 1;
}

void shr512(u512 &a)
{
    shr256(a.lo);
    a.lo.hi |= ((a.hi.lo & 1) ? MSB128 : 0);
    shr256(a.hi);
}

u256 add256(u256 a, u256 b)
{
    u256 ret;
    ret.hi = a.hi + b.hi;
    ret.lo = a.lo + b.lo;
    if (ret.lo < a.lo || ret.lo < b.lo)
        ++ret.hi;
    return ret;
}

u256 sub256(u256 a, u256 b)
{
    u256 ret;
    ret.hi = a.hi - b.hi;
    ret.lo = a.lo - b.lo;
    if (ret.lo > a.lo)
        --ret.hi;
    return ret;
}

u256 mul128(u128 a, u128 b)
{
    u64 a_hi = a >> 64, a_lo = u64(a);
    u64 b_hi = b >> 64, b_lo = u64(b);
    u128 p01 = u128(a_lo) * b_lo;
    u128 p12 = u128(a_hi) * b_lo + u64(p01 >> 64);
    u64 t_hi = p12 >> 64, t_lo = p12;
    p12 = u128(a_lo) * b_hi + t_lo;
    u128 p23 = u128(a_hi) * b_hi + u64(p12 >> 64) + t_hi;
    return u256(u64(p01) | (p12 << 64), p23);
}

u256 div256(u256 a, u256 b)
{
    u512 p;

    p.hi = u256(0, 0), p.lo = a;
    for (unsigned i = 0; i < 256; ++i)
    {
        shl512(p);
        if (cmp256(p.hi, b) >= 0)
        {
            p.hi = sub256(p.hi, b);
            p.lo.lo |= 1;
        }
    }
    return p.lo;
}

u256 mod256(u256 a, u256 b)
{
    u512 p;

    p.hi = u256(0, 0), p.lo = a;
    for (unsigned i = 0; i < 256; ++i)
    {
        shl512(p);
        if (cmp256(p.hi, b) >= 0)
        {
            p.hi = sub256(p.hi, b);
            p.lo.lo |= 1;
        }
    }
    return p.hi;
}

void print(u256 x)
{
    if (x.hi || (x.lo > 9))
        print(div256(x, ten));
    u256 rem = mod256(x, ten);
    putchar((int)rem.lo + '0');
}

u128 pow_u128(u128 a, u128 t, u128 mod)
{
    u128 r = 1;
    for (; t; t >>= 1, a = mod256(mul128(a, a), u256(mod, 0)).lo)
        if (t & 1)
            r = mod256(mul128(r, a), u256(mod, 0)).lo;
    return r;
}

bool check_prime(u128 n)
{
    static const u128 jp[] = {2, 3, 5, 7, 11, 13, 17, 19};
    if (n == 1 || ((!(n & 1)) && n > 2))
        return false;
    for (u128 p : jp)
        if (n % p == 0)
            return n == p;
    u128 r = n - 1, x, y;
    int e = 0;

    while (~r & 1)
        r >>= 1, ++e;

    for (int p : jp)
    {
        x = pow_u128(p, r, n);

        for (int t = 0; t < e && x > 1; ++t)
        {
            y = mod256(mul128(x, x), u256(n, 0)).lo;

            if (y == 1 && x != n - 1)
                return false;

            x = y;
        }

        if (x != 1)
            return false;
    }

    return true;
}

u128 next_prime(u128 n)
{
    n += ~n & 1;

    while (!check_prime(n += 2))
        ;

    return n;
}

u128 ctz(u128 x) { return (!x) ? 128 : u64(x) ? __builtin_ctzll(x) : __builtin_ctzll(x >> 64) + 64; }

u128 gcd(u128 a, u128 b)
{
    if (!a || !b)
        return a | b;

    int shift = ctz(a | b);

    for (b >>= ctz(b); a; a -= b)
        if ((a >>= ctz(a)) < b)
            swap(a, b);

    return b << shift;
}


namespace rho
{
    // global area for mont(N), N is odd
    // assume that mod is odd
    struct Mont
    {
        u128 mod, inv, r2;
        Mont(u128 n) : mod(n)
        {
            assert(n & 1);
            inv = n;

            for (int i = 0; i < 6; ++i)
                inv *= (2 - n * inv);

            r2 = (~n + 1) % n;

            for (int i = 0; i < 4; ++i)
                if ((r2 <<= 1) >= mod)
                    r2 -= mod;

            for (int i = 0; i < 5; ++i)
                r2 = mul(r2, r2);
        }
        u128 reduce(u256 x) const
        {
            u128 y = x.hi - mul128(x.lo * inv, mod).hi;
            return (y & MSB128) ? y + mod : y;
        }
        u128 reduce(u128 x) const { return reduce(u256(x, 0)); }
        u128 init(u128 n) const { return reduce(mul128(n, r2)); }
        u128 mul(u128 a, u128 b) const { return reduce(mul128(a, b)); }
    } mont(1);
    u128 N;
    u128 add(u128 a, u128 b) { return (a < N - b) ? a + b : sub256(add256(u256(a, 0), u256(b, 0)), u256(N, 0)).lo; }
    u128 sub(u128 a, u128 b) { return (a < b) ? sub256(add256(u256(a, 0), u256(N, 0)), u256(b, 0)).lo : a - b; }
    u128 mul(u128 a, u128 b) { return mont.mul(a, b); }

    vector<u128> ans;
    u128 rho(u128 n, int c, int S)
    {
        if (n % 2 == 0)
            return 2;

        u128 x = 2, y = 2, d;

        for (;;)
        {
            u128 a = x, b = y;
            d = 1;

            for (int i = 0; i < S; ++i)
            {
                x = add(mul(x, x), c);
                y = add(mul(y, y), c);
                y = add(mul(y, y), c);
                d = mul(d, sub(x, y));
            }

            d = gcd(d, n);

            if (d == 1)
                continue;

            if (d != n)
                return d;

            x = a, y = b;

            for (int i = 0; i < S; ++i)
            {
                x = add(mul(x, x), c);
                y = add(mul(y, y), c);
                y = add(mul(y, y), c);
                d = gcd(n, sub(x, y));

                if (d != 1)
                    return d % n;
            }

            return 0;
        }
    }

    u128 pollard_brent_montgomery(u128 n)
    {
        u128 res = rho(n, 1, 128), c = 2;
        for (; !res; c++)
            res = rho(n, c, 128);
        return res;
    }

    void doit(u128 n)
    {
        N = n, mont = Mont(N);

        if (check_prime(n))
            ans.push_back(n);
        else
        {
            u128 res = pollard_brent_montgomery(n);
            doit(res), doit(n / res);
        }
    }
    vector<u128> solve(u128 n)
    {
        ans.clear();
        // special optimize for even (or the Mont optimization is unavailable)
        while (!(n & 1))
            ans.push_back(2), n >>= 1;
        if (n <= 1)
            return ans;
        doit(n);
        sort(ans.begin(), ans.end());
        return ans;
    }
}

int main()
{
    u128 T = 1;
    while (T--)
    {
        u128 n = rd();
        vector<u128> ans = rho::solve(n);
        // wr(ans.size()), putchar(' ');
        for (size_t i = 0; i < ans.size(); ++i)
            wr(ans[i]), putchar(' ');
        putchar('\n');
    }
    return 0;
}