#include<bits/stdc++.h>
#define IL inline
#define reg register
#define N 200200
#define int long long
#define oo (1ll<<60)
IL int read()
{
    reg int x=0,f=0; reg char ch=getchar();
    while(ch<'0'||ch>'9')f|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
    return f?-x:x;
}

const int B=3;
int n,q;
std::vector<int>G[N];

IL void add(reg int u,reg int v){G[u].push_back(v),G[v].push_back(u);}

namespace Segment
{

#define ls (o<<1)
#define rs (o<<1|1)
#define mid (l[o]+r[o]>>1)

int l[N<<2],r[N<<2],sum[N<<2],mx[N<<2],tag[N<<2];

IL int max(reg int x,reg int y){return x>y?x:y;}
IL void pushup(reg int o){sum[o]=sum[ls]+sum[rs],mx[o]=max(mx[ls],mx[rs]);}
IL void apply(reg int o,reg int k){sum[o]+=k*(r[o]-l[o]+1),mx[o]+=k,tag[o]+=k;}
IL void pushdown(reg int o){if(tag[o])apply(ls,tag[o]),apply(rs,tag[o]),tag[o]=0;}

void build(reg int o,reg int L,reg int R)
{
    l[o]=L,r[o]=R;
    if(L<R)build(ls,L,mid),build(rs,mid+1,R);
}

void modify(reg int o,reg int L,reg int R,reg int k)
{
    if(L<=l[o]&&r[o]<=R)return apply(o,k);
    if(L>r[o]||l[o]>R)return;
    pushdown(o),modify(ls,L,R,k),modify(rs,L,R,k),pushup(o);
}

int query_sum(reg int o,reg int L,reg int R)
{
    if(L<=l[o]&&r[o]<=R)return sum[o]; if(L>r[o]||l[o]>R)return 0;
    return pushdown(o),query_sum(ls,L,R)+query_sum(rs,L,R);
}

int query_max(reg int o,reg int L,reg int R)
{
    if(L<=l[o]&&r[o]<=R)return mx[o]; if(L>r[o]||l[o]>R)return -oo;
    return pushdown(o),max(query_max(ls,L,R),query_max(rs,L,R));
}

#undef ls
#undef rs
#undef mid

}

int sz[N],dep[N],fa[N],son[N],anc[N];

void dfs1(reg int u)
{
    dep[u]=dep[fa[u]]+(sz[u]=1);
    for(auto v:G[u])if(!sz[v])
    {
        fa[v]=u,dfs1(v),sz[u]+=sz[v];
        if(sz[son[u]]<sz[v])son[u]=v;
    }
}

void dfs2(reg int u,reg int top)
{
    anc[u]=top; if(son[u])dfs2(son[u],top);
    for(auto v:G[u])if(!anc[v])dfs2(v,v);
}

IL int lca(reg int x,reg int y)
{
    for(;anc[x]!=anc[y];x=fa[anc[x]])
        if(dep[anc[x]]<dep[anc[y]])std::swap(x,y);
    return dep[x]<dep[y]?x:y;
}

template<class T>IL void clear(reg T &a){T b; std::swap(a,b);}

int dfn[N],ed[N],dfc;

void dfs3(reg int u)
{
    std::vector<int>P,Q;
    for(reg int x=u;x;x=son[x])
    {
        P.push_back(x);
        if(!dfn[x])dfn[x]=++dfc;
    }
    for(reg int o=1;o<=B;++o)
    {
        clear(Q);
        for(auto u:P)for(auto v:G[u])if(v!=fa[u])
        {
            if(!dfn[v])dfn[v]=++dfc;
            Q.push_back(v);
        }
        std::swap(P,Q);
    }
    for(reg int v=u;v;v=son[v])for(auto w:G[v])
        if(w!=fa[v]&&w!=son[v])dfs3(w);
}

struct Range{int l,r;};

#define Sets std::vector<Range>

Sets work(reg Sets a)
{
    Sets b;
    std::sort(a.begin(),a.end(),[&](const Range &x,const Range &y){return x.l<y.l;});
    reg int L=0,R=-1;
    for(auto &[l,r]:a)
        if(l==R+1)R=r;
        else ~R?b.push_back({L,R}),0:0,L=l,R=r;
    if(~R)b.push_back({L,R});
    return b;
}

Sets merge(const Sets &a,const Sets &b)
{
    Sets c;
    for(auto p:a)c.push_back(p);
    for(auto p:b)c.push_back(p);
    return c;
}

IL void ins(reg Sets &a,const Sets &b)
{
    a=work(merge(a,b));
}

Sets del(const Sets &a,const Sets &b)
{
    Sets c;
    reg int l=0,r=-1,n=b.size();
    for(auto &[al,ar]:a)
    {
        while(r<n-1&&b[r+1].r<=ar)++r;
        reg int p=al,i;
        for(i=l;i<=r;++i)
        {
            if(p<b[i].l)c.push_back({p,b[i].l-1});
            p=b[i].r+1;
        }
        if(p<=ar)c.push_back({p,ar});
        l=r+1;
    }
	return work(c);
}

Sets sub[N],subk[N][4],upk[N][4],linek[N][4],pointk[N][4];

void dfs4(reg int u)
{
    sub[u].push_back({dfn[u],dfn[u]});
    subk[u][0]=sub[u];
    for(auto v:G[u])if(v!=fa[u])
    {
        dfs4(v),ins(sub[u],sub[v]),upk[v][0].push_back({dfn[u],dfn[u]});
        for(reg int i=1;i<=B;++i)ins(subk[u][i],subk[v][i-1]);
    }
    Sets tmp[4];
    std::vector<int>P;
    for(auto v:G[u])if(v!=fa[u])P.push_back(v);
    for(reg int i=0;i<=B;++i)tmp[i].clear();
    for(auto v:P)for(reg int i=1;i<=B;++i)
        ins(upk[v][i],tmp[i]),ins(tmp[i],subk[v][i-1]);
    std::reverse(P.begin(),P.end());
    for(reg int i=0;i<=B;++i)tmp[i].clear();
    for(auto v:P)for(reg int i=1;i<=B;++i)
        ins(upk[v][i],tmp[i]),ins(tmp[i],subk[v][i-1]);
}

void dfs5(reg int u)
{
    for(reg int i=0;i<=B;++i)linek[u][i]=subk[u][i];
    for(reg int i=0;i<=B;++i)ins(linek[u][i],linek[fa[u]][i]);
    for(reg int i=0,j,v;i<=B;++i)
    {
        pointk[u][i]=subk[u][i];
        for(j=1,v=u;j<=i&&v;++j,v=fa[v])
            ins(pointk[u][i],upk[v][i-j]);
    }
    for(reg int i=1;i<=B;++i)ins(pointk[u][i],pointk[u][i-1]);
    for(auto v:G[u])if(v!=fa[u])dfs5(v);
}

Sets split(reg int x,reg int y,reg int k)
{
    reg int z=lca(x,y);
    return work(merge(pointk[z][k],merge(del(linek[x][k],linek[z][k]),del(linek[y][k],linek[z][k]))));
}

IL void cmax(reg int &x,reg int y){x<y?x=y:0;}

main()
{
    n=read(),q=read();
    for(reg int i=1;i<n;++i)add(read(),read());
    Segment::build(1,1,n);
    dfs1(1),dfs2(1,1),dfs3(1),dfs4(1),dfs5(1);
    for(reg int op,x,y,k,w;q--;)
    {
        op=read(),x=read();
        if(op==1)
        {
            y=read(),k=read(),w=read();
            auto P=split(x,y,k);
            for(auto &[l,r]:P)
                Segment::modify(1,l,r,w);
        }else if(op==2)
        {
            w=read();
            auto P=sub[x];
            for(auto &[l,r]:sub[x])
                Segment::modify(1,l,r,w);
        }else if(op==3)
        {
            y=read(),k=read();
            auto P=split(x,y,k);
            reg int res=0;
            for(auto &[l,r]:P)
                res+=Segment::query_sum(1,l,r);
            printf("%lld\n",res);
        }else if(op==4)
        {
            auto P=sub[x];
            reg int res=0;
            for(auto &[l,r]:P)
                res+=Segment::query_sum(1,l,r);
            printf("%lld\n",res);            
        }else if(op==5)
        {
            y=read(),k=read();
            auto P=split(x,y,k);
            reg int res=-oo;
            for(auto &[l,r]:P)
                cmax(res,Segment::query_max(1,l,r));
            printf("%lld\n",res);
        }else
        {
            auto P=sub[x];
            reg int res=-oo;
            for(auto &[l,r]:P)
                cmax(res,Segment::query_max(1,l,r));
            printf("%lld\n",res);
        }
    }
}