#include <bits/stdc++.h>
using namespace std;

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

const int NMAX = 100005;
const int SQRTMAX = 325;

int n , S[NMAX] , F[NMAX] , cnt  , Q , R;

int st[SQRTMAX] , dr[SQRTMAX] , aux , dim , N[NMAX] , ST[NMAX];

bool viz[NMAX];

vector < int > L[NMAX];

struct Rad
{
    bitset < NMAX > freq;
    int SUM = 0;
};
Rad a[SQRTMAX];

/**
    a[i] . SUM = cu ce suma a fost adunata toata bucata i
    ST[i] = cu ce suma a fost adunat elementul i separat
*/

inline void DFS(int node) /// liniarizare arbore
{
    S[node] = ++aux;
    N[aux] = node;
    viz[node] = true;
    for(auto it : L[node])
        if(!viz[it])
            DFS(it);
    F[node] = ++aux;
}


inline void UPDATE(int p , int x , int y , int s)
{
    for(int i = st[p] ; i <= dr[p] ; i++)
        a[p] . freq[ST[i]] = 0;
    for(int i = x ; i <= y ; i++)
        ST[i] += s;
    for(int i = st[p] ; i <= dr[p] ; i++)
        a[p] . freq[ST[i]] = 1;
}
int main()
{
    int x , y , query , sum , node , i , j;
    fin >> n >> Q;
    for( i = 1 ; i < n ; i++)
    {
        fin >> x >> y;
        L[x] . push_back(y);
        L[y] . push_back(x);
    }
    DFS(1);
    R = sqrt(n);
    for(i = 1 ; i <= n ; i += R)
    {
        ++dim;
        st[dim] = i;
        dr[dim] = min(i + R - 1 , n);
    }
    while(Q -- )
    {
        fin >> query;
        if(query == 1)
        {
            fin >> node >> sum;
            x = S[node];
            y = F[node];
            for(i = 1 ; i <= dim && st[i] < x ; i++)
                ;
            for(j = max(i - 1 , 1) ; j <= dim && dr[j] <= y ; j++)
                    ;
            j--;
            for(int k = i ; k <= j ; k++)
                a[k] . SUM += sum;
            if(i - 1)
                UPDATE(i - 1 , x , min(y , dr[i - 1]) , sum);
            if(j + 1 <= dim && (j + 1 != i - 1 || i == 1))
                UPDATE(j + 1 , max(x , st[j + 1]) , y , sum);
        }
        else
        {
            fin >> sum;
            for( i = 1 ; i <= dim ; i++)
                if(a[i] . SUM <= sum && a[i] . freq[sum - a[i] . SUM])
                    break;
            if(i == (dim + 1))
                fout << "-1\n";
            else
            {
                for(j = st[i] ; j <= dr[i] ; j++)
                    if(ST[j] == sum - a[i] . SUM)
                    {
                        fout << N[j] << "\n";
                        break;
                    }
            }
        }
    }
    fin.close();
    fout.close();
    return 0;
}