#include <bits/stdc++.h>
#define rep(i,a,b) for (ll i = (a); i <= (b); ++i)
#define per(i,a,b) for (ll i = (b); i >= (a); --i)
#define all(x) begin(x),end(x)
#define siz(x) int(size(x))
#define fi first
#define se second
using namespace std;
using ll = long long;
using vi = vector<ll>;
using ii = pair<ll,ll>;

const ll N = 1e5+3, Q = N;
ll n, q;
multiset<ll> v[N+Q];
array<ll,3> query[Q];
const ll INF = 1e9;

struct node {
    ll mn, mx;
    ll nxtmn;
    ll diff_g;
    node(): mn(INF), mx(-INF), nxtmn(INF), diff_g(0) {}
    node(ll x, ll y, ll d): mn(x), mx(x), nxtmn(y), diff_g(d) {}
    node operator + (const node &rhs) const {
        node res;
        res.mn = min(mn,rhs.mn);
        res.mx = max(mx,rhs.mx);
        res.nxtmn = min(nxtmn,rhs.nxtmn);
        res.diff_g = gcd(diff_g,rhs.diff_g);
        return res;
    }
} t[2*N]{};

void upd(ll k, node x) {
    k += N;
    for (t[k]=x; (k/=2)>=1;) {
        t[k] = t[2*k] + t[2*k+1];
    }
}

node qry(ll l, ll r) {
    node res;
    for (l+=N,r+=N; l<=r; ++l/=2,--r/=2) {
        if (l&1) res = res+t[l];
        if (~r&1) res = res+t[r];
    }
    return res;
}

ll a[N];
vi vals;

ll nxt(ll x, ll y) { // a[i]=x이면서 y<i인 i의 최솟값
    ll X = lower_bound(all(vals), x) - begin(vals);
    assert(vals[X] == x);
    
    auto it = v[X].upper_bound(y);
    if (it == end(v[X])) return N;
    return *it;
}

void init(ll x, ll y) { // a[x]:=y
    a[x] = y;
    node res(y, nxt(y, x), a[x+1]-a[x]);
    upd(x, res);
    
    ll Y = lower_bound(all(vals), y) - begin(vals);
    assert(vals[Y] == y);
    
    v[Y].insert(x);
}

void update(ll x, ll y) { // a[x]<-y
    ll py = a[x], ny = y;
    
    // delete
    ll PY = lower_bound(all(vals), py) - begin(vals);
    assert(vals[PY] == py);
    
    auto it = v[PY].find(x);
    assert(it != end(v[PY]));
    
    if (it != begin(v[PY])) {
        ll i = *prev(it);
        upd(i, {a[i], next(it) != end(v[PY]) ? *next(it) : N, a[i+1]-a[i]});
    }
    
    v[PY].erase(x);
    
    // add
    ll NY = lower_bound(all(vals), ny) - begin(vals);
    assert(vals[NY] == ny);
    
    v[NY].insert(x);
    a[x] = y;
    
    it = v[NY].find(x);
    assert(it != end(v[PY]));
    
    if (it != begin(v[NY])) {
        ll i = *prev(it);
        upd(i, {a[i], x, a[i+1]-a[i]});
    }
    
    upd(x, {a[x], next(it) != end(v[NY]) ? *next(it) : N, a[x+1]-a[x]});
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    cin >> n >> q;
    rep(i,1,n) cin >> a[i], vals.push_back(a[i]);
    rep(i,1,q) {
        auto &[x,b,c] = query[i];
        cin >> x >> b >> c;
        if (x == 1) vals.push_back(c);
    }
    sort(all(vals)), vals.erase(unique(all(vals)), end(vals));
    per(i,1,n) init(i, a[i]);
    
    rep(i,1,q) {
        auto [x,b,c] = query[i];
        if (x==1) update(b, c);
        else {
            auto [mn,mx,nmn,dg] = qry(b, c);
            if (c-b<=1) cout << "YES\n";
            else if (nmn <= c) assert(nmn > b), cout << (mn==mx ? "YES\n" : "NO\n");
            else {
                assert(mn<mx);
                dg = qry(b, c-1).diff_g;
                ll len = c - b;
                if ((mx-mn)%len) {
                    cout << "NO\n";
                    continue;
                }
                if (dg!=((mx-mn)/len)) cout << "NO\n";
                else cout << "YES\n";
            }
        }
    }
}