#include <bits/stdc++.h>

using namespace std;

#define all(x) (x).begin(), (x).end()
#define pb push_back
#define sz(x) (int)(x).size()

mt19937 rnd(time(NULL));
template<typename T>
void shuf(vector<T>&x) {
    for (int i = 1; i < x.size(); i++) {
        swap(x[i], x[rnd() % i]);
    }
}

bool is_digit(char& c) {
    return c - '0' >= 0 && c - '0' <= 9;
}

struct node {
    int ls, rs, type;
};

struct sg_node {
    int mod[2];
};

sg_node merge(sg_node a, sg_node b) {
    sg_node nw;
    for (int j = 0; j < 2; j++) nw.mod[j] = a.mod[b.mod[j]];
    return nw;
}

struct segtree {
    int n;
    vector<sg_node> a, t;
    segtree() = default;
    segtree(int n_, vector<sg_node> a_) {
        n = n_;
        a = a_;
        t.resize(4 * n);
        build(1, 0, n);
    }

    void build(int v, int tl, int tr) {
        if (tl + 1 == tr) {
            t[v] = a[tl];
            return;
        }
        int tm = (tl + tr) / 2;
        build(v * 2, tl, tm); build(v * 2 + 1, tm, tr);
        t[v] = merge(t[v * 2], t[v * 2 + 1]);
    }

    int get(int v, int tl, int tr, int l, int r, int val) {
        if (tr <= l || tl >= r) return val;
        if (l <= tl && tr <= r) return t[v].mod[val];
        int tm = (tl + tr) / 2;
        return get(v * 2, tl, tm, l, r, get(v * 2 + 1, tm, tr, l, r, val));
    }

    void upd(int v, int tl, int tr, int p, sg_node newmod) {
        if (tl + 1 == tr) {
            t[v] = newmod;return;
        }
        int tm = (tl + tr) / 2;
        if (p < tm) upd(v * 2, tl, tm, p, newmod);
        else upd(v * 2 + 1, tm, tr, p, newmod);
        t[v] = merge(t[v * 2], t[v * 2 + 1]);
    }
};

void solve() {
    int n, q; cin >> n >> q;
    string s; cin >> s; s = '(' + s + ')'; n += 2;

    vector<int> sqb, nxt(n, -1), prv(n, -1), idx(n), otr, ands, xors, ors;
    for (int i = 0; i < n; i++) {
        if (s[i] == '[') sqb.pb(i);
        if (s[i] == '!') otr.pb(i);
        if (s[i] == '&') ands.pb(i);
        if (s[i] == '|') ors.pb(i);
        if (s[i] == '^') xors.pb(i);
    }

    set<int> OT, AD, XR, OR;
    for (int u : otr) OT.insert(u);
    for (int u : ands) AD.insert(u);
    for (int u : ors) OR.insert(u);
    for (int u : xors) XR.insert(u);

    stack<int> st;
    vector<pair<int, int>> segs;
    for (int i = 0; i < n; i++) {
        if (s[i] == '(') st.push(i);
        else if (s[i] == ')') {
            segs.pb({st.top(), i});
            st.pop();
        }
    }
    vector<node> t;
    vector<int> vls;
    for (int u : sqb) {
        int val = 0, cur = u + 1;
        while (is_digit(s[cur])) {
            val = 10 * val + s[cur] - '0';
            cur++;
        }
        nxt[u] = cur;
        prv[cur] = u;
        idx[u] = idx[cur] = t.size();
        t.pb({-1, -1, -1});
        vls.pb(val);
    }
    // types: 0 - otr, 1 - and, 2 - xor, 3 - or
    for (int i = 0; i < segs.size(); i++) {
        {
            if (!OT.empty()) {
                auto it = OT.lower_bound(segs[i].second);
                if (it != OT.begin()) {
                    it--;
                    vector<int> del;
                    while (*it >= segs[i].first) {
                        int val = *it; del.pb(val);
                        t.pb({idx[val + 1], -1, 0});
                        nxt[val] = nxt[val + 1];
                        prv[nxt[val]] = val;
                        idx[val] = idx[nxt[val]] = t.size() - 1;
                        if (it == OT.begin()) {
                            break;
                        }
                        it--;
                    }
                    for (int u : del) OT.erase(u);
                }
            }
        }
        {
            if (!AD.empty()) {
                auto it = AD.lower_bound(segs[i].second);
                if (it != AD.begin()) {
                    it--;
                    vector<int> del;
                    while (*it >= segs[i].first) {
                        int val = *it; del.pb(val);
                        t.pb({idx[val - 1], idx[val + 1], 1});
                        nxt[prv[val - 1]] = nxt[val + 1];
                        prv[nxt[val + 1]] = prv[val - 1];
                        idx[nxt[val + 1]] = idx[prv[val - 1]] = t.size() - 1;
                        if (it == AD.begin()) {
                            break;
                        }
                        it--;
                    }
                    for (int u : del) AD.erase(u);
                }
            }
        }
        {
            if (!XR.empty()) {
                auto it = XR.lower_bound(segs[i].second);
                if (it != XR.begin()) {
                    it--;
                    vector<int> del;
                    while (*it >= segs[i].first) {
                        int val = *it; del.pb(val);
                        t.pb({idx[val - 1], idx[val + 1], 2});
                        nxt[prv[val - 1]] = nxt[val + 1];
                        prv[nxt[val + 1]] = prv[val - 1];
                        idx[nxt[val + 1]] = idx[prv[val - 1]] = t.size() - 1;
                        if (it == XR.begin()) break;
                        it--;
                    }
                    for (int u : del) XR.erase(u);
                }
            }
        }
        {
            if (!OR.empty()) {
                auto it = OR.lower_bound(segs[i].second);
                if (it != OR.begin()) {
                    it--; 
                    vector<int> del;
                    while (*it >= segs[i].first) {
                        int val = *it; del.pb(val);
                        t.pb({idx[val - 1], idx[val + 1], 3});
                        nxt[prv[val - 1]] = nxt[val + 1];
                        prv[nxt[val + 1]] = prv[val - 1];
                        idx[nxt[val + 1]] = idx[prv[val - 1]] = t.size() - 1;
                        if (it == OR.begin()) break;
                        it--;
                    }
                    for (int u : del) OR.erase(u);
                }
            }
        }
        idx[segs[i].first] = idx[segs[i].second] = idx[segs[i].first + 1];
        nxt[segs[i].first] = segs[i].second;
        prv[segs[i].second] = segs[i].first;
    }

    vector<vector<int>> g(sz(t));
    for (int i = 0; i < sz(t); i++) {
        if (t[i].ls != -1) g[i].pb(t[i].ls);
        if (t[i].rs != -1) g[i].pb(t[i].rs);
    }
    // for (int i = 0; i < sz(t); i++) {
    //     for (int u : g[i]) cout << i << ' ' << u << '\n';
    // }

    int N = sz(t);
    vector<int> siz(N);
    int root = N - 1;
    auto dfs = [&](int v, auto&&self) -> void {
        siz[v] = 1;
        for (int u : g[v]) {
            self(u, self); siz[v] += siz[u];
        }
        for (int i = 1; i < g[v].size(); i++) {
            if (siz[g[v][0]] < siz[g[v][i]]) swap(g[v][0], g[v][i]);
        }
    };
    dfs(root, dfs);
    vector<int> tin(N), pr(N), parent(N, -1);
    int cur = 0;
    auto dfs2 = [&](int v, auto&&self) -> void {
        tin[v] = cur++;
        for (int u : g[v]) {
            parent[u] = v;
            pr[u] = (u == g[v][0] ? pr[v] : u);
            self(u, self);
        }   
    };
    pr[root] = root;
    dfs2(root, dfs2);
    vector<int> leaf(N);
    for (int i = 0; i < N; i++) {
        if (g[i].empty()) leaf[pr[i]] = i;
    }

    vector<sg_node> modif(N);
    for (int i = 0; i < N; i++) {
        if (t[i].type == 0) {
            modif[tin[i]].mod[0] = 1; modif[tin[i]].mod[1] = 0;
        }
    }

    auto dfs3 = [&](int v, auto&&self) -> int {
        vector<int> vals;
        for (int u : g[v]) {
            vals.pb(self(u, self));
        }
        if (vals.empty()) return 0;
        if (vals.size() == 1) return 1 - vals[0];
        //cout << v << ' ' << vals.size() << '\n';
        if (t[v].type == 1) {
            modif[tin[v]].mod[0] = 0;
            modif[tin[v]].mod[1] = vals[1];
             #ifdef LOCAL 
            cout << v << '\n';
            for (int j = 0; j < 2; j++) cout << modif[tin[v]].mod[j] << ' ';
            cout << '\n';
            #endif
            return (vals[0] & vals[1]);
        } else if (t[v].type == 2) {
            modif[tin[v]].mod[0] = vals[1];
            modif[tin[v]].mod[1] = (1 ^ vals[1]);
             #ifdef LOCAL 
            cout << v << '\n';
            for (int j = 0; j < 2; j++) cout << modif[tin[v]].mod[j] << ' ';
            cout << '\n';
            #endif
            return (vals[0] ^ vals[1]);
        } else {
            modif[tin[v]].mod[0] = vals[1];
            modif[tin[v]].mod[1] = 1;
            #ifdef LOCAL 
            cout << v << '\n';
            for (int j = 0; j < 2; j++) cout << modif[tin[v]].mod[j] << ' ';
            cout << '\n';
            #endif
            return (vals[0] | vals[1]);
        }
    };
    dfs3(root, dfs3);
    //cout << "ranned\n";
    vector<int> qrs(q);
    for (int i = 0; i < q; i++) cin >> qrs[i];
    vector<int> ord(q, 0);
    iota(all(ord), 0);
    sort(all(ord), [&](int i, int j){return qrs[i] < qrs[j];});
    vector<int> ans(q);
    segtree sg(N, modif);
    vector<int> VAL(N, 0);
    vector<int> ord2(sz(vls)); iota(all(ord2), 0);
    sort(all(ord2), [&](int i, int j){return vls[i] < vls[j];});
    int qind = 0;
    //for (auto u : t) cout << u.ls << ' ' << u.rs << ' ' << u.type << endl;
    auto update = [&](int vt) {
        VAL[vt] = 1;
        while (vt >= 0) {
            int newval = sg.get(1, 0, N, tin[pr[vt]], tin[leaf[pr[vt]]], VAL[leaf[pr[vt]]]);
            vt = pr[vt];
            if (parent[vt] == -1) break;
            sg_node newmod;
            if (t[parent[vt]].type == 1) {
                newmod.mod[0] = 0;
                newmod.mod[1] = newval;
            } else if (t[parent[vt]].type == 2) {
                newmod.mod[0] = newval;
                newmod.mod[1] = 1 - newval;
            } else {
                newmod.mod[0] = newval;
                newmod.mod[1] = 1;
            }
            sg.upd(1, 0, N, tin[parent[vt]], newmod);
            vt = parent[vt];
        }
    };
    // for (int u : tin) cout << u << ' ';
    // cout << '\n';
    for (int i = 0; i < sz(ord2); i++) {
        while (qind < q && qrs[ord[qind]] < vls[ord2[i]]) {
            ans[ord[qind]] = sg.get(1, 0, N, 0, tin[leaf[root]], VAL[leaf[root]]);
            qind++;
        }
        update(ord2[i]);
    }
    while (qind < q) {
        ans[ord[qind]] = sg.get(1, 0, N, 0, tin[leaf[root]], VAL[leaf[root]]);
        qind++;
    }
    for (int u : ans) {
        cout << (u ? "True\n" : "False\n");
    }

    // while (q--) {
    //     int V; cin >> V;
    //     vector<int> gg(sz(t));
    //     for (int i = 0; i < sz(t); i++) {
    //         if (t[i].type == -1) {
    //             gg[i] = (vls[i] <= V);
    //         } else {
    //             if (t[i].type == 0) {
    //                 gg[i] = !gg[t[i].ls];
    //             } else if (t[i].type == 1) {
    //                 gg[i] = (gg[t[i].ls] & gg[t[i].rs]);
    //             } else if (t[i].type == 2) {
    //                 gg[i] = (gg[t[i].ls] ^ gg[t[i].rs]);
    //             } else {
    //                 gg[i] = (gg[t[i].ls] | gg[t[i].rs]);
    //             }
    //         }
    //     }
    //     cout << (gg.back() ? "True" : "False") << '\n';
    // }
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else 
        cin.tie(0)->sync_with_stdio(false);
    #endif

    while (tt--) {
        solve();
    }
}