#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include <map>
using namespace std;
#define TESTER(b)
//(cout<<__LINE__<<"@"<<b<<endl)
const int VALUE = 0;
const int NOT = 1;
const int OR = 2;
const int AND = 3;
const int VAR = 4;

struct expr{
    char type;
    expr * arg1;
    expr * arg2;

    bool value;
    string var;

public:
    expr():arg1(NULL),arg2(NULL){};

};

void lex(string s, vector<string> & vs)
{
    ostringstream os;
    for(int i = 0; i < s.length(); i++){
        if(s[i] == '(' || s[i] == ')')
            os << ' ' << s[i] << ' ';
        else
            os << s[i];
    }
    
    istringstream is(os.str());
    string token;
    while(is >> token)
        vs.push_back(token);
}

expr *expr_node(const vector<string> &lex, int &cur);
expr *expr_not(const vector<string> &lex, int &cur);
expr *expr_and(const vector<string> &lex, int &cur);
expr *expr_or(const vector<string> &lex, int &cur);

expr *expr_node(const vector<string> &lex, int &cur)
{
    TESTER(cur<<" "<<lex[cur]);
    expr *ret;
    if ( lex[cur]=="(" ) {
        cur++;
        ret=expr_or(lex, cur);
        cur++; // ")"
    }
    else if ( lex[cur]=="TRUE" ) {
        cur++;
        ret=new expr();
        ret->type='1';
    }
    else if ( lex[cur]=="FALSE" ) {
        cur++;
        ret=new expr();
        ret->type='0';
    }
    else if ( 'A'<=lex[cur][0] && lex[cur][0]<='Z') {
        ret=new expr();
        ret->type=lex[cur][0];
        cur++;
    }
    TESTER(cur<<" "<<lex[cur]);
    return ret;
}

expr *expr_not(const vector<string> &lex, int &cur)
{
    TESTER(cur<<" "<<lex[cur]);
    expr *ret;
    if ( lex[cur]=="NOT" ) {
        cur++;
        ret=new expr();
        ret->type='!';
        ret->arg1=expr_not(lex,cur);
    }
    else
        ret=expr_node(lex,cur);
    
    TESTER(cur<<" "<<lex[cur]);
    return ret;
}
expr *expr_and(const vector<string> &lex, int &cur)
{
    TESTER(cur<<" "<<lex[cur]);
    expr *ret=expr_not(lex,cur);
    if ( lex[cur]=="AND" ) {
        cur++;
        expr *child=ret;
        ret=new expr();
        ret->type='&';
        ret->arg1=child;
        ret->arg2=expr_and(lex, cur);
    }
    TESTER(cur<<" "<<lex[cur]);
    return ret;
}
expr *expr_or(const vector<string> &lex, int &cur)
{
    TESTER(cur<<" "<<lex[cur]);
    expr *ret=expr_and(lex,cur);
    if ( lex[cur]=="OR" ) {
        cur++;
        expr *child=ret;
        ret=new expr();
        ret->type='|';
        ret->arg1=child;
        ret->arg2=expr_or(lex, cur);
    }
    TESTER(cur<<" "<<lex[cur]);
    return ret;
}

expr *parse(vector<string> lexstr)
{
    int cur=0;
    return expr_or(lexstr, cur);
}

bool eval(expr *ex, const vector<int> &regs){
    switch(ex->type){
    case '|':
        return eval(ex->arg1,regs) || eval(ex->arg2,regs);
    case '&':
        return eval(ex->arg1,regs) && eval(ex->arg2,regs);
    case '!':
        return !eval(ex->arg1,regs);
    case '0':
        return false;
    case '1':
        return true;
    default:
        return regs[ex->type-'A'] == 1;
    }
}

struct xy{
    int x;
    int y;
    xy();
    xy(int x, int y):x(x),y(y){}
};
struct ixy{
    string name;
    xy p;
};
bool operator<(const xy &a, const xy &b){
    return (a.x==b.x?a.y<b.y:a.x<b.x);
}
typedef map<xy,char> Field;

int main(void)
{
    string s;
    getline(cin,s);
    vector<string> vs;
    lex(s, vs);
    vs.push_back(".");
    int i,x,y;
    string registerName;
    
    expr *e = parse(vs);
    //cout<<"test"<<endl;
    int size, forks, invpts;
    cin >> ws >> size >> forks >> invpts;
    
    Field f;
    for(i = 0 ; i < forks ; i ++){
        cin >> x >> y;
        f[xy(x,y)]='f';
    }
    for(i = 0 ; i < invpts ; i++){
        char v;
        cin >> x >> y>>v;
        f[xy(x,y)]=v;
    }
    vector<int> regs(26);
    
    x=0;
    y=0;
    int dx=1,dy=0;
    while ( -size<=x && x<=size && -size<=y && y<=size ){
        cout<<x<<" "<<y<<endl;
        x+=dx;
        y+=dy;
        xy pos(x,y);
        if (f.count(pos)>0){
            char t=f[pos];
            if ( t=='f' ) {
                if ( eval(e,regs) ) {
                    int temp=dx;
                    dx=dy;
                    dy=-temp;
                }
                else {
                    int temp=dx;
                    dx=-dy;
                    dy=temp;
                }
            }
            else{
                regs[t-'A'] = 1-regs[t-'A'];
            }
        }
    }
}