#include <iostream>
#include <vector>
#include <cstdio>
#include <sstream>
#include <map>
#include <string>
#include <algorithm>
#include <queue>
#include <cmath>
#include <functional>
#include <set>
#include <ctime>
#include <stack>
#include <random>
using namespace std;
template<class T> istream& operator >> (istream& is, vector<T>& vec){for(T& val: vec) is >> val; return is;}
template<class T> istream& operator , (istream& is, T& val){ return is >> val;}
template<class T> ostream& operator << (ostream& os, vector<T>& vec){for(int i=0; i<vec.size(); i++) os << vec[i] << (i==vec.size()-1?"\n":" ");return os;}

int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};

#include <cassert>

int main(){
	char buff[100];
	int s = 0;

	int cnt = 0;

	// 0 ?
	// 1 visit
	// 2 wall
	// 3 space
	vector<vector<int>> field(50, vector<int>(50, 0));

	int x = 25;
	int y = 25;
	int dir = 0;

	auto update = [&](){
		string s(buff);
		if(s=="Merry Christmas!") return -1;
		if(s=="20151224") return -2;

		int d;
		sscanf(buff, "%d", &d);
		for(int k=1; k<=d; k++){
			if( !field[x + k*dx[dir]][y + k*dy[dir]] ) field[x + k*dx[dir]][y + k*dy[dir]] = 3;
		}
		field[x + (d+1)*dx[dir] ][ y + (d+1) * dy[dir] ] = 2;
		return d;
	};

	auto check_foward = [&](){
		return field[x + dx[dir] ][y + dy[dir]];
	};

	auto check_right = [&](){
		return field[x + dx[(dir+1)&3]][y + dy[(dir+1)&3]];
	};
	auto check_left = [&](){
		return field[x + dx[(dir+1)&3]][y + dy[(dir+1)&3]];
	};

	auto go_foward = [&](){
		if(field[x + dx[dir]][y + dy[dir]] == 2) return;
		puts("F");
		cnt++;
		fflush(stdout);
		x += dx[dir];
		y += dy[dir];
		gets(buff);
		update();
	};

	auto go_backward = [&](){
		if(field[x + dx[(dir+2)&3]][y + dy[(dir+2)&3]] == 2) return;
		puts("B");
		cnt++;
		fflush(stdout);
		x -= dx[dir];
		y -= dy[dir];
		gets(buff);
		update();
	};

	auto turn_right = [&](){
		puts("R");
		cnt++;
		fflush(stdout);
		dir = (dir+1)&3;
		gets(buff);
		update();

	};

	auto turn_left = [&](){
		puts("L");
		cnt++;
		fflush(stdout);
		dir = (dir+3)&3;
		gets(buff);
		update();
	};

	stack<pair<pair<int,int>,int>> st;

	auto move_ = [&](pair<int,int> to){
		int diff_x = abs(to.first - x);
		int diff_y = abs(to.second - y);
		assert(diff_x + diff_y <= 1);

		if(pair<int,int>{x,y} != to){
			if(to == pair<int,int>{x+dx[(dir+1)&3], y+dy[(dir+1)&3]}){
				turn_right();
				go_foward();
			}else if(to == pair<int,int>{x+dx[(dir+3)&3], y+dy[(dir+3)&3]}){
				turn_left();
				go_foward();
			}else if(to == pair<int,int>{x+dx[(dir+2)&3], y+dy[(dir+2)&3]}){
				go_backward();
			}else{
				go_foward();
			}
		}
	};

	gets(buff);
/*
	while(true){
		int d = update();
		if(d<=0) break;
		go_foward();
	}
*/
	stack<pair<int,int>> unko;

	while(true){
		assert(cnt<=5000);

		int d = update();
		if(d==-1) return 0;
		if(d==-2){
			go_foward();
			continue;
		}


		if(field[x][y] == 0 || field[x][y] == 3){

			field[x][y] = 1;

			vector<pair<pair<int,int>,int>> hoge(5, {{-1,-1},-1});
			for(int i=0; i<4; i++){
				int z = check_foward();
				if(z==0 || z==3){
					hoge[i] = {{x,y},dir};
				}
				turn_right();
				update();
			}
			for(int i:{2,3,0,1}){
				if(hoge[i] == hoge[4]) continue;
				st.push(hoge[i]);
			}

		}

		while(st.top().first != pair<int,int>{x,y}){
			move_(unko.top());
			unko.pop();
		}

		if(st.top().first == pair<int,int>{x,y}){

			unko.push({x,y});
			
			while(st.top() != pair<pair<int,int>,int>{{x,y}, dir}){
				turn_right();
			}
			st.pop();
			go_foward();
			continue;
		}

	}
	return 0;
}