#include <bits/stdc++.h>

 using namespace std;

 struct Node{

     int r, c, dir;// 表示结点的横纵坐标和方向

     Node(int r = , int c = , int dir = ) :r(r), c(c), dir(dir) {};//对结构体元素进行初始化

 };

 const int maxn = ;

 const char *dirs = "NESW";

 const char *turns = "FLR";

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

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

 int has_edge[maxn][maxn][][];//保存(r, c, dir)状态下的可移动方向

 int d[maxn][maxn][];//存储初始状态到(r, c, dir)的最短路长度

 Node p[maxn][maxn][];//同时用p[r][c][dir]保存了状态(r, c, dir)在BFS树中的父节点

 int r0, c0, dir, r1, c1, r2, c2;

 char name[];

 int dir_id(char c) {

     return strchr(dirs, c) - dirs;

 }

 int turn_id(char c) {

     return strchr(turns, c) - turns;

 }

 Node walk(const Node &u, int turn) {

     int dir = u.dir;

     if(turn == ) dir = (dir + ) % ;//逆时针

     if(turn == ) dir = (dir + ) % ;//顺时针

     return Node(u.r + dr[dir], u.c + dc[dir], dir);

 }

 bool inside(int r, int c) {

     return r >=  && r <=  && c >=  && c <=;

 }

 bool read_case () {

     char s[], s2[];

     scanf("%s", name);

     if(!strcmp(name, "END")) return false;

     scanf("%d %d %s %d %d", &r0, &c0, s2, &r2, &c2);

     cout << name << endl;

     dir = dir_id(s2[]);

     r1 = r0 + dr[dir];

     c1 = c0 + dc[dir];

     memset(has_edge, , sizeof(has_edge));

     while(true) {

         int r, c;

         scanf("%d", &r);

         if(r == ) break;

         scanf("%d", &c);

         while(~scanf("%s", s) && s[] != '*') {

             for(int i = ; i < strlen(s); i ++)

                 has_edge[r][c][dir_id(s[])][turn_id(s[i])] = ;

         }

     }

     return true;

 }

 void print_ans(Node u) {

     //从目标节点逆序回溯到初始结点

     vector <Node> nodes;

     while(true) {

         nodes.push_back(u);

         if(d[u.r][u.c][u.dir] == ) break;

         u = p[u.r][u.c][u.dir];

     }

     nodes.push_back(Node(r0, c0, dir));

     //打印解，每行10个

     int cnt = ;

     for(int i = nodes.size() - ; i >= ; i --) {

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

             printf(" (%d,%d)", nodes[i].r, nodes[i].c);

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

     }

     if(nodes.size() %  != ) printf("\n");

 }

 void solve () {

     queue <Node> q;

     memset(d, -, sizeof(d));

     Node u(r1, c1, dir);

     d[u.r][u.c][u.dir] = ;

     q.push(u);

     while(!q.empty()) {

         Node u = q.front();

         q.pop();

         if(u.r == r2 && u.c == c2) {

             print_ans(u);

             return;

         }

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

             Node v = walk(u, i);

             if(has_edge[u.r][u.c][u.dir][i] && inside(v.r, v.c) && d[v.r][v.c][v.dir] < ) {

                 d[v.r][v.c][v.dir] = d[u.r][u.c][u.dir] + ;

                 p[v.r][v.c][v.dir] = u;

                 q.push(v);

             }

         }

     }

     printf("  No Solution Possible\n");

 }

 int main () {

     while(read_case()) {

         solve();

     }

     return ;

 }