#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;

typedef long long LL;
typedef vector<int> VI;

#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)

template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
    for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
    putchar('\n');
}

template<unsigned MOD> struct ModInt {
    unsigned x;
    void undef() { x = (unsigned)-1; }
    bool isnan() const { return x == (unsigned)-1; }
    inline int getInt() const { return (int)x; }
    template<class T> T get() const { return (T)x; }
    ModInt(int y=0) { if (y<0 || (int)MOD<=y) y %= (int)MOD; if (y<0) y += MOD; x=y; }
    ModInt(long long y) { if (y<0 || MOD<=y) y %= MOD; if (y<0) y += MOD; x=y; }
    ModInt(unsigned long long y) { if (MOD<=y) x = y % MOD; else x = y; }
    ModInt &operator+=(const ModInt &y) { if ((x += y.x) >= MOD) x -= MOD; return *this; }
    ModInt &operator-=(const ModInt &y) { if ((x -= y.x) & (1u<<31)) x += MOD; return *this; }
    ModInt &operator*=(const ModInt &y) { x = (unsigned long long)x * y.x % MOD; return *this; }
    ModInt &operator/=(const ModInt &y) { x = (unsigned long long)x * y.inv().x % MOD; return *this; }
    ModInt operator-() const { return (x ? MOD-x: 0); }
    ModInt inv() const {
	unsigned a = MOD, b = x; int u = 0, v = 1;
	while (b) {
	    int t = a / b;
	    a -= t * b; swap(a, b);
	    u -= t * v; swap(u, v);
	}
	if (u < 0) u += MOD;
	return ModInt(u);
    }
    ModInt pow(long long y) const {
	ModInt b = *this, r = 1;
	if (y < 0) { b = b.inv(); y = -y; }
	for (; y; y>>=1) {
	    if (y&1) r *= b;
	    b *= b;
	}
	return r;
    }
};
const LL MOD = 1000000007;
typedef ModInt<MOD> Mint;
Mint operator+(Mint x, const Mint &y) { if ((x.x += y.x) >= (unsigned)MOD) x.x -= (unsigned)MOD; return x; }
Mint operator-(Mint x, const Mint &y) { if ((x.x -= y.x) & (1u<<31)) x.x += (unsigned)MOD; return x; }
Mint operator*(Mint x, const Mint &y) { x.x = (unsigned long long)x.x * y.x % (unsigned long long)MOD; return x; }
Mint operator/(Mint x, const Mint &y) { x.x = (unsigned long long)x.x * y.inv().x % (unsigned long long)MOD; return x; }
bool operator<(const Mint &x, const Mint &y) { return x.x < y.x; }
bool operator==(const Mint &x, const Mint &y) { return x.x == y.x; }
bool operator!=(const Mint &x, const Mint &y) { return x.x != y.x; }

struct Seg {
    static Mint P;
    Mint val;
    int len;
    Seg() : val(0), len(0) {}
    Seg(int val_): val(val_), len(1) {}
};
Mint Seg::P;

Seg operator*(const Seg &x, const Seg &y) {
    // TODO: do stuff something
    Seg z;
    z.len = x.len + y.len;
    z.val = x.val + y.val * Seg::P.pow(x.len);
    return z;
};
const Seg unit = Seg();

struct SegmentTree {
    int n;
    vector<Seg> d;
    SegmentTree(int n_=0): n(n_), d(2*n) { }
    SegmentTree(const vector<Seg> & d_): n(d_.size()), d(2*n) {
	for (int i=0; i<n; i++) d[i+n] = d_[i];
	for (int i=n; --i; ) d[i] = d[i*2] * d[i*2+1];
    }
    void modify(int i, const Seg &s) {
	i += n;
	d[i] = s;
	for (i/=2; i; i/=2) d[i] = d[i*2] * d[i*2+1];
    }
    Seg query(int x, int y) {
	x += n; y += n;
	Seg ls = unit, rs = unit;
	for (; x < y; x>>=1, y>>=1) {
	    if (y & 1) rs = d[--y] * rs;
	    if (x & 1) ls = ls * d[x++];
	}
	return ls * rs;
    }
};

int N;
int A, B, Q;
int C[100111];


int main() {
    scanf("%d%d%d%d", &N, &A, &B, &Q);
    REP (i, N) scanf("%d", C+i);

    Seg::P = (MOD - B) * Mint(A).inv();

    SegmentTree ST(N);
    REP (i, N) ST.modify(i, C[i]);
    REP ($, Q) {
	char o[11];
	scanf("%s", o);
	if (*o == '1') {
	    int I, X;
	    scanf("%d%d", &I, &X);
	    ST.modify(I, X);
	} else {
	    int L, R;
	    scanf("%d%d", &L, &R);
	    R++;
	    bool yes = (ST.query(L, R).val == 0);
	    puts(yes? "Yes": "No");
	}
    }

    return 0;
}