#include <iostream>
#include <fstream>
#include <vector>
#include <bitset>
#include <cmath>

using namespace std;

ifstream fin("arbore.in");
ofstream fout("arbore.out");

const int Nmax = 100000, SqrtN = 320, Valmax = 1000000;

struct Part{
    int start, stop, val;
    bitset <Valmax + 5> b;
};
struct Element{
    int node, val;
}e[Nmax + 5];

vector <int> g[Nmax + 5];
Part v[SqrtN + 5];
int n, m, k, first[Nmax + 5], last[Nmax + 5], nr, sq;
bool use[Nmax + 5];

void Read(){
    fin >> n >> m;
    for (int i = 1; i < n; i++){
        int x, y;
        fin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
}

void DFS(int node){
    use[node] = 1;
    first[node] = ++k;
    e[k].node = node;
    for (auto i : g[node])
        if (!use[i])
            DFS(i);
    last[node] = k;
}

void Constr(){
    sq = sqrt(n);
    for (int i = 1; i <= n; i++){
        if (i % sq == 1){
            v[nr].stop = i - 1;
            nr++;
            v[nr].start = i;
        }
        v[nr].b[0] = 1;
    }
    if (!v[nr].stop)
        v[nr].stop = n;
}

void UpdateBitset(int x){
    v[x].b.reset();
    for (int i = v[x].start; i <= v[x].stop; i++)
        v[x].b[e[i].val] = 1;
}

void Update(int f, int l, int value){
    for (int i = 1; i <= nr; i++){
        if (f <= v[i].start && v[i].stop <= l)
            v[i].val += value;
        else if (f > v[i].start && v[i].stop > l){
            for (int j = f; j <= l; j++)
                e[j].val += value;
            UpdateBitset(i);
        }
        else if (f > v[i].start && f <= v[i].stop){
            for (int j = f; j <= v[i].stop; j++)
                e[j].val += value;
            UpdateBitset(i);
        }
        else if (v[i].stop > l && l >= v[i].start){
            for (int j = v[i].start; j <= l; j++)
                e[j].val += value;
            UpdateBitset(i);
        }
    }
}

int Query(int s){
    for (int i = 1; i <= nr; i++){
        if (s - v[i].val < 0)
            continue;
        if (v[i].b[s - v[i].val])
            for (int j = v[i].start; j <= v[i].stop; j++)
                if (e[j].val == s - v[i].val)
                    return e[j].node;
    }
    return -1;
}

int main(){
    Read();
    DFS(1);
    Constr();
    while (m--){
        int op;
        fin >> op;
        if (op == 1){
            int p, s;
            fin >> p >> s;
            Update(first[p], last[p], s);
        }
        else{
            int s;
            fin >> s;
            fout << Query(s) << '\n';
        }
    }
    return 0;
}