#include <bits/stdc++.h>

using namespace std;

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

const int XD = 400;

int n, q, x, y;
int timer;

vector <int> g[100005];
int fst[100005], lst[100005];
int add[XD], nr[100005], v[101005];
bitset <1000005> f[100005 / XD + 1];

void dfs(int nod, int tata = 0) {
    fst[nod] = ++timer;

    for(auto &fiu : g[nod]) {
        if(fiu == tata)
            continue;
        dfs(fiu, nod);
    }

    lst[nod] = timer;
    nr[fst[nod]] = nod;
}

void fn(int gr, int l, int r, int y) {
    for(int i = gr * XD; i < (gr + 1) * XD; i++) {
        f[gr][v[i]] = 0;
    }
    for(int i = l; i <= r; i++) {
        v[i] += y;
    }
    for(int i = gr * XD; i < (gr + 1) * XD; i++) {
        f[gr][v[i]] = 1;
    }
}

int main() {
    in >> n >> q;
    for(int i = 1; i < n; i++) {
        in >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }

    dfs(1);

    n = timer;

    for(int i = 0; i <= n / XD; i++)
        f[i][0] = 1;

    for(; q; q--) {
        int t;
        in >> t >> x;

        if(t == 1) {
            in >> y;
            int l = fst[x], r = lst[x];
            int gl = l / XD, gr = r / XD;

            if(gl == gr) {
                fn(gl, l, r, y);
                continue;
            }
            fn(gl, l, (gl + 1) * XD - 1, y);

            for(int i = gl + 1; i < gr; i++) {
                add[i] += y;
            }

            fn(gr, gr * XD, r, y);
        } else {
            int lol = -1;
            for(int i = 0; i <= n / XD; i++) {
                if(add[i] > x)
                    continue;
                if(f[i][x - add[i]]) {
                    for(int j = i * XD; j < (i + 1) * XD; j++) {
                        if(v[j] == x - add[i] && j) {
                            lol = j;
                            break;
                        }
                    }
                    break;
                }
            }
            out << (lol != -1 ? nr[lol] : lol) << "\n";
        }
    }
    return 0;
}