#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

constexpr int P = 998244353;

int norm(int x) {
  if (x < 0) x += P;
  if (x >= P) x -= P;
  return x;
}
template<class T>
T power(T base, i64 e) {
  T res = 1;
  for (; e > 0; base *= base, e /= 2) {
    if (e % 2 == 1) res *= base;
  }
  return res;
}
struct Z {
  int x;
  Z(int x = 0) : x(norm(x)) {}
  Z(i64 x) : x(norm(x % P)) {}
  int val() const { return x; }
  Z operator-() const { return Z(norm(P - x)); }
  Z inv() const {
    return assert(x != 0), power(*this, P - 2);
  }
  Z &operator*=(const Z &rhs) {
    return x = i64(x) * rhs.x % P, *this;
  }
  Z &operator+=(const Z &rhs) {
    return x = norm(x + rhs.x), *this;
  }
  Z &operator-=(const Z &rhs) {
    return x = norm(x - rhs.x), *this;
  }
  Z &operator/=(const Z &rhs) {
    return *this *= rhs.inv();
  }
  friend Z operator*(const Z &lhs, const Z &rhs) {
    Z res = lhs;
    res *= rhs;
    return res;
  }
  friend Z operator+(const Z &lhs, const Z &rhs) {
    Z res = lhs;
    res += rhs;
    return res;
  }
  friend Z operator-(const Z &lhs, const Z &rhs) {
    Z res = lhs;
    res -= rhs;
    return res;
  }
  friend Z operator/(const Z &lhs, const Z &rhs) {
    Z res = lhs;
    res /= rhs;
    return res;
  }
  friend std::istream &operator>>(std::istream &is, Z &a) {
    i64 v;
    is >> v;
    a = Z(v);
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os, const Z &a) {
    return os << a.val();
  }
};

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n;
  cin >> n;
  vector<i64> r(n);
  for (int i = 0; i < n; ++i) {
    cin >> r[i];
  }
  vector<Z> s(1 << n);
  {
    string t;
    cin >> t;
    for (int i = 0; i < (1 << n); ++i) {
      s[i] = t[i] - '0';
    }
  }
  vector<Z> f(1 << n);
  f[0] = 1;
  for (int p = 0; p < 60; ++p) {
    auto fmt = [&](vector<Z> &a, int opt) {
      for (int i = 0; i < n; ++i) {
        for (int j = 0; j < (1 << n); ++j) {
          if (r[i] >> p & 1) {
            if (~j >> i & 1) {
              a[j] += opt == 1 ? a[j ^ (1 << i)] : -a[j ^ (1 << i)];
            }
          } else {
            if (j >> i & 1) {
              a[j] += opt == 1 ? a[j ^ (1 << i)] : -a[j ^ (1 << i)];
            }
          }
        }
      }
    };
    auto b = s;
    fmt(b, 1);
    fmt(f, 1);
    for (int i = 0; i < (1 << n); ++i) {
      f[i] *= b[i];
    }
    fmt(f, -1);
  }
  cout << f[0];
}