import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    
    static ArrayList<Long> sumToX ;
    static long root ;
    static long[] c;
    static ArrayList<Long> powVals ;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        Long a = in.nextLong();
        Long b = in.nextLong();
        int q = in.nextInt();
         c = new long[n];
        
        root = sub(0L,divide(b,a));
        //System.out.println("root " + root);
        //System.out.println(mult(root, a));
        for(int c_i=0; c_i < n; c_i++){
            c[c_i] = in.nextLong();
        }
        
         powVals = new ArrayList<Long>();
        powVals.add(1L);
        for(int i=0; i <n+1; ++i){
            powVals.add(mult(powVals.get(i),root));
        }
        long curVal = 0;
        for(int i = 0; i< n; ++i){
            curVal = sum(curVal, mult(c[i],powVals.get(i)));
        }
         sumToX = new ArrayList<Long>();
        sumToX.add(c[0]);
        for(int i = 0; i < n-1; ++i){
            sumToX.add(sum(sumToX.get(i), mult(c[i],powVals.get(i))));
        }
        TreeSet<Tuple> uncommittedChanges = new TreeSet<Tuple>();
        
        
        
        //System.out.println(curVal);
        for(int a0 = 0; a0 < q; a0++){
            int queryType = in.nextInt();
            int first = in.nextInt();
            int second = in.nextInt();
            if(queryType == 1){
                c[first] = (long) second;
            }
            else{
                long polyVal = computePoly(first,second);
                //System.out.println(polyVal);
                if(polyVal == 0)
                    {
                    System.out.println("Yes");
                }
                else{
                    System.out.println("No");
                }
                    
            }
        }
    }
    
    public static long computePoly(int l, int r){
        long total = 0;
        for(int i = l; i<=r; ++i){
            total = sum(total, mult(c[i], powVals.get(i)));
        }
        return total;
    }
    
    
    static HashMap<Long, Long> factorial = new HashMap<>();
    
    static HashMap<Long, HashMap<Long, Long> > chooseVals = new HashMap<>();
    
    static HashMap<Long, Long> pow2Vals = new HashMap<>();
    
    static final long bigMod = 1000000007;
    
    

    
    public static Long fact(long n)
    {
        if( !factorial.containsKey(n))
        {
        	if( n == 0)
        	{
        		factorial.put(n, (long) 1);
        	}
        	else
        	{
	            long f = (n * fact(n-1))%bigMod;
	            factorial.put(n,f);
        	}
        }
        return factorial.get(n);
    }
    
    public static long pow(long base, long power)
    {
        if( power ==0)
            return 1;
        if( power ==1)
            return base;
        
        if( power % 2 == 0)
        {
            long res = pow(base, power/2);
            return (res*res)%bigMod;
        }
        else
        {
            
            long res = pow(base, power/2);
            return ((res*res)% bigMod * base)%bigMod;
            
        }
    }
    public static long inv( long n)
    {
        return pow(n, bigMod-2);
            
    }
    
    public static long choose( long n, long k)
    {
    	if( k == n || k == 0)
    		return 1L;
    	
    	if( !chooseVals.containsKey(n) || !chooseVals.get(n).containsKey(k))
    	{
    		long val = (choose(n-1,k-1) + choose(n-1,k))% bigMod;
    		if( !chooseVals.containsKey(n))
        	{
        		chooseVals.put(n, new HashMap<>());
        	}
        	
        	chooseVals.get(n).put(k, val);
    	}
    	
    	
    	
    	return chooseVals.get(n).get(k);
    	
    }
    
    public static long mult(long x, long y)
    {
    	return (x*y)% bigMod;
    }
    
    public static long sum(long x, long y)
    {
        return (x+y)%bigMod;
    }
    
    public static long divide(long x, long y)
    {
        return mult( x, inv(y));
    }
    
    public static long sub( long x, long y)
    {
    	return sum(x + bigMod, -y);
    }
    
    
    public static long pow2( long power)
    {
    	if(!pow2Vals.containsKey(power))
    	{
    		long val = pow(2, power);
    		pow2Vals.put(power, val);
    	}
    	
    	return pow2Vals.get(power);
    }
    
    public static long geoSum(long r, long max)
    {
        
            // (1-r^max)/(1-r)
        long top = sub(1, pow(r, max%(bigMod-1)));
        long bottom = sub(1,r);
        long result = divide(top,bottom);
        return result;
    }
}



class Tuple implements Comparable<Tuple>
{
	public long[] values;
	public Tuple( long... vals)
	{
		values = vals;
	}

	public int compareTo( Tuple o)
	{
		for(int i = 0; i < values.length; ++i)
		{
			if(values[i] < o.values[i])
				return -1;

			if( values[i] > o.values[i])
				return 1;
		}
		return 0;
	}

	public long get(int index)
	{
		return values[index];
	}
	
	

	public String toString()
	{
		StringBuffer b = new StringBuffer(""+values[0]);
		for( int i = 1; i < values.length; ++i)
		{
			b.append(" " + values[i]);
		}
		return b.toString();
	}
}