#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
using ul = unsigned long long;
using ll = int;
using ld = long double;
using pll = pair<ll,ll>;
#define in(v,c) ((c).find(v) != (c).end())
#define F(i,n) for(ll i = 0; i < (ll)(n); i++)
#define Fun(i,n) for(ul i = 0; i < (n); i++)
#ifdef GPD
template<class F>void lerr(F&&f){cerr<<forward<F>(f)<<endl;}
template<class F,class...R>void lerr(F&&f,R&&...r){cerr<<forward<F>(f)<<' ';lerr(forward<R>(r)...);}
#else
#define lerr(...)
#endif

ll n, q;

vector<vector<ll>> e;

void solve(ll cur, ll parent, ll amount, vector<ll> & ret)
{
    if(e[cur].size() == 0 )
    {

        ret = vector<ll>(amount, cur);
        return;
    }

    if(e[cur].size() == 1  && parent == -1)
{

        solve(e[cur].front(), cur, amount, ret);
        return;
}

    if(e[cur].size() == 1)
{
        ret = vector<ll>(amount, cur);
        return;
}

    ll sons = e[cur].size() - (parent == -1? 0 : 1);

    ll q_sons = amount / sons;
    ll offset = q_sons - amount * sons;

    vector<vector<ll>> sonsCombination;
    sonsCombination.reserve(sons);
    F(i, e[cur].size())
    {
        if(e[cur][i] == parent) continue;

        ll q_sons_i = q_sons;

        if(offset)
        {
            q_sons_i++;
            offset--;
        }

        sonsCombination.push_back({});
        solve(e[cur][i], cur, q_sons_i, sonsCombination.back());
    }


    ll counter = 0;
    ll idx = 0;
    while(true)
    {
        for(ll i = 0; i < sons; i++)
        {
            ret.push_back(sonsCombination[i][idx]);
            counter++;
            if(counter >= amount)
                return;
        }

        idx++;
    }


}

int main()
{
    cin >> n >> q;
    e =  vector<vector<ll>>(n);
    for(ll i= 1; i < n; i++)
    {
        ll p; cin >> p;
        e[i].push_back(p);
        e[p].push_back(i);
    }
    
    vector<ll> ret;
    solve(0, -1, q, ret);
    F(i,ret.size())
        cout << ret[i] << endl;

    return 0;
}