#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define debug(x) cout<<#x<<": "<<x<<endl
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
using ll=long long;
using ull=unsigned long long;
void solve(){
    int n,m;
    cin >> n >> m;
    vector<vector<int>>e(n+1);
    vector<int>fa(n+1);
    vector<int>son_vis(n+1);
    vector<int>label(n+1);
    vector<int>dep(n+1);
    vector<array<int,2>>cmp;

    for(int i = 1;i <= n;i++)
    {
        int opt;
        cin>>opt;
        if(opt == 1)
        {
            int a,b;
            cin>>a>>b;
            e[i].push_back(a);
            e[i].push_back(b);
            son_vis[a] = 0,son_vis[b] = 1;
            fa[a] = fa[b] = i;
            dep[a] = dep[b] = dep[i] + 1;
        }
        else
        {
            cin >> label[i];
            cmp.push_back({label[i],i});        
        }
    }

    sort(cmp.begin(),cmp.end());

    vector<int>ord;
    auto dfs = [&](auto &&self,int u) ->void
    {
        for(auto v:e[u])
            self(self,v);
        if(e[u].empty())
            ord.push_back(u);
    };
    auto LCA = [&](int x,int y)
    {
        int len = 1;
        while(fa[x] != fa[y])
        {
            if(dep[x] > dep[y])
                x = fa[x];
            else if(dep[x] < dep[y]){
                len += (son_vis[x] != son_vis[y]);
                y = fa[y];
            }
            else{
                len += (son_vis[x] != son_vis[y]);
                x = fa[x];
                y = fa[y];
            }
        }   
        return len;
    };
    auto SWAP = [&](int y)
    {
        int f = fa[y];
        swap(e[f][0],e[f][1]);
        swap(son_vis[e[f][0]],son_vis[e[f][1]]);
    };
    auto update = [&](int x,int y)
    {
        while(fa[x] != fa[y])
        {
            if(dep[x] > dep[y])
                x = fa[x];
            else if(dep[x] < dep[y]){
                if(son_vis[y] != son_vis[x])
                    SWAP(y);
                y = fa[y];
            }
            else{
                if(son_vis[x] != son_vis[y])
                    SWAP(y);
                x = fa[x];
                y = fa[y];
            }
        }
        SWAP(y);
    };
    array<int,2> temp = {0,0};
    for(int i = 1; e[i].size() ;i = e[i][1])
    {
        ord.clear();
        dfs(dfs,i);

        sort(ord.begin()+1,ord.end(),[&](const int &x,const int &y){
            return label[x] < label[y];
        });
        for(int j = 1;j<ord.size();j++)
        {
            int lca = LCA(ord[0],ord[j]);
            //cout<<ord[0] <<" "<<ord[j]<<" "<<lca<<endl;
            if(m >= lca)
            {
               // cout<<ord[0]<<" "<<ord[j]<<endl;
                temp = {ord[0],ord[j]};
                update(ord[0],ord[j]);
                m -= lca;
                break;
            }
        }
    }

    ord.clear();
    dfs(dfs,1);
    if(m % 2)
    {
        if(temp[0] != 0)
        {
            auto [x,y] = temp;
            while(fa[x] != fa[y])
            {
                if(dep[x] > dep[y])
                    x = fa[x];
                else if(dep[x] < dep[y]){
                    if(son_vis[y] != son_vis[x]){
                        SWAP(y);
                        m--;
                        break;
                    }
                    y = fa[y];
                }
                else{
                    if(son_vis[x] != son_vis[y]){
                        SWAP(y);
                        m--;
                        break;
                    }
                    x = fa[x];
                    y = fa[y];
                }
            }
            if(m % 2)
                SWAP(y);
            ord.clear();
            dfs(dfs,1);
        }
    }


    for(auto i:ord)
        cout<<label[i]<<" ";
    cout<<endl;
    
}
signed main(){
    ios::sync_with_stdio(0);
    cout.tie(0);
    cin.tie(0);
    int t = 1;
    //cin>>t;
    while(t--){
        solve();
    }
}
/*
贡献法
正难则反
数小状压
关系连边
拆位
广义单调性
最长转最短
*/