#include <bits/extc++.h>
#include<ext/rope>
using namespace __gnu_cxx;
using namespace std;
#define ll long long
#define ull unsigned ll
#define ui unsigned int
#define i128 __int128
#define lid (id << 1)
#define rid (id << 1 | 1)
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int N = 5e5+5;
#ifdef ONLINE_JUDGE
#define cin IO::InputHelper::get_instance()
#define cout IO::OutputHelper::get_instance()
#define INPUT_FILE ""
#define OUTPUT_FILE ""
namespace IO {
	using size_type = size_t;
	static constexpr size_type INPUT_BUFFER_SIZE = 1 << 16, OUTPUT_BUFFER_SIZE = 1 << 16, MAX_INTEGER_SIZE = 20, MAX_FLOAT_SIZE = 50;static constexpr char input_file[] = INPUT_FILE, output_file[] = OUTPUT_FILE;
	struct InputHelper {
		FILE *m_file_ptr;char m_buf[INPUT_BUFFER_SIZE], *m_end, *m_cursor;bool m_ok;
		InputHelper &set_bad() { return m_ok = false, *this; }
		template <size_type BlockSize>
		void _reserve() {size_type a = m_end - m_cursor;if (a >= BlockSize) return;memmove(m_buf, m_cursor, a), m_cursor = m_buf;size_type b = a + fread(m_buf + a, 1, INPUT_BUFFER_SIZE - a, m_file_ptr);if (b < INPUT_BUFFER_SIZE) m_end = m_buf + b, *m_end = EOF;}
		template <typename Tp, typename BinaryOperation>
		InputHelper &fill_integer(Tp &ret, BinaryOperation op) {if (!isdigit(*m_cursor)) return set_bad();ret = op(Tp(0), *m_cursor - '0');size_type len = 1;while (isdigit(*(m_cursor + len))) ret = op(ret * 10, *(m_cursor + len++) - '0');m_cursor += len;return *this;}
		explicit InputHelper(const char *inputFileName) : m_ok(true), m_cursor(m_buf + INPUT_BUFFER_SIZE), m_end(m_buf + INPUT_BUFFER_SIZE) { m_file_ptr = *inputFileName ? fopen(inputFileName, "rt") : stdin; }
		~InputHelper() { fclose(m_file_ptr); }
		static InputHelper &get_instance() {static InputHelper s_obj(input_file);return s_obj;}
		static bool is_blank(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }static bool is_endline(char c) { return c == '\n' || c == EOF; }
		const char &getchar_checked() {_reserve<1>();return *m_cursor;}const char &getchar_unchecked() const { return *m_cursor; }
		void next() { ++m_cursor; }
		template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {while (is_blank(getchar_checked())) next();_reserve<MAX_INTEGER_SIZE>();if (getchar_unchecked() != '-') return fill_integer(num, std::plus<Tp>());next();return fill_integer(num, std::minus<Tp>());}
		template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {while (is_blank(getchar_checked())) next();_reserve<MAX_INTEGER_SIZE>();return fill_integer(num, std::plus<Tp>());}
		template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
		InputHelper &operator>>(Tp &num) {
			bool neg = false, integer = false, decimal = false;while (is_blank(getchar_checked())) next();_reserve<MAX_FLOAT_SIZE>();
			if (getchar_unchecked() == '-') {neg = true;next();}if (!isdigit(getchar_unchecked()) && getchar_unchecked() != '.') return set_bad();
			if (isdigit(getchar_unchecked())) {integer = true;num = getchar_unchecked() - '0';while (next(), isdigit(getchar_unchecked())) num = num * 10 + (getchar_unchecked() - '0');}
			if (getchar_unchecked() == '.') if (next(), isdigit(getchar_unchecked())) {if (!integer) num = 0;decimal = true;Tp unit = 0.1;num += unit * (getchar_unchecked() - '0');while (next(), isdigit(getchar_unchecked())) num += (unit *= 0.1) * (getchar_unchecked() - '0');}
			if (!integer && !decimal) return set_bad();if (neg) num = -num;return *this;
		}
		InputHelper &operator>>(char &c) {while (is_blank(getchar_checked())) next();if (getchar_checked() == EOF) return set_bad();c = getchar_checked(), next();return *this;}
		InputHelper &operator>>(std::string &s) {while (is_blank(getchar_checked())) next();if (getchar_checked() == EOF) return set_bad();s.clear();do {s += getchar_checked();next();} while (!is_blank(getchar_checked()) && getchar_unchecked() != EOF);return *this;}
		explicit operator bool() { return m_ok; }
	};
	struct OutputHelper {
		FILE *m_file_ptr = nullptr;char m_buf[OUTPUT_BUFFER_SIZE], *m_end, *m_cursor;char m_temp_buf[MAX_FLOAT_SIZE], *m_temp_buf_cursor, *m_temp_buf_dot;uint64_t m_float_reserve, m_float_ratio;
		void _write() { fwrite(m_buf, 1, m_cursor - m_buf, m_file_ptr), m_cursor = m_buf; }
		template <size_type BlockSize> void _reserve() {size_type a = m_end - m_cursor;if (a >= BlockSize) return;_write();}
		OutputHelper(const char *outputFileName, size_type prec = 6) : m_cursor(m_buf), m_end(m_buf + OUTPUT_BUFFER_SIZE), m_temp_buf_cursor(m_temp_buf) { m_file_ptr = *outputFileName ? fopen(outputFileName, "wt") : stdout, precision(prec); }
		static OutputHelper &get_instance() {static OutputHelper s_obj(output_file);return s_obj;}
		~OutputHelper() { flush(), fclose(m_file_ptr); }
		void precision(size_type prec) { m_float_reserve = prec, m_float_ratio = uint64_t(std::pow(10, prec)), m_temp_buf_dot = m_temp_buf + prec; }
		OutputHelper &flush() { return _write(), fflush(m_file_ptr), *this; }
		void putchar(const char &c) {if (m_cursor == m_end) _write();*m_cursor++ = c;}
		template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {_reserve<MAX_INTEGER_SIZE>();size_type len = 0;if (ret >= 0) do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;while (ret);else {putchar('-');do *(m_cursor + len++) = '0' - ret % 10, ret /= 10;while (ret);}for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));m_cursor += len;return *this;}
		template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {_reserve<MAX_INTEGER_SIZE>();size_type len = 0;do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;while (ret);for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));m_cursor += len;return *this;}
		template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
		OutputHelper &operator<<(Tp ret) {
			if (ret < 0) {putchar('-');return *this << -ret;}ret *= m_float_ratio;uint64_t integer = ret;if (ret - integer >= 0.4999999999) integer++;do {*m_temp_buf_cursor++ = '0' + integer % 10;integer /= 10;} while (integer);
			if (m_temp_buf_cursor > m_temp_buf_dot) {do putchar(*--m_temp_buf_cursor);while (m_temp_buf_cursor > m_temp_buf_dot);putchar('.');}else {putchar('0'), putchar('.');for (size_type i = m_temp_buf_dot - m_temp_buf_cursor; i--;) putchar('0');}
			do putchar(*--m_temp_buf_cursor);while (m_temp_buf_cursor > m_temp_buf);
			return *this;
		}
		OutputHelper &operator<<(const char &ret) {putchar(ret);return *this;}
		OutputHelper &operator<<(const char *ret) {while (*ret) putchar(*ret++);return *this;}
		OutputHelper &operator<<(const std::string &ret) { return *this << ret.data(); }
	};
	InputHelper &getline(InputHelper &ih, std::string &line) {line.clear();if (ih.getchar_checked() == EOF) return ih.set_bad();while (!InputHelper::is_endline(ih.getchar_checked())) line += ih.getchar_unchecked(), ih.next();if (ih.getchar_unchecked() != EOF) ih.next();return ih;}
}using IO::getline;
#endif
#if __cpp_constexpr >= 201304L
#define CONSTEXPR14 constexpr 
#else
#define CONSTEXPR14 
#endif
template <uint32_t P>
struct ModInt32 {
	using mint = ModInt32<P>;
	using mod_type = uint32_t;
	mod_type m_val;
	static constexpr mod_type _reduce_norm(int32_t x) { return x < 0 ? x + mod() : x; }
	static constexpr mod_type _mul(mod_type a, mod_type b) { return uint64_t(a) * b % mod(); }
	constexpr ModInt32() : m_val(0) {}
	template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value>::type * = nullptr>
	constexpr ModInt32(Tp val) : m_val(_reduce_norm(val % int32_t(mod()))) {}
	template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value>::type * = nullptr>
	constexpr ModInt32(Tp val) : m_val(val % mod()) {}
	static CONSTEXPR14 mint raw(mod_type val) {mint res{};res.m_val = val;return res;}
	static constexpr mod_type mod() { return P; }
	constexpr mod_type val() const { return m_val; }
	CONSTEXPR14 mint pow(uint64_t n) const {mod_type res = 1, b = m_val;while (n) {if (n & 1) res = _mul(res, b);b = _mul(b, b), n >>= 1;}return raw(res);}
	CONSTEXPR14 mint inv() const { return pow(mod() - 2); }
	CONSTEXPR14 mint &operator++() {if (++m_val == mod()) m_val = 0;return *this;}
	CONSTEXPR14 mint &operator--() {if (!m_val) m_val = mod();m_val--;return *this;}
	CONSTEXPR14 mint operator++(int) {mint old(*this);++*this;return old;}
	CONSTEXPR14 mint operator--(int) {mint old(*this);--*this;return old;}
	CONSTEXPR14 mint &operator+=(const mint &rhs) {m_val += rhs.m_val;if (m_val >= mod()) m_val -= mod();return *this;}
	CONSTEXPR14 mint &operator-=(const mint &rhs) {m_val += mod() - rhs.m_val;if (m_val >= mod()) m_val -= mod();return *this;}
	CONSTEXPR14 mint &operator*=(const mint &rhs) {m_val = _mul(m_val, rhs.m_val);return *this;}
	constexpr mint operator+() const { return *this; }
	constexpr mint operator-() const { return raw(m_val ? mod() - m_val : 0); }
	constexpr bool operator==(const mint &rhs) const { return m_val == rhs.m_val; }
	constexpr bool operator!=(const mint &rhs) const { return m_val != rhs.m_val; }
	constexpr bool operator<(const mint &rhs) const { return m_val < rhs.m_val; }
	constexpr bool operator>(const mint &rhs) const { return m_val > rhs.m_val; }
	constexpr bool operator<=(const mint &rhs) const { return m_val <= rhs.m_val; }
	constexpr bool operator>=(const mint &rhs) const { return m_val <= rhs.m_val; }
	template <typename Tp>
	constexpr explicit operator Tp() const { return Tp(m_val); }
	friend CONSTEXPR14 mint operator+(const mint &a, const mint &b) { return mint(a) += b; }
	friend CONSTEXPR14 mint operator-(const mint &a, const mint &b) { return mint(a) -= b; }
	friend CONSTEXPR14 mint operator*(const mint &a, const mint &b) { return mint(a) *= b; }
};
template <typename Istream, uint32_t P>
Istream &operator>>(Istream &is, ModInt32<P> &x) { return is >> x.m_val; }
template <typename Ostream, uint32_t P>
Ostream &operator<<(Ostream &os, const ModInt32<P> &x) { return os << x.val(); }
random_device seed;
mt19937 rnd(seed());
mt19937_64 rnd_64(seed());
namespace tianyu{
	int n, m;
	vector<int> G[N];
	vector<pii> G1[N];
	int ax[N], ay[N];
	int dfn[N], low[N], tot, scc[N], scnt;
	bool vis[N];
	stack<int> st;
	int rt[N], bid[N];	
	void tarjan(int u, int f){
		st.emplace(u);
		dfn[u] = low[u] = ++tot;
		vis[u] = 1;
		for (int v : G[u]){
			if (v == f) continue;
			if (!dfn[v]){
				tarjan(v, u);
				low[u] = min(low[u], low[v]);
			}
			else if (vis[v]) low[u] = min(low[u], dfn[v]);
		}
		if (dfn[u] == low[u]){
			++scnt;while (1){
				int st1 = st.top();st.pop();
				scc[st1] = scnt;
				vis[st1] = 0;
				if (st1 == u) break;
			}
		}
	}
	int fa[N];
	void dfs(int u, int f, int r){
		rt[u] = r;fa[u] = f;
		for (auto [v, id] : G1[u]){
			if (v == f) continue;
			bid[v] = id;
			dfs(v, u, r);
		}
	}
	int ad[N];
	int ans[N];
	void dfs1(int u, int f){
		for (auto [v, id] : G1[u]){
			if (v == f) continue;
			dfs1(v, u);
			ad[u] += ad[v];
		}
		if (u != rt[u]){
			int id = bid[u], x = ax[bid[u]], y = ay[bid[u]];
			int cx = scc[x], cy = scc[y];
			if (cx == u){
				if (ad[u] > 0) ans[id] = 1;
				else if (ad[u] < 0) ans[id] = -1;
				else ans[id] = 0;
			}
			else{
				if (ad[cy] < 0) ans[id] = 1;
				else if (ad[cy] > 0) ans[id] = -1;
				else ans[id] = 0;
			}
		}
	}
	void awa(){
		cin >> n >> m;
		for (int i = 1;i <= m;i++){
			cin >> ax[i] >> ay[i];
			G[ax[i]].emplace_back(ay[i]);
			G[ay[i]].emplace_back(ax[i]);
		}
		for (int i = 1;i <= n;i++) if (!dfn[i]) tarjan(i, 0);
		for (int i = 1;i <= m;i++){
			int u = scc[ax[i]], v = scc[ay[i]];
			if (u != v){
				G1[u].emplace_back(v, i);
				G1[v].emplace_back(u, i);
			}
		}
		for (int i = 1;i <= scnt;i++){
			if (!rt[i]){
				dfs(i, 0, i);
			}
		}
		int k;
		cin >> k;
		while (k--){
			int x, y;
			cin >> x >> y;
			if (scc[x] == scc[y]) continue;
			x = scc[x], y = scc[y];
			++ad[x];
			--ad[y];
		}
		for (int i = 1;i <= scnt;i++){
			if (rt[i] == i){
				dfs1(i, 0);
			}
		}
		for (int i = 1;i <= m;i++){
			if (ans[i] == 1) cout << 'R';
			else if (ans[i] == -1) cout << 'L';
			else cout << 'B';
		}
	}
}
signed main(){
	int T = 1;
	while (T--) tianyu::awa();
	return 0;
}