#include<bits/stdc++.h>

using namespace std;

const int maxn=1100;

int n,m;

int into[maxn];

int arrayA[maxn];

vector<int> dp[maxn][maxn];

vector<int> to[maxn];

int siz[maxn];

void dfs1(int a){
	if(to[a].empty()){
		siz[a]=0;
		return;
	}
	siz[a]=1;
	for(int it : to[a]){
		dfs1(it);
		siz[a]+=siz[it];
	}
	return;
}

void dfs(int a){
	if(to[a].empty()){
		dp[a][0].push_back(arrayA[a]);
		return;
	}
	int l=to[a][0];
	int r=to[a][1];
	dfs(l);
	dfs(r);
	for(int i=0;i<=siz[l];i++){
		for(int j=0;j<=siz[r];j++){
			//先左后右，表示没有交换
			vector<int> temp;
			int len=0;
			for(int it : dp[l][i]){
				temp.push_back(it);
				len++;
			}
			for(int it : dp[r][j]){
				temp.push_back(it);
				len++;
			}
			if(dp[a][i+j].empty()){
				for(int it : temp){
					dp[a][i+j].push_back(it);
				}
			}
			else{
				int judge=0;
				for(int k=0;k<len;k++){
					if(dp[a][i+j][k]<temp[k]){
						judge=-1;
						break;
					}
					else if(dp[a][i+j][k]>temp[k]){
						judge=1;
						break;
					}
				}
				if(judge==1){
					dp[a][i+j].clear();
					for(int it : temp){
						dp[a][i+j].push_back(it);
					}
				}
			}
			//先右后左，表示交换
			if(i+j+1>siz[a]){
				continue;
			}
			temp.clear();
			len=0;
			for(int it : dp[r][j]){
				temp.push_back(it);
				len++;
			}
			for(int it : dp[l][i]){
				temp.push_back(it);
				len++;
			}
			if(dp[a][i+j+1].empty()){
				for(int it : temp){
					dp[a][i+j+1].push_back(it);
				}
			}
			else{
				int judge=0;
				for(int k=0;k<len;k++){
					if(dp[a][i+j+1][k]<temp[k]){
						judge=-1;
						break;
					}
					else if(dp[a][i+j+1][k]>temp[k]){
						judge=1;
						break;
					}
				}
				if(judge==1){
					dp[a][i+j+1].clear();
					for(int it : temp){
						dp[a][i+j+1].push_back(it);
					}
				}
			}
		}
	}
	return;
}


int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int type;
		cin>>type;
		if(type==1){
			int l,r;
			cin>>l>>r;
			into[l]++;
			into[r]++;
			to[i].push_back(l);
			to[i].push_back(r);
		}
		else{
			cin>>arrayA[i];
		}
	}
	int root=0;
	for(int i=1;i<=n;i++){
		if(into[i]==0){
			root=i;
			break;
		}
	}
	dfs1(root);
	dfs(root);
	vector<int> ans;
	int len=dp[root][0].size();
	for(int i=0;i<=siz[root]&&i<=m;i++){
		if((m-i)%2==0){
			if(ans.empty()){
				for(int it : dp[root][i]){
					ans.push_back(it);
				}
			}
			else{
				int judge=0;
				for(int k=0;k<len;k++){
					if(ans[k]<dp[root][i][k]){
						judge=-1;
						break;
					}
					else if(ans[k]>dp[root][i][k]){
						judge=1;
						break;
					}
				}
				if(judge==1){
					ans.clear();
					for(int it : dp[root][i]){
						ans.push_back(it);
					}
				}
			}
		}
	}
	for(int it : ans){
		cout<<it<<' ';
	}
	cout<<'\n';
	return 0;
}