#pragma comment(linker, "/STACK:102400000, 102400000")

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<cctype>

#include<cmath>

#include<iostream>

#include<sstream>

#include<iterator>

#include<algorithm>

#include<string>

#include<vector>

#include<set>

#include<map>

#include<stack>

#include<deque>

#include<queue>

#include<list>

#define Min(a, b) ((a < b) ? a : b)

#define Max(a, b) ((a < b) ? b : a)

typedef long long ll;

typedef unsigned long long llu;

const int INT_INF = 0x3f3f3f3f;

const int INT_M_INF = 0x7f7f7f7f;

const ll LL_INF = 0x3f3f3f3f3f3f3f3f;

const ll LL_M_INF = 0x7f7f7f7f7f7f7f7f;

const int dr[] = {, , , -};

const int dc[] = {, , -, };

const int MOD = 1e9 + ;

const double pi = acos(-1.0);

const double eps = 1e-;

const int MAXN =  + ;

const int MAXT =  + ;

using namespace std;

char s[];

bool edge[][][][];

int dis[][][];

const char* a = "ESWN";//与数组dr,dc方向对应

const char* b = "LFR";

struct Node{

    int x, y, d;//当前点的坐标，及进入该点的朝向

    Node(){}

    Node(int xx, int yy, int dd):x(xx), y(yy), d(dd){}

}num[][][];//记录该点的上一个点

int dir_id(char c){

    return strchr(a, c) - a;

}

int turn_id(char c){

    return strchr(b, c) - b;

}

bool judge(int x, int y){

    return x >=  && x <=  && y >=  && y <= ;

}

Node next(const Node&t, int turn){//turn与字符数组b下标对应

    int dir = t.d;//向前走朝向不变

    if(!turn){//向左走

        dir = (dir + ) % ;//减1等价于加3

    }

    else if(turn == ){

        dir = (dir + ) % ;

    }

    return Node(t.x + dr[dir], t.y + dc[dir], dir);

}

void print_ans(Node t, int tx, int ty, int dir){

    stack<Node> st;

    while(){

        st.push(t);

        if(dis[t.x][t.y][t.d] == ) break;

        t = num[t.x][t.y][t.d];

    }

    st.push(Node(tx, ty, dir));

    int cnt = ;

    while(!st.empty()){

        Node tmp = st.top();

        st.pop();

        ++cnt;

        if(cnt %  == ) printf(" ");

        printf(" (%d,%d)", tmp.x, tmp.y);

        if(cnt %  == ) printf("\n");

    }

    if(cnt %  != ) printf("\n");

}

bool bfs(int sx, int sy, int dir, int ex, int ey){

    memset(dis, -, sizeof dis);

    queue<Node> q;

    q.push(Node(sx, sy, dir));

    dis[sx][sy][dir] = ;

    int tx = sx - dr[dir];//迷宫起点

    int ty = sy - dc[dir];

    while(!q.empty()){

        Node t = q.front();

        q.pop();

        if(t.x == ex && t.y == ey){

            print_ans(t, tx, ty, dir);

            return true;

        }

        for(int i = ; i < ; ++i){

            Node v = next(t, i);

            if(edge[t.x][t.y][t.d][i] && judge(v.x, v.y) && dis[v.x][v.y][v.d] < ){

                dis[v.x][v.y][v.d] = dis[t.x][t.y][t.d] + ;

                num[v.x][v.y][v.d] = t;

                q.push(v);

            }

        }

    }

    return false;

}

int main(){

    while(scanf("%s", s) == ){

        if(strcmp(s, "END") == ) return ;

        printf("%s\n", s);

        memset(edge, , sizeof edge);

        int sx, sy, ex, ey;

        char dir;

        scanf("%d%d %c%d%d", &sx, &sy, &dir, &ex, &ey);

        int d = dir_id(dir);//进起点的下一个点的朝向

        int nx = sx + dr[d];//起点的下一个位置

        int ny = sy + dc[d];

        int x;

        while(scanf("%d", &x) == ){

            if(x == ) break;

            int y;

            scanf("%d", &y);

            while(scanf("%s", s) == ){

                if(s[] == '*') break;

                int tmp_dir = dir_id(s[]);

                int len = strlen(s);

                for(int i = ; i < len; ++i){

                    int tmp_turn = turn_id(s[i]);

                    edge[x][y][tmp_dir][tmp_turn] = ;

                }

            }

        }

        bool ok = bfs(nx, ny, d, ex, ey);//起点的下一个点因为已知，所以将其当为开始的点

        if(!ok){

            printf("  No Solution Possible\n");

        }

    }

    return ;

}