#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, S = N * 64;
vector<int> G[N]; int dft = 0;
int id[N], sz[N], dep[N], fa[N][17];
__int128 sumall[N * 16], sumallnw;
void Dfs(int x) {
    id[x] = ++dft, sz[x] = 1;
    dep[x] = dep[fa[x][0]] + 1;
    for(int i = 0; i < 16; ++i)
        fa[x][i + 1] = fa[fa[x][i]][i];
    for(const int y : G[x]) if(fa[x][0] != y)
        fa[y][0] = x, Dfs(y), sz[x] += sz[y];
};
int Lca(int x, int y) {
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = 16; i >= 0; --i)
        if(dep[fa[x][i]] >= dep[y]) x = fa[x][i];
    if(x == y) return x;
    for(int i = 16; i >= 0; --i)
        if(dep[fa[x][i]] != dep[fa[y][i]])
            x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}
vector<tuple<int, int, long long>> qry;
struct Node { int c; long long s; };
void operator += (Node &a, const Node &b) { a.c += b.c, a.s += b.s; }
Node operator * (const Node &a, int w) { return {a.c * w, a.s * w}; }
struct Tree {
    int n, h; vector<__int128> s2;
    vector<int> v; vector<Node> t;
    void Build() {
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        v.shrink_to_fit();
        n = v.size(), h = __lg(n);
        t.resize(n + 1), s2.resize(n + 1);
    }
    int Id(int V) {
        return lower_bound(v.begin(), v.end(), V) - v.begin() + 1;
    }
    void Add(int p, Node nd, long long o) {
        for(int x = n - p + 1; x <= n; x += x & -x) t[x] += nd;
        for(int x = n - p + 1; x <= n; x += x & -x) s2[x] += o;
    }
    Node Bound0(int val) {
        int pos = 0; Node ret = {0, 0};
        for(int i = 1 << h; i; i >>= 1)
            if(pos + i <= n && v[n - pos - i] >= val)
                ret += t[pos += i];
        return ret;
    }
    __int128 Bound1(int val) {
        int pos = 0; __int128 ret = 0;
        for(int i = 1 << h; i; i >>= 1)
            if(pos + i <= n && v[n - pos - i] >= val)
                ret += s2[pos += i];
        return ret;
    }
} t[N];
int main() {
    cin.tie(0)->sync_with_stdio(0);
    int n, q; cin >> n >> q;
    for(int i = 1; i < n; ++i) {
        int u, v; cin >> u >> v;
        G[u].push_back(v), G[v].push_back(u);
    }
    vector<int> a(n + 1); Dfs(1);
    for(int i = 1; i <= n; ++i) {
        cin >> a[i], qry.emplace_back(0, id[i], a[i]);
        if(id[i] + sz[i] <= n)
            qry.emplace_back(0, id[i] + sz[i], -a[i]);
        sumallnw += 1ll * a[i] * a[i];
    }
    for(int i = 1; i <= q; ++i) {
        int op, u, v; long long m; cin >> op;
        if(op == 1) {
            cin >> u >> m;
            sumallnw -= 1ll * a[u] * a[u];
            sumallnw += 1ll * m * m;
            qry.emplace_back(0, id[u], -a[u]);
            qry.emplace_back(0, id[u], m);
            if(id[u] + sz[u] <= n)
                qry.emplace_back(0, id[u] + sz[u], a[i]),
                qry.emplace_back(0, id[u] + sz[u], -m);
            a[u] = m;
        } else {
            cin >> u >> v >> m;
            sumall[qry.size()] = sumallnw;
            qry.emplace_back(u, v, m);
        }
    }
    cerr << "push qry" << endl;
    for(const auto &[u, v, w] : qry)
        if(!u) for(int x = v; x <= n; )
            t[x].v.push_back(abs(w)), x += x & -x;
    for(int i = 1; i <= n; ++i) t[i].Build();
    cerr << "build" << endl; int nwpos = -1;
    for(const auto &[u, v, w] : qry) {
        ++nwpos;
        if(!u) for(int x = v; x <= n; x += x & -x) {
            const int p = t[x].Id(abs(w));
            const int g = w > 0 ? 1 : -1;
            t[x].Add(p, {g, w}, 1ll * g * w * w);
        } else {
            const int p = Lca(u, v), q = fa[p][0];
            unordered_map<int, int> M;
            for(int x = id[u]; x; x -= x & -x) ++M[x];
            for(int x = id[v]; x; x -= x & -x) ++M[x];
            for(int x = id[p]; x; x -= x & -x) --M[x];
            for(int x = id[q]; x; x -= x & -x) --M[x];
            vector<pair<int, int>> v;
            for(const auto &[x, y] : M)
                if(y) v.emplace_back(x, y);
            int L = 1, R = 1e9, A = -1;
            // cnt a >= m - (sum a - cnt a * v) >= 0
            Node ret = {0, 0};
            for(; L <= R; ret = {0, 0}) {
                const int M = (L + R) >> 1;
                for(const auto &[x, y] : v)
                    ret += t[x].Bound0(M) * y;
                long long W = w - (ret.s - 1ll * ret.c * M);
                if(W < 0) L = M + 1;
                else if(W > ret.c) R = M - 1;
                else { A = M; break; }
            }
            const long long B = 1e16l;
            if(A == -1) {
                __int128 ans = sumall[nwpos];
                for(const auto &[x, y] : v)
                    ans -= t[x].Bound1(0) * y;
                if(ans >= B)
                    printf("%lld%016lld\n",
                        (long long)(ans / B), (long long)(ans % B));
                else printf("%lld\n", (long long)ans);
                continue;
            }
            long long W = w - (ret.s - 1ll * ret.c * A);
            __int128 ans = (__int128)(ret.c - W) * A * A;
            ans += (__int128)W * (A - 1) * (A - 1);
            for(const auto &[x, y] : v)
                ans -= t[x].Bound1(A) * y;
            ans += sumall[nwpos];
            if(ans >= B)
                printf("%lld%016lld\n",
                    (long long)(ans / B), (long long)(ans % B));
            else printf("%lld\n", (long long)ans);
        }
    }
}