#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const long long P = 131;
const long long M = 1e9 + 7;
long long deg[maxn];
long long sum[maxn];
long long binpow(long long a, long long n) {
  if (n == 0) return 1;
  long long r = binpow(a, n >> 1);
  (r *= r) %= M;
  if (n & 1) {
    (r *= a) %= M;
  }
  return r;
}
long long bindiv(long long a, long long b) {
  return (a * binpow(b, M - 2)) % M;
}
void init() {
  deg[0] = 1;
  sum[0] = 0;
  sum[1] = 1;
  for (int i = 1; i < maxn; ++i) {
    deg[i] = (deg[i - 1] * P) % M;
    sum[i + 1] = (deg[i] + sum[i]) % M;
  }
}
int code(char c) { return (c - '0') + 1; }
class segm_tree_t {
  long long t[4 * maxn];
  int p[4 * maxn];
  int n;
  void build(int v, int tl, int tr, const char *s) {
    if (tl == tr) {
      t[v] = code(s[tl]);
      return;
    }
    int tm = (tl + tr) / 2;
    build(2 * v + 1, tl, tm, s);
    build(2 * v + 2, tm + 1, tr, s);
    t[v] = (((t[2 * v + 1] * deg[tr - (tm + 1) + 1]) % M) + t[2 * v + 2]) % M;
  }
  void push(int v, int tl, int tr) {
    if (p[v]) {
      long long len = tr - tl + 1;
      t[v] = (p[v] * sum[len]) % M;
      if (tl != tr) {
        p[2 * v + 1] = p[2 * v + 2] = p[v];
      }
      p[v] = 0;
    }
  }
  void set(int v, int tl, int tr, int l, int r, int x) {
    push(v, tl, tr);
    if (l > r) return;
    if (l == tl && r == tr) {
      p[v] = x;
      push(v, tl, tr);
      return;
    }
    int tm = (tl + tr) / 2;
    set(2 * v + 1, tl, tm, l, min(r, tm), x);
    set(2 * v + 2, tm + 1, tr, max(l, tm + 1), r, x);
    t[v] = (((t[2 * v + 1] * deg[tr - (tm + 1) + 1]) % M) + t[2 * v + 2]) % M;
  }
  long long hash(int v, int tl, int tr, int l, int r) {
    push(v, tl, tr);
    if (l > r) return 0;
    if (l == tl && r == tr) {
      return t[v];
    }
    int tm = (tl + tr) / 2;
    long long h1 = hash(2 * v + 1, tl, tm, l, min(r, tm));
    long long h2 = hash(2 * v + 2, tm + 1, tr, max(l, tm + 1), r);
    if (tl <= l && r <= tm) return h1;
    if (tm + 1 <= l && r <= tr) return h2;
    int rlen = r - max(tm + 1, l) + 1;
    return (((h1 * deg[rlen]) % M) + h2) % M;
  }

 public:
  segm_tree_t(int n, const char *s) : n(n) {
    memset(p, 0, sizeof(p));
    build(0, 0, n - 1, s);
  }
  void set(int l, int r, int x) { set(0, 0, n - 1, l, r, x); }
  long long hash(int l, int r) { return hash(0, 0, n - 1, l, r); }
  bool check(int l, int r, int period) {
    long long len = r - l + 1;
    if (period > len) {
      return false;
    }
    long long h = hash(l, l + period - 1);
    long long cnt = len / period;
    h = h * bindiv((binpow(deg[period], cnt) - 1 + M) % M,
                   (deg[period] - 1 + M) % M);
    h %= M;
    long long md = len % period;
    if (md) {
      h = ((h * deg[md]) % M) + hash(l, l + md - 1);
      h %= M;
    }
    return h == hash(l, r);
  }
};
char str[maxn];
int n, m, k;
int main() {
  init();
  scanf("%d %d %d %s", &n, &m, &k, str);
  segm_tree_t st(n, str);
  for (int i = 0; i < m + k; ++i) {
    int t, l, r, x;
    scanf("%d %d %d %d", &t, &l, &r, &x);
    --l, --r;
    if (t == 1) {
      st.set(l, r, code(x + '0'));
    } else {
      puts(st.check(l, r, x) ? "YES" : "NO");
    }
  }
  return 0;
}
