#include <bits/stdc++.h>
#define sz(x) ((int)(x).size())
#define all(x) begin(x), end(x)
#define rep(i, l, r) for (int i = (l), i##end = (r); i <= i##end; ++i)
#define per(i, l, r) for (int i = (l), i##end = (r); i >= i##end; --i)
#ifdef memset0
#define log(...) fprintf(stderr, __VA_ARGS__)
#else
#define log(...) (void(0))
#define endl '\n'
#endif
using namespace std;
using ll = long long;
using lf = long double;
using lll = __int128;
using ull = unsigned long long;

const int N = 11, M = N * N * 4 + 9;
const int nxt[4][2] = {
    {1, 0},
    {0, -1},
    {-1, 0},
    {0, 1},
};
int n, m, tot, s, e[4], a[N][N], id[N][N][4], lt[M], rt[M], fr[M], ep[M];
string ord(int u) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++)
      for (int k = 0; k < 4; k++)
        if (id[i][j][k] == u) {
          return to_string(i) + ", " + to_string(j) + ", " + to_string(k);
        }
  return "???";
}

const int lim_commands = 20;
const int lim_controls = 5;
enum COMMAND { LT, RT, FR, GOTO, IF };
int len, cnt;
struct command {
  COMMAND o;
  int j;
} c[lim_commands];
ostream &operator<<(ostream &out, const command &rhs) {
  switch (rhs.o) {
  case LT:
    out << "LEFT";
    break;
  case RT:
    out << "RIGHT";
    break;
  case FR:
    out << "FORWARD";
    break;
  case GOTO:
    out << "GOTO";
    break;
  case IF:
    out << "IF-OPEN";
    break;
  }
  if (rhs.o == GOTO || rhs.o == IF) {
    out << ' ' << (rhs.j + 1);
  }
  return out;
}

int tim, vis[lim_commands][M];
bool check() {
  // log("=== check ===\n");
  // for (int i = 0; i < len; i++) cerr << c[i] << endl;
  int pc = 0, u = s;
  ++tim;
  vis[pc][u] = tim;
  while (true) {
    // log("> %d %d(%s) : ", pc, u, ord(u).c_str());
    // cerr << c[pc] << endl;
    if (c[pc].o == LT) {
      pc = (pc + 1) % len;
      u = lt[u];
    } else if (c[pc].o == RT) {
      pc = (pc + 1) % len;
      u = rt[u];
    } else if (c[pc].o == FR) {
      pc = (pc + 1) % len;
      u = fr[u];
    } else if (c[pc].o == IF) {
      if (ep[u]) {
        pc = c[pc].j;
      } else {
        pc = (pc + 1) % len;
      }
    } else if (c[pc].o == GOTO) {
      pc = c[pc].j;
    }
    if (u == e[0] || u == e[1] || u == e[2] || u == e[3]) return true;
    if (vis[pc][u] == tim) return false;
    vis[pc][u] = tim;
  }
  return false;
}

void dfs(int u) {
  if (u == len) {
    if (check()) {
      cout << len << endl;
      for (int i = 0; i < len; i++) {
        cout << c[i] << endl;
      }
      exit(0);
    }
    return;
  }
  c[u].o = LT, dfs(u + 1);
  c[u].o = RT, dfs(u + 1);
  c[u].o = FR, dfs(u + 1);
  if (cnt <= lim_controls) {
    c[u].o = IF, ++cnt;
    for (c[u].j = 0; c[u].j < len; c[u].j++) {
      dfs(u + 1);
    }
    --cnt;
    c[u].o = GOTO, ++cnt;
    for (c[u].j = 0; c[u].j < len; c[u].j++) {
      dfs(u + 1);
    }
    --cnt;
  }
}

int main() {
#ifdef memset0
  freopen("C.in", "r", stdin);
#endif
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> m;
  for (int i = 0; i < n; i++) {
    string buf;
    cin >> buf;
    for (int j = 0; j < m; j++) {
      if (buf[j] == '#') {
        a[i][j] = 1;
      } else {
        for (int k = 0; k < 4; k++) id[i][j][k] = ++tot;
        if (buf[j] == 'S') {
          s = id[i][j][0];
        } else if (buf[j] == 'G') {
          for (int k = 0; k < 4; k++) e[k] = id[i][j][k];
        }
      }
    }
  }
  for (int i = 0; i < n; i++)
    for (int j = 0; j < m; j++)
      for (int k = 0; k < 4; k++)
        if (id[i][j][k]) {
          rt[id[i][j][k]] = id[i][j][(k + 1) % 4];
          // log("rt[%d] = %d\n", id[i][j][k], rt[id[i][j][k]]);
          lt[id[i][j][k]] = id[i][j][(k + 3) % 4];
          int vi = i + nxt[k][0];
          int vj = j + nxt[k][1];
          if (vi >= 0 && vj >= 0 && vi < n && vj < m && a[vi][vj] == 0) {
            ep[id[i][j][k]] = true;
            fr[id[i][j][k]] = id[vi][vj][k];
          } else {
            ep[id[i][j][k]] = false;
            fr[id[i][j][k]] = id[i][j][k];
          }
        }

  // len = 4;
  // c[0].o = LT;
  // c[1].o = FR;
  // c[2].o = RT;
  // c[3].o = FR;
  // cerr << check() << endl;
  // return 0;

  for (len = 1; len < lim_commands; len++) {
    log(">>> len = %d\n", len);
    dfs(0);
  }
}

/*
> 0 5(0, 3, 0) : LEFT
> 1 8(0, 3, 3) : FORWARD
> 2 12(0, 4, 3) : RIGHT
> 3 9(0, 4, 0) : FORWARD
> 0 37(1, 4, 0) : LEFT
> 1 40(1, 4, 3) : FORWARD
> 2 44(1, 5, 3) : RIGHT
> 3 41(1, 5, 0) : FORWARD
> 0 73(2, 5, 0) : LEFT
> 1 76(2, 5, 3) : FORWARD
> 2 76(2, 5, 3) : RIGHT
> 3 73(2, 5, 0) : FORWARD
> 0 97(3, 5, 0) : LEFT
> 1 100(3, 5, 3) : FORWARD
> 2 104(3, 6, 3) : RIGHT
> 3 101(3, 6, 0) : FORWARD
> 0 133(4, 6, 0) : LEFT
> 1 136(4, 6, 3) : FORWARD
> 2 140(4, 7, 3) : RIGHT
> 3 137(4, 7, 0) : FORWARD
> 0 177(5, 7, 0) : LEFT
> 1 180(5, 7, 3) : FORWARD
> 2 184(5, 8, 3) : RIGHT
> 3 181(5, 8, 0) : FORWARD
> 0 181(5, 8, 0) : LEFT
> 1 184(5, 8, 3) : FORWARD
> 2 188(5, 9, 3) : RIGHT
> 3 185(5, 9, 0) : FORWARD
> 0 209(6, 9, 0) : LEFT
> 1 212(6, 9, 3) : FORWARD
> 2 212(6, 9, 3) : RIGHT
> 3 209(6, 9, 0) : FORWARD
> 0 237(7, 9, 0) : LEFT
> 1 240(7, 9, 3) : FORWARD
> 2 240(7, 9, 3) : RIGHT
> 3 237(7, 9, 0) : FORWARD
> 0 265(8, 9, 0) : LEFT
> 1 268(8, 9, 3) : FORWARD
> 2 268(8, 9, 3) : RIGHT
> 3 265(8, 9, 0) : FORWARD
1
*/