#include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <queue>

 #include <stack>

 using namespace std;

 #define MAXNUM 105

 #define isDigit(ch) ch>='0' && ch<='9'

 typedef struct node_st{

     int x, y, time;

     node_st() {

     }

     node_st(int a, int b, int t) {

         x = a; y = b; time = t;

     }

     friend bool operator < (node_st p, node_st q) {

         return p.time > q.time;

     }

 } node_st;

 priority_queue<node_st> que;

 typedef struct subnode {

     int x, y;

     subnode() {

     }

     subnode (int a, int b) {

         x = a; y = b;

     }

 } subnode;

 stack<subnode> path;

 char map[MAXNUM][MAXNUM];

 bool visit[MAXNUM][MAXNUM];

 int pos[MAXNUM][MAXNUM];

 int direct[][]={{,-}, {-,}, {,}, {,}};

 int n, m;

 void output();

 bool check(int x, int y) {

     if (x>= && x<n && y>= && y<m) {

         if (visit[x][y]==false && map[x][y]!='X')

             return true;

         else

             return false;

     } else

         return false;

 }

 void bfs() {

     node_st cur, next;

     int newx, newy, newt;

     que.push(node_st(,,));

     visit[][] = true;

     while ( !que.empty() ) {

         cur = que.top();

         que.pop();

         // printf("cur node: x=%d,y=%d,cur.time=%d\n",cur.x, cur.y, cur.time);

         if (cur.x==n- && cur.y==m-) {

             printf("It takes %d seconds to reach the target position, let me show you the way.\n", cur.time);

             output();

             printf("FINISH\n");

             return ;

         }

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

             newx = cur.x + direct[i][];

             newy = cur.y + direct[i][];

             newt = cur.time + ;

             if ( check(newx, newy) ) {

                 next = node_st(newx, newy, newt);

                 if ( isDigit(map[newx][newy]) )

                     next.time += map[newx][newy] - '';

                 // printf("after check, ch=%c, time=%d\n", map[newx][newy], next.time);

                 pos[newx][newy] = i;

                 visit[newx][newy] = true;

                 que.push(next);

             }

         }

     }

     printf("God please help our poor hero.\n");

     printf("FINISH\n");

 }

 int main() {

     int i;

     while (scanf("%d %d", &n, &m) != EOF) {

         getchar();

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

             gets(map[i]);

         }

         memset(visit, false, sizeof(visit));

         memset(pos, , sizeof(pos));

         while (!que.empty())

             que.pop();

         while (!path.empty())

             path.pop();

         bfs();

     }

     return ;

 }

 void output() {

     subnode cur, next;

     int x, y, i, time = ;

     x = n-; y =m-;

     while (x||y) {

         path.push(subnode(x, y));

         i = pos[x][y];

         x -= direct[i][];

         y -= direct[i][];

     }

     // Don;t forget to push (0, 0)

     path.push(subnode(, ));

     cur = path.top();

     path.pop();

     while (!path.empty()) {

         next = path.top();

         x = cur.x;

         y = cur.y;

         if (map[x][y] != '.') {

             i = map[x][y] - '';

             while (i--) {

                 printf("%ds:FIGHT AT (%d,%d)\n", ++time, x, y);

             }

         }

         time++;

         printf("%ds:(%d,%d)->(%d,%d)\n", time, cur.x, cur.y, next.x, next.y);

         cur = path.top();

         path.pop();

     }

     // if final-point has a monster, then ight

     x = next.x;

     y = next.y;

     if (map[x][y] != '.') {

         i = map[x][y] - '';

         while (i--) {

             printf("%ds:FIGHT AT (%d,%d)\n", ++time, x, y);

         }

     }

 }