#include <iostream>
#include <cassert>
#include <cstdio>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <time.h>
#include <map>
#define MAXN 100000
#define MODD 1000000007
#define ll long long
using namespace std;

ll C[MAXN+2];
ll tree[MAXN+2];

ll modpow(ll x, ll y) {
    x%=MODD;
    ll xs = x;
    ll answer = 1;
    while(y) {
        if (y&1) {
            answer = (answer * xs) % MODD;
        }
        y >>= 1;
        xs = (xs * xs) % MODD;
    }
    return answer;
}

ll read(int idx){
    ll sum = 0;
    while (idx > 0){
        sum += tree[idx];
        if (sum >= MODD)
            sum -= MODD;
        idx -= (idx & -idx);
    }
    return sum;
}

void update(int idx ,ll val, int n){
    val %= MODD;
    if (val < 0)
        val += MODD;
    while (idx <= n){
        tree[idx] += val;
        if (tree[idx] >= MODD)
            tree[idx] -= MODD;
        if (tree[idx] < 0)
            tree[idx] += MODD;
        idx += (idx & -idx);
    }
}


int main() {
    int n,Q;
    ll a,b;
    cin>>n>>a>>b>>Q;
    
    
    a%=MODD;
    b%=MODD;
    
    for(int i=0;i<n;i++) {
        cin>>C[i];
    }
    
    ll gamma = b * modpow(a,MODD-2)%MODD;

    
    for(int i=0;i<=n+1;i++)
        tree[i]=0;
    
    for(int i=0;i<n;i++) {
        update(i+1,(i&1 ? -1 : 1)*modpow(gamma, i)*C[i],n);
    }
    
    
    
    for(int q=1;q<=Q;q++) {
        int type;
        cin>>type;
        if (type==1) {
            int x;
            cin>>x;
            
            
            update(x+1,(x&1 ? 1 : -1)*modpow(gamma, x)*C[x],n);
            
            cin>>C[x];
            update(x+1,(x&1 ? -1 : 1)*modpow(gamma, x)*C[x],n);

            
            
        } else {
            int L,R;
            cin>>L>>R;
            
            
            
            ll rem = 0;
            
            
            
            ll tmp = (read(R+1)-read(L+1))%MODD;
            if (tmp < 0)
                tmp += MODD;
            
            if ((L+1)&1) {
                tmp = (MODD-tmp)%MODD;
            }
            
            tmp = (tmp * modpow(modpow(gamma, L), MODD-2))%MODD;
            

            
            if (tmp == C[L])
                printf("Yes\n");
            else
                printf("No\n");
            
            
            
            
        }
    }
    
    
    
}