#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)

typedef long long ll;
const ll INF = (1LL << 62) - (1LL << 31); /*オーバーフローしない程度に大きい数*/
// const ll MOD = 1000000007;
using namespace std;

struct UnionFind {
    vector<int> par, siz;

    UnionFind(int n) : par(n, -1), siz(n, 1) {}

    int root(int x) {
        if (par[x] == -1)
            return x;
        else
            return par[x] = root(par[x]);
    }

    bool issame(int x, int y) { return root(x) == root(y); }

    bool unite(int x, int y) {
        // x,yを根まで移動する
        x = root(x);
        y = root(y);
        // すでに同じグループのときは何もしない
        if (x == y) return false;
        /// union by size (y側のサイズが小さくなるようにする)
        if (siz[x] < siz[y]) swap(x, y);
        // yをxの子とする
        par[y] = x;
        siz[x] += siz[y];
        return true;
    }

    // xを含むグループのサイズ
    int size(int x) {
        int ret = siz[root(x)];
        return ret;
    }
};

// 辺を表す型，ここでは重みを表す型を long long 型とする
struct Edge {
    int to;       // 隣接頂点番号
    long long w;  // 重み
    Edge(int to, long long w) : to(to), w(w) {}
};

// 重み付きグラフを表す型
using Graph = vector<vector<Edge>>;

// 緩和を実施する関数
template <class T>
bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    } else
        return false;
}

int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
// int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
// int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};

int ctoi(char c) {
    if (c >= '0' && c <= '9') {
        return c - '0';
    }
    return 0;
}

using P = pair<ll, ll>;

int mod = 998244353;
struct mint {
    ll x;  // typedef long long ll;
    mint(ll x = 0) : x((x % mod + mod) % mod) {}
    mint operator-() const { return mint(-x); }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod - a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        mint res(*this);
        return res += a;
    }
    mint operator-(const mint a) const {
        mint res(*this);
        return res -= a;
    }
    mint operator*(const mint a) const {
        mint res(*this);
        return res *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t >> 1);
        a *= a;
        if (t & 1) a *= *this;
        return a;
    }

    // for prime mod
    mint inv() const { return pow(mod - 2); }
    mint& operator/=(const mint a) { return (*this) *= a.inv(); }
    mint operator/(const mint a) const {
        mint res(*this);
        return res /= a;
    }
};

int main() {
#ifdef LOCAL
    std::ifstream in("input.txt");
    std::cin.rdbuf(in.rdbuf());
#endif

    int n;
    cin >> n;
    vector<string> s(n);
    rep(i, n) cin >> s[i];

    // reverse(s.begin(), s.end());

    int now = 1;
    ll ans = 1;

    vector<vector<ll>> dp(n + 1, vector<ll>(2, 0));
    dp[0][0] = 1;
    dp[0][1] = 1;

    rep(i, n) {
        if (s[i] == "AND") {
            dp[i + 1][0] = dp[i][0] * 2 + dp[i][1];
            dp[i + 1][1] = dp[i][1];
        } else {
            dp[i + 1][0] = dp[i][0];
            dp[i + 1][1] = dp[i][0] + dp[i][1] * 2;
        }
    }

    cout << dp[n][1];

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
template<typename T> struct fenwickTree {
    int n;
    vector<int> tree;
    fenwickTree(int n_ = 0) : n(n_) { tree.resize(n_ + 1, 0); }
    int lowbit(int x) { return x & (-x); }
    int size() { return n; }
    void add(int pos, int x) { // pos位置加上x
        for (; pos <= n; pos += lowbit(pos)) {
            tree[pos] += x;
        }
    }
    T query(int pos) { // 查询pos位置的前缀和 即a[1] + a[2] + ... + a[pos]
        T res = 0;
        for (; pos > 0; pos -= lowbit(pos)) {
            res += tree[pos];
        }
        return res;
    }
    T sum(int l, int r) { // [l, r]区间查询
        return query(r) - query(l - 1);
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n;
    cin >> n;
    vector<int> a(n + n), pos(n + n), col(n + n);
    iota(pos.begin(), pos.end(), 0);
    for (int i = 0; i < n + n; i++) {
        cin >> a[i];
    }
    sort(pos.begin(), pos.end(), [&](int i, int j) {
        return a[i] < a[j];
    });
    for (int i = 0; i < n + n; i++) {
        col[pos[i]] = (i < n);
    }
    vector<int> stk;
    string res(n + n, ' ');
    for (int i = 0; i < n + n; i++) {
        if (stk.empty()) {
            stk.push_back(i);
        } else {
            if (col[stk.back()] != col[i]) {
                res[stk.back()] = '(';
                stk.pop_back();
                res[i] = ')';
            } else {
                stk.push_back(i);
            }
        }
    }
    cout << res << "\n";
    return 0;
}