#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = (a);i <= (b);++i)
#define per(i, a, b) for(int i = (a);i >= (b);--i)
#define lc (k << 1)
#define rc (k << 1 | 1)
#define lowbit(x) ((x) & -(x))
#define odd(x) ((x) & 1)
#define even(x) (!odd(x))
#define fir first
#define sec second
#define pb push_back
#define il inline
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define i128 __int128
#define f128 __float128
#define pii pair<int, int>
#define pli pair<ll, int>
#define pll pair<ll, ll>
#define SZ(x) ((int)(x).size())
#define debug(x) cerr << "In Line " << __LINE__ << " the " << #x << " = " << (x) << "\n"
using namespace std;
using ll = long long;
using ull = unsigned long long;
template<class T> using vc = vector<T>;
template<class Tx, class Ty>
il void chkmx(Tx& x, const Ty y) {x = max<common_type_t<Tx, Ty>>(x, y);}
template<class Tx, class Ty>
il void chkmn(Tx& x, const Ty y) {x = min<common_type_t<Tx, Ty>>(x, y);}
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3fll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
bool ms;

constexpr int p = 998244353;
struct mint {
    int x;
    mint(ll x = 0) : x(normalize(x % p)) {}
    static int normalize(int x) {
        if(x >= p)
            x -= p;
        else if(x < 0)
            x += p;
        return x;
    }
    constexpr int val() const {return x;}
    mint pow(int b) const {
        ll ans = 1, a = x;
        while(b) {
            if(b & 1)
                ans = ans * a % p;
            a = a * a % p;
            b >>= 1;
        }
        return ans;
    }
    mint inv() const {
        return pow(p - 2);
    }
    mint operator - () const {
        return (mint)normalize(p - x);
    }
    friend mint& operator += (mint& lhs, const mint& rhs) {
        lhs.x = normalize(lhs.x + rhs.x);
        return lhs;
    }
    friend mint& operator -= (mint& lhs, const mint& rhs) {
        lhs.x = normalize(lhs.x - rhs.x);
        return lhs;
    }
    friend mint& operator *= (mint& lhs, const mint& rhs) {
        lhs.x = 1ll * lhs.x * rhs.x % p;
        return lhs;
    }
    friend mint& operator /= (mint& lhs, const mint& rhs) {
        assert(rhs.val());
        lhs.x = 1ll * lhs.x * rhs.inv().x % p;
        return lhs;
    }
    friend mint operator + (mint lhs, const mint& rhs) {
        lhs += rhs;
        return lhs;
    }
    friend mint operator - (mint lhs, const mint& rhs) {
        lhs -= rhs;
        return lhs;
    }
    friend mint operator * (mint lhs, const mint& rhs) {
        lhs *= rhs;
        return lhs;
    }
    friend mint operator / (mint lhs, const mint& rhs) {
        lhs /= rhs;
        return lhs;
    }
    friend istream& operator >> (istream& is, mint& a) {
        return is >> a.x;
    }
    friend ostream& operator << (ostream& os, const mint& a) {
        return os << a.x;
    }
    friend bool operator == (const mint& lhs, const mint& rhs) {
        return lhs.x == rhs.x;
    }
    friend bool operator != (const mint& lhs, const mint& rhs) {
        return lhs.x != rhs.x;
    }
};

const int N = 18, M = 61, MAXN = 1 << 11;
short a[MAXN], b[M], c[MAXN][MAXN];
ll r[N];
mint f[2][MAXN];

bool mt;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    cerr << fabs(&ms - &mt) / 1024 / 1024 << "\n";
    int n;
    cin >> n;
    rep(i, 0, n - 1) {
        cin >> r[i];
        for(ll j = r[i];j;j ^= lowbit(j))
            b[__builtin_ctzll(j)] += 1 << i;
    }
    rep(i, 0, (1 << n) - 1) {
        char c;
        cin >> c;
        a[i] = c ^ 48;
    }
    if(*max_element(r, r + n) <= 3) {
        int x[N]{};
        mint ans = 0;
        auto dfs = [&](auto&& self, int i) -> void {
            if(i == n) {
                rep(j, 0, 59) {
                    int t = 0;
                    rep(k, 0, n - 1)
                        t |= (x[k] >> j & 1) << k;
                    if(!a[t])
                        return;
                }
                ans += 1;
                return;
            }
            rep(j, 0, r[i]) {
                x[i] = j;
                self(self, i + 1);
            }
        };
        dfs(dfs, 0);
        cout << ans << "\n";
        return 0;
    }
    rep(i, 0, (1 << n) - 1) {
        auto& c = ::c[i];
        memcpy(c, a, sizeof(a));
        rep(k, 0, n - 1) {
            if(!(i >> k & 1))
                continue;
            per(j, (1 << n) - 1, 0) {
                if(!(j >> k & 1))
                    c[j] += c[j ^ 1 << k];
            }
        }
    }
    f[60 & 1][(1 << n) - 1] = 1;
    per(i, 60, 1) {
        int cur = i & 1, nxt = cur ^ 1;
        memset(f[nxt], 0, sizeof(f[nxt]));
        rep(j, 0, (1 << n) - 1) {
            if(!f[cur][j].val())
                continue;
            auto c = ::c[(1 << n) - 1 ^ j];
            int k = j & b[i - 1];
            for(int l = k;;l = l - 1 & k) {
                f[nxt][j ^ l] += f[cur][j] * c[l ^ k];
                if(!l)
                    break;
            }
        }
    }
    mint ans = 0;
    rep(i, 0, (1 << n) - 1)
        ans += f[0][i];
    cout << ans << "\n";
    cerr << 1e3 * clock() / CLOCKS_PER_SEC << " ms\n";
    return 0;
}