#include <bits/stdc++.h>

constexpr int INF = 1e9 + 7;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m;
    std::cin >> n >> m;

    std::vector<int> a(n);
    std::vector<std::pair<int, int>> son(n);
    std::vector<uint8_t> has_father(n);
    for (int i = 0; i < n; ++i) {
        int tp;
        std::cin >> tp;
        if (tp == 1) {
            int l, r;
            std::cin >> l >> r;
            --l, --r;
            son[i] = {l, r};
            has_father[l] = has_father[r] = true;
        } else {
            std::cin >> a[i];
        }
    }
    int rt = 0;
    while (has_father[rt]) {
        ++rt;
    }

    auto concatenate = [](std::vector<int> a, std::vector<int> b) {
        a.insert(a.end(), b.begin(), b.end());
        return a;
    };

    struct Node {
        std::vector<int> arr;
        int m;
        bool f;
    };
    std::vector<Node> dp(n);
    std::vector<int> sz(n);
    std::vector<std::vector<int>> origin(n);
    auto dfs0 = [&](auto self, int node) -> void {
        if (son[node].first == son[node].second) {
            sz[node] = 1;
            
            dp[node].arr = std::vector<int>{a[node]};
            dp[node].m = 0;
            dp[node].f = false;

            origin[node] = std::vector<int>{a[node]};
            return;
        }
        auto [l, r] = son[node];
        self(self, l);
        self(self, r);
        sz[node] = sz[l] + sz[r];

        origin[node] = concatenate(origin[l], origin[r]);

        std::vector<int> l_first = concatenate(dp[l].arr, dp[r].arr);
        std::vector<int> r_first = concatenate(dp[r].arr, dp[l].arr);

        if (l_first == r_first) {
            dp[node].arr = std::move(l_first);
            dp[node].m = dp[l].m + dp[r].m;
            dp[node].f = true;
        } else if (l_first < r_first) {
            dp[node].arr = std::move(l_first);
            dp[node].m = dp[l].m + dp[r].m;
            dp[node].f = false;
        } else {
            dp[node].arr = std::move(r_first);
            dp[node].m = dp[l].m + dp[r].m + 1;
            dp[node].f = false;
        }
    };
    dfs0(dfs0, rt);

    auto check = [](const std::vector<int> &v, auto it) -> bool {
        for (int i = 0; i < v.size(); ++i) {
            if (v[i] > it[i]) {
                return false;
            }
        }
        return true;
    };    

    auto solve = [&](auto self, int node, int m, bool f, auto it) -> std::vector<int> {
        if (m == 0) {
            return origin[node];
        }

        if (son[node].first == son[node].second) {
            if (m % 2 == 0 || f) {
                return std::vector<int>{a[node]};
            } else {
                return std::vector<int>{INF};
            }
        }
        
        auto [l, r] = son[node];
        std::vector<int> ans(it, it + sz[node]);
        bool flag = false;
        
        // Not change
        {
            std::vector<int> res(sz[node], INF);
            if (m <= dp[l].m) {
                res = concatenate(self(self, l, m, f, ans.begin()), origin[r]);
            } else if (check(dp[l].arr, ans.begin())) {
                res = concatenate(dp[l].arr, self(self, r, m - dp[l].m, f || dp[l].f, res.begin() + sz[l]));
            }

            if (std::find(res.begin(), res.end(), INF) == res.end() && res <= ans) {
                ans = res;
                flag = true;
            }
        }

        // Change
        {
            m -= 1;
            std::vector<int> res(sz[node], INF);
            if (m <= dp[r].m) {
                res = concatenate(self(self, r, m, f, ans.begin()), origin[l]);
            } else if (check(dp[r].arr, ans.begin())) {
                res = concatenate(dp[r].arr, self(self, l, m - dp[r].m, f || dp[r].f, res.begin() + sz[r]));
            }
            
            if (std::find(res.begin(), res.end(), INF) == res.end() && res <= ans) {
                ans = res;
                flag = true;
            }
        }

        if (flag) {
            return ans;
        } else {
            return std::vector<int>(sz[node], INF);
        }
    };

    std::vector<int> ans(sz[rt], INF);
    ans = solve(solve, rt, m, false, ans.begin());
    for (int i : ans) {
        std::cout << i << ' ';
    }
    
    return 0;
}