#include<bits/stdc++.h>
using namespace std;

const int A = 1e9 + 10;

#define AND 0
#define OR 1
#define XOR 2

const int MEM = 2e7;

int L[MEM], R[MEM];
bool xr[MEM];
int SZ = 0;

void push(int t) {
    if (!xr[t]) return;
    if (L[t] == -1) L[t] = SZ++;
    if (R[t] == -1) R[t] = SZ++;
    xr[L[t]] = !xr[L[t]];
    xr[R[t]] = !xr[R[t]];
    xr[t] = 0;
}

int merge(int t1, int t2, int l, int r, int op) {
    if (t1 == -1) return op == AND ? -1 : t2;
    if (t2 == -1) return op == AND ? -1 : t1;
    if (L[t1] == -1 && R[t1] == -1) swap(t2, t1);
    if (L[t2] == -1 && R[t2] == -1 && !xr[t2]) return op == AND ? -1 : t1;
    if (L[t2] == -1 && R[t2] == -1 && xr[t2]) {
        if (op == XOR) xr[t1] = !xr[t1];
        if (op == AND) {}
        if (op == OR) L[t1] = L[t2], R[t1] = R[t2], xr[t1] = xr[t2];
        return t1;
    }
    if (l == r) {
        if (op == AND) xr[t1] = xr[t1] & xr[t2];
        if (op == OR) xr[t1] = xr[t1] | xr[t2];
        if (op == XOR) xr[t1] = xr[t1] ^ xr[t2];
        return t1;
    }
    int m = (l + r) / 2;
    push(t1);
    push(t2);
    L[t1] = merge(L[t1], L[t2], l, m, op);
    R[t1] = merge(R[t1], R[t2], m + 1, r, op);
    return t1;
}

int upd(int t, int ql, int qr, int l, int r) {
    if (r < ql || qr < l) return t;
    if (t == -1) t = SZ++;
    if (ql <= l && r <= qr) {
        xr[t] ^= 1;
        return t;
    }
    push(t);
    int m = (l + r) / 2;
    L[t] = upd(L[t], ql, qr, l, m);
    R[t] = upd(R[t], ql, qr, m + 1, r);
    return t;
}

bool get(int t, int k, int l, int r) {
    if (t == -1) return 0;
    if (l == r) return xr[t];
    int m = (l + r) / 2;
    if (k <= m) return get(L[t], k, l, m) ^ xr[t];
    else return get(R[t], k, m + 1, r) ^ xr[t];
}

string s;
vector<vector<int>> pos_or, pos_and, pos_xor;
vector<int> pref;
vector<int> vec = {0, 1, 2, 3, 4};
int get(int l, int r) {
    {
        int k = *--upper_bound(pos_or[pref[l]].begin(), pos_or[pref[l]].end(), r);
        if (k >= l) {
            int left = get(l, k - 1);
            int right = get(k + 1, r);
            int ret = merge(left, right, 0, A, OR);
            return ret;
        }
    }
    {
        int k = *--upper_bound(pos_xor[pref[l]].begin(), pos_xor[pref[l]].end(), r);
        if (k >= l) {
            int left = get(l, k - 1);
            int right = get(k + 1, r);
            int ret = merge(left, right, 0, A, XOR);
            return ret;
        }
    }
    {
        int k = *--upper_bound(pos_and[pref[l]].begin(), pos_and[pref[l]].end(), r);
        if (k >= l) {
            int left = get(l, k - 1);
            int right = get(k + 1, r);
            int ret = merge(left, right, 0, A, AND);
            return ret;
        }
    }
    if (s[l] == '!'){
        int ret = get(l + 1, r);
        if (ret == -1) ret = SZ++;
        xr[ret] = !xr[ret];
        return ret;
    }
    if (s[l] == '(') {
        int ret = get(l + 1, r - 1);
        return ret;
    }
    long long q = 0;
    for (int i = l + 1; i < r; ++i) {
        q *= 10;
        q += s[i] - '0';
        q = min(q, (long long)1e9 + 1);
    }
    int ret = -1;
    ret = upd(ret, q, A, 0, A);
    return ret;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    fill(L, L + MEM, -1);
    fill(R, R + MEM, -1);

    int n, q;
    cin >> n >> q;
    cin >> s;
    pref.assign(n + 1, 0);
    pos_or.resize(n + 1, {-1}), pos_and.resize(n + 1, {-1}), pos_xor.resize(n + 1, {-1});
    for (int i = 0; i < n; ++i) pref[i + 1] = pref[i] + (s[i] == '(') - (s[i] == ')');
    for (int i = 0; i < n; ++i) {
        if (s[i] == '^') pos_xor[pref[i + 1]].push_back(i);
        if (s[i] == '&') pos_and[pref[i + 1]].push_back(i);
        if (s[i] == '|') pos_or[pref[i + 1]].push_back(i);
    }
    int ret = get(0, n - 1);
    while (q--) {
        int x;
        cin >> x;
        cout << (get(ret, x, 0, A) ? "True" : "False") << '\n';
    }
}