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

const int Max = 1e5;
vector<vector<int> > Next;

vector<int> getNext(vector<int> &arr) {
    vector<int> res;
    for(int &x : arr) {
        for(int f : Next[x]) {
            res.push_back(f);
            if(res.size() == Max) return res;
        }
    }
    return res;
}

vector<int> getDouble(vector<int> &arr) {
    vector<int> firsts;
    firsts.push_back(-1);
    int pos = 0;
    for(int i = 0; i < arr.size(); ++i) {
        if(arr[i] == pos) {
            pos++;
            firsts.push_back(i);
        }
    }
    vector<int> res;
    for(int i = 0; i < arr.size(); ++i) {
        for(int j = firsts[arr[i]]+1; j <= firsts[arr[i]+1]; ++j) {
            res.push_back(arr[j]);
            if(res.size() == Max) return getNext(res);
        }
    }
    return getNext(res);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll x, k;
    cin >> x >> k;
    if(k == 0) {
        cout << x << '\n';
        return 0;
    }
    vector<ll> divisors;
    for(ll i = 1; i*i <= x; ++i) {
        if(x%i == 0) {
            divisors.push_back(i);
            if(x/i != i) {
                divisors.push_back(x/i);
            }
        }
    }
    int n = divisors.size();
    sort(divisors.begin(), divisors.end());
    Next.resize(n);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(divisors[i] % divisors[j] == 0) {
                Next[i].push_back(j);
            }
        }
    }
    k = min(k, (ll)Max+1);
    vector<int> arr = {n-1};
    arr = getNext(arr);
    while(k > 1) {
        arr = getDouble(arr);
        if(k%2 == 1) {
            arr = getNext(arr);
        }
        k /= 2;
    }
    for(int pos : arr) cout << divisors[pos] << ' ';
    cout << '\n';
    return 0;
}


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

const int Max = 1e5;
vector<vector<int> > Next;

vector<int> getNext(vector<int> &arr) {
    vector<int> res;
    for(int &x : arr) {
        for(int f : Next[x]) {
            res.push_back(f);
            if(res.size() == Max) return res;
        }
    }
    return res;
}

vector<int> getDouble(vector<int> &arr) {
    vector<int> firsts;
    firsts.push_back(-1);
    int pos = 0;
    for(int i = 0; i < arr.size(); ++i) {
        if(arr[i] == pos) {
            pos++;
            firsts.push_back(i);
        }
    }
    vector<int> res;
    for(int i = 0; i < arr.size(); ++i) {
        for(int j = firsts[arr[i]]+1; j <= firsts[arr[i]+1]; ++j) {
            res.push_back(arr[j]);
            if(res.size() == Max) return getNext(res);
        }
    }
    return getNext(res);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll x, k;
    cin >> x >> k;
    if(k == 0) {
        cout << x << '\n';
        return 0;
    }
    vector<ll> divisors;
    for(ll i = 1; i*i <= x; ++i) {
        if(x%i == 0) {
            divisors.push_back(i);
            if(x/i != i) {
                divisors.push_back(x/i);
            }
        }
    }
    int n = divisors.size();
    sort(divisors.begin(), divisors.end());
    Next.resize(n);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(divisors[i] % divisors[j] == 0) {
                Next[i].push_back(j);
            }
        }
    }
    k = min(k, (ll)Max);
    vector<int> arr = {n-1};
    arr = getNext(arr);
    while(k/2 > 0) {
        arr = getDouble(arr);
        if(k%2 == 1) {
            arr = getNext(arr);
        }
        k /= 2;
    }
    for(int pos : arr) cout << divisors[pos] << ' ';
    cout << '\n';
    return 0;
}


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

const int Max = 1e5;
vector<vector<int> > Next;

vector<int> getNext(vector<int> &arr) {
    vector<int> res;
    for(int &x : arr) {
        for(int f : Next[x]) {
            res.push_back(f);
            if(res.size() == Max) return res;
        }
    }
    return res;
}

vector<int> getDouble(vector<int> &arr) {
    if(arr.size() == 1) return arr;
    vector<int> firsts;
    firsts.push_back(-1);
    int pos = 0;
    for(int i = 0; i < arr.size(); ++i) {
        if(arr[i] == pos) {
            pos++;
            firsts.push_back(i);
        }
    }
    vector<int> res;
    for(int i = 0; i < arr.size(); ++i) {
        for(int j = firsts[arr[i]]+1; j <= firsts[arr[i]+1]; ++j) {
            res.push_back(arr[j]);
            if(res.size() == Max) return getNext(res);
        }
    }
    return getNext(res);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll x, k;
    cin >> x >> k;
    if(k == 0) {
        cout << x << '\n';
        return 0;
    }
    vector<ll> divisors;
    for(ll i = 1; i*i <= x; ++i) {
        if(x%i == 0) {
            divisors.push_back(i);
            if(x/i != i) {
                divisors.push_back(x/i);
            }
        }
    }
    int n = divisors.size();
    sort(divisors.begin(), divisors.end());
    Next.resize(n);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(divisors[i] % divisors[j] == 0) {
                Next[i].push_back(j);
            }
        }
    }
    vector<int> arr = {n-1};
    //arr = getNext(arr);
    int bit = 0;
    while((1LL<<bit) <= k) bit++;
    bit--;
    while(bit >= 0) {
        arr = getDouble(arr);
        if(k&(1LL<<bit)) {
            arr = getNext(arr);
        }
        bit--;
    }
    for(int pos : arr) cout << divisors[pos] << ' ';
    cout << '\n';
    return 0;
}


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

const int Max = 1e5;
vector<vector<int> > Next;

vector<int> getNext(vector<int> &arr) {
    vector<int> res;
    for(int &x : arr) {
        for(int f : Next[x]) {
            res.push_back(f);
            if(res.size() == Max) return res;
        }
    }
    return res;
}

vector<int> getDouble(vector<int> &arr) {
    vector<int> firsts;
    firsts.push_back(-1);
    int pos = 0;
    for(int i = 0; i < arr.size(); ++i) {
        if(arr[i] == pos) {
            pos++;
            firsts.push_back(i);
        }
    }
    vector<int> res;
    for(int i = 0; i < arr.size(); ++i) {
        for(int j = firsts[arr[i]]+1; j <= firsts[arr[i]+1]; ++j) {
            res.push_back(arr[j]);
            if(res.size() == Max) return getNext(res);
        }
    }
    return getNext(res);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll x, k;
    cin >> x >> k;
    if(k == 0) {
        cout << x << '\n';
        return 0;
    }
    vector<ll> divisors;
    for(int i = 1; i*i <= x; ++i) {
        if(x%i == 0) {
            divisors.push_back(i);
            if(x/i != i) {
                divisors.push_back(x/i);
            }
        }
    }
    int n = divisors.size();
    sort(divisors.begin(), divisors.end());
    Next.resize(n);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(divisors[i] % divisors[j] == 0) {
                Next[i].push_back(j);
            }
        }
    }
    k = min(k, (ll)Max);
    vector<int> arr = {n-1};
    arr = getNext(arr);
    while(k/2 > 0) {
        arr = getDouble(arr);
        if(k%2 == 1) {
            arr = getNext(arr);
        }
        k /= 2;
    }
    for(int pos : arr) cout << divisors[pos] << ' ';
    cout << '\n';
    return 0;
}


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

const int Max = 1e5;
vector<vector<int> > Next;

vector<int> getNext(vector<int> &arr) {
    vector<int> res;
    for(int &x : arr) {
        for(int f : Next[x]) {
            res.push_back(f);
            if(res.size() == Max) return res;
        }
    }
    return res;
}

vector<int> getDouble(vector<int> &arr) {
    vector<int> firsts;
    firsts.push_back(-1);
    int pos = 0;
    for(int i = 0; i < arr.size(); ++i) {
        if(arr[i] == pos) {
            pos++;
            firsts.push_back(i);
        }
    }
    vector<int> res;
    for(int i = 0; i < arr.size(); ++i) {
        for(int j = firsts[arr[i]]+1; j <= firsts[arr[i]+1]; ++j) {
            res.push_back(arr[j]);
            if(res.size() == Max) return getNext(res);
        }
    }
    return getNext(res);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    ll x, k;
    cin >> x >> k;
    if(k == 0) {
        cout << x << '\n';
        return 0;
    }
    vector<ll> divisors;
    for(ll i = 1; i*i <= x; ++i) {
        if(x%i == 0) {
            divisors.push_back(i);
            if(x/i != i) {
                divisors.push_back(x/i);
            }
        }
    }
    int n = divisors.size();
    sort(divisors.begin(), divisors.end());
    Next.resize(n);
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(divisors[i] % divisors[j] == 0) {
                Next[i].push_back(j);
            }
        }
    }
    vector<int> arr = {n-1};
    arr = getNext(arr);
    while(k > 1) {
        arr = getDouble(arr);
        if(k%2 == 1) {
            arr = getNext(arr);
        }
        k /= 2;
    }
    for(int pos : arr) cout << divisors[pos] << ' ';
    cout << '\n';
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<int,int> ii;
typedef vector<ii > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vi d;
vi yo[10000];
vii f(int k){

	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		return ans;
	}
	if(!(k&1)){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			{ans.pb(ii(itt,it.S));if(ans.size()==N)break;}
			if(ans.size()==N)break;
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vi mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			{ans.pb(ii(itt,it.S));if(ans.size()==N)break;}
		if(ans.size()==N)break;

	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    if(k==0){cout<<n;return 0;}
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));

    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);

	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<ll,ll> ii;
typedef vector<pair<ll,ll> > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vll d;
vll yo[10000];
vii f(int k){
	if(k==0){
		return {{d.back(),-1}};
	}
	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		return ans;
	}
	if(k^1&1){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			ans.pb(ii(itt,it.S));
			if(ans.size()>N){break;}
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vll mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			ans.pb(ii(itt,it.S));
		if(ans.size()>N){break;}
	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));
    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);
	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<int,int> ii;
typedef vector<ii > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vll d;
vi yo[10000];
vii f(int k){

	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		return ans;
	}
	if(!(k&1)){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			{ans.pb(ii(itt,it.S));if(ans.size()==N)break;}
			if(ans.size()==N)break;
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vi mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			{ans.pb(ii(itt,it.S));if(ans.size()==N)break;}
		if(ans.size()==N)break;
	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    if(k==0){cout<<n;return 0;}
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));

    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);

	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<ll,ll> ii;
typedef vector<pair<ll,ll> > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vll d;
vll yo[10000];
vii f(int k){

	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		if(ans.size()>N)ans.resize(N);
		return ans;
	}
	if(k^1&1){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			ans.pb(ii(itt,it.S));
			if(ans.size()>N){ans.resize(N);break;}
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vll mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			ans.pb(ii(itt,it.S));
		if(ans.size()>N){ans.resize(N);break;}
	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    if(k==0){cout<<n;return 0;}
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));
    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);
	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<ll,ll> ii;
typedef vector<pair<ll,ll> > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vll d;
vll yo[10000];
vii f(int k){

	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		return ans;
	}
	if(k^1&1){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			ans.pb(ii(itt,it.S));
			if(ans.size()>N){break;}
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vll mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			ans.pb(ii(itt,it.S));
		if(ans.size()>N){break;}
	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    if(k==0){cout<<n;return 0;}
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));
    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);
	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define INF 1000000007

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > vvi;
typedef pair<ll,ll> ii;
typedef vector<pair<ll,ll> > vii;
typedef vector<vector<pair<int,int> > > vvii;

#define all(x) (x).begin(), (x).end()
#define nall(x) (x).rbegin(), (x).rend()
#define sz(a) int((a).size())
#define boost ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define pb push_back
#define rz resize
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define NFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define TCASE int __T;cin>>__T;FOR(Tc,1,__T)
inline int add(int a,int b, int m=INF){a+=b;if(a>=m)a-=m;return a;}
inline int mul(int a,int b, int m=INF){return (int)(((ll)a*(ll)b)%m);}

const int N = 1e5;
vll d;
vll yo[10000];
vii f(int k){
	if(k==1)
	{
		vii ans;
		FOR(i,0,sz(d)-1)ans.pb(ii(i,i));
		return ans;
	}
	if(k^1&1){
		vii ans;
		vii bc = f(k-1);
		for(auto it:bc)
		{
			for(auto itt:yo[it.F])
			ans.pb(ii(itt,it.S));
			if(ans.size()>N){break;}
		}
		return ans;
	}
	vii bc = f((k+1)>>1);
	vll mp[sz(d)+1];
	for(auto it:bc)
	mp[it.S].pb(it.F);
	vii ans;
	for(auto it:bc){
		for(auto itt:mp[it.F])
			ans.pb(ii(itt,it.S));
		if(ans.size()>N){break;}
	}
	return ans;
}
int main()
{
    boost;
    ll n,k;
    cin>>n>>k;
    k=min(k,N+0LL);
    for(ll i=1;i*i<=n;++i){
    	if(n%i)continue;
    	d.pb(i);
    	if(i*i!=n)d.pb(n/i);
    }
    sort(all(d));
    FOR(i,0,sz(d)-1)FOR(j,0,sz(d)-1)
    	if(d[i]%d[j]==0)yo[i].pb(j);
	vii ans = f(k);
	FOR(i,0,min(N,sz(ans))-1)
	cout<<d[ans[i].F]<<" ";
	return 0;
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(D.size(), vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<map<int, ll> > cache;
ll dp(int d, int k) {
//	cout << k << ' ' << d << endl;
	ll& ret = cache[k][d];
	if(ret != 0) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%I64d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache.resize(K+1);
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%I64d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(D.size(), vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%I64d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(300, vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt, ssub;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		ssub.clear();
		ssub.resize(tt.size());
		for(int i = 0; i < tt.size(); i++) {
			ssub[i].resize(tt[i].size());
			for(int j = 0; j < tt[i].size(); j++) {
				ssub[i][j] = tt[i][j];
			}
		}
		tt.clear();
		tt.resize(ssub.size());
		for(int i = 0; i < tt.size(); i++) {
			for(int j = 0; j < ssub[i].size(); j++) {
				for(int k = 0; k < min((int)ssub[ssub[i][j]].size(), MN-sz); k++) {
					tt[i].push_back(ssub[ssub[i][j]][k]);
				}
				sz += min((int)ssub[ssub[i][j]].size(), MN-sz);
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
///*
	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
//	cout << ans.size() << endl;
//	return 0;
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				if(sub[j]==j) {
					for(int k = 0; k < min((int)sub.size(), MN-sz); k++) {
						tt[i].push_back(sub[sub[k]]);
					}
					sz += min((int)sub.size(), MN-sz);
				}
				else {
					for(int k = 0; k < min((int)tt[sub[j]].size(), MN-sz); k++) {
						tt[i].push_back(tt[sub[j]][k]);
					}
					sz += min((int)tt[sub[j]].size(), MN-sz);
				}
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}

/*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
/*	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(D.size(), vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				if(sub[j]==i) {
					for(int k = 0; k < min((int)sub.size(), MN-sz); k++) {
						tt[i].push_back(sub[k]);
					}
					sz += min((int)sub.size(), MN-sz);
				}
				else {
					for(int k = 0; k < min((int)tt[sub[j]].size(), MN-sz); k++) {
						tt[i].push_back(tt[sub[j]][k]);
					}
					sz += min((int)tt[sub[j]].size(), MN-sz);
				}
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
///*
	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
			}
			else {
				dfs(tt, k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(D.size(), vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
		sort(DD[i].begin(), DD[i].end());
	}
}

int dfs(int x, int k, int upp) {
	if(k==0) {
		printf("%I64d ", D[x]);
		return 1;
	}
	int cnt = 0;
	for(int i = 0; i < DD[x].size(); i++) {
		int tmp = dfs(DD[x][i], k - 1, upp);
		if(tmp >= upp) return inf;
		else {
			upp -= tmp;
			cnt += tmp;
		}
	}
	return cnt;
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	dfs(dx[X], K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<map<ll, ll> > cache;
ll dp(int k, int d) {
	ll& ret = cache[k][d];
	if(ret != 0) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%I64d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache.resize(K+1);
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		for(int i = tt.size(); i--;) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				if(sub[j]==i) {
					for(int k = 0; k < min((int)sub.size(), MN-sz); k++) {
						tt[i].push_back(sub[k]);
					}
					sz += min((int)sub.size(), MN-sz);
				}
				else {
					for(int k = 0; k < min((int)tt[sub[j]].size(), MN-sz); k++) {
						tt[i].push_back(tt[sub[j]][k]);
					}
					sz += min((int)tt[sub[j]].size(), MN-sz);
				}
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
///*
	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt, ssub;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		ssub.clear();
		ssub.resize(tt.size());
		for(int i = 0; i < tt.size(); i++) {
			ssub[i].resize(tt[i].size());
			for(int j = 0; j < tt[i].size(); j++) {
				ssub[i][j] = tt[i][j];
			}
		}
		tt.clear();
		tt.resize(ssub.size());
		for(int i = 0; i < tt.size(); i++) {
			for(int j = 0; j < ssub[i].size(); j++) {
				for(int k = 0; k < min((int)ssub[ssub[i][j]].size(), MN-sz); k++) {
					tt[i].push_back(ssub[ssub[i][j]][k]);
				}
				sz += min((int)ssub[ssub[i][j]].size(), MN-sz);
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
///*
	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				if(sub[j]==i) {
					for(int k = 0; k < min((int)sub.size(), MN-sz); k++) {
						tt[i].push_back(sub[sub[k]]);
					}
					sz += min((int)sub.size(), MN-sz);
				}
				else {
					for(int k = 0; k < min((int)tt[sub[j]].size(), MN-sz); k++) {
						tt[i].push_back(tt[sub[j]][k]);
					}
					sz += min((int)tt[sub[j]].size(), MN-sz);
				}
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
///*
	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%I64d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
				if(upp==0) return;
			}
			else {
				dfs(tmp[i], k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(100, vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const ll inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
	}
}
vector<vector<ll> > cache;
ll dp(int d, int k) {
	ll& ret = cache[d][k];
	if(ret != -1) return ret;

	if(k==0) return ret = 1;

	ret = 0;
	for(int i = 0; i < DD[d].size(); i++) {
		ret += dp(DD[d][i], k - 1);
	}
	if(ret > 100000) ret = inf;
	return ret;
}

void out(ll x, ll k) {
	if(k==0) {
		printf("%d ", x);
		return;
	}
	vector<ll> tmp;
	for(ll i = 1; i <= sqrt(x); i++) {
		if(x%i==0) {
			tmp.push_back(i);
			if(i*i!=x) tmp.push_back(x/i);
		}
	}
	sort(tmp.begin(), tmp.end());
	for(int i = 0; i < tmp.size(); i++) {
		out(tmp[i], k-1);
	}
}
void dfs(ll x, ll k, ll upp) {
	if(dp(dx[x], k) <= upp) out(x, k);
	else {
		vector<ll> tmp;
		for(ll i = 1; i <= sqrt(x); i++) {
			if(x%i==0) {
				tmp.push_back(i);
				if(i*i!=x) tmp.push_back(x/i);
			}
		}
		sort(tmp.begin(), tmp.end());
		for(int i = 0; i < tmp.size(); i++) {
			ll tt = dx[tmp[i]];
			if(dp(tt, k-1) <= upp) {
				out(tmp[i], k-1);
				upp -= dp(tt, k-1);
			}
			else {
				dfs(tt, k-1, upp);
				return;
			}
		}
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	cache = vector<vector<ll> >(D.size(), vector<ll>(K+1, -1));
	dfs(X, K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int inf = 987654321;

ll X, K;
vector<ll> D;
void get_D() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			D.push_back(i);
			if(i*i!=X) D.push_back(X/i);
		}
	}
	sort(D.begin(), D.end());
}
map<ll, int> dx;
void get_dx() {
	for(int i = 0; i < D.size(); i++) {
		dx[D[i]] = i;
	}
}
vector<vector<ll> > DD;
void get_DD() {
	DD.resize(D.size());
	for(int i = 0; i < D.size(); i++) {
		for(ll j = 1; j <= sqrt(D[i]); j++) {
			if(D[i]%j==0) {
				DD[i].push_back(dx[j]);
				if(j*j!=D[i]) DD[i].push_back(dx[D[i]/j]);
			}
		}
		sort(DD[i].begin(), DD[i].end());
	}
}

int dfs(int x, int k, int upp) {
	if(k==0) {
		printf("%I64d ", D[x]);
		return 1;
	}
	for(int i = 0; i < DD[x].size(); i++) {
		int tmp = dfs(DD[x][i], k - 1, upp);
		if(tmp >= upp) return inf;
		else upp -= tmp;
	}
}

int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X == 1) {
		printf("1");
		return 0;
	}
	if(K >= 100000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_D(); get_dx(); get_DD();
	dfs(dx[X], K, 100000);
}


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<map>
using namespace std;
typedef long long int ll;
const int MN = 100000;

ll X, K;
vector<ll> d;
map<ll, int> dx;
void get_d() {
	for(ll i = 1; i <= sqrt(X); i++) {
		if(X%i==0) {
			d.push_back(i);
			if(i*i!=X) d.push_back(X/i);
		}
	}
	sort(d.begin(), d.end());
	for(int i = 0; i < d.size(); i++) dx[d[i]] = i;
}
vector<vector<ll> > dd;
void get_dd() {
	dd.resize(d.size());
	for(int i = 0; i < d.size(); i++) {
		for(ll j = 1; j <= sqrt(d[i]); j++) {
			if(d[i]%j==0) {
				dd[i].push_back(dx[j]);
				if(j*j!=d[i]) dd[i].push_back(dx[d[i]/j]);
			}
		}
		sort(dd[i].begin(), dd[i].end());
	}
}
vector<vector<ll> > tt;
vector<ll> ans, sub;
void get_ans(ll k) {
	if(k==0) {
		ans.push_back(d.size()-1);
		return;
	}
	if(k%2) {
		get_ans(k - 1);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		if(k==1) return;
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz += min((int)dd[sub[j]].size(), MN-sz);
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}
	}
	else {
		get_ans(k/2);
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz = ans.size();
			for(int j = 0; j < min((int)tt[sub[i]].size(), MN-sz); j++) {
				ans.push_back(tt[sub[i]][j]);
			}
			if(ans.size()==MN) break;
		}
		int sz = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				if(sub[j]==j) {
					for(int k = 0; k < min((int)sub.size(), MN-sz); k++) {
						tt[i].push_back(sub[sub[k]]);
					}
					sz += min((int)sub.size(), MN-sz);
				}
				else {
					for(int k = 0; k < min((int)tt[sub[j]].size(), MN-sz); k++) {
						tt[i].push_back(tt[sub[j]][k]);
					}
					sz += min((int)tt[sub[j]].size(), MN-sz);
				}
				if(sz==MN) break;
			}
			if(sz==MN) break;
		}

///*
		sub.clear();
		for(int i = 0; i < ans.size(); i++) {
			sub.push_back(ans[i]);
		}
		ans.clear();
		for(int i = 0; i < sub.size(); i++) {
			int sz3 = ans.size();
			for(int j = 0; j < min((int)dd[sub[i]].size(), MN-sz3); j++) {
				ans.push_back(dd[sub[i]][j]);
			}
			if(ans.size() == MN) break;
		}
		int sz2 = 0;
		for(int i = 0; i < tt.size(); i++) {
			sub.clear();
			for(int j = 0; j < tt[i].size(); j++) {
				sub.push_back(tt[i][j]);
			}
			tt[i].clear();
			for(int j = 0; j < sub.size(); j++) {
				for(int k = 0; k < min((int)dd[sub[j]].size(), MN-sz2); k++) {
					tt[i].push_back(dd[sub[j]][k]);
				}
				sz2 += min((int)dd[sub[j]].size(), MN-sz2);
				if(sz2==MN) break;
			}
			if(sz2==MN) break;
		}
//*/
	}
/*
	cout << k << endl;
	for(int i = 0; i < ans.size(); i++) {
		cout << ans[i] << ' ';
	}
	cout << endl;
/*	for(int i = 0; i < d.size(); i++) {
		for(int j = 0; j < tt[i].size(); j++) {
			cout << tt[i][j] << '*';
		}
		cout << endl;
	}
//*/
}
int main() {
	scanf("%I64d %I64d", &X, &K);
	if(X==1) {
		printf("1");
		return 0;
	}
	if(K>=10000) {
		for(int i = 0; i < 100000; i++) {
			printf("1 ");
		}
		return 0;
	}
	get_d(); get_dd();
	tt.resize(d.size());
	for(int i = 0; i < d.size(); i++) tt[i].push_back(i);
	get_ans(K);
	for(int i = 0; i < ans.size(); i++) {
		printf("%I64d ", d[ans[i]]);
	}
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        cout << n << ' ';
        SZ--;
        return;
    }
    if (!K){
        cout << n << ' ';
        SZ--;
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) cout << 1 << ' ';
            cout << n << ' ';
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i){
                cout << 1 << ' ';
            }
            cout << ' ';
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    ios_base::sync_with_stdio(false);
    cin >> x >> k;
    if (!k){
        cout << x << '\n';
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (!K){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) printf("%d ", 1);
            printf("%I64d ", n);
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i) printf("%I64d ", 1);
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    //ios_base::sync_with_stdio(false);
    scanf("%I64d%I64d", &x, &k);
    if (!k){
        printf("%I64d\n", x);
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (!K){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) printf("%d ", 1);
            printf("%I64d ", n);
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i) printf("%I64d ", n);
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    //ios_base::sync_with_stdio(false);
    scanf("%I64d%I64d", &x, &k);
    if (!k){
        printf("%I64d\n", x);
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
map<ll, vector<ll> > d;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (!K){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) printf("%d ", 1);
            printf("%I64d ", n);
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i) printf("%d ", 1);
            SZ = 0;
        }
        return;
    }
    vector<ll>& cur = d[n];
    if (cur.empty()){
        vector<ll> p;
        for(ll i = 1; i * i <= n; ++i){
            if (n % i == 0){
                cur.push_back(i);
                if (i * i != n) p.push_back(n / i);
            }
        }
        for(int i = p.size() - 1; i >= 0; --i){
            cur.push_back(p[i]);
        }
    }
    for(int i = 0; i < cur.size(); ++i){
        f(cur[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> divs;
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            divs.push_back(i);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        divs.push_back(p[i]);
    }
    d[n] = divs;
    for(int i = 0; i < divs.size(); ++i){
        f(divs[i], k - 1);
    }
}
int main(){
    //ios_base::sync_with_stdio(false);
    scanf("%I64d%I64d", &x, &k);
    if (!k){
        printf("%I64d\n", x);
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        cout << n << ' ';
        return;
    }
    if (!K){
        cout << n << ' ';
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) cout << 1 << ' ';
            cout << n << ' ';
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i){
                cout << 1 << ' ';
            }
            cout << ' ';
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    ios_base::sync_with_stdio(false);
    cin >> x >> k;
    if (!k){
        cout << x << '\n';
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (!K){
        printf("%I64d ", n);
        SZ--;
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) printf("%d ", 1);
            printf("%I64d ", n);
            SZ -= K + 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i) printf("%d ", 1);
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    //ios_base::sync_with_stdio(false);
    scanf("%I64d%I64d", &x, &k);
    if (!k){
        printf("%I64d\n", x);
        return 0;
    }
    rec(x);
    return 0;
}


#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 1e3 + 5;
const int nmax = 2e4 + 5;
const int mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const int inf = 1e9;
const ld big = 1e18;
ll SZ = 1e5;
ll x, k;
map<ll, int> pr;
int isp(ll n){
    if (pr[n]) return pr[n];
    for(ll i = 2; i * i <= n; ++i){
        if (n % i == 0){
            pr[n] = -1;
            return pr[n];
        }
    }
    pr[n] = 1;
    return pr[n];
}
void f(ll n, ll K){
    if (!SZ) return;
    if (n == 1){
        cout << n << ' ';
        return;
    }
    if (!K){
        cout << n << ' ';
        return;
    }
    if (isp(n) == 1){
        if (SZ >= K + 1ll){
            for(ll i = 0; i < K; ++i) cout << 1 << ' ';
            cout << n << ' ';
            SZ -= K - 1ll;
        }
        else {
            for(int i = 0; i < SZ; ++i){
                cout << 1 << ' ';
            }
            cout << ' ';
            SZ = 0;
        }
        return;
    }
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, K - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], K - 1);
    }
}
void rec(ll n){
    vector<ll> p;
    for(ll i = 1; i * i <= n; ++i){
        if (n % i == 0){
            f(i, k - 1);
            if (i * i != n) p.push_back(n / i);
        }
    }
    for(int i = p.size() - 1; i >= 0; --i){
        f(p[i], k - 1);
    }
}
int main(){
    ios_base::sync_with_stdio(false);
    cin >> x >> k;
    if (!k){
        cout << x << '\n';
        return 0;
    }
    rec(x);
    return 0;
}


/***********************************
*                                  *
*    Auther Rhapsody               *
*    E-mail addf400@foxmail.com    *
*                                  *
***********************************/
#include <set>
#include <map>
#include <cmath>
#include <deque>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#define MP make_pair
#define PB push_back

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 1e6 + 7;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;

LL num[N];

vector <LL> p[N];

map <LL, int> mapper;

int cnt, sum;

LL Ans[N + N];

void add(LL idx) {
    LL n = num[idx];
    p[idx].clear();
    for (LL i = 1ll; i * i <= n; ++i)
        if (n % i == 0) {
            p[idx].PB(mapper[i]);
            if (i * i != n && i > 1)
                p[idx].PB(mapper[n / i]);
        }
    sort(p[idx].begin(), p[idx].end());
    /*
    cout << "Add" << n << endl;
    for (int i = 0; i < p[idx].size(); ++i) {
        cout << num[p[idx][i]] << endl;
    }
    cout << "------\n";
    */
}

void find(int x, LL k) {
    if (x == 1 || k == 0) {
        ++sum;
        Ans[sum] = num[x];
        return;
    }
    for (LL j = k - 1; j >= 0; --j) {
        for (int i = 0; i < p[x].size(); ++i) {
            find(p[x][i], j);
            if (sum >= N)
                return;
        }
    }
    ++sum;
    Ans[sum] = num[x];
}

int main(void) {
    LL x, k;
    while (cin >> x >> k) {
        cnt = sum = 0;
        mapper.clear();
        for (LL i = 1ll; i * i <= x; ++i) {
            if (x % i == 0) {
                num[++cnt] = i;
                if (i * i != x)
                    num[++cnt] = x / i;
            }
        }
        sort(num + 1, num + cnt + 1);
        for (int i = 1; i <= cnt; ++i) {
            mapper[num[i]] = i;
        }
        for (int i = 1; i <= cnt; ++i)
            add(i);
        find(cnt, k);
        sum = min(sum, 100000);
        for (int i = 1; i <= sum; ++i) {
            printf("%I64d", Ans[i]);
            if (i < sum)
                putchar(' ');
            else
                putchar('\n');
        }
    }
    return 0;
}


/***********************************
*                                  *
*    Auther Rhapsody               *
*    E-mail addf400@foxmail.com    *
*                                  *
***********************************/
#include <set>
#include <map>
#include <cmath>
#include <deque>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#define MP make_pair
#define PB push_back

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 1e6 + 7;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;

LL num[N];

vector <LL> p[N];

map <LL, int> mapper;

int cnt, sum;

LL Ans[N + N];

void add(LL idx) {
    LL n = num[idx];
    p[idx].clear();
    for (LL i = 1ll; i * i <= n; ++i)
        if (n % i == 0) {
            p[idx].PB(mapper[i]);
            if (i * i != n && i > 1)
                p[idx].PB(mapper[n / i]);
        }
    sort(p[idx].begin(), p[idx].end());
    //cout << "Add" << n << endl;
    //for (int i = 0; i < p[idx].size(); ++i) {
    //  cout << num[p[idx][i]] << endl;
    //}
    //cout << "------\n";
}

void find(int x, LL k) {
    if (x == 1 || k == 0) {
        ++sum;
        Ans[sum] = num[x];
        return;
    }
    for (int j = k - 1; j >= 0; --j) {
        for (int i = 0; i < p[x].size(); ++i) {
            find(p[x][i], j);
            if (sum >= N)
                return;
        }
    }
    ++sum;
    Ans[sum] = num[x];
}

int main(void) {
    LL x, k;
    while (cin >> x >> k) {
        cnt = sum = 0;
        mapper.clear();
        for (LL i = 1ll; i * i <= x; ++i) {
            if (x % i == 0) {
                num[++cnt] = i;
                if (i * i != x)
                    num[++cnt] = x / i;
            }
        }
        sort(num + 1, num + cnt + 1);
        for (int i = 1; i <= cnt; ++i) {
            mapper[num[i]] = i;
        }
        for (int i = 1; i <= cnt; ++i)
            add(i);
        find(cnt, k);
        sum = min(sum, 100000);
        for (int i = 1; i <= sum; ++i) {
            printf("%I64d", Ans[i]);
            if (i < sum)
                putchar(' ');
            else
                putchar('\n');
        }
    }
    return 0;
}


/***********************************
*                                  *
*    Auther Rhapsody               *
*    E-mail addf400@foxmail.com    *
*                                  *
***********************************/
#include <set>
#include <map>
#include <cmath>
#include <deque>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

#define MP make_pair
#define PB push_back

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 1e6 + 7;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;

LL num[N];

vector <LL> p[N];

map <LL, int> mapper;

int cnt, sum;

LL Ans[N + N];

void add(LL idx) {
    LL n = num[idx];
    p[idx].clear();
    for (LL i = 1ll; i * i <= n; ++i)
        if (n % i == 0) {
            p[idx].PB(mapper[i]);
            if (i * i != n && i > 1)
                p[idx].PB(mapper[n / i]);
        }
    sort(p[idx].begin(), p[idx].end());
    /*
    cout << "Add" << n << endl;
    for (int i = 0; i < p[idx].size(); ++i) {
        cout << num[p[idx][i]] << endl;
    }
    cout << "------\n";
    */
}

void find(int x, LL k) {
    if (x == 1 || k == 0) {
        ++sum;
        Ans[sum] = num[x];
        return;
    }
    for (LL j = k - 1; j >= 0; --j) {
        for (int i = 0; i < p[x].size(); ++i) {
            find(p[x][i], j);
            if (sum >= 100000)
                return;
        }
    }
    ++sum;
    Ans[sum] = num[x];
}

int main(void) {
    LL x, k;
    while (cin >> x >> k) {
        cnt = sum = 0;
        mapper.clear();
        for (LL i = 1ll; i * i <= x; ++i) {
            if (x % i == 0) {
                num[++cnt] = i;
                if (i * i != x)
                    num[++cnt] = x / i;
            }
        }
        sort(num + 1, num + cnt + 1);
        for (int i = 1; i <= cnt; ++i) {
            mapper[num[i]] = i;
        }
        for (int i = 1; i <= cnt; ++i)
            add(i);
        find(cnt, k);
        sum = min(sum, 100000);
        for (int i = 1; i <= sum; ++i) {
            printf("%I64d", Ans[i]);
            if (i < sum)
                putchar(' ');
            else
                putchar('\n');
        }
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define forr(a,b,c) for(int a=b;a<c;a++)
#define forrev(a,b,c) for(int a=b;a>c;a--)
#define all(v) v.begin(),v.end()
#define revall(v) v.rbegin(),v.rend()
#define allk(v,k) v.begin()+k,v.end()
#define revallk(v,k) v.rbegin()+k,v.rend()
#define allkj(v,k,j) v.begin()+k,v.end()-j
#define revallkj(v,k,j) v.rbegin()+j,v.rend()-k
#define ff first
#define ss second
#define next ksfhuksfkhdn
#define prev uegrfjsfgsji
#define count jgsfhksadvk
#define x1 khgrkgbdjkgbjd
#define y1 bjdlgbdfshfbvl
#define left lihfjksfhskk
#define right kgsfskgfksh

//int Y[] = {-1,1,0,0};
//int X[] = {0,0,-1,1};
int Y[] = {-1,1,0,0,-1,-1,1,1};// up, down, left, right, up-left, up-right, low-left, low-right
int X[] = {0,0,-1,1,-1,1,-1,1};
int directions = 4;
////////////////////////// non-modifiable /////////////////////////////////

#define mod 1000000007
#define eps 1e-9
#define inf INT_MAX
#define infl LONG_LONG_MAX
ll power(ll a,ll n)
{
	if(a==0)return 0;
	if(a==1 || n==0)return 1;
	if(n==1)return a%mod;//can remove mod?
	ll t=power(a,n/2);
	t=t*t%mod;
	if(n&1)return t*a%mod;
	return t;
}
#define P (int)(2e6)+9
#define FACTORIZE 1
#define DETERMINE 2
/*int primes[P];
void sieve(int prime=2)//2->detects prime, 1->max prime in factorization
{
	forr(i,2,P-3)
	{
		if(!primes[i])
		for(int j=prime*i;j<P-3;j+=i)primes[j]=i;
	}
	//forr(i,1,21)cout<<primes[i]<<" ";cout<<endl;
	if(prime==2)
	{
		forr(i,1,P-3)
		{
			primes[i] = ( primes[i] == 0 );
		}
	}
	else
		primes[1] = 1;
}*/
void keywords() // add commonly used keywords here for autocompletion
{
	return;
	int x;
	scanf("%d",&x);	printf("lol");
	cin >> x;	cout << "lol" << endl;
	while(1) continue; while(1) break;
}
int popcount(ll a)
{
	int c=0;
	while(a)
	{
		c++;
		a-=a&-a;
	}
	return c;
}
void factorize(ll a, map<ll,int> &mapp)
{
	for(ll i=2;i*i<=a;i++)
	{
		while( a%i == 0 )
		{
			mapp[i]++;
			a /= i;
		}
	}

	mapp[1]=1;

	if( a > 1 )
		mapp[a]++;
}
void update(int tree[],int idx,int val,int maxval)
{
	for(;idx<=maxval;idx+=idx&-idx)
	{
		tree[idx]+=val;
		//tree[idx]%=mod;
	}
}
int read(int tree[],int idx)
{
	ll sum=0;
	for(;idx>0;idx-=idx&-idx)
	{
		sum+=tree[idx];
		//sum%=mod;
	}
	return sum;
}
/*
void func( int id, int par ) // undirected tree
{
	for(auto u : v[id])
	{
		if( u == par ) continue;

	}
}
*/
////////////////////////// MODIFIABLE /////////////////////////////////////

struct node2
{
	int id,val;
	node2()
	{
		static int ctx=1;
		id=ctx++;
	};
	node2(int a,int b=0,int c=0,int d=0,int e=0,int f=0)
	{
		val=a;
	}
};
struct comp2
{
	bool operator()(int a,int b)
	{
		//return a<b;
		return b<a;	//min heap
	}
};
bool cmp2(int a,int b)
{
	//return a<b;
	return b<a;
}

struct node
{
	int id,val;
	node()
	{
		static int ctx=1;
		id=ctx++;
	};
	node(int a,int b=0,int c=0,int d=0,int e=0,int f=0)
	{
		val=a;
	}
};
struct comp
{
	bool operator()(int a,int b)
	{
		//return a<b;
		return b<a;	//min heap
	}
};
bool cmp(int a,int b)
{
	//return a<b;
	return b<a;
}
////////////////////////// custom-defined /////////////////////////////////
#define N 100009
ll n,m,a,b,c,d,k,h,w,x,y,p,q,t,ans[2*N],res,ma,mi,T,act=0,pas=1,cur,flag,now;
int uu,vv,ww,l,r;
int dp,dp2,cnt;
char s[1];
//string s;
//vector<string> s;
double f,z,e;
vector<int> v, vec;
set<int> sett;
typedef map<ll,int> Mapp;
Mapp mapp;
#define div divisor_list
map<ll,vector<ll> > div;
////////////////////////// variable declarations //////////////////////////

void print()//for detailed output of [a data structure]
{

}
void print2()//for detailed output of [a data structure]
{

}
void input()
{
	ios_base::sync_with_stdio(false);cin.tie(NULL);
	cin >> x >> k;
	k = min( 100000ll, k );
}

inline void divisors( ll x, vector<ll> &v )
{
	if( !v.empty() ) return;

	vector< pll > cnt;

	for(auto u : mapp) // 40
	{
		if( x % u.ff == 0 )
		{
			if( u.ff == 1 )
			{
				cnt.pb( mp( 1, 1 ) );
				continue;
			}

			ll p = u.ff, c = 0;

			while( x % p == 0 )
			{
				c++;

				if( p > 2e12 / u.ff )
					break;

				p *= u.ff;
			}

			cnt.pb( mp( u.ff, c ) );
		}
	}

	//cout << x << " : "; for(auto u : cnt) cout << "(" << u.ff << " " << u.ss << ") "; cout << endl;

	for(auto u : cnt)
	{
		vector<ll> vec;

		if( v.empty() ) vec.pb( u.ff );

		for(auto a : v) // 3^11
		{
			ll p = u.ff;

			forr(i,1,u.ss+1) // 40
			{
				vec.pb( a * p );
				p *= u.ff;
			}
		}

		for(auto a : vec)
			v.pb( a );
	}

	sort( all(v) );

	//cout << x << " : "; for(auto u : v) cout << u << " "; cout << endl;
}

bool calc(ll x,ll k)
{
	if( cur >= N-6 )
		return true;

	if( x == 1 )
	{
		ans[cur++] = 1;
		return false;
	}

	divisors( x, div[x] );

	if( k == 1 )
	{
		forr(i,0,div[x].size())
		{
			ans[cur++] = div[x][i];

			if( cur >= N-6 )
				return true;
		}
		return false;
	}

	forr(i,0,div[x].size())
	{
		if( calc( div[x][i], k-1 ) )
			return true;
	}
	return false;
}
void solve()
{
	factorize(x,mapp); // mapp of ALL primes and max frequencies

	//for(auto u : mapp) cout << u.ff << " : " << u.ss << endl;

	calc(x,k);

	forr(i,0, min(100000ll,cur) )
		cout << ans[i] << " ";
}
void output()
{

}
///////////////////////////// my functions ////////////////////////////////

int main()
{
	input();
	solve();
	output();
	return 0;
}
//// MAIN //// MAIN //// MAIN //// MAIN //// MAIN //// MAIN //// MAIN ////


#include <bits/stdc++.h>
using namespace std;
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define forr(a,b,c) for(int a=b;a<c;a++)
#define forrev(a,b,c) for(int a=b;a>c;a--)
#define all(v) v.begin(),v.end()
#define revall(v) v.rbegin(),v.rend()
#define allk(v,k) v.begin()+k,v.end()
#define revallk(v,k) v.rbegin()+k,v.rend()
#define allkj(v,k,j) v.begin()+k,v.end()-j
#define revallkj(v,k,j) v.rbegin()+j,v.rend()-k
#define ff first
#define ss second
#define next ksfhuksfkhdn
#define prev uegrfjsfgsji
#define count jgsfhksadvk
#define x1 khgrkgbdjkgbjd
#define y1 bjdlgbdfshfbvl
#define left lihfjksfhskk
#define right kgsfskgfksh

//int Y[] = {-1,1,0,0};
//int X[] = {0,0,-1,1};
int Y[] = {-1,1,0,0,-1,-1,1,1};// up, down, left, right, up-left, up-right, low-left, low-right
int X[] = {0,0,-1,1,-1,1,-1,1};
int directions = 4;
////////////////////////// non-modifiable /////////////////////////////////

#define mod 1000000007
#define eps 1e-9
#define inf INT_MAX
#define infl LONG_LONG_MAX
ll power(ll a,ll n)
{
	if(a==0)return 0;
	if(a==1 || n==0)return 1;
	if(n==1)return a%mod;//can remove mod?
	ll t=power(a,n/2);
	t=t*t%mod;
	if(n&1)return t*a%mod;
	return t;
}
#define P (int)(2e6)+9
#define FACTORIZE 1
#define DETERMINE 2
/*int primes[P];
void sieve(int prime=2)//2->detects prime, 1->max prime in factorization
{
	forr(i,2,P-3)
	{
		if(!primes[i])
		for(int j=prime*i;j<P-3;j+=i)primes[j]=i;
	}
	//forr(i,1,21)cout<<primes[i]<<" ";cout<<endl;
	if(prime==2)
	{
		forr(i,1,P-3)
		{
			primes[i] = ( primes[i] == 0 );
		}
	}
	else
		primes[1] = 1;
}*/
void keywords() // add commonly used keywords here for autocompletion
{
	return;
	int x;
	scanf("%d",&x);	printf("lol");
	cin >> x;	cout << "lol" << endl;
	while(1) continue; while(1) break;
}
int popcount(ll a)
{
	int c=0;
	while(a)
	{
		c++;
		a-=a&-a;
	}
	return c;
}
void factorize(ll a, map<ll,int> &mapp)
{
	for(ll i=2;i*i<=a;i++)
	{
		while( a%i == 0 )
		{
			mapp[i]++;
			a /= i;
		}
	}

	mapp[1]=1;

	if( a > 1 )
		mapp[a]++;
}
void update(int tree[],int idx,int val,int maxval)
{
	for(;idx<=maxval;idx+=idx&-idx)
	{
		tree[idx]+=val;
		//tree[idx]%=mod;
	}
}
int read(int tree[],int idx)
{
	ll sum=0;
	for(;idx>0;idx-=idx&-idx)
	{
		sum+=tree[idx];
		//sum%=mod;
	}
	return sum;
}
/*
void func( int id, int par ) // undirected tree
{
	for(auto u : v[id])
	{
		if( u == par ) continue;

	}
}
*/
////////////////////////// MODIFIABLE /////////////////////////////////////

struct node2
{
	int id,val;
	node2()
	{
		static int ctx=1;
		id=ctx++;
	};
	node2(int a,int b=0,int c=0,int d=0,int e=0,int f=0)
	{
		val=a;
	}
};
struct comp2
{
	bool operator()(int a,int b)
	{
		//return a<b;
		return b<a;	//min heap
	}
};
bool cmp2(int a,int b)
{
	//return a<b;
	return b<a;
}

struct node
{
	int id,val;
	node()
	{
		static int ctx=1;
		id=ctx++;
	};
	node(int a,int b=0,int c=0,int d=0,int e=0,int f=0)
	{
		val=a;
	}
};
struct comp
{
	bool operator()(int a,int b)
	{
		//return a<b;
		return b<a;	//min heap
	}
};
bool cmp(int a,int b)
{
	//return a<b;
	return b<a;
}
////////////////////////// custom-defined /////////////////////////////////
#define N 100009
ll n,m,a,b,c,d,k,h,w,x,y,p,q,t,ans[2*N],res,ma,mi,T,act=0,pas=1,cur,flag,now;
int uu,vv,ww,l,r;
int dp,dp2,cnt;
char s[1];
//string s;
//vector<string> s;
double f,z,e;
vector<int> v, vec;
set<int> sett;
typedef map<ll,int> Mapp;
Mapp mapp;
#define div divisor_list
map<ll,vector<ll> > div;
////////////////////////// variable declarations //////////////////////////

void print()//for detailed output of [a data structure]
{

}
void print2()//for detailed output of [a data structure]
{

}
void input()
{
	ios_base::sync_with_stdio(false);cin.tie(NULL);
	cin >> x >> k;
	k = min( 100000ll, k );
}

inline void divisors( ll x, vector<ll> &v )
{
	if( !v.empty() ) return;

	vector< pll > cnt;

	for(auto u : mapp) // 40
	{
		if( x % u.ff == 0 )
		{
			if( u.ff == 1 )
			{
				cnt.pb( mp( 1, 1 ) );
				continue;
			}

			ll p = u.ff, c = 0;

			while( x % p == 0 )
			{
				c++;

				if( p > 2e12 / u.ff )
					break;

				p *= u.ff;
			}

			cnt.pb( mp( u.ff, c ) );
		}
	}

	//cout << x << " : "; for(auto u : cnt) cout << "(" << u.ff << " " << u.ss << ") "; cout << endl;

	for(auto u : cnt)
	{
		vector<ll> vec;

		if( v.empty() ) vec.pb( u.ff );

		for(auto a : v) // 3^11
		{
			ll p = u.ff;

			forr(i,1,u.ss+1) // 40
			{
				vec.pb( a * p );
				p *= u.ff;
			}
		}

		for(auto a : vec)
			v.pb( a );
	}

	sort( all(v) );

	//cout << x << " : "; for(auto u : v) cout << u << " "; cout << endl;
}

bool calc(ll x,ll k)
{
	if( cur >= N-6 )
		return true;

	if( x == 1 )
	{
		ans[cur++] = 1;
		return false;
	}

	divisors( x, div[x] );

	if( k == 1 )
	{
		forr(i,0,div[x].size())
		{
			ans[cur++] = div[x][i];

			if( cur >= N-6 )
				return true;
		}
		return false;
	}

	forr(i,0,div[x].size())
	{
		if( calc( div[x][i], k-1 ) )
			return true;
	}
	return false;
}
void solve()
{
	if( k == 0 )
	{
		cout << x;
		return;
	}

	factorize(x,mapp); // mapp of ALL primes and max frequencies

	//for(auto u : mapp) cout << u.ff << " : " << u.ss << endl;

	calc(x,k);

	forr(i,0, min(100000ll,cur) )
		cout << ans[i] << " ";
}
void output()
{

}
///////////////////////////// my functions ////////////////////////////////

int main()
{
	input();
	solve();
	output();
	return 0;
}
//// MAIN //// MAIN //// MAIN //// MAIN //// MAIN //// MAIN //// MAIN ////