#define DEBUG 0
#include <iostream>
#include <algorithm>
#include <cassert>
#include <vector>
typedef long long LL;
typedef unsigned long long ULL;
template <class T> using Arr = std::vector<T>;
const int base = 998244353;
typedef long long LL;
#define MID ((l + r) >> 1)
#define LS (p << 1)
#define RS (LS | 1)
const long long MOD = 100055128505716009l;

// struct ULL {
// 	long long _;
// 	ULL(long long __) : _(__) {}
// 	ULL() : _(0) {}
// 	friend ULL operator+(ULL u, ULL v) { return (u._ + v._) % MOD; }
// 	friend ULL &operator+=(ULL &u, ULL v) { return u = ((u._ + v._) % MOD); }
// 	friend ULL &operator*=(ULL &u, ULL v) { return u = u * v; }
// 	friend ULL operator-(ULL u, ULL v) { return (u._ - v._) % MOD; }
// 	friend ULL operator*(ULL u, ULL v) { return (ULL)((__int128(u._) * v._) % MOD); }
// 	friend bool operator!=(ULL u, ULL v) { return (u._ % MOD + MOD) % MOD != (v._ % MOD + MOD) % MOD; }
// 	friend bool operator==(ULL u, ULL v) { return (u._ % MOD + MOD) % MOD == (v._ % MOD + MOD) % MOD; }
// };

const int MAXN = 200002;
const int B = 5e8;
int n, q, K, b;
int a[MAXN];
ULL pw[MAXN], ppw[MAXN];
ULL tr1[MAXN << 2], tag1[MAXN << 2], add1[MAXN << 2], hash1[MAXN];
ULL tr2[MAXN << 2], tag2[MAXN << 2], add2[MAXN << 2], hash2[MAXN];

void build(ULL tr[], ULL hash[], int p, int l, int r) {
	if (l == r) {
		tr[p] = hash[l];
		return;
	}
	build(tr, hash, LS, l, MID);
	build(tr, hash, RS, MID + 1, r);
}

ULL cons(int l, int r) {
	return ppw[r - l] * pw[l];
}

ULL ask(ULL tr[], ULL tag[], ULL add[], int p, int l, int r, int ps) {
	if (ps < l || ps > r)
		return 0;
	ULL delta = tag[p] * cons(l, ps) + add[p];
	if (l == r)
		return tr[p] + delta;
	return delta + (ask(tr, tag, add, LS, l, MID, ps) + ask(tr, tag, add, RS, MID + 1, r, ps));
}

ULL ask_int(int l, int r, ULL tr[], ULL tag[], ULL add[]) {
	ULL ls = ask(tr, tag, add, 1, 1, n, l - 1);
	ULL rs = ask(tr, tag, add, 1, 1, n, r);
	// printf("ask_int %d %d %llu %llu\n", l, r, ls, rs);
	return rs - ls;
}

void add_add(ULL add[], int p, int l, int r, int lp, int rp, ULL v) {
	if (rp < l || lp > r)
		return;
	if (lp <= l && r <= rp) {
		add[p] += v;
		return;
	}
	add_add(add, LS, l, MID, lp, rp, v);
	add_add(add, RS, MID + 1, r, lp, rp, v);
}

void add_tag(ULL add[], ULL tag[], int p, int l, int r, int lp, int rp, ULL v) {
	if (rp < l || lp > r)
		return;
	if (lp <= l && r <= rp) {
		tag[p] += v;
		return;
	}
	add_tag(add, tag, LS, l, MID, lp, rp, v);
	add_tag(add, tag, RS, MID + 1, r, lp, rp, v);
	if (rp >= MID + 1 && lp <= MID)
		add_add(add, RS, MID + 1, r, MID + 1, rp, v * cons(lp, MID));
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin >> n >> q >> K >> b;
	for (int i = 1; i <= n; ++i) {
		std::cin >> a[i];
		a[i] = a[i] * 2 - K * i;
		a[i] += B;
		assert(a[i] > 0);
	}
	pw[0] = 1;
	ppw[0] = 1;
	for (int i = 1; i < MAXN; ++i) {
		pw[i] = pw[i - 1] * base;
		ppw[i] = ppw[i - 1] + pw[i];
	}
	for (int i = 1; i <= n; ++i)
		hash1[i] = hash1[i - 1] + pw[i] * (a[i] + 2 * b);
	for (int i = 1; i <= n; ++i)
		hash2[i] = hash2[i - 1] + pw[i] * a[n - i + 1];
	build(tr1, hash1, 1, 1, n);
	build(tr2, hash2, 1, 1, n);
	// puts("HELLO");
#if DEBUG
	for (int i = 1; i <= n; ++i)
		printf("%llu ", hash1[i]);
	puts("");
	printf("! %llu %llu\n", hash1[2] * pw[5], (hash2[6] - hash2[4]) * pw[1]);
	for (int i = 1; i <= n; ++i)
		printf("%llu ", hash2[i]);
	puts("");
	for (int i = 1; i <= n; ++i)
		printf("%llu ", ask(tr1, tag1, add1, 1, 1, n, i));
	puts("");
#endif
	for (int i = 1; i <= q; ++i) {
		int op;
		std::cin >> op;
		if (op == 1) {
			int l, r, v;
			std::cin >> l >> r >> v;
			v *= 2;
			add_tag(add1, tag1, 1, 1, n, l, r, v);
			add_tag(add2, tag2, 1, 1, n, n - r + 1, n - l + 1, v);
			add_add(add1, 1, 1, n, r + 1, n, v * cons(l, r));
			add_add(add2, 1, 1, n, n - l + 2, n, v * cons(n - r + 1, n - l + 1));
		} else {
			int x;
			std::cin >> x;
			int h = 0;
			for (; x - (1 << h) >= 1 && x + (1 << h) <= n; ++h) {
				int lp = x - (1 << h), rp = x + (1 << h);
				ULL l = ask_int(lp, x - 1, tr1, tag1, add1);
				ULL r = ask_int(n - rp + 1, n - (x + 1) + 1, tr2, tag2, add2);
				// printf("== %llu %llu\n", l, r);
				// l += 2 * b * cons(lp, x - 1);
				l *= pw[n - rp + 1];
				r *= pw[lp];
				// printf("= %llu %llu\n", l, r);
				if (l != r)
					break;
			}
			if (h == 0) {
				puts("0");
				continue;
			}
			int ans = 1 << (h - 1);
			for (--h; h >= 0; --h) {
				int lp = x - (ans + (1 << h));
				int rp = x + (ans + (1 << h));
				if (lp < 1 || rp > n)
					continue;
				ULL l = ask_int(lp, x - 1, tr1, tag1, add1);
				ULL r = ask_int(n - rp + 1, n - (x + 1) + 1, tr2, tag2, add2);
				// l += 2 * b * cons(lp, x - 1);
				l *= pw[n - rp + 1];
				r *= pw[lp];
				// printf("# %llu %llu\n", l, r);
				if (l == r)
					ans += (1 << h);
			}
			printf("%d\n", ans);
		}
	}
	return 0;
}