#include <bits/stdc++.h>
using namespace std;
template <class node>
struct segment_tree {
  using node_container = decltype(node().nod);

 private:
  template <typename RAIter>
  void build(int x, int b, int e, const RAIter &a) {
    if (b + 1 == e) {
      st[x].nod.build(a[b]);
      return;
    }
    int m = (b + e) >> 1;
    int y = x + ((m - b) << 1);
    build(x + 1, b, m, a);
    build(y, m, e, a);
    st[x].nod = st[x + 1].nod + st[y].nod;
  }
  node_container query(int x, int b, int e) {
    if (lo <= b && e <= hi) return st[x].nod;
    int m = (b + e) >> 1;
    int y = x + ((m - b) << 1);
    if (m >= hi) return query(x + 1, b, m);
    if (m <= lo) return query(y, m, e);
    return query(x + 1, b, m) + query(y, m, e);
  }
  int n, lo, hi;
  vector<node> st;

 public:
  template <typename RAIter>
  void build(const RAIter &a) {
    build(0, 0, n, a);
  }
  node_container query(int l, int r) { return lo = l, hi = r, query(0, 0, n); }
  segment_tree(int n) : n(n), st(2 * n - 1) {}
};
const int N = 2e5 + 5;
int Pow(int a, int b, int mod) {
  int x = 1;
  for (; b > 0; b >>= 1) {
    if (b & 1) x = (long long)x * a % mod;
    a = (long long)a * a % mod;
  }
  return x;
}
namespace _hash {
const int d = 5;
const int mod[] = {(int)1e9 + 7, (int)1e9 + 9, 1003193101, 1003173439,
                   961760309};
const int b[] = {2, 3, 5, 17, 101};
int p[d][N], ip[d];
void init() {
  for (int i = 0; i < d; ++i) {
    ip[i] = Pow(b[i], mod[i] - 2, mod[i]);
    p[i][0] = 1;
    for (int j = 1; j < N; ++j)
      p[i][j] = (long long)p[i][j - 1] * b[i] % mod[i];
  }
}
};  // namespace _hash
inline void add(int &x, int y, int mod) {
  x += y;
  if (x >= mod) x -= mod;
}
struct node {
  struct node_container {
    array<int, _hash::d> h;
    int len;
    bool b, e;
    template <typename T>
    inline void build(const T &a) {
      if (a == '1') {
        len = 1, b = e = 1;
        for (int i = 0; i < _hash::d; ++i) h[i] = _hash::p[i][0];
      } else {
        len = 1, b = e = 0;
        for (int i = 0; i < _hash::d; ++i) h[i] = 0;
      }
    }
    friend node_container operator+(node_container l, node_container r) {
      if (!l.len) return r;
      if (!r.len) return l;
      node_container x;
      if (l.e && r.b) {
        for (int i = 0; i < _hash::d; ++i) {
          add(l.h[i], _hash::mod[i] - _hash::p[i][l.len - 1], _hash::mod[i]);
          add(r.h[i], _hash::mod[i] - _hash::p[i][0], _hash::mod[i]);
          r.h[i] = (long long)r.h[i] * _hash::ip[i] % _hash::mod[i];
        }
        if (l.len == 1) l.b = 0;
        if (r.len == 1) r.e = 0;
        --l.len;
        --r.len;
      }
      for (int i = 0; i < _hash::d; ++i)
        x.h[i] =
            (l.h[i] + (long long)r.h[i] * _hash::p[i][l.len]) % _hash::mod[i];
      x.len = l.len + r.len;
      x.b = l.b;
      x.e = r.e;
      return x;
    }
  } nod;
};
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  _hash::init();
  int n;
  string s;
  cin >> n >> s;
  segment_tree<node> st(n);
  st.build(s.begin());
  int q;
  cin >> q;
  for (int i, j, l; q--;) {
    cin >> i >> j >> l;
    --i, --j;
    auto n1 = st.query(i, i + l), n2 = st.query(j, j + l);
    bool ok = n1.len == n2.len;
    for (int i = 0; i < _hash::d; ++i) ok &= n1.h[i] == n2.h[i];
    if (ok)
      cout << "Yes\n";
    else
      cout << "No\n";
  }
  return 0;
}
