#include <bits/stdc++.h>
typedef struct {
  int l, r;
  unsigned long long hash;
  bool lazy;
  int lazy_value;
} node_t;
node_t tree[(1 << 20)];
char initial_string[(1 << 20) / 2 + 1];
unsigned long long memo[(1 << 20)] = {};
unsigned long long ullpow(unsigned long long base, unsigned long long exp) {
  if (!memo[exp]) {
    if (exp == 0) {
      memo[exp] = 1;
    } else {
      unsigned long long v = ullpow(base, exp / 2);
      memo[exp] = v * v * (exp % 2 == 1 ? base : 1);
      memo[exp] %= 35408267LLU;
    }
  }
  return memo[exp];
}
unsigned long long hmemo[(1 << 20)] = {};
unsigned long long lazy_hash_r(int length) {
  if (!hmemo[length]) {
    long long v;
    long long rl;
    if (length == 1) {
      hmemo[length] = 1;
    } else {
      rl = (length + 1) / 2;
      v = ullpow(9001LLU, rl) + 1;
      v *= lazy_hash_r(rl);
      if (length % 2 == 1) {
        v -= ullpow(9001LLU, length);
      }
      hmemo[length] = v;
      hmemo[length] %= 35408267LLU;
    }
  }
  return hmemo[length];
}
unsigned long long lazy_hash(int d, int length) {
  return (lazy_hash_r(length) * d) % 35408267LLU;
}
void init(int index, int l, int r) {
  node_t *node = &tree[index];
  int left_index = 2 * index + 1;
  int right_index = 2 * index + 2;
  node_t *left = &tree[left_index];
  node_t *right = &tree[right_index];
  node->lazy = false;
  assert(l <= r);
  node->l = l;
  node->r = r;
  if (l < r) {
    int m = (l + r) / 2;
    init(left_index, l, m);
    init(right_index, m + 1, r);
    node->hash =
        (left->hash + ullpow(9001LLU, left->r - left->l + 1) * right->hash) %
        35408267LLU;
  } else {
    node->hash = (initial_string[l] - '0');
  }
}
void update_children_lazy(int index) {
  node_t *node = &tree[index];
  int left_index = 2 * index + 1;
  int right_index = 2 * index + 2;
  node_t *left = &tree[left_index];
  node_t *right = &tree[right_index];
  if (node->lazy && node->l < node->r) {
    left->lazy = true;
    left->lazy_value = node->lazy_value;
    left->hash = lazy_hash(left->lazy_value, left->r - left->l + 1);
    right->lazy = true;
    right->lazy_value = node->lazy_value;
    right->hash = lazy_hash(right->lazy_value, right->r - right->l + 1);
    node->lazy = false;
  }
}
unsigned long long query(int index, int l, int r) {
  node_t *node = &tree[index];
  int left_index = 2 * index + 1;
  int right_index = 2 * index + 2;
  node_t *left = &tree[left_index];
  node_t *right = &tree[right_index];
  assert(node->l <= l && l <= r && r <= node->r);
  if (l == node->l && r == node->r) {
    return node->hash;
  } else {
    update_children_lazy(index);
    if (r <= left->r) {
      return query(left_index, l, r);
    } else if (l >= right->l) {
      return query(right_index, l, r);
    } else {
      return (query(left_index, l, left->r) +
              ullpow(9001LLU, left->r - l + 1) *
                  query(right_index, right->l, r)) %
             35408267LLU;
    }
  }
}
void update(int index, int l, int r, int v) {
  node_t *node = &tree[index];
  int left_index = 2 * index + 1;
  int right_index = 2 * index + 2;
  node_t *left = &tree[left_index];
  node_t *right = &tree[right_index];
  assert(node->l <= l && l <= r && r <= node->r);
  if (l == node->l && r == node->r) {
    if (l == r) {
      node->hash = v;
    } else {
      node->lazy = true;
      node->lazy_value = v;
      node->hash = lazy_hash(v, node->r - node->l + 1);
    }
  } else {
    update_children_lazy(index);
    if (r <= left->r) {
      update(left_index, l, r, v);
    } else if (l >= right->l) {
      update(right_index, l, r, v);
    } else {
      update(left_index, l, left->r, v);
      update(right_index, right->l, r, v);
    }
    node->hash =
        (left->hash + ullpow(9001LLU, left->r - left->l + 1) * right->hash) %
        35408267LLU;
  }
}
int main(void) {
  int n, m, k;
  scanf("%d %d %d %s", &n, &m, &k, initial_string);
  init(0, 0, n - 1);
  m += k;
  while (m--) {
    int c, l, r, v;
    scanf("%d %d %d %d", &c, &l, &r, &v);
    l--;
    r--;
    if (c == 1) {
      update(0, l, r, v);
    } else {
      puts((l == r || v == (r - l + 1) ||
            query(0, l, r - v) == query(0, l + v, r))
               ? "YES"
               : "NO");
    }
  }
  return 0;
}
