#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

namespace MyNamespace {
namespace IO {
    static char buf[1000000], *p1 = buf, *p2 = buf;
    #define getchar() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++)

    inline int rd() {
        char ch = getchar();
        int s = 0, w = 1;
        while (ch < '0' || ch > '9') {
            if (ch == '-') w = -1;
            ch = getchar();
        }
        while (ch >= '0' && ch <= '9') {
            s = (s << 3) + (s << 1) + (ch ^ 48);
            ch = getchar();
        }
        return (s * w);
    }
    // void wr(int x) {
    //     if (x < 0) {
    //         putchar('-');
    //         x = -x;
    //     }
    //     if (x <= 9) {
    //         putchar(x + 48);
    //         return;
    //     }
    //     wr(x / 10);
    //     putchar(x % 10 + 48);
    // }
    inline void wr(int x) {
        static char t[32] = "0123456789012345678901234567890", *sbeg;
        sbeg = t + 31;
        do {
            *--sbeg = x % 10 + 48, x /= 10;
        } while (x);
        fputs(sbeg, stdout);
    }
}
using namespace IO;

const int INF = 2e9;

const int fn = 2e5, fm = 6e5;
const int N = fn + 10, M = fm + 10;

int n, m, X[M], Y[M];
struct oprD {
    int opt, x;
} O[M];

// edges

int num, H[N];
struct edg {
    int t, nxt, k;
} E[N * 2];
inline void add_edg(int x, int y, int k) {
    ++num;
    E[num].t = y;
    E[num].nxt = H[x];
    E[num].k = k;
    H[x] = num;
}

// BIT

int f[M];
inline int lowbit(int x) {
    return (x & (-x));
}
inline void upd(int x, int k) {
    // cout << "F " << x << ' ' << k << endl;
    // ++x;
    // if (x <= 0) return;
    for (int i = x; i <= m; i += lowbit(i)) {
        f[i] += k;
    }
}
inline int qry(int x) {
    int res = 0;
    for (int i = x; i > 0; i -= lowbit(i)) {
        res += f[i];
    }
    return res;
}

// cd dcm

int h[M];
vector<int> Q[N], c[N];

namespace MyCentroidDecomposition {
    int ct, sum_sz, sz[N], ma_sz[N];
    bool vis[N];
    void calc_sz(int x, int fr) {
        sz[x] = 1;
        ma_sz[x] = 0;
        for (int i = H[x]; i > 0; i = E[i].nxt) {
            int v = E[i].t;
            if (v == fr || vis[v]) continue;

            calc_sz(v, x);
            sz[x] += sz[v];
            ma_sz[x] = max(ma_sz[x], sz[v]);
        }
        ma_sz[x] = max(ma_sz[x], sum_sz - sz[x]);
        if (ma_sz[x] < ma_sz[ct]) ct = x;
    }

    int fa[N], ek[N], tp[N];
    vector<pii> d[N];
    inline int calc(int x, int y) {
        return (*lower_bound(c[x].begin(), c[x].end(), y));
    }
    inline int calc_d(int x, int y) {
        int l = 0, r = int(d[x].size()) - 1, mid, res = -1;
        while (l <= r) {
            mid = ((l + r) >> 1);
            if (d[x][mid].second > y) {
                res = mid;
                r = mid - 1;
            }
            else {
                l = mid + 1;
            }
        }
        return res;
    }

	vector<int> g[N];

    void pre_proc(int x, int fr, int gn) {
        for (int i = H[x]; i > 0; i = E[i].nxt) {
            int v = E[i].t, k = E[i].k;
            if (v == fr || vis[v]) continue;

            fa[v] = x;
            ek[v] = k;
            tp[v] = (x == gn ? v : tp[x]);

            pre_proc(v, x, gn);
        }
    }

	void proc_g(int x, int fr, int gn) {
		d[gn].emplace_back(g[x][0], g[x][0]);
		for (int i = H[x]; i > 0; i = E[i].nxt) {
			int v = E[i].t, k = E[i].k;
			if (v == fr || vis[v]) continue;

			int p = 0;
			g[v].clear();
			for (int i = 0; i < int(c[k].size()); ++i) {
				while (p < int(g[x].size()) && c[ek[x]][p] < c[k][i]) ++p;
				g[v].push_back(g[x][p]);
			}

			proc_g(v, x, gn);
		}
	}

    // int cnt;

    // vector<int> P[N];
    struct updD {
        int x, k, t, u;
        // updD (int x = 0, int k = 0, int t = 0, int u = 0) : x(x), k(k), t(t), u(u) {}
    };
    // vector<updD> U[N];

    int numPP, J[M * 5], nxtPP[M * 5];
    int G[M * 5];
    inline void ins_PP(int x, int y) {
        ++numPP;
        G[numPP] = y;
        nxtPP[numPP] = J[x];
        J[x] = numPP;
    }

    int numUU, I[M * 5], nxtUU[M * 5];
    updD F[M * 5];
    inline void ins_UU(int x, updD y) {
        // cout << "N " << x << ' ' << y.x << ' ' << y.k << ' ' << y.t << ' ' << y.u << endl;
        ++numUU;
        F[numUU] = y;
        nxtUU[numUU] = I[x];
        I[x] = numUU;
    }

    int cntP, cntU;
    int P[M * 5];
    updD U[M * 5];

    int cntb, cntV;
    int b[M * 5];
    updD V[M * 5];

    // bool cmp_P(const int &p, const int &q) {
    //     return g[p] < g[q];
    // }
    // bool cmp_U(const updD &p, const updD &q) {
    //     return p.t < q.t;
    // }

    void proc_d(int x, int fr, int gn) {
        I[x] = 0; J[x] = 0;
        b[cntb++] = x;
        for (int i = 0; i < int(d[x].size()) - 1; ++i) {
            int y = d[x][i].second, t = d[x][i].first;
            if (y >= 0 && y <= m - 1) {
                V[cntV++] = (updD){y + 1, 1, t, x};
                V[cntV++] = (updD){y + 1, -1, d[x][i + 1].first, x};
            }
        }
        // cnt += int(d[x].size());

        for (int i = H[x]; i > 0; i = E[i].nxt) {
            int v = E[i].t, k = E[i].k;
            if (v == fr || vis[v]) continue;

            // d[v].clear();
            // for (pii j : d[x]) {
            //     int y = calc(k, j.second);
            //     if (!d[v].empty() && y == d[v].back().second) continue;
            //     d[v].emplace_back(j.first, y);
            // }

            d[v].clear();
            // int lst = 0;
            // auto func = [&](int p, int q) {
            //     int res = calc_d(x, p, lst);
            //     // cout << "J " << x << ' ' << v << ' ' << p << ' ' << q << endl;
            //     if (res == -1) return;
            //     lst = res;
            //     // cout << "I " << x << ' ' << v << ' ' << d[x][res].first << ' ' << d[x][res].second << ' ' << q << endl;
            //     if (d[x][res].second <= q) {
            //         d[v].emplace_back(d[x][res].first, q);
            //     }
            // };
            // cout << "H " << (int)(c[k].size()) << ' ' << c[k][0] << ' ' << c[k].back() << endl;
            int pp = -1, qq = 0;
            while (qq < int(c[k].size())) {
                int res = calc_d(x, pp);
                if (res == -1) break;
                while (qq < int(c[k].size()) && d[x][res].second > c[k][qq]) ++qq;
                if (qq >= int(c[k].size())) break;
                d[v].emplace_back(d[x][res].first, c[k][qq]);
                pp = c[k][qq];
            }
            // func(-1, c[k][0]);
            // for (int j = 0; j < int(c[k].size()) - 1; ++j) {
            //     func(c[k][j], c[k][j + 1]);
            // }

            proc_d(v, x, gn);
        }
    }

    // void ins_pnt(int x, int fr) {
    //     P[cntP++] = x;
    //     for (int i = I[x]; i > 0; i = nxtUU[i]) {
    //         updD v = F[i];
    //         U[cntU++] = v;
    //     }
    //     for (int i = H[x]; i > 0; i = E[i].nxt) {
    //         int v = E[i].t;
    //         if (v == fr || vis[v]) continue;

    //         ins_pnt(v, x);
    //     }
    // }
    void work(int x, int w) {
        // cout << "D " << x << ' ' << w << endl;
        // cntP = 0;
        // cntU = 0;
        // ins_pnt(x, 0);
        // cout << "L " << cntP << ' ' << cntU << endl;
        // sort(P, P + cntP, cmp_P);
        // sort(U, U + cntU, cmp_U);
        
        int p = I[x];
        // cout << "O " << p << ' ' << F[p].t << endl;
        for (int i = J[x]; i > 0; i = nxtPP[i]) {
            int u = G[i];
            while (p > 0 && F[p].t <= g[u][0]) {
                // cout << "B " << F[p].x << ' ' << F[p].k << ' ' << F[p].t << endl;
                upd(F[p].x, F[p].k);
                p = nxtUU[p];
            }
            // cout << "G " << u << ' ' << g[u] << endl;
            for (int j : Q[u]) {
                h[j] += qry(j) * w;
            }
        }
        while (p > 0) {
            // cout << "B " << F[p].x << ' ' << F[p].k << ' ' << F[p].t << endl;
            upd(F[p].x, F[p].k);
            p = nxtUU[p];
        }
    }

    void solve(int x) {
        // cout << "A " << x << endl;
        vis[x] = 1;
        calc_sz(x, 0);

        fa[x] = 0;
        ek[x] = 0;
        tp[x] = x;

        numPP = 0; numUU = 0;
		pre_proc(x, 0, x);

		d[x].clear();
		g[x].clear();
		g[x].push_back(0);
		d[x].emplace_back(g[x][0], g[x][0]);
		for (int i = H[x]; i > 0; i = E[i].nxt) {
			int v = E[i].t, k = E[i].k;
			if (vis[v]) continue;

			g[v].clear();
			for (int j : c[k]) {
				g[v].push_back(j);
			}
			proc_g(v, 0, x);
		}

        d[x].emplace_back(m + 1, m + 1);
        sort(d[x].begin(), d[x].end());
        cntb = 0; cntV = 0;
        proc_d(x, 0, x);
        sort(b, b + cntb, [&](const int &p, const int &q) -> bool {
            return g[p] > g[q];
        });
        sort(V, V + cntV, [&](const updD &p, const updD &q) -> bool {
            return p.t > q.t;
        });
        
        // cout << "E\n";
        // for (int u = 1; u <= 5; ++u) {
        //     cout << "F " << u << ' ' << g[u][0] << ' ' << tp[u] << endl;
        //     for (pii i : d[u]) cout << i.first << ' ' << i.second << endl;
        // }

        // cout << "M " << cntb << ' ' << cntV << endl;
        for (int i = 0; i < cntb; ++i) {
            int p = tp[b[i]];
            ins_PP(x, b[i]);
            if (p != x) ins_PP(p, b[i]);
        }
        for (int i = 0; i < cntV; ++i) {
            int p = tp[V[i].u];
            // cout << "P " << p << endl;
            ins_UU(x, V[i]);
            if (p != x) ins_UU(p, V[i]);
        }
        work(x, 1);
        for (int i = H[x]; i > 0; i = E[i].nxt) {
            int v = E[i].t;
            if (vis[v]) continue;

            work(v, -1);
        }

        // cout << "Q\n";
        // for (int i = 1; i <= m; ++i) {
        //     if (O[i].opt == 1) cout << h[i] << ' ';
        // }
        // cout << endl;

        // cout << "C\n";
        // for (int i = 1; i <= m + 1; ++i) cout << f[i] << ' ';
        // cout << endl;

        for (int i = H[x]; i > 0; i = E[i].nxt) {
            int v = E[i].t;
            if (vis[v]) continue;

            sum_sz = sz[v];
            ct = 0;
            calc_sz(v, 0);
            solve(ct);
        }
    }
    void doit() {
        ma_sz[0] = INF;

        sum_sz = n;
        ct = 0;
        calc_sz(1, 0);
        solve(ct);
    }
}

void proc_input() {
    n = rd(), m = rd();
    for (int i = 1; i < n; ++i) {
        X[i] = rd(), Y[i] = rd();
        add_edg(X[i], Y[i], i);
        add_edg(Y[i], X[i], i);
    }
    for (int i = 1; i <= m; ++i) {
        O[i].opt = rd(), O[i].x = rd();
        int opt = O[i].opt, x = O[i].x;
        if (opt == 1) Q[x].emplace_back(i);
        else c[x].emplace_back(i);
    }
    for (int i = 1; i < n; ++i) c[i].emplace_back(m + 1);
}
void proc_output() {
    for (int i = 1; i <= m; ++i) {
        if (O[i].opt == 1) wr(h[i]), putchar('\n');
    }
}

void MyNamespaceMain() {
    proc_input();
    MyCentroidDecomposition::doit();
    proc_output();
    // cout << "\nK " << MyCentroidDecomposition::cnt << endl;
}
}
int main() {
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    MyNamespace::MyNamespaceMain();
    return 0;
}