GENERIC-MST-FUNCTION (G,w)
1    T := 空集合
2    while T 还不是生成树
3        do 找出对 T 来说是不会形成环，且权重最低的边 (u, v)
4            T := T U {(u, v)}
5    return T

//基于并查集
class Edge{
public:
    int u, v;       //两个结点
    double len;     //边权
    //bool choose;  //边是否使用过

    Edge(){}
    Edge(int _u, int _v, double _len){
        u = _u;
        v = _v;
        len = _len;
        //choose = false;
    }
};

//比较函数，升序
bool cmp(const Edge &a, const Edge &b){
    if (a.len < b.len){
        return true;
    }else{
        return false;
    }
}

class kruskal{
    vector<Edge> edge;  //边的集合
    vector<int> father; //结点的父亲结点
    int n;              //n points
    int ans;            //the least values of the spanning tree

    void Solve(){
        ///Init///
        edge.clear();
        father.clear();
    
        ///read point///
        (read edge[])
        (initial father[])
    
        ///get edges sorted///
        sort(edge.begin(), edge.end(), cmp);
    
        ///kruskal start///
        int cnt = 0;//number of edges
        ans = 0;
        for (int i = 0; i < edge.size(); i++){
            if (cnt == n-s-1) break;
            //一般地，s为0.
            //如果有s条边在算法开始之前确定是最小生成树的一部分，当cnt=n-s-1时，算法完成。
            if (IsSameFa(edge[i].u, edge[i].v)) continue;
            Union(edge[i].u, edge[i].v);
            edge[i].choose = true;
            ans += edge[i].len;
            cnt++;
        }
    
        ///output///
    }
    
    bool IsSameFa(int x, int y){
        return GetFather(x) == GetFather(y);
    }

    void Union(int x, int y){
        father[GetFather(x)] = GetFather(y);
    }

    int GetFather(int x){
        if (father[x] == x) return x;
        else return father[x] = GetFather(father[x]);
    }

}

#include <iostream>
using namespace std;

void fac(int n){
    int a = 2;
    while(a*a <= n){
        while(n%a == 0){
            cout << a << endl;
            n = n/a;
        }
        a++;
    }
    if (n > 1) cout << n << endl;
}

int main(){
    int n;
    cin >> n;
    fac(n);
}