#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <stdlib.h>     //exit(0)
#define NMAX 201

using namespace std;

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

struct nod
{
    pair<int, int> coord;
    int index;
}M[NMAX];

queue< pair < int ,int > >Q;
vector <int> v[NMAX];
int n, m, X, Y, k, G;
int a[NMAX][NMAX];
int dx[12] = {-1,0,1, 0,-1,-1,1, 1,-2,0,2, 0};
int dy[12] = {0 ,1,0,-1,-1, 1,1,-1, 0,2,0,-2};

int ok(int i, int j)
{
    return (i>=1 && j>=1 && i<=n && j<=m);
}

int updateMuchie(int x, int y)
{
    int i;
    for(i=1; i<=M[0].index; ++i)
        if(M[i].coord.first==x && M[i].coord.second==y)return M[i].index;

    ++M[0].index;
    M[M[0].index].coord.first   = x;
    M[M[0].index].coord.second  = y;
    M[M[0].index].index         = M[0].index;

    return M[M[0].index].index;
}

void Euler(int i)
{
    int j, nod, jj;
    for(j=0; j<v[i].size(); ++j){
        if(v[i][j]!=0){
            nod=v[i][j];
            v[i][j]=0;
            for(jj=0; jj<v[nod].size(); ++jj){
                if(v[nod][jj]==i){
                    v[nod][jj]=0;
                    break;
                }
            }
            Euler(nod);
        }
    }
    g<<M[i].coord.first<<' '<<M[i].coord.second<<'\n';
}

int main()
{
    short int prob;
    int i, j, x, y, r, ii, jj, dir;

    f >> prob >> n >> m >> X >> Y >> k;

    for(i=1; i<=k; ++i){
        f >> x >> y >> r;

        switch(r){
            case 0:{
                a[x][y]=-1;
                break;
            }
            case 1:{
                a[x][y]=-1;
                for(dir=0; dir<4; ++dir){
                    ii = x+dx[dir];
                    jj = y+dy[dir];
                    if(ok(ii, jj))
                        a[ii][jj] = -1;
                }
                break;
            }
            case 2:{
                a[x][y] = -1;
                for(dir=0; dir<12; ++dir){
                    ii = x+dx[dir];
                    jj = y+dy[dir];
                    if(ok(ii, jj))
                        a[ii][jj]=-1;
                }
                break;
            }
        }
    }

    f >> G;
    for(i=1; i<=G; ++i){
        int nod1, nod2;
        f >> x >> y >> ii >> jj;

        if(a[x][y]==0)  a[x][y]     = -2;
        if(a[ii][jj]==0)a[ii][jj]   = -2;

        nod1 = updateMuchie(x, y);
        nod2 = updateMuchie(ii, jj);

        v[nod1].push_back(nod2);
        v[nod2].push_back(nod1);
    }

    switch(prob){
        case 1:{
            if(a[X][Y] == -2)
                g << X << ' ' << Y << ' ' << 0;
            else{
                g << "LEE IN PROGRESS";
            }
            break;
        }
        case 2:{
            for(i=1; i<=M[0].index; ++i)
                if(a[M[i].coord.first][M[i].coord.second]!=-1){
                    Euler(i);
                    break;
                }
            break;
        }
    }

    g.close();
    return 0;
}