#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

template <typename T>
struct Fenwick {
    int n;
    vector<T> a;
    Fenwick(int n = 0) : n(n), a(n) {}
    void add(int p, T v) {
        while (p < n) {
            a[p] += v;
            p |= p + 1;
        }
    }
    T sum(int p) {
        T res = {};
        while (p >= 0) {
            res += a[p];
            p = (p & p + 1) - 1;
        }
        return res;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    auto solve = [&]() {
        int n, q;
        cin >> n >> q;

        vector<vector<int>> adj(n);
        for (int i = 1; i < n; i++) {
            int p;
            cin >> p;
            adj[--p].push_back(i);
        }

        constexpr int K = 20;

        vector<int> dep(n), par(n, -1), tin(n), tout(n), sz(n, 1);
        vector childCnt(n, vector<int>(K));
        int T = 0;

        auto dfs = [&](auto dfs, int u) -> void {
            tin[u] = T++;
            childCnt[u][0]++;
            for (auto v : adj[u]) {
                dep[v] = dep[u] + 1;
                par[v] = u;
                dfs(dfs, v);
                sz[u] += sz[v];
                for (int i = 1; i < K; i++) {
                    childCnt[u][i] += childCnt[v][i - 1];
                }
            }
            tout[u] = T;
        };
        dfs(dfs, 0);

        Fenwick<i64> f(n), g(n);
        vector childAdd(n, vector<i64>(K));

        while (q--) {
            int op;
            cin >> op;

            if (op == 1) {
                int x, y, k;
                cin >> x >> y >> k;
                x--;

                if (k == 1) {
                    f.add(tin[x], y);
                    f.add(tin[x], -y);
                    g.add(tin[x], 1LL * sz[x] * y);
                } else {
                    i64 s = 0;
                    for (int i = 0; i < K; i++) {
                        childAdd[x][i] += y;
                        s += 1LL * childCnt[x][i] * y;
                        y /= k;
                    }
                    g.add(tin[x], s);
                }
            } else {
                int x;
                cin >> x;
                x--;
                i64 ans = f.sum(tin[x]) * sz[x] + g.sum(tout[x] - 1) - g.sum(tin[x]);

                int u = x;
                for (int i = 0; i < K && u != -1; i++) {
                    for (int j = 0; i + j < K; j++) {
                        ans += childAdd[u][i + j] * childCnt[x][j];
                    }
                    u = par[u];
                }

                cout << ans << '\n';
            }
        }
    };
    
    solve();
    
    return 0;
}