#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

typedef long long ll;

const int M = 507;
const int N = 1007;

int dp[M][M];
int ndp[M][M];
int buff[M];

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> l(n, -1), r(n, -1);
    vector<int> a(n, -1);
    for (int i = 0; i < n; ++i) {
        int t;
        cin >> t;
        if (t == 1) {
            cin >> l[i] >> r[i];
            --l[i], --r[i];
        } else {
            cin >> a[i];
        }
    }
    vector<int> sz(n);
    vector<int> h(n);
    vector<vector<int>> layers(n + 1);
    function<void(int)> dfs = [&](int u) {
        layers[h[u]].push_back(u);
        if (a[u] != -1) {
            sz[u] = 1;
        }
        for (int v : {l[u], r[u]}) {
            if (v != -1) {
                h[v] = h[u] + 1;
                dfs(v);
                sz[u] += sz[v];
            }
        }
    };
    dfs(0);
    vector<int> pos(n, -1);
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j < (int)layers[i].size(); ++j) {
            pos[layers[i][j]] = j;
        }
    }
    vector<vector<int>> pref(n + 1);
    for (int i = n; i >= 0; --i) {
        if (!layers[i].empty()) {
            pref[i].reserve(layers[i].size() + 1);
            pref[i].push_back(0);
            for (int x : layers[i]) {
                pref[i].push_back(pref[i].back() + sz[x]);
            }
        }
    }

    int cl = n;
    while (layers[cl].empty()) {
        --cl;
    }

    const int Inf = 1e9;
    for (int i = 0; i <= m; ++i) {
        fill(dp[i], dp[i] + pref[cl].back() + 1, Inf);
    }

    for (int i = 0; i < layers[cl].size(); ++i) {
        dp[0][pref[cl][i]] = a[layers[cl][i]];
    }

    for (int lx = cl - 1; lx >= 0; --lx) {
        for (int i = 0; i <= m; ++i) {
            fill(ndp[i], ndp[i] + pref[lx].back() + 1, Inf);
        }
        for (int i = 0; i < layers[lx].size(); ++i) {
            int v = layers[lx][i];
            if (a[v] != -1) {
                ndp[0][pref[lx][i]] = a[v];
            } else {
                int start_v = pref[lx][i];
                int l_ch = l[v], r_ch = r[v];
                int start_l = pref[lx + 1][pos[l_ch]];
                int start_r = pref[lx + 1][pos[r_ch]];
                auto min_eq = [&](int l_op, int r_op, int sw) {
                    int v_op = l_op + r_op + sw;
                    if (v_op > m) {
                        return;
                    }
                    if (!sw) {
                        for (int k = 0; k < sz[l_ch]; ++k) {
                            buff[k] = dp[l_op][start_l + k];
                        }
                        for (int k = 0; k < sz[r_ch]; ++k) {
                            buff[sz[l_ch] + k] = dp[r_op][start_r + k];
                        }
                    } else {
                        for (int k = 0; k < sz[r_ch]; ++k) {
                            buff[k] = dp[r_op][start_r + k];
                        }
                        for (int k = 0; k < sz[l_ch]; ++k) {
                            buff[sz[r_ch] + k] = dp[l_op][start_l + k];
                        }
                    }

                    bool is_better = true;
                    for (int k = 0; k < sz[l_ch] + sz[r_ch]; ++k) {
                        if (buff[k] > ndp[v_op][start_v + k]) {
                            is_better = false;
                            break;
                        }
                        if (buff[k] < ndp[v_op][start_v + k]) {
                            break;
                        }
                    }
                    if (is_better) {
                        for (int k = 0; k < sz[l_ch] + sz[r_ch]; ++k) {
                            ndp[v_op][start_v + k] = buff[k];
                        }
                    }
                };
                for (int go_l = 0; go_l <= min(m, sz[l_ch] + 1); ++go_l) {
                    for (int go_r = 0; go_r <= min(m, sz[r_ch] + 1); ++go_r) {
                        for (int sw = 0; sw <= 1; ++sw) {
                            min_eq(go_l, go_r, sw);
                        }
                    }
                }
            }
        }
        swap(dp, ndp);
    }
    for (int i = 0; i < sz[0]; ++i) {
        cout << dp[m][i] << " ";
    }
    cout << '\n';
}