#define DEBUG 0
#define LOCAL 0
#define LOCAL_DEBUG 0
#define MBF 0
#include <iostream>
#include <algorithm>
#include <chrono>
#include <random>
#include <cassert>
#include <vector>
typedef long long LL;
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;

int Rand() {
	std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
	int r = rng();
	return r < 0 ? -r : r;
}
int Rand(int l, int r) { return Rand() % (r - l + 1) + l; }

#if 1
typedef unsigned long long ULL;
#else
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; }
};
#endif

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 LOCAL_DEBUG
	printf("add_tag %d %d %d\n", p, l, r);
#endif
	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(std::max(lp, l), MID));
}

#if MBF
struct BF_t {
	Arr<int> a;
	void init() {
		a.resize(n);
		for (int i = 0; i < n; ++i)
			a[i] = (::a[i + 1] - B + K * (i + 1)) / 2;
	}
	void op1(int l, int r, int v) {
		for (int i = l - 1; i < r; ++i)
			a[i] += v;
#if LOCAL_DEBUG
		printf("* ");
		for (int i = 0; i < n; ++i)
			printf("%d ", a[i]);
		puts("");
		Arr<ULL> hash(n + 1);
		for (int i = 0; i < n; ++i) {
			hash[i + 1] = hash[i] + (a[i] * 2 - K * (i + 1) + B + 2 * b) * pw[i + 1];
			ULL LHS = hash[i + 1], RHS = ask(tr1, tag1, add1, 1, 1, n, i + 1);
			printf("[] %d %llu %llu\n", i + 1, LHS, RHS);
			assert(LHS == RHS);
		}
#endif
	}
	int op2(int p) {
		int r = 1;
		for (--p; p - r >= 0 && p + r < n && a[p + r] - a[p - r] == K * r + b; ++r)
			;
		return r - 1;
	}
} BF;
#endif

int main() {
	std::ios::sync_with_stdio(false);
#if LOCAL
	n = 30, q = 100, K = 0, b = Rand(-10, 10);
	printf("%d %d %d %d\n", n, q, K, b);
#else
	std::cin >> n >> q >> K >> b;
#endif
	for (int i = 1; i <= n; ++i) {
#if LOCAL
		a[i] = Rand(-10, 10);
		printf("%d ", a[i]);
#else
		std::cin >> a[i];
#endif
		a[i] = a[i] * 2 - K * i;
		a[i] += B;
		assert(a[i] > 0);
	}
#if LOCAL
	puts("");
#endif
#if MBF
	BF.init();
#endif
	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;
#if LOCAL
		op = Rand(1, 2);
		printf("%d ", op);
#else
		std::cin >> op;
#endif
		if (op == 1) {
			int l, r, v;
#if LOCAL
			l = Rand(1, n), r = Rand(1, n);
			if (l > r)
				std::swap(l, r);
			v = Rand(-10, 10);
			printf("%d %d %d\n", l, r, v);
#else
			std::cin >> l >> r >> v;
#endif
			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));
#if MBF
			BF.op1(l, r, v / 2);
#endif
		} else {
			int x;
#if LOCAL
			x = Rand(1, n);
			printf("%d\n", x);
#else
			std::cin >> x;
#endif
#if MBF
			int mbf = BF.op2(x);
#endif
			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);
#if DEBUG
				printf("== %llu %llu\n", l, r);
#endif
				// l += 2 * b * cons(lp, x - 1);
				l *= pw[n - rp + 1];
				r *= pw[lp];
#if DEBUG
				printf("= %llu %llu\n", l, r);
#endif
				if (l != r)
					break;
			}
			if (h == 0) {
#if MBF
				if (mbf)
					printf("= %d\n", mbf);
				assert(mbf == 0);
#endif
				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);
			}
#if MBF
			assert(ans == mbf);
#endif
			printf("%d\n", ans);
		}
	}
	return 0;
}