#include <bits/stdc++.h>

// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#pragma pack(1)
// #define isPbdsFile

#ifdef isPbdsFile

#include <bits/extc++.h>

#else

#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>

#endif

using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}

template <typename T>
T lowBit(T x)
{
    return x & -x;
}

template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}

template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}

template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c) if (b & 1) (ans *= a) %= c;
    return modt(ans, c);
}

template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-') sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}

template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}

template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char)) return;
    if (x < 0) x = -x, putchar('-');
    if (x > 9) write(x / 10);
    putchar(x % 10 ^ 48);
}

template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}


template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;

    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow) return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }

    T3()
    {
        one = tow = three = 0;
    }

    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};

template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y) x = y;
}

template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y) x = y;
}

constexpr int N = 4e5 + 10;
constexpr ll MOD = 1 << 31;
constexpr int MX = 1e9;
constexpr int T = log2(5e4) + 1;
int n, q, cnt;
int root[N], fa[N][T + 1], deep[N];
vector<int> child[N];

struct Node
{
    int left, right;
    ll kSum, valSum;
} node[N * 100];

#define left(x) node[x].left
#define right(x) node[x].right
#define kSum(x) node[x].kSum
#define valSum(x) node[x].valSum

inline void pushUp(const int curr)
{
    kSum(curr) = kSum(left(curr)) + kSum(right(curr));
    valSum(curr) = valSum(left(curr)) + valSum(right(curr));
}

inline void update(const int pre, int& curr, const int color, const int kAdd, const ll val, const int l = 1,
                   const int r = MX)
{
    if (!curr) curr = ++cnt;
    kSum(curr) += kAdd, valSum(curr) += val;
    if (l == r) return;
    const int mid = l + r >> 1;
    if (color <= mid) update(left(pre),left(curr), color, kAdd, val, l, mid);
    else update(right(pre),right(curr), color, kAdd, val, mid + 1, r);
}

inline ll query(const int curr, const int color, const int dep, const int l = 1, const int r = MX)
{
    if (!curr) return 0;
    if (r <= color) return kSum(curr) * (dep - 1) + valSum(curr);
    const int mid = l + r >> 1;
    ll ans = query(left(curr), color, dep, l, mid);
    if (color > mid) ans += query(right(curr), color, dep, mid + 1, r);
    return ans;
}

inline void merge(int& curr, const int rtL, const int rtR, const int l = 1, const int r = MX)
{
    if (!rtL or !rtR)
    {
        curr = rtL | rtR;
        return;
    }
    curr = ++cnt;
    kSum(curr) = kSum(rtL) + kSum(rtR);
    valSum(curr) = valSum(rtL) + valSum(rtR);
    if (l == r) return;
    const int mid = l + r >> 1;
    merge(left(curr), left(rtL), left(rtR), l, mid);
    merge(right(curr), right(rtL), right(rtR), mid + 1, r);
}

struct Query
{
    int color, kAdd;
    ll valAdd;
};

vector<Query> op[N];

inline void initFa(const int curr)
{
    forn(i, 1, T) fa[curr][i] = fa[fa[curr][i - 1]][i - 1];
}

inline void dfs(const int curr, const int pa, const bool init = false)
{
    if (init)
    {
        deep[curr] = deep[fa[curr][0] = pa] + 1;
        initFa(curr);
    }
    for (const auto [color,kAdd,valAdd] : op[curr])
    {
        update(root[curr], root[curr], color, kAdd, valAdd);
    }
    for (const int nxt : child[curr])
    {
        if (nxt == pa) continue;
        dfs(nxt, curr, init);
        if (!init) merge(root[curr], root[curr], root[nxt]);
    }
    op[curr].clear();
}

inline int LCA(int x, int y)
{
    if (deep[x] < deep[y]) swap(x, y);
    forv(i, T, 0) if (deep[fa[x][i]] >= deep[y]) x = fa[x][i];
    if (x == y) return x;
    forv(i, T, 0) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}

typedef tuple<int, int, int, int, ll> qOp;
vector<qOp> build, all;

inline void rebuild()
{
    forn(i, 1, n) root[i] = 0;
    forn(i, 1, cnt)
        left(i) = right(i) = kSum(i) = valSum(i) = 0;
    cnt = 0;
    all.insert(all.end(),all(build));
    build.clear();
    for (const auto [u,v,lca,c,k] : all)
    {
        //树上点差分
        const int Fa = fa[lca][0];
        op[u].emplace_back(c, -k, k * deep[u]);
        op[v].emplace_back(c, -k, k * deep[v]);
        op[lca].emplace_back(c, k, -k * deep[lca]);
        op[Fa].emplace_back(c, k, -k * deep[Fa]);
    }
    dfs(1, 0);
}

inline ll cale(const int curr, const int color, const qOp& qu)
{
    const auto [u,v,lca,c,k] = qu;
    if (color < c) return 0;
    if (LCA(lca, curr) == curr) return (deep[u] + deep[v] - deep[lca] - deep[fa[lca][0]]) * k;
    if (LCA(u, curr) == curr) return (deep[u] - deep[curr] + 1) * k;
    if (LCA(v, curr) == curr) return (deep[v] - deep[curr] + 1) * k;
    return 0;
}

ll last;
int type;

namespace fasI
{
    constexpr int BF_SIZE = 1 << 12;
    bool IOerr = false;

    inline char nc()
    {
        static char buf[BF_SIZE], *p1 = buf + BF_SIZE, *pend = buf + BF_SIZE;
        if (p1 == pend)
        {
            p1 = buf;
            pend = buf + fread(buf, 1, BF_SIZE,stdin);
            if (pend == p1)
            {
                IOerr = true;
                return -1;
            }
        }
        return *p1++;
    }

    inline bool bla(const char ch)
    {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }

    template <typename T>
    void Rd(T& x)
    {
        char ch;
        while (bla(ch = nc()));
        T sign = 1;
        if (ch == '-') sign = -1, ch = nc();
        for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
        x *= sign;
    }

    template <typename T, typename... U>
    void Rd(T& x, U&... y)
    {
        Rd(x);
        Rd(y...);
    }
#undef BF_SIZE
}

using namespace fasI;

inline void solve()
{
    Rd(n, q);
    const int siz = sqrt(10 * n + q);
    forn(i, 1, n-1)
    {
        int u, v;
        Rd(u, v);
        child[u].push_back(v);
        child[v].push_back(u);
    }
    dfs(1, 0, true);
    while (q--)
    {
        Rd(type);
        if (type == 1)
        {
            int pos;
            Rd(pos);
            pos ^= last;
            ++n;
            child[n].push_back(pos), child[pos].push_back(n);
            fa[n][0] = pos, deep[n] = deep[pos] + 1;
            initFa(n);
        }
        else if (type == 2)
        {
            int u, v, c, k;
            Rd(u, v, c, k);
            u ^= last, v ^= last, c ^= last, k ^= last;
            build.emplace_back(u, v, LCA(u, v), c, k);
        }
        else
        {
            int u, c;
            Rd(u, c);
            u ^= last, c ^= last;
            if (build.size() > siz) rebuild();
            last = query(root[u], c, deep[u]);
            for (const auto& t : build) last += cale(u, c, t);
            cout << last << endl;
            last %= MOD;
        }
    }
}

signed int main()
{
    // MyFile
    Spider
    //------------------------------------------------------
    // clock_t start = clock();
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test) solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
    // clock_t end = clock();
    // cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}

// 3 5
// 1 2
// 1 3
// 2 2 3 1 4
// 3 1 1
// 1 13
// 2 13 8 14 13
// 3 13 14