#include <bits/stdc++.h>
using namespace std;
const int hashmodcnt = 2;
const int mod = 1000000007;
;
const int maxn = 800010;
unsigned long long powmod(unsigned long long n, unsigned long long k) {
  unsigned long long ret = 1;
  while (k) {
    if (k & 1) ret = ret * n % mod;
    n = n * n % mod;
    k >>= 1;
  }
  return ret;
}
unsigned long long hashmi[hashmodcnt][maxn];
unsigned long long hashseed[hashmodcnt];
unsigned long long hashmod[hashmodcnt];
unsigned long long validseed[20] = {
    10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093,
    10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169};
bool _isprime(int n) {
  if (n % 2 == 0) return false;
  for (int i = 3; i * i <= n; i += 2)
    if (n % i == 0) return false;
  return true;
}
void InitTemplate() {
  srand(time(0));
  for (int i = 0; i < hashmodcnt; i++) {
    hashseed[i] = validseed[rand() % 20];
    while (true) {
      int tmp = rand() % 1000000 + 1e9;
      if (_isprime(tmp)) {
        hashmod[i] = tmp;
        break;
      }
    }
    hashmi[i][0] = 1;
    for (int j = 1; j < maxn; j++)
      hashmi[i][j] = hashmi[i][j - 1] * hashseed[i] % hashmod[i];
  }
}
struct Hash {
  Hash() {
    memset(val, 0, sizeof(val));
    len = 0;
  }
  Hash(unsigned long long v) {
    len = 1;
    for (int i = 0; i < hashmodcnt; i++) val[i] = v % hashmod[i];
  }
  void merge(const Hash& lc, const Hash& rc) {
    len = lc.len + rc.len;
    for (int i = 0; i < hashmodcnt; i++) {
      if (rc.len == 0)
        val[i] = lc.val[i];
      else
        val[i] = (lc.val[i] * hashmi[i][rc.len] + rc.val[i]) % hashmod[i];
    }
  }
  Hash append(unsigned long long v) const {
    Hash ret(*this);
    ret.len++;
    for (int i = 0; i < hashmodcnt; i++)
      ret.val[i] = (ret.val[i] * hashseed[i] + v) % hashmod[i];
    return ret;
  }
  Hash update(unsigned long long v) const { return append(v); }
  Hash upd(unsigned long long v) const { return append(v); }
  Hash operator+(const Hash& obj) const {
    Hash ret;
    ret.merge(*this, obj);
    return ret;
  }
  Hash operator-(const Hash& obj) const {
    Hash ret(*this);
    ret.len -= obj.len;
    for (int i = 0; i < hashmodcnt; i++)
      ret.val[i] = (ret.val[i] - obj.val[i] * hashmi[i][ret.len] % hashmod[i] +
                    hashmod[i]) %
                   hashmod[i];
    return ret;
  }
  bool operator==(const Hash& obj) const {
    if (len != obj.len) return false;
    for (int i = 0; i < hashmodcnt; i++)
      if (val[i] - obj.val[i]) return false;
    return true;
  }
  int len;
  unsigned long long val[hashmodcnt];
};
struct StaticClass {
  StaticClass() { InitTemplate(); }
};
static StaticClass _nonsence;
int lft[maxn], rht[maxn];
char str[maxn];
Hash hhash[2][maxn];
void build(int n, int l, int r) {
  lft[n] = l, rht[n] = r;
  if (l == r) {
    if (str[l - 1] == '0') {
      hhash[0][n] = Hash(3 + l % 2);
      hhash[1][n] = Hash(4 - l % 2);
    }
    return;
  }
  int mid = (l + r) / 2;
  build(n * 2, l, mid);
  build(n * 2 + 1, mid + 1, r);
  hhash[0][n].merge(hhash[0][n * 2], hhash[0][n * 2 + 1]);
  hhash[1][n].merge(hhash[1][n * 2], hhash[1][n * 2 + 1]);
}
void get(int n, int l, int r, Hash& ret, int idx) {
  if (lft[n] == l && rht[n] == r) {
    ret = hhash[idx][n];
    return;
  }
  int mid = (lft[n] + rht[n]) / 2;
  if (r <= mid)
    get(n * 2, l, r, ret, idx);
  else if (l > mid)
    get(n * 2 + 1, l, r, ret, idx);
  else {
    Hash lc, rc;
    get(n * 2, l, mid, lc, idx);
    get(n * 2 + 1, mid + 1, r, rc, idx);
    ret.merge(lc, rc);
  }
}
void getvec(int p, int len, int n, vector<int>& vec) {
  for (int i = p; i <= n && i <= p + len - 1; i++)
    if (str[i - 1] == '0') vec.push_back((i - p) % 2);
}
int main() {
  int n;
  scanf("%d", &n);
  scanf("%s", str);
  build(1, 1, n);
  int q;
  int idx = 0;
  scanf("%d", &q);
  vector<int> ans;
  while (q--) {
    idx++;
    int p1, p2, len;
    scanf("%d%d%d", &p1, &p2, &len);
    Hash h1, h2;
    get(1, p1, p1 + len - 1, h1, 0);
    get(1, p2, p2 + len - 1, h2, p1 % 2 == p2 % 2 ? 0 : 1);
    if (h1 == h2)
      ans.push_back(1);
    else
      ans.push_back(0);
  }
  for (int i = 0; i < ans.size(); i++)
    if (ans[i])
      puts("Yes");
    else
      puts("No");
}
