#include <bits/stdc++.h>

const int MAXN = 100005;

const int32_t base = 31;

int32_t n, q, k, b;

int32_t a[MAXN], c[MAXN], d[MAXN];

uint64_t p[MAXN], w[MAXN];

namespace Segtree1 {
	struct node {
		int32_t len;
		uint64_t hsh;
		
		inline node operator + (const node & a) const {
			return {len + a.len, hsh * w[a.len] + a.hsh};
		}
	} T[MAXN << 2];
	
	#define LC (x << 1)
	#define RC (x << 1 | 1)
	#define m ((l + r) >> 1)
	
	inline void Build (const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
		T[x].len = r - l + 1;
		if (l == r) return T[x].hsh = c[l], void ();
		Build (l, m, LC), Build (m + 1, r, RC), T[x] = T[LC] + T[RC];
	}
	
	inline void Modify (const int32_t p, const int32_t val, const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
		if (l == r) return T[x].hsh += val, void ();
		p <= m ? Modify (p, val, l, m, LC) : Modify (p, val, m + 1, r, RC); T[x] = T[LC] + T[RC];
	}
	
	inline node Sum (const int32_t L, const int32_t R, const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
	//	std::cerr << L << ' ' << R << ' ' << l << ' ' << r << ' ' << T[x].hsh << '\n';
		if (L <= l && r <= R) return T[x];
		if (L <= m && R >  m) return Sum (L, R, l, m, LC) + Sum (L, R, m + 1, r, RC);
		if (L <= m) return Sum (L, R, l, m, LC);
		if (R >  m) return Sum (L, R, m + 1, r, RC);
		return (node) {0, 0};
	}
	
}

namespace Segtree2 {
	struct node {
		int32_t len;
		uint64_t hsh;
		
		inline node operator + (const node & a) const {
			return {len + a.len, a.hsh * w[len] + hsh};
		}
	} T[MAXN << 2];
	
	#define LC (x << 1)
	#define RC (x << 1 | 1)
	#define m ((l + r) >> 1)
	
	inline void Build (const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
		T[x].len = r - l + 1;
		if (l == r) return T[x].hsh = d[l], void ();
		Build (l, m, LC), Build (m + 1, r, RC), T[x] = T[LC] + T[RC];
	}
	
	inline void Modify (const int32_t p, const int32_t val, const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
		if (l == r) return T[x].hsh += val, void ();
		p <= m ? Modify (p, val, l, m, LC) : Modify (p, val, m + 1, r, RC); T[x] = T[LC] + T[RC];
	}
	
	inline node Sum (const int32_t L, const int32_t R, const int32_t l = 1, const int32_t r = n, const int32_t x = 1) {
		if (L <= l && r <= R) return T[x];
		if (L <= m && R >  m) return Sum (L, R, l, m, LC) + Sum (L, R, m + 1, r, RC);
		if (L <= m) return Sum (L, R, l, m, LC);
		if (R >  m) return Sum (L, R, m + 1, r, RC);
		return {0, 0};
	}
	
}

int32_t opt, l, r, x, val, ans;

int main () {
	
	std::ios::sync_with_stdio (0);
	std::cin.tie (0), std::cout.tie (0);
	
	std::cin >> n >> q >> k >> b, w[0] = 1;
	
	for (int i = 1; i <= n; ++ i)
		std::cin >> a[i];
	
	for (int i = 1; i <= n; ++ i)
		c[i] = a[i] - a[i - 1], d[i] = a[i] - a[i + 1];
	
	for (int i = 1; i <= n; ++ i)
		w[i] = w[i - 1] * base;
	
	p[1] = k + b;
	
	for (int i = 2; i <= n; ++ i)
		p[i] = p[i - 1] * base + k;
	
	Segtree1::Build (1, n), Segtree2::Build (1, n);
	
	for (int i = 1; i <= q; ++ i) {
		std::cin >> opt;
		
		if (opt == 1) std::cin >> l >> r >> val;
		if (opt == 2) std::cin >> x;
		
		if (opt == 1) {
			c[l] += val, c[r + 1] -= val;
			d[l - 1] -= val, d[r] += val;
			Segtree1::Modify (l, + val), Segtree1::Modify (r + 1, - val);
			Segtree2::Modify (l - 1, - val), Segtree2::Modify (r, + val);
			
		} else {
			
			l = 1, r = std::min (x, n - x), ans = 0;
			
		//	std::cerr << p[3] << ' ' << Segtree1::Sum (x + 1, x + 3).hsh << '\n';
			
			if (c[x] - d[x] != k + b) {
				std::cout << ans << '\n';
				continue ;
			}
			
			if (l == r)
				ans = (Segtree1::Sum (x + 1, x + l).hsh - Segtree2::Sum (x - l, x - 1).hsh == p[m]) * l;
			
		//	r = 0;
			
			while (l <= r) {
				std::cerr << i << ' ' << l << ' ' << r << ' ' << m << ' ' << Segtree1::Sum (x + 1, x + m).hsh - Segtree2::Sum (x - m, x - 1).hsh << ' ' << p[m] << '\n';
				if (Segtree1::Sum (x + 1, x + m).hsh - Segtree2::Sum (x - m, x - 1).hsh == p[m]) ans = m, l = m + 1;
				else r = m - 1;
			}
			
			std::cout << ans << '\n';
			
		//	std::cerr << now << ' ' << p[1] << '\n';
		}
		
	}
		
	return 0;
}