#include<iostream>
#include<vector>
#include<algorithm>
#define ep emplace
#define eb emplace_back
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef pair<int,int>pi;
typedef pair<ll,ll>pl;
const int inf=1e9+7;
const ll INF=1e18;
const int mx=200010;
struct seg
{
    ll sm[mx*4];
    ll lza[mx*4],lzb[mx*4];
    void init(int n,int s,int e)
    {
        sm[n]=lza[n]=lzb[n]=0;
        if(s==e)
            return;
        int m=s+(e-s)/2;
        init(n*2,s,m);
        init(n*2+1,m+1,e);
        return;
    }
    inline void put(int n,int s,int e,ll a,ll b)
    {
        sm[n]+=(s+e)*a*(e-s+1)/2;
        sm[n]+=(e-s+1)*b;
        lza[n]+=a;
        lzb[n]+=b;
        return;
    }
    inline void prop(int n,int s,int e,int m)
    {
        if(lza[n]==0&&lzb[n]==0)
            return;
        put(n*2,s,m,lza[n],lzb[n]);
        put(n*2+1,m+1,e,lza[n],lzb[n]);
        lza[n]=lzb[n]=0;
        return;
    }
    void upd(int n,int s,int e,int S,int E,ll a,ll b)
    {
        if(s>E||S>e)
            return;
        if(S<=s&&e<=E)
            return put(n,s,e,a,b);
        int m=s+(e-s)/2;
        prop(n,s,e,m);
        upd(n*2,s,m,S,E,a,b);
        upd(n*2+1,m+1,e,S,E,a,b);
        sm[n]=sm[n*2]+sm[n*2+1];
        return;
    }
    ll query(int n,int s,int e,int S,int E)
    {
        if(s>E||S>e)
            return 0;
        if(S<=s&&e<=E)
            return sm[n];
        int m=s+(e-s)/2;
        prop(n,s,e,m);
        return query(n*2,s,m,S,E)+query(n*2+1,m+1,e,S,E);
    }
}st1;
struct seg2
{
    ll sz[mx*4],sm[mx*4];
    ll lz[mx*4];
    void init(int n,int s,int e,int*isz)
    {
        sm[n]=lz[n]=0;
        if(s==e)
        {
            sz[n]=isz[s];
            return;
        }
        int m=s+(e-s)/2;
        init(n*2,s,m,isz);
        init(n*2+1,m+1,e,isz);
        sz[n]=sz[n*2]+sz[n*2+1];
        return;
    }
    inline void put(int n,ll p)
    {
        sm[n]+=p*sz[n];
        lz[n]+=p;
        return;
    }
    inline void prop(int n)
    {
        if(lz[n]==0)
            return;
        put(n*2,lz[n]);
        put(n*2+1,lz[n]);
        lz[n]=0;
        return;
    }
    void upd(int n,int s,int e,int S,int E,ll p)
    {
        if(s>E||S>e)
            return;
        if(S<=s&&e<=E)
            return put(n,p);
        int m=s+(e-s)/2;
        prop(n);
        upd(n*2,s,m,S,E,p);
        upd(n*2+1,m+1,e,S,E,p);
        sm[n]=sm[n*2]+sm[n*2+1];
        return;
    }
    ll query(int n,int s,int e,int S,int E)
    {
        if(s>E||S>e)
            return 0;
        if(S<=s&&e<=E)
            return sm[n];
        int m=s+(e-s)/2;
        prop(n);
        return query(n*2,s,m,S,E)+query(n*2+1,m+1,e,S,E);
    }
}st2;
int spa[mx][20];
inline int kpa(int x,int k)
{
    while(k>0)
        x=spa[x][__builtin_ctz(k)],k&=k-1;
    return x;
}
int dep[mx];
inline int lca(int x,int y)
{
    if(dep[x]<dep[y])
        y=kpa(y,dep[y]-dep[x]);
    else
        x=kpa(x,dep[x]-dep[y]);
    if(x==y)
        return x;
    for(int i=20;i-->0;)
        if(spa[x][i]!=spa[y][i])
            x=spa[x][i],y=spa[y][i];
    return spa[x][0];
}
vector<int>adj[mx];
int sz[mx];
int pa[mx];
void dfs(int x)
{
    spa[x][0]=pa[x];
    for(int i=0;i<19;i++)
        spa[x][i+1]=spa[spa[x][i]][i];
    sz[x]=1;
    for(int&t:adj[x])
        dep[t]=dep[pa[t]=x]+1,adj[t].erase(find(all(adj[t]),x)),dfs(t),sz[x]+=sz[t];
    sort(all(adj[x]),[&](const int&x,const int&y){return sz[x]>sz[y];});
    return;
}
int hc[mx];
int in[mx],out[mx],rev[mx];
int dct;
void hld(int x)
{
    in[x]=++dct;
    rev[in[x]]=x;
    if(hc[x]==0)
        hc[x]=x;
    if(!adj[x].empty())
        hc[adj[x][0]]=hc[x];
    for(int&t:adj[x])
        hld(t);
    out[x]=dct;
    return;
}
int n;
ll dissum;
ll dps[mx];
inline ll depsum(int l,int r)
{
    return dps[r]-dps[l-1];
}
ll asum;
inline void rootupd(int v,ll cnt)
{
    asum+=cnt;
    while(v!=0)
    {
        st1.upd(1,1,n,in[hc[v]],in[v],0,cnt);
        v=pa[hc[v]];
    }
    return;
}
inline void __subtreeupd(int v,int p)
{
    dissum+=p*depsum(in[v],out[v]);
    st2.upd(1,1,n,in[v],out[v],p);
    rootupd(pa[v],p*(out[v]-in[v]+1));
    return;
}
inline void subtreeupd(int u,int v)
{
    if(u==v)
    {
        __subtreeupd(1,1);
        return;
    }
    int l=lca(u,v);
    if(l==v)
        __subtreeupd(1,1),__subtreeupd(kpa(u,dep[u]-dep[v]-1),-1);
    else
        __subtreeupd(v,1);
    return;
}
inline void pathupd(int u,int v)
{
    ll lfc=0,rgc=0;
    while(hc[u]!=hc[v])
    {
        if(in[hc[u]]>in[hc[v]])
            swap(u,v),swap(lfc,rgc);
        dissum+=depsum(in[hc[v]],in[v]);
        st1.upd(1,1,n,in[hc[v]],in[v],-1,rgc+in[v]+1);
        rgc+=in[v]-in[hc[v]]+1;
        v=pa[hc[v]];
    }
    if(in[u]<in[v])
        swap(u,v),swap(lfc,rgc);
    dissum+=depsum(in[v],in[u]);
    st1.upd(1,1,n,in[v],in[u],-1,lfc+in[u]+1);
    st1.upd(1,1,n,in[v],in[v],0,rgc);
    rootupd(pa[v],lfc+rgc+in[u]-in[v]+1);
    return;
}
inline ll getsum(int v)
{
    ll ans=dissum+asum;
    while(v!=0)
    {
        ans-=(st1.query(1,1,n,in[hc[v]],in[v])+st2.query(1,1,n,in[hc[v]],in[v]))*2;
        ans+=asum*(in[v]-in[hc[v]]+1);
        v=pa[hc[v]];
    }
    return ans;
}
int sz2[mx];
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin>>n;
    for(int i=1;i<n;i++)
    {
        int u,v;
        cin>>u>>v;
        adj[u].eb(v);
        adj[v].eb(u);
    }
    dfs(1);
    hld(1);
    for(int i=0;i++<n;)
        dps[i]=dps[i-1]+dep[rev[i]];
    st1.init(1,1,n);
    for(int i=0;i++<n;)
        sz2[in[i]]=sz[i];
    st2.init(1,1,n,sz2);
    int q;
    cin>>q;
    for(int qi=0;qi<q;qi++)
    {
        int t;
        cin>>t;
        if(t==1)
        {
            int u,v;
            cin>>u>>v;
            subtreeupd(u,v);
        }
        else if(t==2)
        {
            int u,v;
            cin>>u>>v;
            pathupd(u,v);
        }
        else
        {
            int v;
            cin>>v;
            cout<<getsum(v)<<'\n';
        }
    }
    return 0;
}