#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Node {
  ll ones;
  int end, len;
  bool has_left_one;
  Node() : ones(0), end(0), len(0), has_left_one(0) {}
  Node(ll ones, int end, int len, bool has_left_one)
      : ones(ones), end(end), len(len), has_left_one(has_left_one) {}
  bool operator==(const Node &arg) const {
    return ones == arg.ones && end == arg.end && len == arg.len &&
           has_left_one == arg.has_left_one;
  }
};
struct SegmentTree {
  const int BASE = 2;
  const int MOD = 1e9 + 7;
  int n;
  vector<int> pows;
  vector<Node> tree;
  SegmentTree(const string &s) : n(s.size()), tree(4 * n), pows(n + 1) {
    pows[0] = 1;
    for (int i = 1; i <= n; ++i) {
      pows[i] = pows[i - 1] * BASE % MOD;
    }
    build(s, 1, 0, n - 1);
  }
  Node combine(Node a, Node b) {
    auto left = a.ones;
    auto right = b.ones;
    int shift = a.end;
    if (b.end == b.len) {
      left = left * pows[b.len] % MOD;
      return Node(left, a.end + b.end, a.len + b.len, a.has_left_one);
    }
    bool left_one = a.has_left_one;
    if (b.has_left_one) {
      if (a.end % 2) {
        right = (MOD + right - pows[b.len - 1]) % MOD;
        shift++;
      } else if (a.end == a.len) {
        left_one = true;
      }
    } else {
      if (a.end % 2) {
        left = (left + pows[a.end - 1]) % MOD;
        --shift;
        if (a.end == a.len) {
          left_one = true;
        }
      }
    }
    left = left * pows[b.len] % MOD;
    right = right * pows[shift] % MOD;
    Node c;
    c.len = a.len + b.len;
    c.has_left_one = left_one;
    c.end = b.end + shift;
    c.ones = (left + right) % MOD;
    return c;
  }
  void build(const string &s, int tv, int tl, int tr) {
    if (tl == tr) {
      tree[tv] = Node(0, s[tr] == '1', 1, 0);
    } else {
      int tm = (tl + tr) / 2;
      build(s, 2 * tv, tl, tm);
      build(s, 2 * tv + 1, tm + 1, tr);
      tree[tv] = combine(tree[2 * tv], tree[2 * tv + 1]);
    }
  }
  Node getval(int l, int r) { return getval(l, r, 1, 0, n - 1); }
  Node getval(int l, int r, int tv, int tl, int tr) {
    if (l <= tl && tr <= r) {
      return tree[tv];
    }
    if (tr < l || r < tl) {
      return Node();
    }
    int tm = (tl + tr) / 2;
    return combine(getval(l, r, 2 * tv, tl, tm),
                   getval(l, r, 2 * tv + 1, tm + 1, tr));
  }
};
vector<char> solve_fast(int n, const string &s, int q,
                        const vector<tuple<int, int, int>> &queries) {
  SegmentTree tree(s);
  vector<char> res;
  for (auto [l1, l2, len] : queries) {
    auto s1 = tree.getval(l1, l1 + len - 1);
    auto s2 = tree.getval(l2, l2 + len - 1);
    res.push_back(s1 == s2);
  }
  return res;
}
vector<char> solve_slow(int n, const string &s, int q,
                        const vector<tuple<int, int, int>> &queries) {
  auto sort_string = [](string &s) {
    int curlen = 0;
    for (int i = 0; i < s.size(); ++i) {
      if (curlen >= 2) {
        if (s[i] == '1') {
          ++curlen;
        } else {
          if (curlen % 2) {
            curlen--;
          }
          swap(s[i], s[i - curlen]);
        }
      } else {
        if (s[i] == '1') {
          ++curlen;
        } else {
          curlen = 0;
        }
      }
    }
  };
  vector<char> res;
  for (auto [l1, l2, len] : queries) {
    auto s1 = s.substr(l1, len);
    auto s2 = s.substr(l2, len);
    sort_string(s1);
    sort_string(s2);
    res.push_back(s1 == s2);
  }
  return res;
}
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n;
  while (cin >> n) {
    string s;
    cin >> s;
    int q;
    cin >> q;
    vector<tuple<int, int, int>> queries(q);
    for (auto &[l1, l2, len] : queries) {
      cin >> l1 >> l2 >> len;
      --l1, --l2;
    }
    auto res = solve_fast(n, s, q, queries);
    for (auto e : res) cout << (e ? "Yes" : "No") << "\n";
  }
}
