#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;


const int MOD = 1'000'000'547;

int add(int a, int b) {
  return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
  return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
  return (1ll * a * b) % MOD;
}

int pw(int x, int n) {
  int res = 1;
  while (n) {
    if (n % 2 == 0) {
      x = mul(x, x);
      n /= 2;
    } else {
      res = mul(res, x);
      --n;
    }
  }
  return res;
}

const int MAXN = 400200;
const int BASE = 9461;
int BASEPOW[MAXN];

// tree1: add on subsegment, get in point

int mod[(1 << 19) + 228];

void build(int v, int left, int right, vector<int>& A) {
  if (left + 1 == right) {
    mod[v] = A[left];
    return;
  }
  int mid = (left + right) / 2;
  build(2 * v + 1, left, mid, A);
  build(2 * v + 2, mid, right, A);
}

int get(int v, int left, int right, int i) {
  if (left + 1 == right)
    return mod[v];
  int mid = (left + right) / 2;
  if (i < mid)
    return get(2 * v + 1, left, mid, i) + mod[v];
  return get(2 * v + 2, mid, right, i) + mod[v];
}

void add(int v, int left, int right, int x, int y, int d) {
  if (y <= left || right <= x)
    return;
  if (x <= left && right <= y) {
    mod[v] += d;
    return;
  }
  int mid = (left + right) / 2;
  add(2 * v + 1, left, mid, x, y, d);
  add(2 * v + 2, mid, right, x, y, d);
}

struct Hash {
  int len;
  int val;
  Hash(): len(0), val(0) {}
  Hash(int len, int val): len(len), val(val) {}
};

Hash combine(const Hash& left, const Hash& right) {
  return Hash(left.len + right.len, add(mul(left.val, BASEPOW[right.len]), right.val));
}

Hash hashes[(1 << 20) + 228];

int to_mod(int x) {
  if (x < 0)
    return MOD + x;
  return x;
}

void build_hashes(int v, int left, int right, vector<int>& C) {
  if (left + 1 == right) {
    hashes[v] = Hash(1, to_mod(C[left]));
    return;
  }
  int mid = (left + right) / 2;
  build_hashes(2 * v + 1, left, mid, C);
  build_hashes(2 * v + 2, mid, right, C);
  hashes[v] = combine(hashes[2 * v + 1], hashes[2 * v + 2]);
}

void add_hash(int v, int left, int right, int i, int x) {
  if (left + 1 == right) {
    hashes[v].val = add(hashes[v].val, to_mod(x));
    return;
  }
  int mid = (left + right) / 2;
  if (i < mid)
    add_hash(2 * v + 1, left, mid, i, x);
  else
    add_hash(2 * v + 2, mid, right, i, x);
  hashes[v] = combine(hashes[2 * v + 1], hashes[2 * v + 2]);
}

Hash get_hash(int v, int left, int right, int x, int y) {
  if (y <= left || right <= x)
    return Hash();
  if (x <= left && right <= y)
    return hashes[v];
  int mid = (left + right) / 2;
  return combine(get_hash(2 * v + 1, left, mid, x, y), get_hash(2 * v + 2, mid, right, x, y));
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);

  BASEPOW[0] = 1;
  for (int i = 1; i < MAXN; ++i)
    BASEPOW[i] = mul(BASEPOW[i - 1], BASE);

  int n, q, k, b;
  cin >> n >> q >> k >> b;
  b *= 2;
  vector<int> A(n);
  for (int i = 0; i < n; ++i) {
    cin >> A[i];
    A[i] = 2 * A[i] - i * k;
  }
  build(0, 0, n, A);
  vector<int> C(2 * n);
  for (int i = 0; i < n; ++i) {
    C[i] = A[i] - (i == 0 ? 0 : A[i - 1]);
    C[2 * n - i - 1] = -C[i];
  }
  build_hashes(0, 0, 2 * n, C);

  auto get_r = [&](int i) {
    if (i == 0 || i == n - 1)
      return 0;
    int prev = get(0, 0, n, i - 1), nxt = get(0, 0, n, i + 1);
    if (nxt - prev != b)
      return 0;
    int left = 1, right = min(i + 1, n - i);
    while (right - left > 1) {
      int mid = (left + right) / 2;
      
      auto h1 = get_hash(0, 0, 2 * n, i + 2, i + mid + 1);
      auto h2 = get_hash(0, 0, 2 * n, 2 * n - i, 2 * n - i + mid - 1);

      if (h1.val == h2.val)
        left = mid;
      else
        right = mid;
    }
    return left;
  };

  while (q--) {
    int t;
    cin >> t;
    if (t == 1) {
      int l, r, v;
      cin >> l >> r >> v;
      v *= 2;
      --l;
      --r;
      add(0, 0, n, l, r + 1, v);
      add_hash(0, 0, 2 * n, l, v);
      add_hash(0, 0, 2 * n, 2 * n - l - 1, -v);
      if (r + 1 < n) {
        add_hash(0, 0, 2 * n, r + 1, -v);
        add_hash(0, 0, 2 * n, 2 * n - r - 1, v);
      }
    } else {
      int i;
      cin >> i;
      --i;
      cout << get_r(i) << '\n';
    }
  }


  return 0;
}