#include <fstream>
#include <string>
using namespace std;
ifstream cin("bool.in");
ofstream cout("bool.out");
bool CONSTANTS[26] = {0};

bool Or(string &str, int &position);
bool And(string &str, int &position);
bool Not(string &str, int &position);
bool Paranteze(string &str, int &position);


bool Or(string &str, int &position){
    bool expression = And(str, position);
    while (str[position] == '|'){
        bool expression2;
        position += 1;
        expression2 = And(str, position);
        expression = expression || expression2;
    }
    return expression;
}

bool And(string &str, int &position){
    bool expression = Not(str, position);
    while (str[position] == '&'){
        bool expression2;
        position += 1;
        expression2 = Not(str, position);
        expression = expression && expression2;
    }
    return expression;
}
bool Not(string &str, int &position){
    bool expression;
    int NotCount = 0;
    while (str[position] == '!'){
        NotCount += 1;
        position += 1;
    }
    NotCount %= 2;
    if (NotCount == 1) {
        expression = !Paranteze(str, position);
    } else {
        expression = Paranteze(str, position);
    }
    return expression;
}
bool Paranteze(string &str, int &position){
    bool expression;
    if (str[position] == '('){
        position += 1;
        expression = Or(str, position);
        position += 1;
    } else {
        if (str[position] >= 'A' && str[position] <= 'Z') {
            expression = CONSTANTS[str[position] - 'A'];
        } else if (str[position] == '0') {
            expression = false;
        } else {
            expression = true;
        }
        position += 1;
    }
    return expression;
}

void CheckNewPos(int &pos1, int &pos2, int increment){
    if (pos1 > pos2)
        pos1 -= increment;
}

void PreProcessExpressions(string &str){
    int positionNot = 0;
    int positionOr = 0;
    int positionAnd = 0;
    int positionTrue = 0;
    int positionFalse = 0;
    while (positionNot >= 0 || positionOr >= 0 || positionAnd >= 0 || positionTrue >= 0 || positionFalse >= 0){
        positionNot = str.find("NOT", positionNot);
        positionOr = str.find("OR", positionOr);
        positionAnd = str.find("AND", positionAnd);
        positionTrue = str.find("TRUE",positionTrue);
        positionFalse = str.find("FALSE", positionFalse);
        if (positionNot >= 0) {
            str.replace(positionNot, 4, "!");
            positionNot += 1;
            CheckNewPos(positionOr, positionNot, 3);
            CheckNewPos(positionAnd, positionNot, 3);
            CheckNewPos(positionTrue, positionNot, 3);
            CheckNewPos(positionFalse, positionNot, 3);
        }
        if (positionOr >= 0){
            str.replace(positionOr, 2, "|");
            positionOr += 1;
            CheckNewPos(positionNot, positionOr, 1);
            CheckNewPos(positionAnd, positionOr, 1);
            CheckNewPos(positionTrue, positionOr, 1);
            CheckNewPos(positionFalse, positionOr, 1);
        }
        if (positionAnd >= 0){
            str.replace(positionAnd, 3, "&");
            positionAnd += 1;
            CheckNewPos(positionNot, positionAnd, 2);
            CheckNewPos(positionOr, positionAnd, 2);
            CheckNewPos(positionTrue, positionAnd, 2);
            CheckNewPos(positionFalse, positionAnd, 2);
        }
        if (positionTrue >= 0){
            str.replace(positionTrue, 4, "1");
            CheckNewPos(    positionNot, positionTrue, 3);
            CheckNewPos(positionOr, positionTrue, 3);
            CheckNewPos(positionAnd, positionTrue, 3);
            CheckNewPos(positionFalse, positionTrue, 3);
        }
        if (positionFalse >= 0){
            str.replace(positionFalse, 5, "0");
            CheckNewPos(positionNot, positionFalse, 4);
            CheckNewPos(positionOr, positionFalse, 4);
            CheckNewPos(positionAnd, positionFalse, 4);
            CheckNewPos(positionTrue, positionFalse, 4);
        }
    }
}
void PreProcessSpaces(string &str){
    int position = 0;
    while (position >= 0){
        position = str.find(" ", position);
        if (position >= 0)
            str.erase(str.begin()+position);
    }
}
int main(){

    string expression;
    getline(cin, expression);
    PreProcessExpressions(expression);
    PreProcessSpaces(expression);
    cout << expression;
    int changes;
    cin >> changes;
    string change;
    cin >> change;
    for (int i = 0; i < change.size(); i++){
        CONSTANTS[change[i] - 'A'] = !CONSTANTS[change[i] - 'A'];
        int position = 0;
        cout << Or(expression, position);
    }
    return 0;
}