#include<bits/stdc++.h>
#define all(x) begin(x), end(x)
using namespace std;
using ll = long long;
const int B = 512;

struct DSU {
    vector<int> e;
    DSU(int n) : e(n, -1) {}
    int find(int v) { return e[v] < 0 ? v : e[v] = find(e[v]); }
    void join(int u, int v) {
        u = find(u), v = find(v);
        if(u == v) return;
        if(u < v) swap(u, v);
        e[u] += e[v];
        e[v] = u;
    }
};

struct Tree {
    int n;
    vector<int> a, ba, up, up_len;
    DSU jump;
    Tree(int n) : n(n), a(n), ba(n / B + 1), up(n), up_len(n), jump(n + 1) {}

    inline int get_par(int x) {
        return max(0, a[x] + ba[x / B]);
    }

    inline array<int, 2> get_up(int p) {
        int par = get_par(p);
        if(p / B != par / B)
            return {par, 1};
        return {up[p], up_len[p]};
    }

    void read() {
        up[0] = 0;
        up_len[0] = 0;
        for(int i = 1; i < n; i++) {
            cin >> a[i], a[i]--;
            if((a[i] / B) != (i / B))
                up[i] = a[i], up_len[i] = 1;
            else {
                auto [x, y] = get_up(a[i]);
                up[i] = x;
                up_len[i] = 1 + y;
            }
        }
    }

    inline void sub(int l, int r, int x) {
        int p = l;
        while(l <= r && (l & (B - 1)))
            a[l++] -= x;
        for(; l + B - 1 <= r; l += B)
            ba[l / B] -= x;
        while(l <= r)
            a[l++] -= x;

        for(p = jump.find(p); p <= r; p = jump.find(p + 1)) {
            int par = get_par(p);
            if((p / B) != (par / B)) {
                jump.join(p, p + 1);
            } else {
                auto [x, y] = get_up(par);
                up[p] = x;
                up_len[p] = 1 + y;
            }
        }
    }
};

int main() {
    cin.tie(0)->sync_with_stdio(0);
    int n, m;
    cin >> n >> m;
    Tree T(n);
    T.read();

    vector<vector<int>> ch(n);
    vector<int> to_clear, vis(n);
    int sum, lca = n;
    auto clear = [&]() {
        sum = 1;//to account for root
        for(auto i : to_clear) {
            vis[i] = 0;
            ch[i].clear();
        }
        to_clear = { 0 };
    };
    auto crawl = [&](int v, int slow) {
        int add = 0, chi = -1;
        // cout << v << " -->\n";
        while(!vis[v]++ && v) {
            if(!slow && chi != -1) {
                ch[v].push_back(chi);
            }
            chi = v;

            vis[v] = 1;
            to_clear.push_back(v);
            if(slow) {
                v = T.get_par(v);
                add++;
            } else {
                auto [x, y] = T.get_up(v);
                v = x;
                add += y;
            }
        }
        // cout << v << " " << add << " yay" << endl;
        if(!slow && chi != -1) {
            ch[v].push_back(chi);
        }
        return add;
    };
    auto correct = [&](int v) {
        int add = 1;
        while(v) {
            auto [x, y] = T.get_up(v);
            if(vis[v] >= 2)
                add = 0;
            else
                add += y;
            v = x;
        }
        if(vis[v] >= 2) add = 0;
        // cout << add << endl;
        return add;
    };

    for(int t, qi = 0; qi < m; qi++) {
        cin >> t;
        if(t == 1) {
            int l, r, x;
            cin >> l >> r >> x;
            // cout << 1 << " " << l << " " << r << " " << x << endl;
            --l, --r;
            T.sub(l, r, x);
        } else {
            int k;
            cin >> k;
            vector<int> V(k);
            for(auto &i : V) cin >> i, i--;

            clear();
            for(auto i : V)
                sum += crawl(i, 0);

            // cout << sum << " -\n";
            for(int rel = to_clear.size(), i = 0; i < rel; i++) {
                int UP = to_clear[i];
                // if(ch[UP].size() > 1)
                // cout << UP << " " << ch[UP].size() << endl;
                for(auto p : ch[UP]) {
                    sum -= T.get_up(p)[1] - 1;
                    int U = crawl(T.get_par(p), 1);
                    // cout << UP << " -> " << p << " " << T.get_par(p) << " " << (T.get_up(p)[1] - 1) << " | " << U << endl;
                    sum += U;
                }
                vis[UP] -= ch[UP].size();
            }
            // cout << sum << " - ";
            
            int lca = 0;
            for(auto i : to_clear) if(vis[i] == 1)
                lca = max(lca, i);
            sum -= correct(V[0]);
            cout << sum << '\n';
        }
    }
}