#include <bits/stdc++.h>

#define FOR(i,b,e) for(int i=(b); i <= (e); ++i)
#define FORD(i,b,e) for(int i=(b); i >= (e); --i)
#define SIZE(c) (int) (c).size()
#define FORE(i,c) FOR(i,0,SIZE(c)-1)
#define FORDE(i,c) FORD(i,SIZE(c)-1,0)

#define pb push_back
#define mp make_pair
#define st first
#define nd second


using namespace std;

typedef long long ll;
typedef pair <int,int> pii;
typedef pair <ll,ll> pll;

typedef vector <int> VI;
typedef vector <bool> VB;
typedef vector <pii> VP;
typedef vector <ll> VL;
typedef vector <pll> VPL;

typedef vector <VI> VVI;
typedef vector <VL> VVL;
typedef vector <VB> VVB;
typedef vector <VP> VVP;

const int MOD = 1000000007;
const int INF = 1000000001;
const ll LINF = 1000000000000000001LL;


ll expo(ll a, ll n, ll mod) {
    ll ans = 1;

    while (n) {
        if (n & 1LL) ans = (ans * a) % mod;

        n >>= 1;
        a = (a * a) % mod;
    }

    return ans;
}

ll revMod(ll a, ll mod) {
    return expo(a, mod - 2, mod);
}

/*************************************************************************/

VL xn;

void pre(int a, int b, int n) {
	if (a == 0) {
		xn.resize(n, 0);
	} else {
		xn.resize(n);
		xn[0] = 1;
		
		xn[1] = (revMod(a, MOD) * b) % MOD;
		xn[1] = (MOD - xn[1]) % MOD;
		
		FOR(i,2,n-1) {
			xn[i] = (xn[i-1] * xn[1]) % MOD;
		}
	}
}

/*************************************************************************/

typedef pair <ll,int> val_t;

val_t join(val_t left, val_t right) {
	return {
		(left.st + xn[left.nd] * right.st) % MOD,
		left.nd + right.nd
	};
}

struct ITree {
    vector <val_t> T;
    int p = 1;

    ITree(int n) {
        while (p < n) p *= 2;
        T.resize(2*p-1);
    }

    int par(int x) { return (x - 1) / 2; }

    void change(int l, int v) {
        l += p-1;
        T[l] = {v, 1};

        while (l > 0) {
            l = par(l);
            T[l] = join(T[2*l+1], T[2*l+2]);
        }
    }

    int query(int l, int r) {
        l += p-1; r += p-1;
        
        if (l == r) {
        	return T[l].st;
        }

        val_t left = T[l];
        val_t right = T[r];

        while (par(l) != par(r)) {
            if (l%2 == 1) left = join(left, T[l+1]);
            if (r%2 == 0) right = join(T[r-1], right);

            l = par(l);
            r = par(r);
        }

        return join(left, right).st;
    }
};

/*************************************************************************/

int main() {
    ios_base::sync_with_stdio(0);
    
    int n, a, b, q;
    cin >> n >> a >> b >> q;
    
    pre(a, b, n);
    
    ITree tree(n);
    FOR(i,0,n-1) {
    	int c;
    	cin >> c;
    	
    	tree.change(i, c);
    }
    
    while (q--) {
    	int type;
    	cin >> type;
    	
    	if (type == 1) {
    		int i, x;
    		cin >> i >> x;
    		
    		tree.change(i, x);
    	} else {
    		int l, r;
    		cin >> l >> r;
    		
    		auto res = tree.query(l, r);
    		cout << (res == 0 ? "Yes\n" : "No\n");
    	}
    }

    return 0;
}

/*************************************************************************/