#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int INF = numeric_limits<int>::max();

const int N = 200010, L = 20;

const int NO = 0, FI = 1, LF = 2, RF = 3;

namespace SEG {

struct Node {
  int v;
  char typ;
  union {
    struct { int lb, rb; };
    int b[2];
  };
  union {
    struct { int ls, rs; };
    int s[2];
  };
} P[N * L * 8];

int top;

void updB(int o) {
  for (int i = 0; i < 2; ++i)
    P[o].b[i] = max(P[P[o].ls].b[i], P[P[o].rs].b[i]);
}

int build(int* beg, int* ed) {
  int ret = ++top;
  if (ed - beg == 1) {
    P[ret].lb = *beg;
    P[ret].rb = *ed;
    return ret;
  }
  int sz = ed - beg;
  P[ret].ls = build(beg, beg + (sz >> 1));
  P[ret].rs = build(beg + (sz >> 1), ed);
  updB(ret);
  return ret;
}

int cpy(int o) {
  int ret = ++top;
  memcpy(P + ret, P + o, sizeof(Node));
  return ret;
}

void pd(int o) {
  if (P[o].typ == NO) return;
  for (int i = 0; i < 2; ++i)
    P[o].s[i] = cpy(P[o].s[i]);
  if (P[o].typ == FI) {
    for (int i = 0; i < 2; ++i) {
      P[P[o].s[i]].typ = FI;
      P[P[o].s[i]].v = P[o].v;
    }
    P[o].typ = NO;
    return;
  }
  int dir = P[o].typ - LF;
  int cur = P[o].v, p = !dir;
  P[P[o].ls].typ = P[P[o].rs].typ = LF + dir;
  do {
    P[P[o].s[p]].v = cur;
    cur = max(cur, P[P[o].s[p]].b[dir]);
    p = !p;
  } while (p != !dir);
  P[o].typ = NO;
}

template <bool DIR>
int chB(int o, int l, int r, int k, int x) {
  o = cpy(o);
  if (l == r) {
    P[o].b[DIR] = x;
    return o;
  }
  int mid = (l + r - 1) >> 1;
  pd(o);
  if (k <= mid)
    P[o].ls = chB<DIR>(P[o].ls, l, mid, k, x);
  else
    P[o].rs = chB<DIR>(P[o].rs, mid + 1, r, k, x);
  updB(o);
  return o;
}

template <bool DIR>
int bound(int o, int l, int r, int x) {
  if (P[o].b[DIR] < x) return -1;
  if (l == r) return l;
  int mid = (l + r - 1) >> 1;
  int ret = bound<DIR>(P[o].s[!DIR], !DIR ? (mid + 1) : l, !DIR ? r : mid, x);
  if (ret == -1)
    ret = bound<DIR>(P[o].s[DIR], DIR ? (mid + 1) : l, DIR ? r : mid, x);
  return ret;
}

template <bool DIR>
int bound(int o, int l, int r, int k, int x) {
  if (P[o].b[DIR] < x) return -1;
  if (l == r) return l;
  int mid = (l + r - 1) >> 1;
  int ret;
  if (k <= mid) {
    ret = bound<DIR>(P[o].ls, l, mid, k, x);
    if (ret == -1 && DIR == 1)
      ret = bound<DIR>(P[o].rs, mid + 1, r, x);
  } else {
    ret = bound<DIR>(P[o].rs, mid + 1, r, k, x);
    if (ret == -1 && DIR == 0)
      ret = bound<DIR>(P[o].ls, l, mid, x);
  }
  return ret;
}

int fil(int o, int l, int r, int ql, int qr, int x) {
  o = cpy(o);
  if (ql == l && qr == r) {
    P[o].v = x;
    P[o].typ = FI;
    return o;
  }
  int mid = (l + r - 1) >> 1;
  pd(o);
  if (qr <= mid)
    P[o].ls = fil(P[o].ls, l, mid, ql, qr, x);
  else if (ql > mid)
    P[o].rs = fil(P[o].rs, mid + 1, r, ql, qr, x);
  else {
    P[o].ls = fil(P[o].ls, l, mid, ql, mid, x);
    P[o].rs = fil(P[o].rs, mid + 1, r, mid + 1, qr, x);
  }
  return o;
}

int res;

int query(int o, int l, int r, int k) {
  o = cpy(o);
  if (l == r) {
    res = P[o].v;
    return o;
  }
  int mid = (l + r - 1) >> 1;
  pd(o);
  if (k <= mid)
    P[o].ls = query(P[o].ls, l, mid, k);
  else
    P[o].rs = query(P[o].rs, mid + 1, r, k);
  return o;
}

template <bool DIR>
int pr(int o, int l, int r, int ql, int qr) {
  o = cpy(o);
  if (ql == l && qr == r) {
    P[o].v = res;
    P[o].typ = LF + DIR;
    res = max(res, P[o].b[DIR]);
    return o;
  }
  int mid = (l + r - 1) >> 1;
  pd(o);
  if (qr <= mid)
    P[o].ls = pr<DIR>(P[o].ls, l, mid, ql, qr);
  else if (ql > mid)
    P[o].rs = pr<DIR>(P[o].rs, mid + 1, r, ql, qr);
  else {
    if (DIR) {
      P[o].ls = pr<DIR>(P[o].ls, l, mid, ql, mid);
      P[o].rs = pr<DIR>(P[o].rs, mid + 1, r, mid + 1, qr);
    } else {
      P[o].rs = pr<DIR>(P[o].rs, mid + 1, r, mid + 1, qr);
      P[o].ls = pr<DIR>(P[o].ls, l, mid, ql, mid);
    }
  }
  return o;
}

}

int h[N];
int rf[N];

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, q;
  cin >> n >> q;
  for (int i = 1; i < n; ++i)
    cin >> h[i];
  h[0] = h[n] = INF;
  rf[0] = SEG::build(h, h + n);
  for (int j = 1; j <= q; ++j) {
    int opt, i, x, ht;
    cin >> opt >> i >> x;
    int o = rf[i];
    if (opt == 0) {
      cin >> ht;
      o = SEG::query(o, 1, n, x);
      if (SEG::res < ht) {
        int l = SEG::bound<0>(o, 1, n, x, ht);
        int r = SEG::bound<1>(o, 1, n, x, ht);
        //if (ht == 832154179) {
        //  cerr<<"TELL YOU "<<SEG::res<<'\n';
       // }
        //cerr << ht << " cover " << l << ' ' << r << '\n';
        o = SEG::fil(o, 1, n, l, r, ht);
      }
    } else if (opt == 1) {
      o = SEG::query(o, 1, n, x);
      int l = SEG::bound<0>(o, 1, n, x, SEG::res);
      int r = SEG::bound<1>(o, 1, n, x, SEG::res);
      //cerr << "SHRINK " << l << " - " << x << " - " << r << '\n';
      SEG::res = 0;
      o = SEG::pr<0>(o, 1, n, l, x);
      SEG::res = 0;
      o = SEG::pr<1>(o, 1, n, x, r);
    } else if (opt == 2) {
      cin >> ht;
      o = SEG::chB<1>(o, 1, n, x, ht);
      o = SEG::chB<0>(o, 1, n, x + 1, ht);
    } else {
      o = SEG::query(o, 1, n, x);
      cout << SEG::res << '\n';
    }
    rf[j] = o;
  }

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}