#include <bits/stdc++.h>

using i64 = long long;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;
    
    std::vector<int> p(n);
    p[0] = -1;
    for (int i = 1; i < n; i++) {
        std::cin >> p[i];
        p[i]--;
    }
    
    const int B = std::sqrt(n);
    
    const int nb = (n + B - 1) / B;
    
    std::vector<int> tag(nb);
    std::vector<int> fin(nb);
    
    std::vector<int> top(n), dep(n);
    auto build = [&](int b) {
        if (fin[b]) {
            return;
        }
        int l = b * B, r = std::min(n, l + B);
        fin[b] = 1;
        for (int i = std::max(1, l); i < r; i++) {
            int P = std::max(p[i] - tag[b], 0);
            if (P < l) {
                top[i] = i, dep[i] = 0;
            } else {
                top[i] = top[P], dep[i] = dep[P] + 1;
                fin[b] = 0;
            }
        }
    };
    
    for (int i = 0; i < nb; i++) {
        build(i);
    }
    
    std::vector<int> f(n), tmp(n);
    std::vector<std::vector<int>> bl(nb);
    
    while (m--) {
        int o;
        std::cin >> o;
        
        if (o == 1) {
            int l, r, d;
            std::cin >> l >> r >> d;
            l--, r--;
            int lb = l / B, rb = r / B;
            if (lb == rb) {
                for (int i = l; i <= r; i++) {
                    p[i] -= 1;
                }
                build(lb);
            } else {
                for (int i = l; i < (lb + 1) * B; i++) {
                    p[i] -= 1;
                }
                build(lb);
                for (int i = lb + 1; i < rb; i++) {
                    tag[i] += 1;
                    build(i);
                }
                for (int i = rb * B; i <= r; i++) {
                    p[i] -= 1;
                }
                build(rb);
            }
        } else {
            int k;
            std::cin >> k;
            
            int mn = n;
            std::vector<int> a(k);
            for (int i = 0; i < k; i++) {
                std::cin >> a[i];
                a[i]--;
                mn = std::min(mn, a[i]);
                if (!f[a[i]]) {
                    f[a[i]] = 1;
                    bl[a[i] / B].push_back(a[i]);
                }
            }
            int ans = 1;
            for (int b = nb - 1; b >= 0; b--) {
                if (bl[b].empty()) {
                    continue;
                }
                int dup = 0;
                for (auto x : bl[b]) {
                    dup |= tmp[top[x]];
                    tmp[top[x]] = 1;
                }
                for (auto x : bl[b]) {
                    tmp[top[x]] = 0;
                }
                if (dup) {
                    for (int x = std::min(n, (b + 1) * B) - 1; x >= b * B; x--) {
                        if (f[x]) {
                            f[x] = 0;
                            if (x == mn) {
                                break;
                            }
                            int y = std::max(0, p[x] - tag[b]);
                            ans += 1;
                            mn = std::min(mn, y);
                            if (!f[y]) {
                                f[y] = 1;
                                bl[y / B].push_back(y);
                            }
                        }
                    }
                } else {
                    if (bl[b].size() == 1 && mn == bl[b][0]) {
                        bl[b].clear();
                        f[mn] = 0;
                        break;
                    }
                    for (auto x : bl[b]) {
                        ans += dep[x] + 1;
                        f[x] = 0;
                        int y = std::max(p[top[x]] - tag[b], 0);
                        mn = std::min(mn, y);
                        if (!f[y]) {
                            f[y] = 1;
                            bl[y / B].push_back(y);
                        }
                    }
                    bl[b].clear();
                }
            }
            
            std::cout << ans << "\n";
        }
    }
    
    return 0;
}