import std.algorithm, std.conv, std.range, std.stdio, std.string;
import std.bitmanip;  // BitArray
import std.container;

void main()
{
  auto n = readln.chomp.to!size_t;
  auto di = readln.split.to!(int[]);
  auto wi = readln.split.to!(int[]).to!(bool[]);

  auto aij = new bool[][](n + 1, n);
  foreach (i; n.iota) {
    auto d1 = (i.to!int + di[i]) % n;
    auto d2 = ((i.to!int - di[i]) % n + n) % n;
    aij[i][d1] = aij[i][d2] = true;
  }
  aij[n][] = (wi.map!"!a".array)[];

  auto bi = transposedBitArray(aij, n);

  foreach (i; n.iota) {
    if (!bi[i][i]) {
      auto j = bi[i+1..$].countUntil!(b => b[i]);
      if (j != -1) swap(bi[i], bi[i + j]);
    }
    if (bi[i][i])
      foreach (ref b; bi[i+1..$])
        if (b[i]) b ^= bi[i];
  }

  writeln(hasSolution(bi, n) ? "Yes" : "No");
}

auto transposedBitArray(bool[][] aij, size_t n)
{
  auto bi = new BitArray[](n);
  auto i = size_t(0);
  foreach (ai; aij.transposed)
    bi[i++] = BitArray(ai.array);
  return bi;
}

auto hasSolution(BitArray[] bi, size_t n)
{
  foreach (i, b; bi)
    if (!b[i] && b[n]) return false;
  return true;
}