#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr int DX[4] = {+1, 0, -1, 0};
constexpr int DY[4] = {0, +1, 0, -1};

int GOTO(int l) { return 0 + l; }
int IF(int l) { return 8 + l; }
constexpr int FORWARD = 16;
constexpr int LEFT = 17;
constexpr int RIGHT = 18;

int M, N;
char A[11][11];
int SY, TY;

bool check(const vector<int> &prog) {
  bool vis[11][11][4][6] = {};
  for (int x = 0, y = SY, dir = 0, pc = 0; ; ) {
// cerr<<"  "<<prog<<": "<<x<<" "<<y<<" "<<dir<<" "<<pc<<endl;
    if (x == M - 1 && y == TY) return true;
    if (vis[x][y][dir][pc]) return false;
    vis[x][y][dir][pc] = true;
    const int op = prog[pc];
    if (0 <= op && op < 8) {
      pc = op - 0;
    } else if (8 <= op && op < 16) {
      const int xx = x + DX[dir];
      const int yy = y + DY[dir];
      if (0 <= xx && xx < M && 0 <= yy && yy < N && A[xx][yy] != '#') {
        pc = op - 8;
      } else {
        ++pc;
      }
    } else if (op == FORWARD) {
      const int xx = x + DX[dir];
      const int yy = y + DY[dir];
      if (0 <= xx && xx < M && 0 <= yy && yy < N && A[xx][yy] != '#') {
        x = xx;
        y = yy;
      }
      ++pc;
    } else if (op == LEFT) {
      ++dir &= 3;
      ++pc;
    } else if (op == RIGHT) {
      --dir &= 3;
      ++pc;
    } else {
      assert(false);
    }
    if (pc == (int)prog.size()) pc = 0;
  }
}


vector<int> ans;
int L;
vector<int> ops;
vector<int> prog;
void dfs(int l) {
  if (l == L) {
    if (check(prog)) {
      ans = prog;
    }
  } else {
    for (const int op : ops) {
      prog[l] = op;
      dfs(l + 1);
      if (ans.size()) return;
    }
  }
}

int main() {
  for (; ~scanf("%d%d", &M, &N); ) {
    for (int x = 0; x < M; ++x) {
      scanf("%s", A[x]);
    }
    SY = TY = -1;
    for (int y = 0; y < N; ++y) if (A[0][y] == 'S') SY = y;
    for (int y = 0; y < N; ++y) if (A[M - 1][y] == 'G') TY = y;
    
#ifdef LOCAL
cerr<<"["<<__LINE__<<"] "<<check({FORWARD,LEFT})<<endl;
cerr<<"["<<__LINE__<<"] "<<check({IF(2),LEFT,FORWARD})<<endl;
cerr<<"["<<__LINE__<<"] "<<check({RIGHT,RIGHT,FORWARD,GOTO(1)})<<endl;
cerr<<"["<<__LINE__<<"] "<<check({LEFT,FORWARD,RIGHT,FORWARD,IF(3)})<<endl;
#endif
    
    ans.clear();
    for (L = 1; L <= 4; ++L) {
      ops.clear();
      for (int l = 0; l < L; ++l) ops.push_back(GOTO(l));
      for (int l = 0; l < L; ++l) ops.push_back(IF(l));
      ops.push_back(FORWARD);
      ops.push_back(LEFT);
      ops.push_back(RIGHT);
      prog.resize(L);
      dfs(0);
      if (ans.size()) break;
    }
    if (!ans.size()) {
      ans = {LEFT, IF(4), RIGHT, GOTO(1), FORWARD};
      assert(check(ans));
    }
    
    printf("%d\n", (int)ans.size());
    for (const int op : ans) {
      if (0 <= op && op < 8) {
        printf("GOTO %d\n", (op - 0) + 1);
      } else if (8 <= op && op < 16) {
        printf("IF-OPEN %d\n", (op - 8) + 1);
      } else if (op == FORWARD) {
        puts("FORWARD");
      } else if (op == LEFT) {
        puts("LEFT");
      } else if (op == RIGHT) {
        puts("RIGHT");
      } else {
        assert(false);
      }
    }
  }
  return 0;
}