#include <bits/stdc++.h>
#define L 100350
#define LL 1000005
using namespace std;
ifstream fin("arbore.in");
ofstream fout("arbore.out");

vector <int> G[L];
bitset <LL> is_val[350];
int lin_tree[L], pos_in_lin_tree[L], sons[L], bucket_sum[L], elem_sum[L], bucket_size, buckets, i1 = 1, n;
bool vis[L];

void DFS(int node){
  vis[node] = true;
  pos_in_lin_tree[node] = i1;
  lin_tree[i1++] = node;
  sons[node] = 1;
  for (auto it : G[node])
    if (!vis[it]){
      DFS(it);
      sons[node] += sons[it];
    }
}

inline int search_for(int x){
  int i, pos = 0;
  for (i = 1; i <= buckets && !pos; i++)
    if (is_val[i][(x - bucket_sum[i] >= 0 ? x - bucket_sum[i] : LL - 1)])
      pos = i;
  return pos;
}

inline int get_sum(int node){
  return elem_sum[node] + bucket_sum[(node - 1) / bucket_size + 1];
}

inline void init_is_val(){
  int i;
  for (i = 1; i <= buckets; i++)
    is_val[i][0] = true;
}

int main(){
  int q, t, p, s, i, j, a, b, j1, j2, r, ok, root = 1;
  fin >> n >> q;
  for (i = 1; i < n; i++){
    fin >> a >> b;
    G[a].push_back(b);
    G[b].push_back(a);
  }
  DFS(root);
  bucket_size = sqrt(n);
  buckets = (n - 1) / bucket_size + 1;
  init_is_val();
  for (j = 0; j < q; j++){
    fin >> t;
    if (t == 1){
      fin >> p >> s;
      j1 = pos_in_lin_tree[p];
      j2 = pos_in_lin_tree[p] + sons[p] - 1;
      if (j2 - j1 + 1 <= bucket_size)
        for (i = j1; i <= j2; i++){
          is_val[(i - 1) / bucket_size + 1][elem_sum[i]] = false;
          is_val[(i - 1) / bucket_size + 1][elem_sum[i] + s] = true;
          elem_sum[i] += s;
        }
      else{
        for (i = j1; i % bucket_size != 0; i++){
          is_val[(i - 1) / bucket_size + 1][elem_sum[i]] = false;
          is_val[(i - 1) / bucket_size + 1][elem_sum[i] + s] = true;
          elem_sum[i] += s;
        }
        is_val[(i - 1) / bucket_size + 1][elem_sum[i]] = false;
        is_val[(i - 1) / bucket_size + 1][elem_sum[i] + s] = true;
        elem_sum[i] += s;
        a = i;
        for (i = j2; i % bucket_size != 1; i--){
          is_val[(i - 1) / bucket_size + 1][elem_sum[i]] = false;
          is_val[(i - 1) / bucket_size + 1][elem_sum[i] + s] = true;
          elem_sum[i] += s;
        }
        is_val[(i - 1) / bucket_size + 1][elem_sum[i]] = false;
        is_val[(i - 1) / bucket_size + 1][elem_sum[i] + s] = true;
        elem_sum[i] += s;
        b = i - 1;
        for (i = a / bucket_size + 1; i <= b / bucket_size; i++)
          bucket_sum[i] += s;
      }
    }
    else{
      fin >> s;
      p = search_for(s);
      if (p == 0)
        ok = 0;
      else
        ok = 1;
      for (i = (p - 1) * bucket_size + 1; i <= p * bucket_size; i++)
        if (get_sum(i) == s){
          r = i;
          i = p * bucket_size;
        }
      if (r > n)
        ok = 0;
      if (ok == 0)
        fout << "-1\n";
      else
        fout << lin_tree[r] << "\n";
    }
  }
  return 0;
}