#include <fstream>
#include <iomanip>
#include <string>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <math.h>
#include <set>
#include <map>
#include <string.h>
#include <queue>
#include <stack>

#define INF 0x3f3f3f3f

using namespace std;

#ifdef DEBUG
string name = "data";
#else
string name = "bool";
#endif

ifstream fin(name + ".in");
ofstream fout(name + ".out");

string s;
int k;

bool varValue[50];

bool isNotOperator() {
    if (k + 2 >= s.size()) {
        return false;
    }
    
    if (s[k] == 'N' && s[k + 1] == 'O' && s[k + 2] == 'T') {
        k += 3;
        return true;
    }
    return false;
}

bool evalLinear(vector<bool> &vals, vector<char> &ops) {
    
    stack<bool> valueStack;
    
    valueStack.push(vals[0]);
    
    for (int i = 0; i < ops.size(); ++i) {
        if (ops[i] == '&') {
            int t = valueStack.top();
            valueStack.pop();
            valueStack.push(t && vals[i + 1]);
        } else {
            valueStack.push(vals[i + 1]);
        }
    }
    
    while (valueStack.size() > 1) {
        bool v1 = valueStack.top();
        valueStack.pop();
        bool v2 = valueStack.top();
        valueStack.pop();
        valueStack.push(v1 || v2);
    }
    
    return valueStack.top();
}

char nextOperator() {
    if (k + 2 < s.size() && s[k] == 'A' && s[k + 1] == 'N' && s[k + 2] == 'D') {
        k += 3;
        return '&';
    }
    
    k += 2;
    return '|';
}

bool nextTerm() {
    if (k + 3 < s.size() && s[k] == 'T' && s[k + 1] == 'R' && s[k + 2] == 'U' && s[k + 3] == 'E') {
        k += 4;
        return true;
    }
    
    if (k + 4 < s.size() && s[k] == 'F' && s[k + 1] == 'A' && s[k + 2] == 'L' && s[k + 3] == 'S' && s[k + 4] == 'E') {
        k += 5;
        return false;
    }
    
    bool val = varValue[s[k] - 'A'];
    
    k++;
    
    return val;
}

int eval() {
    vector<bool> vals;
    vector<char> ops;
    
    bool negateNext = false;
    bool foundTerm = false;
    
    while (k < s.size()) {
        if (s[k] == ' ') {
            k++;
            continue;
        }
        
        if (s[k] == '(') {
            k++;
            int val = eval();
            if (negateNext) {
                negateNext = false;
                vals.push_back(!val);
            } else {
                vals.push_back(val);
            }
            foundTerm = true;
            continue;
        }
        
        if (s[k] == ')') {
            k++;
            return evalLinear(vals, ops);
        }
        
        if (isNotOperator()) {
            negateNext = !negateNext;
            continue;
        }
        
        if (foundTerm) {
            ops.push_back(nextOperator());
            foundTerm = false;
            continue;
        }
        
        bool next = nextTerm();
        
        if (negateNext) {
            vals.push_back(!next);
            negateNext = false;
        } else {
            vals.push_back(next);
        }
        
        foundTerm = true;
    }

    return evalLinear(vals, ops);
}

int main() {
    
    getline(fin, s);
    
    int n;
    fin >> n;
    
    string change;
    fin >> change;
    
    for (int i = 0; i < n; ++i) {
        varValue[change[i] - 'A'] = !varValue[change[i] - 'A'];
        k = 0;
        fout << eval();
    }
    
    return 0;
}