#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

#define A first
#define B second

typedef pair<LL,LL> PT;
typedef pair<PT,PT> LINE;

void fixup(LINE &line)
{
	if (line.A > line.B)
		swap(line.A, line.B);
}

int N[2];
LINE lines[4][2345];

bool intersects(int a, int b, int c, int d)
{
	return min(a,b) <= max(c,d) && max(a,b) >= min(c,d);
}

bool merge(int L, int a, int b)
{
	int adx = lines[L][a].B.A - lines[L][a].A.A;
	int ady = lines[L][a].B.B - lines[L][a].A.B;
	int bdx = lines[L][b].B.A - lines[L][b].A.A;
	int bdy = lines[L][b].B.B - lines[L][b].A.B;
	if (adx*bdy != ady*bdx) return false;
	if (!intersects(lines[L][a].A.A, lines[L][a].B.A, lines[L][b].A.A, lines[L][b].B.A)) return false;
	if (!intersects(lines[L][a].A.B, lines[L][a].B.B, lines[L][b].A.B, lines[L][b].B.B)) return false;
	LINE newline;
	newline.A = min(lines[L][a].A, lines[L][b].A);
	newline.B = max(lines[L][a].B, lines[L][b].B);
	lines[L][a] = newline;
	lines[L][b] = lines[L][--N[L]];
	return true;
}

LL sqr(LL x)
{
	return x*x;
}

LL dist(const LINE &ln)
{
	return sqr(ln.B.A - ln.A.A) + sqr(ln.B.B - ln.A.B);
}

int main()
{
	char cmd[8];
	while (true) {
		for (int L = 0; L < 2; ++L) {
			int pos_x = 0, pos_y = 0;
			N[L] = 0;
			while (true) {
				scanf("%s", cmd);
				if (cmd[0] == 'Q') return 0;
				if (cmd[0] == 'E') break;
				int x, y;
				scanf("%d %d", &x, &y);
				if (cmd[0] == 'M') {
					pos_x += x;
					pos_y += y;
				} else if (cmd[0] == 'L') {
					int nx = pos_x + x;
					int ny = pos_y + y;
					lines[L][N[L]] = make_pair(make_pair(pos_x,pos_y), make_pair(nx,ny));
					fixup(lines[L][N[L]]);
					N[L] += 1;
					pos_x = nx;
					pos_y = ny;
				}
			}
			bool changed = true;
			while (changed) {
				changed = false;
				for (int i = 0; i < N[L]; ++i) {
					for (int j = i+1; j < N[L]; ++j) {
						if (merge(L, i, j)) changed = true;
					}
				}
			}
			//printf("there are %d lines[L]:\n", N[L]);
			//for (int i = 0; i < N[L]; ++i)
			//	printf("(%3lld %3lld) -> (%3lld %3lld)\n", lines[L][i].A.A, lines[L][i].A.B, lines[L][i].B.A, lines[L][i].B.B);
		}

		if (N[0] != N[1]) {
			puts("NO");
			continue;
		}
		if (N[0] == 0) {
			puts("YES");
			continue;
		}

		LL n = N[0];
		LL v[2];
		LINE vl;

		LL l = 123123123123123LL;
		for (int i = 0; i < n; ++i) {
			LL ll = dist(lines[0][i]);
			if (ll < l) {
				l = ll;
				vl = lines[0][i];
				v[0] = lines[0][i].B.A - lines[0][i].A.A;
				v[1] = lines[0][i].B.B - lines[0][i].A.B;
			}
		}

		for (int i = 0; i < n; ++i) {
			lines[0][i].A.A = lines[0][i].A.A - vl.A.A;
			lines[0][i].A.B = lines[0][i].A.B - vl.A.B;
			lines[0][i].B.A = lines[0][i].B.A - vl.A.A;
			lines[0][i].B.B = lines[0][i].B.B - vl.A.B;
		}

		for (int i = 0; i < n; ++i) {
			LL w[2];
			PT wp;
			w[0] = lines[1][i].B.A - lines[1][i].A.A;
			w[1] = lines[1][i].B.B - lines[1][i].A.B;
			
			for (int dir = 0; dir < 2; ++dir) {
				if (dir) {
					w[0] = -w[0];
					w[1] = -w[1];
					wp = lines[1][i].B;
				} else {
					wp = lines[1][i].A;
				}
				LL B[2][2];
				B[0][0] = w[0]*v[0] + w[1]*v[1];
				B[0][1] = w[0]*v[1] - w[1]*v[0];
				B[1][0] = w[1]*v[0] - w[0]*v[1];
				B[1][1] = w[0]*v[0] + w[1]*v[1];

//				LL b[2] = {0, 0};
//				LL c[2] = {0, 0};
//				for (int j = 0; j < n; ++j) {
//					c[0] += lines[0][j].A.A + lines[0][j].B.A;
//					c[1] += lines[0][j].A.B + lines[0][j].B.B;
//					b[0] += lines[1][j].A.A + lines[1][j].B.A;
//					b[1] += lines[1][j].A.B + lines[1][j].B.B;
//				}
//				for (int j = 0; j < 2; ++j) {
//					b[j] *= l;
//					b[j] -= B[j][0] * c[0] + B[j][1] * c[1];
//				}

				for (int j = 0; j < n; ++j) {
					lines[3][j].A.A = (lines[1][j].A.A - wp.A)*l;
					lines[3][j].A.B = (lines[1][j].A.B - wp.B)*l;
					lines[3][j].B.A = (lines[1][j].B.A - wp.A)*l;
					lines[3][j].B.B = (lines[1][j].B.B - wp.B)*l;
				}

				sort(lines[3], lines[3]+n);

				for (int j = 0; j < n; ++j) {
					lines[2][j].A.A = B[0][0] * lines[0][j].A.A + B[0][1] * lines[0][j].A.B;
					lines[2][j].A.B = B[1][0] * lines[0][j].A.A + B[1][1] * lines[0][j].A.B;
					lines[2][j].B.A = B[0][0] * lines[0][j].B.A + B[0][1] * lines[0][j].B.B;
					lines[2][j].B.B = B[1][0] * lines[0][j].B.A + B[1][1] * lines[0][j].B.B;
					fixup(lines[2][j]);
				}

				sort(lines[2], lines[2]+n);

				if (memcmp(lines[2], lines[3], n*sizeof(lines[0][0])) == 0) {
					puts("YES");
					goto HELL;
				}
			}
		}
		puts("NO");
HELL:
		;
	}
	return 0;
}