#include <cstdio>

 #include <iostream>

 #include <cstring>

 #include <vector>

 #include <queue>

 #define max_n 10

 using namespace std;

 struct Node

 {

     int r;

     int c;

     int dir;

     Node(int r1=,int c1=,int d1=) :r(r1),c(c1),dir(d1) {}

     //构造Node,带有默认参数，不然会在Node p[][][]那里报错，认为这个语句是在构造Node

 };

 int d[max_n][max_n][];//表示初始状态到(r,c,dir)的最短路长度

 Node p[max_n][max_n][];//保存了状态(r,c,dir)在BFS数中的父结点

 int has_edge[max_n][max_n][][];//当前状态是(r,c,dir)，是否可以沿着转弯方向turn行走

 //行走

 const char* dirs = "NESW"; //顺时针旋转的顺序

 const char* turns = "FLR";

 int dir_id(char c) {return strchr(dirs,c)-dirs;} //将char类型的dir转化为dirs中相应的所在位置

 int turn_id(char c) {return strchr(turns,c)-turns;}//将char类型的turn在turns中找到对应的元素位置

 const int dr[] = {-,,,};//用上面找到的元素位置来确定当前行行走方向

 const int dc[] = {,,,-};//用上面找到的元素位置来确定当前列行走方向

 char maze[];//迷宫名称

 int r0,c0,dir;//原始位置和方向

 int r1,c1;//初始位置和方向

 int r2,c2;//目标位置

 //巧妙的行走函数和对应关系

 //dirs 0N 1E 2S 3W

 //顺时针

 //dir' 3  0  1  2

 //逆时针

 //dir' 1  2  3  0

 //dr  -1  0  1  0

 //dc   0  1  0 -1

 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);

 }

 //判断越界函数

 int inside(int r,int c)

 {

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

 }

 //输出函数

 //要求：

 //第一行输出迷宫名

 //后几行输出路径，且除最后一行外，其他每行都是空两格+10个(r,c)形式空格分隔的坐标

 void printa(Node u)

 {

     vector<Node> nodes;//可用递归方式打印，但可能溢栈，可改用循环，用vector存储

     for(;;)

     {

         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));

     int cnt = ;

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

     {

         if(cnt%==) //值得品味的细节1

         {

             printf(" ");

         }

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

         if(++cnt%==)//值得品味的细节2

         {

             printf("\n");

         }

     }

     if(nodes.size()%!=)

     {

         printf("\n");

     }

 }

 //输入函数

 //先读入迷宫名，若为END返回0，

 //然后一行读入起点r,c,dir,终点r,c

 //然后处理交叉处的方向改变，将这些信息用数组has_edge[r][c][dir][turn]记录下来，为以后BFS提供基础

 //读到*结束小循环，读到0结束大循环

 int read()

 {

     cin >> maze;

     if(maze[]=='E'&&maze[]=='N'&&maze[]=='D'&&strlen(maze)==) return ;

     cout << maze << endl;

     memset(maze,,sizeof(maze[]));

     char dirs;

     cin >> r0 >> c0 >> dirs >> r2 >> c2;

     dir = dir_id(dirs);

     r1 = r0+dr[dir];

     c1 = c0+dc[dir];

     memset(has_edge,,sizeof(has_edge));

     for(;;)

     {

         int r,c;

         cin >> r;

         if(r==)

         {

             break;

         }

         cin >> c;

         char chr[];

         while(cin >> chr)

         {

             if(chr[]=='*')

             {

                 break;

             }

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

             {

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

             }

             //cout << r << " " << c << " " << chr << endl;

             memset(chr,,sizeof(chr[]));

         }

     }

     return true;

 }

 //BFS主过程

 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)

         {

             printa(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())

     solve();

     return ;

 }