#include <cstdio>
#include <cstdlib>
#include <string>
#include <list>

FILE *fin=fopen("bool.in","r");
FILE *fout=fopen("bool.out","w");

enum kOperators
{
    kNull = 0,
    kLeftPar,
    kRightPar,
    kOR,
    kAND,
    kNOT
};

/*
inline int pri(int op)
{
    switch (op)
    {
        case kNull:
            return 0;
        case kLeftPar:
            return 1;
        case kRightPar:
            return 2;
        case kOR:
            return 3;
        case kAND:
            return 3;
        case kNOT:
            return 4;
        default:
            exit(-1);
    }
}*/

enum kTypes
{
    kOperator = 0,
    kOperand,
    kVar
};

struct el
{
    int type,value;
} a[1000];
int n=0;

bool var[30]={};

std::list<int> stack;

void process_operator(int op)
{
    int back;
    if (op!=kLeftPar)
        while (!stack.empty()&&((back=stack.back())>(op)))
        {
            stack.pop_back();
            a[n].type=kOperator;
            a[n].value=back;
            n++;
        }
    if (op==kRightPar)
        stack.pop_back();
    if (op!=kRightPar)
        stack.push_back(op);
}

void process_tok(char * s)
{
    if (!s[1])
    {
        a[n].type=kVar;
        a[n].value=s[0]-'A';
        n++;
        return;
    }
    if (strcmp(s,"TRUE")==0)
    {
        a[n].type=kOperand;
        a[n].value=1;
        n++;
        return;
    }
    if (strcmp(s,"FALSE")==0)
    {
        a[n].type=kOperand;
        a[n].value=0;
        n++;
        return;
    }
    if (strcmp(s,"AND")==0)
    {
        process_operator(kAND);
        return;
    }
    if (strcmp(s,"NOT")==0)
    {
        process_operator(kNOT);
        return;
    }
    if (strcmp(s,"OR")==0)
    {
        process_operator(kOR);
        return;
    }
}

bool solve_polonese()
{
    std::list<bool> stack;
    for (int i=0; i<n; i++)
    {
        if (a[i].type==kVar)
            stack.push_back(var[a[i].value]);
        if (a[i].type==kOperand)
            stack.push_back(a[i].value);
        if (a[i].type==kOperator)
        {
            if (a[i].value==kNOT)
            {
                int v = stack.back();
                stack.pop_back();
                stack.push_back(!v);
            } else {
                bool ond1,ond2;
                ond2=stack.back();
                stack.pop_back();
                ond1=stack.back();
                stack.pop_back();
                if (a[i].value==kAND)
                    stack.push_back(ond1&&ond2);
                if (a[i].value==kOR)
                    stack.push_back(ond1||ond2);
            }
        }
    }
    return stack.back();
}

int main (int argc, char * const argv[]) {
    int c = '\0';
    int nr = 0;



    char s[10];
    while (c!='\n')
    {
        c=fgetc(fin);
        if ((c=='(')||(c==')')||(c==' ')||(c=='\r')||(c=='\n'))
        {
            if (nr)
                process_tok(s);
            s[0]='\0';
            nr=0;
        } else {
            s[nr]=c;
            nr++;
            s[nr]='\0';
        }
        if (c==')')
            process_operator(kRightPar);
        if (c=='(')
            process_operator(kLeftPar);
    }
    process_operator(kNull);



    int n;
    fscanf(fin, "%d",&n);
    \


    for (int i=0; i<n; i++)
    {
        int c=' ';
        while ((c==' ')||(c=='\n')||(c=='\r'))
            c=fgetc(fin);
            //dasdasdasdhusahduiusa
        var[c-'A']=!var[c-'A'];
        fprintf(fout,"%d",solve_polonese());
    }
    fputc('\n',fout);
    fclose(fin);
    // jjdsjiads


    //dasdasdasdasd
    //dasdasdasdlaksdlkasdasdaskd

    fclose(fout);
    return 0;
}