#include <cstdio>
#include <cstring>
#include <bitset>
#include <ctime>
#include <random>

#define MaxN 100050
#define MaxS 1000050
#define BUCKET 500
#define MaxBuckets 410
#define NIL -1

#define RANDOM_PASS 100

using namespace std;

struct Edge {
	int v;
	int next;
};

Edge l[2 * (MaxN - 1)];
int adj[MaxN];
int sum[2 * MaxN + BUCKET];

bitset <MaxS + 2> H[MaxBuckets];
int lazy[MaxBuckets];
int euler[2 * MaxN];
pair <int, int> node2Euler[MaxN];
int ptr;

int numBuckets;

static inline void addEdge(const int &u, const int &v, const int &pos) {
	l[pos].v =v;
	l[pos].next = adj[u];
	adj[u] = pos;
}

void DFS(int u, int parent) {
	euler[ptr] = u;
	node2Euler[u].first = ptr++;
	for (int i = adj[u]; i != NIL; i = l[i].next) {
		if (l[i].v != parent) {
			DFS(l[i].v, u);
		}
	}
	euler[ptr] = u;
	node2Euler[u].second = ptr++;
}

static inline int getRandom(void) {
	static mt19937 gen(time(0));
	int x = gen();
	return x < 0 ? -x : x;
}

static inline int randomCheck(const int &need) {
	for (int i = 0; i < RANDOM_PASS; i++) {
		int bucket = getRandom() % (numBuckets + 1);
		
		if (need - lazy[bucket] >= 0 && H[bucket][need - lazy[bucket]]) {
			return bucket;
		}
	}
	return -1;
}

int main() {
	freopen("arbore.in", "r", stdin);
	freopen("arbore.out", "w", stdout);
	int N, Q;
	int u, v;
	int opType, add;
	
	scanf("%d%d", &N, &Q);
	memset(adj, NIL, 4 * N);
	for (int i = 1; i < N; i++) {
		scanf("%d%d", &u, &v);
		addEdge(u - 1, v - 1, 2 * i - 2);
		addEdge(v - 1, u - 1, 2 * i - 1);
	}
	
	DFS(0, -1);
	numBuckets = -1;
	for (int i = 0; i < ptr; i++) {
		numBuckets += (i == i / BUCKET * BUCKET);
		H[numBuckets][0] = 1;
	}
	
	while (ptr != ptr / BUCKET * BUCKET) {
		sum[ptr++] = MaxS + 1;
	}
	
	while (Q--) {
		scanf("%d", &opType);
		if (opType == 1) {
			scanf("%d%d", &u, &add); u--;
			
			int bucket = node2Euler[u].first / BUCKET;
			int startBucket = bucket * BUCKET;
			int endBucket = startBucket + BUCKET;
			
			for (int i = startBucket; i < endBucket; i++) {
				H[bucket][sum[i]] = 0;
			}
			for (int i = node2Euler[u].first; (i < endBucket) && (i <= node2Euler[u].second); i++) {
				sum[i] += add;
			}
			for (int i = startBucket; i < endBucket; i++) {
				H[bucket][sum[i]] = 1;
			}
			
			if (node2Euler[u].second / BUCKET != bucket) {
				int fnBucket = node2Euler[u].second / BUCKET;
				for (int i = bucket + 1; i < fnBucket; i++) {
					lazy[i] += add;
				}
				startBucket = fnBucket * BUCKET;
				endBucket = startBucket + BUCKET;
				for (int i = startBucket; i < endBucket; i++) {
					H[fnBucket][sum[i]] = 0;
				}
				for (int i = startBucket; i <= node2Euler[u].second; i++) {
					sum[i] += add;
				}
				for (int i = startBucket; i < endBucket; i++) {
					H[fnBucket][sum[i]] = 1;
				}
			}
		} else {
			scanf("%d", &add);
			
			int bucket = randomCheck(add);
			
			if (bucket == -1) {
				do {
					bucket++;
				} while (bucket <= numBuckets && (add - lazy[bucket] < 0 || !H[bucket][add - lazy[bucket]]));
			}
			
			if (bucket <= numBuckets) {
				add -= lazy[bucket];
				bucket *= BUCKET;
				while (sum[bucket] != add) {
					bucket++;
				}
				printf("%d\n", 1 + euler[bucket]);
			} else {
				puts("-1");
			}
		}
	}
	fclose(stdin);
	fclose(stdout);
	return 0;
}