#define _USE_MATH_DEFINES
#include <math.h>
#include <time.h>
#include <limits.h>
#include <memory.h>
#include <vector>
#include <list>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <set>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <algorithm>

#include <iomanip>
using namespace std;
typedef long long     ll;
typedef unsigned int  UInt;
#define ALL(a)             (a).begin(), (a).end()
#define FOR(i,a,b)      for(int i = a;   i <  (int)(b); ++i)
#define FOR_REV(i,a,b)  for(int i = b-1; i >= (int)(a); --i)
#define FOR_EACH(it,a)     for(remove_reference<decltype(a)>::type::iterator it = (a).begin(); it != (a).end(); ++it)
#define FOR_EACH_CONST(it,a) for(remove_reference<decltype(a)>::type::const_iterator it = (a).begin(); it != (a).end(); ++it)
template<class T> inline T   sqr(T v) { return v * v; }
template<class T> inline int sign(T v) {return v == 0 ? 0 : (v > 0 ? 1 : -1);}
template<class T> int get_bit(T v, int bit_index) { return (v >> bit_index) & 1; } //return {0,1}


istream& input()
{
  ios_base::sync_with_stdio(false);
  //#undef INPUT_FROM_FILE
#ifdef INPUT_FROM_FILE
  static ifstream is("HackerRank/input.txt");
#else
  istream& is = cin;
#endif
  return is;
}

ostream& output()
{
  cout << setprecision(15);
  return cout;
}

//////////////////////////////////////////////////////////////////////////

////a
//int main()
//{
//  istream& is = input();
//  ostream& os = output();
//
//  int n;
//  is >> n;
//  vector<int> a(n);
//  FOR (i,0,n)
//  {
//    is >> a[i];
//    --a[i];
//  }
//  FOR (i,0,n)
//    FOR (j,0,n)
//  {
//    if (a[a[j]]==i)
//      cout<<j+1<<"\n";
//  }
//
//  //int res = 0;
//  //os << res;
//  //os << "\n";
//  return 0;
//}

//////////////////////////////////////////////////////////////////////////

//int main()
//{
//  istream& is = input();
//  ostream& os = output();
//
//  int n,k;
//  is >> n>>k;
//
//  if (k>n)
//  {
//    os<<-1;
//    return 0;
//  }
//  if (k==2)
//  {
//    os<<(n==2?1:-1);
//    return 0;
//  }
//  int l = n-k;
//  os<<k-1+2*l;
//
//  //int res = 0;
//  //os << res;
//  //os << "\n";
//
//  return 0;
//}

//////////////////////////////////////////////////////////////////////////
vector<int> primes;

template<class T> 
inline vector<pair<T, int>> get_primes(T a)
{
  vector<pair<T, int>> r;
  r.reserve(16);
  for (int ind = 0; (ll)primes[ind]*primes[ind] <= a; ++ind)
  {
    T i = primes[ind];
    if (a % i == 0)
    {
      r.push_back(make_pair(i,0));
      while (a%i == 0)
      {
        ++r.back().second;
        a /= i;
      }
    }
  }

  if (a != 1)
    r.push_back(make_pair(a,1));

  return r;
}

vector<int> get_primes_linear(int n_max)
{
  int N = n_max;
  vector<int> pr;
  vector<int> lp(N+1,0);
  for (int i=2; i<=N; ++i) {
    if (lp[i] == 0) {
      lp[i] = i;
      pr.push_back (i);
    }
    for (int j=0; j<(int)pr.size() && pr[j]<=lp[i] && i*pr[j]<=N; ++j)
      lp[i * pr[j]] = pr[j];
  }
  return pr;
}

//int main()
//{
//  istream& is = input();
//  ostream& os = output();
//
//  primes = get_primes_linear(1000000);
//
//  int n;
//  is >> n;
//  vector<ll> a(n);
//
//  map<ll,vector<int>> div;
//  vector<pair<ll, int>> long_divs;
//  FOR (i,0,n)
//  {
//    is >> a[i];
//    vector<pair<ll, int>> ps=get_primes(a[i]);
//    if (ps.back().first>primes.back())
//    {
//      ll v=ps.back().first;
//      ll vsqrt=ll(sqrt((long double)v)+1e-6);
//      if (sqr(vsqrt)==v)
//        long_divs.push_back(make_pair(vsqrt,2));
//      else
//        long_divs.push_back(make_pair(v,1));
//      ps.pop_back();
//    }
//    FOR_EACH(it,ps)
//    {
//      div[it->first].push_back(it->second);
//      //if (div.find(it->first)==div.end())
//      //  div[it->first]=it->second;
//      //else
//      //  div[it->first]=min(it->second,div[it->first]);
//    }
//  }
//
//  FOR_EACH(it,div)
//  {
//    if (it->second.size()<n-1)
//      continue;
//    if (it->second.size()==n-1)
//    {
//      os<<it->first;
//      return 0;
//    }
//    
//    vector<int>& a= it->second;
//    int mina=a[0];
//    int minat=0;
//    FOR_EACH(it,a)
//    {
//      if (*it<mina)
//      {
//        mina=*it;
//        minat=1;
//      }
//      else if (*it==mina)
//        ++minat;
//    }
//    if (minat==1)
//    {
//      ll res=it->first;
//      FOR (i,0,mina)
//        res*=it->first;
//      os<<res;
//      return 0;
//    }
//  }
//
//  if (long_divs.size()>=n-1)
//  {
//    sort(ALL(long_divs));
//
//  }
//
//  //int res = 0;
//  //os << res;
//  //os << "\n";
//  srand(time(nullptr));
//  os<<a[rand()%a.size()];
//
//  return 0;
//}

//////////////////////////////////////////////////////////////////////////

int main()
{
  istream& is = input();
  ostream& os = output();

  int n,a,b,q;
  is >> n>>a>>b>>q;
  vector<int> c(n);
  FOR (i,0,n)
    is >> c[i];
  FOR (qq,0,q)
  {
    int q,l,r;
    is>>q>>l>>r;
    if (q==1)
    {
      c[l]=r;
    }
    else
    {
      //polynomial division
      int mod=1e9+7;
      double rest=0;
      bool ok=true;
      FOR (i,l,r+1)
      {
        //if((c[i]+rest)%b==0)
        {
          double d=(c[i]+rest)/b;
          rest=-a*d;
        }
        //else
        //{
        //  ok=false;
        //  break;
        //}
      }
      os<< (ok&&abs(rest)<1e-8?"Yes":"No")<<"\n";
    }
  }

  //int res = 0;
  //os << res;
  //os << "\n";

  return 0;
}

//////////////////////////////////////////////////////////////////////////

//int main()
//{
//  istream& is = input();
//  ostream& os = output();
//
//  int n;
//  is >> n;
//  vector<int> a(n);
//  FOR (i,0,n)
//    is >> a[i];
//
//  //int res = 0;
//  //os << res;
//  //os << "\n";
//
//  return 0;
//}