#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 15;
const int HA = 2;
const int PP[] = {318255569, 259906247, 66604919, 19260817},
          QQ[] = {1010451419, 1011111133, 1021111159, 1033111117};
int pw[HA][N];
struct hashInit {
  hashInit() {
    for (int h = 0; h < HA; h++) {
      pw[h][0] = 1;
      for (int i = 1; i < N; i++)
        pw[h][i] = int((long long)pw[h][i - 1] * PP[h] % QQ[h]);
    }
  }
} __init_hash;
struct Hash {
  int v[HA], len;
  Hash() {
    memset(v, 0, sizeof v);
    len = 0;
  }
  Hash(int first) {
    for (int h = 0; h < HA; h++) v[h] = first;
    len = 1;
  }
  friend Hash operator+(const Hash &a, const Hash &b) {
    Hash ret;
    ret.len = a.len + b.len;
    for (int h = 0; h < HA; h++)
      ret.v[h] = int(((long long)a.v[h] * pw[h][b.len] + b.v[h]) % QQ[h]);
    return ret;
  }
  friend Hash operator+(const Hash &a, const int &b) {
    Hash ret;
    ret.len = a.len + 1;
    for (int h = 0; h < HA; h++)
      ret.v[h] = int(((long long)a.v[h] * PP[h] + b) % QQ[h]);
    return ret;
  }
  friend Hash operator+(const int &a, const Hash &b) {
    Hash ret;
    ret.len = b.len + 1;
    for (int h = 0; h < HA; h++)
      ret.v[h] = int(((long long)a * pw[h][b.len] + b.v[h]) % QQ[h]);
    return ret;
  }
  friend Hash operator-(const Hash &a, const Hash &b) {
    Hash ret;
    ret.len = a.len - b.len;
    for (int h = 0; h < HA; h++) {
      ret.v[h] = int((a.v[h] - (long long)pw[h][b.len] * b.v[h]) % QQ[h]);
      if (ret.v[h] < 0) ret.v[h] += QQ[h];
    }
    return ret;
  }
  friend bool operator==(const Hash &a, const Hash &b) {
    for (int h = 0; h < HA; h++)
      if (a.v[h] != b.v[h]) return false;
    return a.len == b.len;
  }
};
char a[N];
template <class V>
class Tree {
  struct Node {
    int l, r;
    V v;
  } t[N * 2];
  int tcnt, L, R;
  int build(int l, int r) {
    int first = ++tcnt;
    if (l < r) {
      int mid = (l + r) / 2;
      t[first].l = build(l, mid);
      t[first].r = build(mid + 1, r);
      t[first].v = t[t[first].l].v + t[t[first].r].v;
    } else {
      t[first].l = t[first].r = 0;
      if (a[l] == '1')
        t[first].v = V(Hash(), Hash());
      else
        t[first].v = V(Hash(l % 2 + 1), Hash((l + 1) % 2 + 1));
    }
    return first;
  }
  V qry(int first, int l, int r, int ql, int qr) {
    if (l == ql && r == qr) return t[first].v;
    int mid = (l + r) / 2;
    if (qr <= mid) return qry(t[first].l, l, mid, ql, qr);
    if (ql > mid) return qry(t[first].r, mid + 1, r, ql, qr);
    return qry(t[first].l, l, mid, ql, mid) +
           qry(t[first].r, mid + 1, r, mid + 1, qr);
  }

 public:
  Tree() {}
  void init(int l, int r) {
    L = l, R = r;
    tcnt = 0;
    build(l, r);
  }
  inline V qry(int l, int r) { return qry(1, L, R, l, r); }
};
struct V {
  Hash a, b;
  V() {}
  V(Hash first, Hash second) { a = first, b = second; }
  friend V operator+(const V &c, const V &d) { return V(c.a + d.a, c.b + d.b); }
};
int n, Q;
Tree<V> t;
int main() {
  scanf("%d", &n);
  scanf("%s", a + 1);
  t.init(1, n);
  scanf("%d", &Q);
  for (int i = 1; i <= Q; i++) {
    int l, r, len;
    scanf("%d", &l);
    scanf("%d", &r);
    scanf("%d", &len);
    V a1 = t.qry(l, l + len - 1);
    V a2 = t.qry(r, r + len - 1);
    puts((l & 1 ? a1.a : a1.b) == (r & 1 ? a2.a : a2.b) ? "YES" : "NO");
  }
}
