#include <bits/stdc++.h>
#define N 100005
#define ls(u) tr[u].ls
#define rs(u) tr[u].rs
using namespace std;
typedef long long ll;

int T, n, m, tmp1;
vector <int> to[N];
int sz[N], son[N], top[N], tI[N], tmr, dep[N], p[N];
struct Seg { int ls, rs, sum, tg, lv, rv; } tr[N*2];
int rt, tot;

void dfs_son (int u, int fa)
{
    sz[u]=1; son[u]=0;
    for (int i=0; i<(int)to[u].size(); i++) {
        int v=to[u][i];
        if (v==fa) { continue; }
        dfs_son(v, u); sz[u]+=sz[v];
        if (sz[son[u]]<sz[v]) { son[u]=v; }
    }
}
void dfs_top (int u, int fa)
{
    if (son[fa]==u) { top[u]=top[fa]; }
    else { top[u]=u; }

    tI[u]=++tmr; dep[u]=dep[fa]+1; p[u]=fa;

    if (son[u]) { dfs_top(son[u], u); }
    for (int i=0; i<(int)to[u].size(); i++) {
        int v=to[u][i];
        if (v==fa || v==son[u]) { continue; }
        dfs_top(v, u);
    }
}

inline void merge (int u)
{
    tr[u].sum=tr[ls(u)].sum+tr[rs(u)].sum + (tr[ls(u)].rv==tr[rs(u)].lv && tr[rs(u)].lv);
    tr[u].rv=tr[rs(u)].rv;
    tr[u].lv=tr[ls(u)].lv;
}
inline void pushdown (int u, int l, int r)
{
    if (!tr[u].tg) { return; }
    if (l==r) { return; }
    int val=tr[u].tg;
    int md=(l+r)>>1;
    tr[ls(u)].sum=md-l; tr[ls(u)].tg=val; tr[ls(u)].lv=val; tr[ls(u)].rv=val;
    tr[rs(u)].sum=r-md-1; tr[rs(u)].tg=val; tr[rs(u)].lv=val; tr[rs(u)].rv=val;
    tr[u].tg=0;
}
void buildST (int &u, int l, int r)
{
    if (!u) { u=++tot; }
    tr[u].tg=0; tr[u].sum=0; tr[u].lv=0; tr[u].rv=0;
    if (l==r) { return; }
    int md=(l+r)>>1;
    buildST(ls(u), l, md);
    buildST(rs(u), md+1, r);
}
void upd (int u, int l, int r, int ql, int qr, int val)
{
    if (ql>r || qr<l) { return; }
    if (ql<=l && r<=qr) { tr[u].sum=r-l; tr[u].tg=val; tr[u].lv=val; tr[u].rv=val; return; }
    pushdown(u, l, r);
    int md=(l+r)>>1;
    upd(ls(u), l, md, ql, qr, val);
    upd(rs(u), md+1, r, ql, qr, val);
    merge(u);
}
int qry_sum (int u, int l, int r, int ql, int qr)
{
    if (ql>r || qr<l) { return 0; }
    if (ql<=l && r<=qr) { tmp1=tr[u].lv; return tr[u].sum; }
    pushdown(u, l, r);
    int md=(l+r)>>1;
    int resr=qry_sum(rs(u), md+1, r, ql, qr);
    int resl=qry_sum(ls(u), l, md, ql, qr);
    return resl+resr+(ql<=md && qr>md && tr[ls(u)].rv==tr[rs(u)].lv && tr[rs(u)].lv);
}
int qry_val (int u, int l, int r, int id)
{
    if (l==r) { return tr[u].tg; }
    pushdown(u, l, r);
    int md=(l+r)>>1;
    if (id<=md) { return qry_val(ls(u), l, md, id); }
    else { return qry_val(rs(u), md+1, r, id); }
}

void uupd (int u, int v, int cur)
{
    while (top[u]!=top[v]) {
        if (dep[top[u]]<dep[top[v]]) { swap(u, v); }
        upd(rt, 1, n, tI[top[u]], tI[u], cur);
        u=p[top[u]];
    }
    if (dep[u]>dep[v]) { swap(u, v); }
    upd(rt, 1, n, tI[u], tI[v], cur);
}
int qqry (int u, int v)
{
    int res=0;
    while (top[u]!=top[v]) {
        if (dep[top[u]]<dep[top[v]]) { swap(u, v); }
        res+=qry_sum(rt, 1, n, tI[top[u]], tI[u]);
        int tmp2=qry_val(rt, 1, n, tI[p[top[u]]]);
        res+=(tmp1==tmp2 && tmp1);
        u=p[top[u]];
    }
    if (dep[u]>dep[v]) { swap(u, v); }
    res+=qry_sum(rt, 1, n, tI[u], tI[v]);

    return res;
}

void clr ()
{
    for (int i=1; i<=tot; i++) { tr[i].ls=0; tr[i].rs=0; }
    rt=0; tot=0; tmr=0;
    for (int i=1; i<=n; i++) { to[i].clear(); }
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &n, &m);
        clr();
        for (int i=1; i<n; i++) {
            int u, v; scanf("%d %d", &u, &v);
            to[u].push_back(v); to[v].push_back(u);
        }
        dfs_son(1, 0);
        dfs_top(1, 0);
        buildST(rt, 1, n);

        for (int t=1; t<=m; t++) {
            int op, u, v; scanf("%d %d %d", &op, &u, &v);
            if (op==1) {
                uupd(u, v, t);
            }
            else {
                int ans=qqry(u, v);
                printf("%d\n", ans);
            }
        }
    }

    return 0;
}