#include <fstream>
	
#include <vector>
	
#include <bitset>
	
#include <cmath>
	
 
	
using namespace std;
	
 
	
ifstream fin("arbore.in");
	
ofstream fout("arbore.out");
	
 
	
const int NMax = 1e5, XMax = 1e6, BMax = 400;
	
 
	
int N, K, M, V[NMax + 5], A[NMax + 5], S[NMax + 5], D[NMax + 5], id, Find[NMax + 5];
	
vector <int> G[NMax + 5];
	
 
	
/**
	
V contine liniarizarea arborelui
	
S[i] pozitia nodului i in liniarizare
	
D[i] pozitia maxima a unui nod ce apartine subarborelui cu radacina in i din liniarizare
	
F[i] indicele bucket-ului in care se afla nodul i
	
**/
	
 
	
struct
	
{
	
    int st, dr, l;
	
    bitset <XMax + 5> X;
	
}
	
B[BMax + 5];///bucket-urile pt Batog
	
 
	
void DFS(int Nod, int Tata)
	
{
	
    S[Nod] = ++K, V[K] = Nod;
	
 
	
    for(auto Vecin : G[Nod])
	
    {
	
        if(Vecin == Tata) continue;
	
        DFS(Vecin, Nod);
	
    }
	
    D[Nod] = K;
	
}
	
 
	
inline bool In(int x, int y)///daca x este in subarborele cu radacina y
	
{
	
    return (S[y] <= S[x] && D[x] <= D[y]);
	
}
	
 
	
void Update(int Nod, int val, int i)
	
{
	
    bool x = In(V[B[i].st], Nod), y = In(V[B[i].dr], Nod);
	
 
	
    if(x && y) {B[i].l += val; return;}
	
 
	
    for(int j = B[i].st; j <= B[i].dr; j++)
	
    {
	
        B[i].X[A[j]] = 0;
	
 
	
        if(In(V[j], Nod))
	
            A[j] += val;
	
    }
	
 
	
    for(int j = B[i].st; j <= B[i].dr; j++)
	
        B[i].X[A[j]] = 1;
	
}
	
 
	
int Q(int s)
	
{
	
    for(int i = 1, val; i <= K; i++)
	
    {
	
        val = s - B[i].l;
	
        if(val < 0) continue;

        if(B[i].X[val] == 0) continue;
	
 
	
        for(int j = B[i].st; j <= B[i].dr; j++)
	
            if(A[j] == val)
	
                return j;
	
    }
	
    return -1;
	
}
	
 
	
int main()
	
{
	
    fin >> N >> M;
	
 
	
    for(int i = 1, a, b; i < N; i++)
	
    {
	
        fin >> a >> b;
	
 
	
        G[a].push_back(b);
	
        G[b].push_back(a);
	
    }
	
    DFS(1, 0);
	
 
	
    int lung = (int)sqrt(N) + 1; K = 0;
	
 
	
    for(int i = 1; i <= N; i += lung)
	
    {
	
        B[++K].st = i, B[K].dr = min(i + lung - 1, N), B[K].X[0] = 1;
	
 
	
        for(int j = B[K].st; j <= B[K].dr; j++)
	
            Find[V[j]] = K;
	
    }
	
 
	
    for(int i = 1, t, p, s; i <= M; i++)
	
    {
	
        fin >> t;
	
 
	
        if(t == 1)
	
        {
	
            fin >> p >> s;
	
 
	
            int st = Find[p], dr = Find[V[D[p]]];///indicii bucket-urilor exteme
	
 
	
            for(int k = st; k <= dr; k++)
	
                Update(p, s, k);
	
        }
	
        else
	
        {
	
            fin >> s;
	
            fout << Q(s) << '\n';
	
        }
	
    }
	
    fin.close();
	
    fout.close();
	
 
	
    return 0;
	
}