#pragma GCC optimize("Ofast,unroll-loops")
#include <bits/stdc++.h>
using namespace std;

#ifdef WAIMAI
#define debug(HEHE...) cout<<"["<<#HEHE<<"] : ",dout(HEHE)
void dout(){cout<<'\n';}
template<typename T,typename...U>
void dout(T t,U...u){cout<<t<<(sizeof...(u)?", ":""),dout(u...);}
#else
#define debug(...) 7122
#endif

#define int long long
#define ll long long
#define Waimai ios::sync_with_stdio(false),cin.tie(0)
#define FOR(x,a,b) for(int x=a,I=b;x<=I;x++)
#define pb emplace_back
#define F first
#define S second

#define lpos pos*2
#define rpos pos*2+1

const int INF = 1e9;
const int SIZE = 1e5 + 5;

int n, q;
int a[SIZE];

struct ds {
    int len = 1, s1 = 0, s2 = 0;
    int lz1 = INF, lz2 = 0;
    ds operator + (const ds &x) const {
        ds re;
        re.len = len + x.len;
        re.s1 = s1 + x.s1;
        re.s2 = s2 + len * x.s1 + x.s2;
        return re;
    }
} node[4 * SIZE];

void Push (int pos, int l, int r) {
    auto &[len, s1, s2, lz1, lz2] = node[pos];
    if (lz1 != INF) {
        s1 = (r - l + 1) * lz1;
        s2 = (r - l + 1) * (r - l + 2) / 2 * lz1;
    }
    s1 += lz2 * (r - l + 1);
    s2 += (r - l + 1) * (r - l + 2) / 2 * lz2;
    if (l < r) {
        ds &nl = node[lpos], &nr = node[rpos];
        if (lz1 != INF) {
            nl.lz1 = nr.lz1 = lz1;
            nl.lz2 = nr.lz2 = 0;
        }
        nl.lz2 += lz2, nr.lz2 += lz2;
    }
    lz1 = INF, lz2 = 0;
}

void Pull (int pos, int l, int r) {
    int mid = (l + r) / 2;
    Push (lpos, l, mid);
    Push (rpos, mid + 1, r);
    node[pos] = node[lpos] + node[rpos];
}

void build (int pos, int l, int r) {
    if (l == r) {
        node[pos].s1 = node[pos].s2 = a[l];
        return;
    }
    int mid = (l + r) / 2;
    build (lpos, l, mid);
    build (rpos, mid + 1, r);
    Pull (pos, l, r);
}

void upd (int pos, int l, int r, int L, int R, int ty, int x) {
    Push (pos, L, R);
    if (l == L && r == R) {
        if (ty == 1) {
            node[pos].lz2 += x;
        } else {
            node[pos].lz1 = x;
            node[pos].lz2 = 0;
        }
        return;
    }
    int mid = (L + R) / 2;
    if (r <= mid) upd (lpos, l, r, L, mid, ty, x);
    else if (l > mid) upd (rpos, l, r, mid + 1, R, ty, x);
    else {
        upd (lpos, l, mid, L, mid, ty, x);
        upd (rpos, mid + 1, r, mid + 1, R, ty, x);
    }
    Pull (pos, L, R);
}

ds que (int pos, int l, int r, int L, int R) {
    Push (pos, L, R);
    if (l == L && r == R) return node[pos];
    int mid = (L + R) / 2;
    if (r <= mid) return que (lpos, l, r, L, mid);
    if (l > mid) return que (rpos, l, r, mid + 1, R);
    return que (lpos, l, mid, L, mid) + que (rpos, mid + 1, r, mid + 1, R);
}

void solve() {
    cin >> n >> q;
    FOR (i, 1, n) cin >> a[i];
    build (1, 1, n);
    while (q--) {
        int t, l, r, x;
        cin >> t >> l >> r;
        if (t <= 2) {
            cin >> x;
            upd (1, l, r, 1, n, t, x);
        } else {
            ds ans = que (1, l, r, 1, n);
            int s1 = ans.s1, s2 = ans.s2;
            if (s1 == 0 && s2 == 0) {
                cout << "Yes\n";
            } else if (s1 == 0 || s2 % s1 != 0) {
                cout << "No\n";
            } else {
                int x = s2 / s1;
                if (1 <= x && x <= r - l + 1) cout << "Yes\n";
                else cout << "No\n";
            }
        }
    }
}

int32_t main() {
    Waimai;
    int tt = 1;
    //cin >> tt;
    while (tt--) solve();
}