#include <bits/stdc++.h>

using namespace std;

FILE *fin = fopen( "arbore.in", "r" );
FILE *fout= fopen( "arbore.out","w" );

const int BUF  = (1<<17);
const int maxv = 1e6 + 1;
const int maxn = 1e5 + 5;
const int Sqrt = 320;
const int buck = 320;

char buf[BUF], buf2[BUF];
int pos = BUF, pos2;

inline char getChar() {
    if (pos == BUF)
        pos = 0, fread( buf, 1, BUF, fin );
    return buf[ pos++ ];
}

inline int getInt() {
    int nr = 0;
    char c = getChar();
    while (!isdigit(c))
        c = getChar();
    while (isdigit(c)) {
        nr = nr*10 + c-'0';
        c = getChar();
    }
    return nr;
}

inline void writeChar( char c ) {
    buf2[ pos2++ ] = c;
    if (pos2 == BUF)
        pos2 = 0, fwrite( buf2, 1, BUF, fout );
}

inline void writeInt( int nr ) {
    char s[ 15 ];
    int sg = 1, top = 0;
    if (nr < 0)
        sg = -1, nr *= -1;
    while (nr) {
        s[ top++ ] = nr%10 + '0';
        nr /= 10;
    }
    if (sg == -1)
        s[ top++ ] = '-';
    while (top) {
        top--;
        writeChar( s[ top ] );
    }
}

vector < int > G[maxn];
pair < int, int > Ends[maxn];
bitset < maxv > val[buck];

int n, m, k, tbuckets, v[maxn], values[maxn], where[maxn], lazy[buck];

void dfs( int node, int dad ) {
    v[ ++k ] = node;
    Ends[ node ].first = k;
    for (int son: G[ node ])
        if (son != dad)
            dfs( son, node );
    Ends[ node ].second = k;
}

inline void compute( int idx ) {
    int left = (idx-1 ) * Sqrt + 1, right = min( idx * Sqrt, n );
    for (int i = left; i <= right; i++)
        val[ idx ][ values[ i ] ] = 1;
}

inline void update( int x, int y, int value ) {
    for (int i = where[ x ] + 1; i < where[ y ]; i++)
        lazy[ i ] += value;

    if (where[ x ] == where[ y ]) {
        for (int i = x; i <= y; i++) {
            val[ where[ x ] ][ values[ i ] ] = 0;
            values[ i ] += value;
        }
        compute( where[ x ] );
        return;
    }

    int s = where[ x ] * Sqrt;
    for (int i = x; i <= s; i++) {
        val[ where[ x ] ][ values[ i ] ] = 0;
        values[ i ] += value;
    }
    compute( where[ x ] );

    s = (where[ y ] - 1) * Sqrt + 1;
    for (int i = s; i <= y; i++) {
        val[ where[ y ] ][ values[ i ] ] = 0;
        values[ i ] += value;
    }
    compute( where[ y ] );
}

inline int searchBucket( int idx, int sum ) {
    int left = (idx-1)*Sqrt + 1, right = idx * Sqrt;
    for (int i = left; i <= right; i++)
        if (values[ i ] == sum)
            return v[ i ];
    return -1;
}

inline int query( int sum ) {
    for (int i = 1; i <= tbuckets; i++)
        if (val[ i ][ sum - lazy[ i ] ])
            return searchBucket( i, sum - lazy[ i ] );
    return -1;
}

int main()
{
    int op, x, y;

    n = getInt();
    m = getInt();

    for (int i = 1; i < n; i++) {
        x = getInt();
        y = getInt();
        G[ x ].push_back( y );
        G[ y ].push_back( x );
    }

    for (int i = 1; i <= n; i++)
        where[ i ] = (i + Sqrt - 1) / Sqrt;

    tbuckets = where[ n ];

    dfs( 1, 0 );

    for (int i = 1; i <= m; i++) {
        op = getInt();
        if (op == 1) {
            x = getInt();
            y = getInt();
            update( Ends[ x ].first, Ends[ x ].second, y );
        }
        else {
            x = getInt();
            writeInt( query( x ) );
            writeChar( '\n' );
        }
    }

    if (pos2)
        fwrite( buf2, 1, pos2, fout );

    return 0;
}