#include<fstream>

#include<vector>

#include<cmath>

#include<algorithm>

#include<bitset>

using namespace std;

ifstream fin("arbore.in");

ofstream fout("arbore.out");

const int DIM = 1e5 + 5;

const int DIM1 = 460;

vector<int> G[DIM];

int First[DIM], Last[DIM], N, M, K, pos;

int Bucket[DIM * 2], StPos_Bucket[DIM1], S[DIM1], V[DIM * 2], Liniar[DIM * 2];

bitset<1000003> F[DIM1];

void dfs( int nod, int father ){

    First[nod] = ++pos;

    Liniar[pos] = nod;

    for( int i = 0; i < G[nod].size(); i++ ){

        int vecin = G[nod][i];

        if( vecin != father )

            dfs( vecin, nod );

    }

    Last[nod] = ++pos;

    Liniar[pos] = nod;

}

int Final( int x ){

    return min( 2 * N, StPos_Bucket[x] + K - 1 );

}

void update( int st, int dr, int val ){

    int buc = Bucket[st];

    int buc1 = Bucket[dr];

    if( buc == buc1 ){

        for( int i = st; i <= dr; i++ ){

            F[buc][ V[i] ] = 0;

            V[i] += val;

        }

        for( int i = StPos_Bucket[buc]; i <= Final(buc); i++ )

            F[buc][ V[i] ] = 1;

        return;

    }

    if( StPos_Bucket[buc] < st ){

        for( int i = st; i <= Final(buc); i++ ){

            F[buc][ V[i] ] = 0;

            V[i] += val;

        }

        for( int i = StPos_Bucket[buc]; i <= Final(buc); i++ )

            F[buc][ V[i] ] = 1;

        buc++;

    }

    if( StPos_Bucket[buc1] + K - 1 > dr ){

        for( int i = StPos_Bucket[buc1]; i <= dr; i++ ){

            F[buc1][ V[i] ] = 0;

            V[i] += val;

        }

        for( int i = StPos_Bucket[buc1]; i <= Final( buc1 ); i++ )

            F[buc1][ V[i] ] = 1;

        buc1--;

    }

    while( buc <= buc1 ){

        S[buc] += val;

        buc++;

    }

    return;

}

void solution( int buc, int val ){

    for( int i = StPos_Bucket[buc]; i <= Final(buc); i++ ){

        if( V[i] == val ){

            fout << Liniar[i] << "\n";

            return;

        }

    }

}

int main(){

    fin >> N >> M;

    K = (int)sqrt( 2 * N ) + 1;

    for( int i = 1; i < N; i++ ){

        int a, b; fin >> a >> b;

        G[a].push_back( b );

        G[b].push_back( a );

    }

    dfs( 1, 0 );

    for( int i = 1; i <= 2 * N; i++ ){

        if( (i - 1) % K == 0 )

            Bucket[i] = Bucket[i - 1] + 1, StPos_Bucket[ Bucket[i] ] = i;

        else

            Bucket[i] = Bucket[i - 1];

    }

    for( int i = 1; i <= Bucket[2 * N]; i++ )

        F[i][0] = 1;

    for( int i = 1; i <= M; i++ ){

        int op; fin >> op;

        if( op == 1 ){

            int p, x; fin >> p >> x;

            update( First[p], Last[p], x );

        }else{

            int x; fin >> x;

            bool ok = false;

            for( int j = 1; j <= Bucket[2 * N] && ok == false; j++ ){

                if( x - S[j] >= 0 && F[j][ x - S[j] ] == 1 ){

                    ok = true;

                    solution( j, x - S[j] );

                }

            }

            if( ok == false )

                fout << "-1\n";

        }

    }

    return 0;

}