#include<cstdio>

#include<algorithm>

#define int long long

#define LL long long

#define ull long long

using namespace std;

const int MAXN = 1e6 + ;

const double eps = 1e-;

inline int read() {

    char c = getchar(); int x = , f = ;

    while(c < '' || c > '') {if(c == '-') f = -; c = getchar();}

    while(c >= '' && c <= '') x = x *  + c - '', c = getchar();

    return x * f;

}

int N, M, K;

char s[MAXN];

struct Segment {

    ull sum[MAXN], po[MAXN], seed, mod;

    #define ls k << 1

    #define rs k << 1 | 1

    struct Node {

        int l, r, siz;

        ull ha, f;

    }T[MAXN];

    void update(int k) {

        T[k].ha = (T[ls].ha % mod + po[T[ls].siz] * T[rs].ha % mod) % mod;

    }

    void ps(int k, int son) {

        T[son].f = T[k].f;

        T[son].ha = sum[T[son].siz - ] * T[son].f % mod;

    }

    void pushdown(int k) {

        if(T[k].f == -) return ;

        ps(k, ls); ps(k, rs);

        T[k].f = -;

    }

    void Build(int k, int ll, int rr) {

        T[k] = (Node) {ll, rr, rr - ll + , , -};

        if(ll == rr) {

            T[k].ha = s[ll] - '';

            return ;

        }

        int mid = T[k].l + T[k].r >> ;

        Build(ls, ll, mid); Build(rs, mid + , rr);

        update(k);

    }

    void IntervalChange(int k, int ll, int rr, ull val) {

        if(ll <= T[k].l && T[k].r <= rr) {

            T[k].f = val % mod;

            T[k].ha = sum[T[k].siz - ] * val % mod;

            return ;

        }

        pushdown(k);

        int mid = T[k].l + T[k].r >> ;

        if(ll <= mid) IntervalChange(ls, ll, rr, val);

        if(rr >  mid) IntervalChange(rs, ll, rr, val);

        update(k);

    }

    ull IntervalQuery(int k, int ll, int rr) {

        if(ll > rr) return ;

        if(ll <= T[k].l && T[k].r <= rr) return T[k].ha % mod;

        pushdown(k);

        int mid = T[k].l + T[k].r >> ;

        if(ll > mid) return IntervalQuery(rs, ll, rr) % mod;

        else if(rr <= mid) return IntervalQuery(ls, ll, rr) % mod;

        else return (IntervalQuery(ls, ll, rr) % mod + po[mid - max(T[k].l, ll) + ] * IntervalQuery(rs, ll, rr) % mod) % mod;

    }

    void work() {

        po[] = ; sum[] = ;

        for(int i = ; i <= N; i++) po[i] = po[i - ] * seed % mod, sum[i] = (sum[i - ] + po[i]) % mod;

        Build(, , N);

    }

    int Query(int l, int r, int k) {

        return IntervalQuery(, l, r - k) == IntervalQuery(, l + k, r);

    }

}Se[];

main() {

    Se[].seed = ; Se[].mod = 1e9 + ;

    Se[].seed = ; Se[].mod = 1e9 + ;

    N = read(); M = read(); K = read();

    scanf("%s", s + );

    Se[].work(); Se[].work();

    for(int i = ; i <= M + K; i++) {

        int opt = read(), l = read(), r  = read(), k = read();

        if(opt == ) Se[].IntervalChange(, l, r, k), Se[].IntervalChange(, l, r, k);

        else {

            if((r - l + ) == k) {

                puts("YES");

                continue;

            }

            puts((Se[].Query(l, r, k) && Se[].Query(l, r, k))? "YES" : "NO");

        }

    }

    return ;

}