#include <bits/stdc++.h>

using namespace std;

ifstream f("bool.in");
ofstream g("bool.out");

#define last(v) v[v.size()-1]

map<char,bool> Values;

class Expression
{
private:
    vector<string> E;
    vector<bool> Expandable;
public:
    Expression(string s)
    {
        E.push_back("");
        int p=0;
        for(int i=0;i<s.length();i++) /// impart Expr in mai multe subexpresii
        {   /// Ex: A OR (B AND NOT (C)) -> "A", "OR", "B AND NOT (C)"
            switch(s[i])
            {
            case '(':
                {
                    if(p==0) {if(last(E)!="") E.push_back("");}
                        else last(E)+="(";
                    p++;
                    break;
                }
            case ')' :
                {
                    p--;
                    if(p==0) E.push_back("");
                        else last(E)+=")";
                    break;
                }
            case ' ' :
                {
                    if(p==0) {if(last(E)!="") E.push_back("");}
                        else last(E)+=" ";
                    break;
                }
            default:
                last(E)+=s[i];
            }
        };
        for(auto &i:E)
        {
            if(i=="AND") i="&"; ///simplificare simboluri
            if(i=="OR") i="|";  ///conventie: sir cu lungimea 1 se considera
            if(i=="NOT") i="!"; ///de sine statator (variabila, constanta, operator)
            if(i=="TRUE") i="1";///lugime mai mare ca 1 -> rezolvare recursiva
            if(i=="FALSE") i="0";
            Expandable.push_back(i.length()>1);
        }
    }
    bool solve()
    {
        bool result,first_not=0;/// inceputul expresiei se trateaza special
        if(E[0].length()==1) /// daca expresia este de sine statatoare
        {
            if(E[0]!="!") result=Values[E[0][0]]; /// daca nu este operator, se incarca valoarea
            else /// altfel, se neaga expresia de dupa
            {
                Expression e(E[1]);
                result=!e.solve();
                first_not=1;
            }
        }
        else
            {
                Expression e(E[0]); /// daca este o expresie complexa, se va calcula valoarea
                result=e.solve();
            }
        int crtsgn=0; /// ultimul semn binar citit (AND=1,OR=2)
        bool _not=0;  /// 1 daca se citeste NOT
        for(int i=1+first_not;i<E.size();i++) ///procesare...
        {
            if(E[i].length()==1)
            {
                if(E[i]=="&") crtsgn=1;
                else if(E[i]=="|") crtsgn=2;
                    else
                        if(E[i]=="!") _not=1;
                        switch(crtsgn)
                        {
                            case 1:result&=_not ? Values[E[i][0]] : !Values[E[i][0]]; break;
                            case 2:result|=_not ? Values[E[i][0]] : !Values[E[i][0]]; break;
                        }
                _not=0;
            }
            else
                if(E[i].length()>1)
                {
                    Expression e(E[i]);
                    switch(crtsgn)
                    {
                        case 1:result&=e.solve(); break;
                        case 2:result|=e.solve(); break;
                    }
                }
        }
        return result;
    }
};

int main()
{
    for(int c='A';c<='Z';c++) Values[c]=0; ///initializare
    Values['1']=1, Values['0']=0; /// tratam constantele ca valori oarecare

    string exprstr;
    getline(f,exprstr);
    Expression E(exprstr);

    int n;
    string change;
    f>>n>>change;
    for(auto i:change)
    {
        Values[i]=!Values[i];
        g<<E.solve();
    }
    return 0;
}