#include <bits/stdc++.h>

using namespace std;

#define FILE_IO

int BLOCK_SIZE, K;

int N, Q;
vector <int> edg[100005];
int I, itv[100005][2];
int nd[210005];
int vl[210005];

bitset <1000005> bts[455];
int add[455];

void DFS(int nod, int fth)
{
    itv[nod][0] = ++I;
    nd[I] = nod;

    for(auto nxt: edg[nod])
    {
        if(nxt == fth)  continue;
        DFS(nxt, nod);
    }

    itv[nod][1] = ++I;
    nd[I] = nod;
}

void update(int st, int dr, int val)
{
    int blkst = st / BLOCK_SIZE;
    int blkdr = dr / BLOCK_SIZE;

    if(blkst == blkdr)
    {
        for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
            bts[blkst][ vl[i] ] = 0;
        for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
            vl[i] += add[blkst];
        add[blkst] = 0;
        for(int i = st; i <= dr; i++)
            vl[i] += val;
        //bts[blkst].reset();
        for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
            bts[blkst][ vl[i] ] = 1;
        return;
    }

    for(int i = blkst + 1; i < blkdr; i++)
        add[i] += val;

    for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
            bts[blkst][ vl[i] ] = 0;
    for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
        vl[i] += add[blkst];
    add[blkst] = 0;
    for(int i = st; i < (blkst + 1) * BLOCK_SIZE; i++)
        vl[i] += val;
    //bts[blkst].reset();
    for(int i = blkst * BLOCK_SIZE; i < (blkst + 1) * BLOCK_SIZE; i++)
        bts[blkst][ vl[i] ] = 1;

    for(int i = blkdr * BLOCK_SIZE; i < (blkdr + 1) * BLOCK_SIZE; i++)
            bts[blkst][ vl[i] ] = 0;
    for(int i = blkdr * BLOCK_SIZE; i < (blkdr + 1) * BLOCK_SIZE; i++)
        vl[i] += add[blkdr];
    add[blkdr] = 0;
    for(int i = blkdr * BLOCK_SIZE; i <= dr; i++)
        vl[i] += val;
    //bts[blkdr].reset();
    for(int i = blkdr * BLOCK_SIZE; i < (blkdr + 1) * BLOCK_SIZE; i++)
        bts[blkdr][ vl[i] ] = 1;
}

int query(int val)
{
    for(int i = 0; i < K - 1; i++)
        if(val >= add[i] && bts[i][ val - add[i] ])
        {
            for(int j = i * BLOCK_SIZE; j < (i + 1) * BLOCK_SIZE; j++)
                if(vl[j] + add[i] == val)
                    return nd[j];
        }
    for(int i = (K - 1) * BLOCK_SIZE; i < I; i++)
        if(vl[i] + add[K - 1] == val)
            return nd[i];
    return (-1);
}

int main()
{
    #ifdef FILE_IO
    freopen("arbore.in", "r", stdin);
    freopen("arbore.out", "w", stdout);
    #endif

    scanf("%d%d", &N, &Q);
    for(int i = 1; i < N; i++)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        edg[x].push_back(y);
        edg[y].push_back(x);
    }

    I = -1;
    DFS(1, 0);
    I++;

    BLOCK_SIZE = (int)sqrt(I);
    K = I / BLOCK_SIZE + 1;
    for(int i = 0; i < K; i++)
        bts[i][0] = 1;

    while(Q--)
    {
        int op;
        scanf("%d", &op);
        if(op == 1)
        {
            int nod, val;
            scanf("%d%d", &nod, &val);
            update(itv[nod][0], itv[nod][1], val);
        }
        else
        {
            int val;
            scanf("%d", &val);
            int ans = query(val);
            printf("%d\n", ans);
        }
    }

    return 0;
}