#include <bits/stdc++.h>

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<std::vector<int>> origin(n);
    auto dfs0 = [&](auto self, int node) -> void {
        if (son[node].first == son[node].second) {
            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);

        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 solve = [&](auto self, int node, int m, bool f) -> std::vector<int> {
        if (son[node].first == son[node].second) {
            if (m % 2 == 0 || f) {
                return std::vector<int>{a[node]};
            } else {
                return std::vector<int>{-1};
            }
        }
        
        auto [l, r] = son[node];
        std::vector<int> ans;
        
        // Not change
        {
            std::vector<int> res;
            if (m <= dp[l].m) {
                res = concatenate(self(self, l, m, f), origin[r]);
            } else {
                res = concatenate(dp[l].arr, self(self, r, m - dp[l].m, f || dp[l].f));
            }

            if (std::find(res.begin(), res.end(), -1) == res.end() && (ans.empty() || res < ans)) {
                ans = res;
            }
        }

        // Change
        {
            m -= 1;
            std::vector<int> res;
            if (m <= dp[r].m) {
                res = concatenate(self(self, r, m, f), origin[l]);
            } else {
                res = concatenate(dp[r].arr, self(self, l, m - dp[r].m, f || dp[r].f));
            }

            if (std::find(res.begin(), res.end(), -1) == res.end() && (ans.empty() || res < ans)) {
                ans = res;
            }
        }

        assert(!ans.empty());

        return ans;
    };

    auto ans = solve(solve, rt, m, false);
    for (int i : ans) {
        std::cout << i << ' ';
    }
    
    return 0;
}