#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
using i64 = int64_t;
using v64 = vector<i64>;

#define rep(i, s, n) for (i64 i = (s); i < (n); ++i)

template <typename T>
ostream &operator<<(ostream &os, const std::unordered_set<T> &x) {
  os << "unordered_set{";
  for (const auto &v : x) {
    os << v << ", ";
  }
  os << "}";
  return os;
}

template <typename T>
ostream &operator<<(ostream &os, const std::vector<T> &x) {
  os << "vector{";
  for (const auto &v : x) {
    os << v << ", ";
  }
  os << "}";
  return os;
}

template <typename F, typename S>
std::ostream &operator<<(std::ostream &os, const std::pair<F, S> &x) {
  os << "pair{" << x.first << ", " << x.second << "}";
  return os;
}

template <typename T1>
void dbg(const T1 &x1) {
  std::cerr << x1 << std::endl;
}

template <typename T1, typename T2>
void dbg(const T1 &x1, const T2 &x2) {
  std::cerr << x1 << " " << x2 << std::endl;
}

template <typename T1, typename T2, typename T3>
void dbg(const T1 &x1, const T2 &x2, const T3 &x3) {
  std::cerr << x1 << " " << x2 << " " << x3 << std::endl;
}

template <typename T1, typename T2, typename T3, typename T4>
void dbg(const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4) {
  std::cerr << x1 << " " << x2 << " " << x3 << " " << x4 << std::endl;
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void dbg(const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5) {
  std::cerr << x1 << " " << x2 << " " << x3 << " " << x4 << " " << x5
            << std::endl;
}

template <typename T1, typename T2, typename T3, typename T4, typename T5,
          typename T6>
void dbg(const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5,
         const T6 &x6) {
  std::cerr << x1 << " " << x2 << " " << x3 << " " << x4 << " " << x5 << " "
            << x6 << std::endl;
}

template <typename T>
std::vector<pair<std::int64_t, std::int64_t>> factor(T n) {
  assert(1 <= n);
  std::vector<pair<std::int64_t, std::int64_t>> ret{};
  std::int64_t i{2};
  while (i * i <= n) {
    std::int64_t count{0};
    while (n % i == 0) {
      n /= i;
      ++count;
    }
    if (count) {
      ret.push_back(std::make_pair(i, count));
    }
    if (i % 2) {
      ++i;
    }
    ++i;
  }
  if (1 < n) {
    ret.push_back(std::make_pair(n, 1));
  }
  return ret;
}

template <typename T>
constexpr T ipow(T x, T n) {
  assert(0 <= n);
  T ret{1};
  while (0 < n) {
    if (n % 2 == 1) {
      ret *= x;
      --n;
    } else {
      x *= x;
      n /= 2;
    }
  }
  return ret;
}

void run() {
  i64 n;
  cin >> n;
  auto fs = factor(n);
  i64 nret{1};
  for (const auto &[f, c] : fs) {
    nret *= c + 1;
  }
  v64 ret(nret, 1);
  i64 chunk{1};
  for (const auto &[f, c] : fs) {
    rep(ir, 0, nret / (chunk * (c + 1))) {
      i64 s{1};
      rep(ic, 1, c + 1) {
        s *= f;
        rep(ichunk, 0, chunk) {
          ret[ir * chunk * (c + 1) + ic * chunk + ichunk] *= s;
        }
      }
    }
    chunk *= c + 1;
  }
  sort(begin(ret), end(ret));
  for (const auto r : ret) {
    cout << r << endl;
  };
}

int main() {
  cin.tie(nullptr);
  cout.precision(std::numeric_limits<double>::max_digits10);
  run();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265358979323
#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define ff first
#define ss second
#define MOD 1000000007
ll power(ll a, ll b) { //a^b
	ll res = 1;
	a = a % MOD;
	while (b > 0) {
		if (b & 1) {res = (res * a) % MOD; b--;}
		a = (a * a) % MOD;
		b >>= 1;
	}
	return res;
}

ll gcd(ll a, ll b) {return (b == 0) ? a : gcd(b, a % b);}

int main() {
#ifndef ONLINE_JUDGE
	// for getting input from input.txt
	freopen("input.txt", "r", stdin);
	// for writing output to output.txt
	freopen("output.txt", "w", stdout);
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	ll n;
	cin >> n;
	vl fact;
	for (ll i = 1; i * i <= n; i++) {
		if (n % i)
			continue;
		if (i * i != n)
			fact.pb(n / i);
		fact.pb(i);
	}
	sort(all(fact));
	for (auto i : fact)
		cout << i << "\n";
}
