import java.io.*;
import java.util.*;

public class Solution {

    public static void solve(int testCase) throws Exception {
        int n = in.nextInt();
        long a = in.nextLong();
        long b = in.nextLong();
        int q = in.nextInt();
        Long[] arr = new Long[n];
        for (int i = 0; i < n; i ++) {
            arr[i] = in.nextLong();
        }
        final long aInverse = power(a, MOD - 2, MOD);
        final long mlt = (aInverse * b) % MOD;
        final long mult = (MOD - mlt) % MOD;

        SegmentTree<Node, Long> st = new SegmentTree<Node, Long>(arr) {
            @Override
            public Node initLeaf(Long data) {
                Node x = new Node();
                x.val = (aInverse * data ) % MOD;
                x.num = 1;
                return x;
            }

            @Override
            public Node merge(Node left, Node right) {
                Node ret = new Node();
                ret.num = left.num + right.num;
                ret.val = left.val + (power(mult, left.num, MOD) * right.val) % MOD;
                ret.val %= MOD;
                return ret;
            }
        };

        int type;
        for (int i = 0; i < q; i ++) {
            type = in.nextInt();
            if (type == 1) {
                int ind = in.nextInt();
                long val = in.nextLong();
                st.update(ind, val);
            } else {
                int l = in.nextInt(), r = in.nextInt();
                
                long val = st.query(l, r).val;
                if (val == 0) {
                    sb.append("Yes\n");
                } else {
                    sb.append("No\n");
                }
            }
        }
    }

    static long MOD = 1000000007L;

    static long power(long b, long e, long mod) {
        if (e == 0)
            return 1L;
        else if (e == 1)
            return b % mod;
        long ans = power(b, e / 2, mod);
        ans = (ans * ans) % mod;
        if (e % 2 == 1) {
            ans = (ans * b) % mod;
        }
        return ans;
    }
    static class Node {
        long val;
        long num;
    }
    private static InputReader in;
    private static PrintWriter ou;
    private static PrintWriter dbg;
    private static StringBuilder sb;
    private static final boolean MULTIPLE_TEST_CASES = false;
    private static boolean DEBUG = false;

    public static void main(String[] args) throws Exception {
        in = new InputReader(System.in);
        ou = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        sb = new StringBuilder("");
        debugInit();

        int t = 1;
        if (MULTIPLE_TEST_CASES) {
            t = in.nextInt();
        }

        for (int i = 1; i <= t; i++) {
            solve(i);
        }

        ou.print(sb);
        ou.close();
        debugEnd();
    }

    static class InputReader {

        private final InputStream st;
        private final byte[] buf = new byte[8192];
        private int cc, sc;
        private SpaceCharFilter f;

        public InputReader(InputStream st) {
            this.st = st;
        }

        public int t() {
            if (sc == -1)
                throw new InputMismatchException();
            if (cc >= sc) {
                cc = 0;
                try {
                    sc = st.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (sc <= 0)
                    return -1;
            }
            return buf[cc++];
        }

        public int nextInt() {
            int c = t();
            while (isSpaceChar(c)) {
                c = t();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = t();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = t();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = t();
            while (isSpaceChar(c)) {
                c = t();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = t();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = t();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

        public String readString() {
            int c = t();
            while (isSpaceChar(c)) {
                c = t();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = t();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public String nextLine() {
            int c = t();
            while (isSpaceChar(c))
                c = t();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = t();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (f != null)
                return f.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void debugInit() {
        if (DEBUG)
            dbg = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.err)));
    }

    public static void debug(Object o) {
        if (DEBUG)
            dbg.println(o.toString());
    }

    public static void debugEnd() {
        if (DEBUG)
            dbg.close();
    }
}

abstract class SegmentTree<T, V> {

    private int[] leafInd;
    private int N;
    private T[] tree;

    public SegmentTree(V[] arr) {
        this.N = arr.length;
        leafInd = new int[N];
        tree = (T[])new Object[(N<<2) + 1];
        build(1, 0, N - 1, arr);
    }

    private void build(int index, int start, int end, V[] arr) {
        if(start > end)
            return;
        if(start == end) {
            tree[index] = initLeaf(arr[start]);
            leafInd[start] = index;
        }
        else if(start < end) {
            int mid = (start + end) / 2;
            build(2 * index, start, mid, arr);
            build(2 * index + 1, mid + 1, end, arr);
            tree[index] = merge(tree[2 * index], tree[2 * index + 1]);
        }
    }

    public void update(int ind, V data) {
        if(ind <0 || ind >= N)
            throw new IllegalArgumentException("Index not present in array");
        int index = leafInd[ind];

        tree[index] = initLeaf(data);
        index /= 2;

        while(index >= 1) {
            tree[index] = merge(tree[2 * index], tree[2 * index + 1]);
            index /= 2;
        }
    }

    public T query(int i, int j) {
        return query(1, 0, N - 1, i, j);
    }

    public T queryAll() {
        return tree[1];
    }

    private T query(int index, int start, int end, int i, int j) {
        if(start > end)
            return null;
        else if(start >= i && end <= j)
            return tree[index];
        int mid = (start + end) / 2;
        if(j <= mid)
            return query(2 * index, start, mid, i, j);
        else if(i > mid)
            return query(2 * index + 1, mid + 1, end, i, j);
        else {
            T left = query(2 * index, start, mid, i, j);
            T right = query(2 * index + 1, mid + 1, end, i, j);
            return merge(left, right);
        }

    }

    public abstract T initLeaf(V data);

    public abstract T merge(T left, T right);
}