/**
 * @author n685
 * @brief
 * @date 2024-10-19 17:11:02
 *
 *
 */
#include <algorithm>

#include "bits/stdc++.h"

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif

namespace rs = std::ranges;
namespace rv = std::views;

constexpr int BL = 450;

int start(int val) { return val / BL * BL; }
int end(int val) { return (val / BL + 1) * BL - 1; }

struct Arr {
  std::vector<int> arr, la;
  Arr() = default;
  explicit Arr(int n) : arr(n), la(n / BL) {}
  void add(int i, int v) { arr[i] += v; }
  void set(int i, int v) { arr[i] = v - la[i / BL]; }
  void add_i(int i, int v) { la[i] += v; }
  int get(int i) const { return std::max(0, arr[i] + la[i / BL]); }
  int operator[](int i) const { return get(i); }
};
struct RBArr {
  std::vector<int> arr, la;
  RBArr() = default;
  explicit RBArr(int n) : arr(n) {}
  void add(int i, int v) {
    if (arr[i] == 0) {
      la.push_back(i);
    }
    arr[i] += v;
  }
  void set(int i, int v) {
    if (arr[i] == 0) {
      la.push_back(i);
    }
    arr[i] = v;
  }
  const int& operator[](int i) const { return arr[i]; }
  void reset() {
    for (int i : la) {
      arr[i] = 0;
    }
    la.clear();
  }
};

int main() {
#ifndef LOCAL
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
#endif

  int nn, m;
  std::cin >> nn >> m;
  int n = (nn + BL - 1) / BL * BL;
  Arr fa(n), nxt(n);
  for (int i = 1; i < nn; ++i) {
    int v;
    std::cin >> v;
    --v;
    fa.set(i, v);
  }
  std::vector<int> cnt(n);
  auto recomp = [&](int ind) {
    for (int i = BL * ind; i < BL * (ind + 1); ++i) {
      if (fa[i] < BL * ind) {
        nxt.set(i, fa[i]);
        cnt[i] = 1;
      } else {
        nxt.set(i, nxt[fa[i]]);
        cnt[i] = cnt[fa[i]] + 1;
      }
    }
    cnt[BL * ind] = 1;
  };
  for (int i = 1; i < n / BL; ++i) {
    recomp(i);
  }

  auto sub = [&](int l, int r, int d) {
    for (int i = l; i <= end(l); ++i) {
      fa.add(i, -d);
    }
    recomp(l / BL);
    for (int i = end(l) + 1; i < start(r); i += BL) {
      bool re = fa.la[i / BL] < BL;
      fa.add_i(i / BL, -d);
      if (re) {
        recomp(i / BL);
      } else {
        nxt.add_i(i / BL, -d);
      }
    }
    for (int i = start(r); i <= r; ++i) {
      fa.add(i, -d);
    }
    recomp(r / BL);
  };
  auto lca = [&](int a, int b) {
    while (nxt[a] != nxt[b]) {
      if (a < b) {
        std::swap(a, b);
      }
      a = nxt[a];
    }
    if (a / BL != b / BL) {
      return nxt[a];
    }
    while (a != b) {
      if (a < b) {
        std::swap(a, b);
      }
      a = fa[a];
    }
    return a;
  };
  RBArr freq(n);
  auto query = [&](const std::vector<int>& b) -> int {
    int l = b[0];
    for (int i = 1; i < std::ssize(b); ++i) {
      l = lca(l, b[i]);
    }
    std::vector<std::vector<int>> gr(n / BL);
    for (int i : b) {
      gr[i / BL].push_back(i);
    }
    int ans = 0;
    for (int i = n / BL - 1; i >= 0 && l <= (i + 1) * BL - 1; --i) {
      if (gr[i].empty()) {
        continue;
      }
      freq.reset();
      std::vector<int> ele;
      for (int j : gr[i]) {
        freq.add(j, 1);
        if (freq[j] == 1) {
          ele.push_back(j);
        }
      }

      freq.reset();
      bool two = false;
      for (int j : ele) {
        freq.add(nxt[j], 1);
        if (freq[nxt[j]] >= 2) {
          two = true;
        }
      }
      if (!two && l < i * BL) {
        for (int j : ele) {
          gr[nxt[j] / BL].push_back(nxt[j]);
          ans += cnt[j];
        }
        continue;
      }
      freq.reset();
      for (int j : ele) {
        freq.add(j, 1);
      }
      for (int j = (i + 1) * BL - 1; j >= std::max(l, i * BL); --j) {
        if (freq[j] == 0) {
          continue;
        }
        ++ans;
        if (fa[j] >= i * BL) {
          freq.add(fa[j], 1);
        } else {
          gr[fa[j] / BL].push_back(fa[j]);
        }
      }
    }
    return ans;
  };

  while ((m--) != 0) {
    int op;
    std::cin >> op;
    if (op == 1) {
      int l, r, d;
      std::cin >> l >> r >> d;
      --l;
      --r;
      sub(l, r, d);
    } else {
      int k;
      std::cin >> k;
      std::vector<int> b(k);
      for (int& i : b) {
        std::cin >> i;
        --i;
      }
      std::cout << query(b) << '\n';
    }
  }
}