#include <bits/stdc++.h>
const int MV = 100002 ;
const int MVSQ = 320 ;
const int MN = 1000002 ;

///FILE *in = fopen("arbore.in", "r"), *out = fopen("arbore.out", "w") ;
std::ifstream in ("arbore.in") ;
std::ofstream out ("arbore.out") ;

int n, m, limit ;
int pos[MV], e, len[MV], real_val[MV] ;
std::vector <int> V[MV] ;
std::bitset <MN> isv[MVSQ] ;
int a[MV], b[MVSQ] ;

void dfs (int x) {
        int i, nod, l = V[x].size() ;
        len[x] = 1 ;
        pos[x] = ++ e ;
        real_val[e] = x ;
        for (i = 0 ; i < l ; ++ i) {
                if (!pos[nod = V[x][i]]) {
                        dfs (nod) ;
                        len[x] += len[nod] ;
                }
        }
}

void solve() {
        dfs (1) ; /// :)
}

void update (int x, int y, int val) {
        int i, st_int = (x - 1) / limit + 1 ;
        if (x != (st_int - 1) * limit + 1) { /// iese din interval pe stanga
                for (i = x ; i <= st_int * limit && i <= y ; ++ i) {
                        isv[st_int][a[i]] = 0 ;
                        a[i] += val ;
                }
                ++ st_int ;
        } else i = x ;
        for ( ; i + limit - 1 <= y && st_int <= limit ; i += limit) { /// desetam tot
                //isv[st_int][0] = 0 ;
                b[st_int] += val ;
                ++ st_int ;
        }
        if (st_int <= limit) { /// iese din interval pe dreapta
                for ( ; i <= y ; ++ i) {
                        isv[st_int][a[i]] = 0 ;
                        a[i] += val ;
                }
        }
        st_int = (x - 1) / limit + 1 ;
        for (i = (st_int - 1) * limit + 1 ; i <= st_int * limit ; ++ i) {
                isv[st_int][a[i]] = 1 ; /// setam tot
        }
        ++ st_int ;
        for ( ; i + limit - 1 <= y && st_int <= limit ; i += limit) {
                //isv[st_int][0] = 1 ;/// desetam
                ++ st_int ;
        }
        if (st_int <= limit) {
                for ( ; i <= st_int * limit ; ++ i) {
                        isv[st_int][a[i]] = 1 ;
                }
        }
}

int query (int s) {
        int i, j ;
        for (i = 1 ; i <= limit ; ++ i) {
                if (s >= b[i] && isv[i][s - b[i]]) {
                        for (j = (i - 1) * limit + 1 ; j <= n && j <= i * limit ; ++ j)
                                if (a[j] + b[i] == s) {
                                        return real_val[j] ;
                                }
                }
        }
        return -1 ;
}

void answer_querys() {
        limit = 1 + (int) sqrt (n - 1) ;
        while (m --) {
                int t, x, s ;
                ///fscanf (in, "%d", &t) ;
                in >> t ;
                if (t == 1) {
                        ///fscanf (in, "%d %d", &x, &s) ;
                        in >> x >> s ;
                        update (pos[x], pos[x] + len[x] - 1, s) ;
                } else {
                        ///fscanf (in, "%d", &s) ;
                        in >> s ;
                        ///fprintf (out, "%d\n", query(s)) ;
                        out << query(s) << '\n' ;
                }
        }
}

int main() {
        int i ;
        ///fscanf (in, "%d %d", &n, &m) ;
        in >> n >> m ;
        for (i = 1  ; i < n  ; ++ i) {
                int x, y ;
                ///fscanf (in, "%d %d", &x, &y) ;
                in >> x >> y ;
                V[y].push_back (x) ;
                V[x].push_back (y) ;
        }
        solve() ;
        answer_querys() ;
}