/* Written by Filip Hlasek 2017 */
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>

#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(i,b) for(int i=0;i<(b);i++)

using namespace std;

#define MOD 1000000007
int N, A, B, Q;
#define MAXN 111111
int C[MAXN];

int power(int base, long long exponent) {
  int result = 1, m = base;
  while (exponent) {
    if (exponent & 1) result = ((long long)result * m) % MOD;
    m = ((long long)m * m) % MOD;
    exponent /= 2;
  }
  return result;
}

int powx[MAXN];

template <class ValueType>
class SegmentTree {
  private:
    int SIZE; // the smallest power of two, which is at least number of elements
    int *Left, *Right;
    ValueType *value;

    ValueType getSum(int v, int l, int r) {
      if (l == Left[v] && r == Right[v]) return value[v];
      int middle = (Left[v] + Right[v]) / 2;
      if (middle >= r) return getSum(2 * v, l, r);
      if (middle <= l) return getSum(2 * v + 1, l, r);
      return (
        getSum(2 * v, l, middle) +
        ((long long)powx[middle - l] * getSum(2 * v + 1, middle, r)) % MOD
      ) % MOD;
    }

    void setValue(int v, int l, int r, ValueType val) {
      if (l == Left[v] && r == Right[v]) {
        value[v] = val;
        return;
      }
      int middle = (Left[v] + Right[v]) / 2;
      if (middle >= r) setValue(2 * v, l, r, val);
      else if (middle <= l) setValue(2 * v + 1, l, r, val);

      value[v] = (
        value[2 * v] +
        ((long long)powx[Right[2 * v] - Left[2 * v]] * value[2 * v + 1]) % MOD
      ) % MOD;
    }

  public:
    // Elements are indexed from 0 to len - 1
    // All queries work with elements l, l + 1, ... r - 1
    void init(int len) {
      for (SIZE = 1; SIZE < len; SIZE *= 2) ;

      Left = (int*)malloc(sizeof(int) * 2 * SIZE);
      Right = (int*)malloc(sizeof(int) * 2 * SIZE);
      value = (ValueType*)malloc(sizeof(ValueType) * 2 * SIZE);

      Left[1] = 0;
      Right[1] = SIZE;
      FOR(i, 1, SIZE - 1) {
        Left[2 * i] = Left[i];
        Right[2 * i] = (Left[i] + Right[i]) / 2;
        Left[2 * i + 1] = (Left[i] + Right[i]) / 2;
        Right[2 * i + 1] = Right[i];
      }
      REP(i, 2 * SIZE) {
        value[i] = ValueType();
      }
    }
    ValueType getSum(int l, int r) { return getSum(1, l, r); }
    void setValue(int l, int r, ValueType val) { setValue(1, l, r, val); }
};

SegmentTree<int> s;

int main(int argc, char *argv[]) {
  scanf("%d%d%d%d", &N, &A, &B, &Q);
  REP(i, N) scanf("%d", C + i);

  int x = ((long long)B * power(A, MOD - 2)) % MOD;
  if (x) x = MOD - x;

  powx[0] = 1;
  REP(i, MAXN - 1) powx[i + 1] = ((long long)powx[i] * x) % MOD;

  s.init(N);
  REP(i, N) s.setValue(i, i + 1, C[i]);

  while (Q--) {
    int t;
    scanf("%d", &t);
    if (t == 1) {
      int i, x;
      scanf("%d%d", &i, &x);
      s.setValue(i, i + 1, x);
    }
    else {
      int l, r;
      scanf("%d%d", &l, &r);
      printf("%s\n", s.getSum(l, r + 1) == 0 ? "Yes" : "No");
    }
  }

  return 0;
}