#include<cstdio>
#include<vector>
#include<cassert>
#include<cmath>
#include<algorithm>
using namespace std;

#define debug if(0)

const int N = 20004;

const long double eps = 1e-8L;

const int inf = 1000000;
template <typename K>
struct xy {
	K x, y;
	xy(K _x=inf, K _y=inf):x(_x),y(_y){};
	void print(){
		printf("(%d %d)",x,y);
	}
	bool operator < (const xy& xy2) const{
		if(x!=xy2.x) return x<xy2.x;
		return y<xy2.y;
	}
	bool operator != (const xy& xy2) const{
		return x!=xy2.x || y!=xy2.y;
	}
};

template <typename K>
long double operator * (xy<K> a, xy<K> b){
	return a.x*b.x + a.y*b.y;
}

template <typename K>
xy<K> operator - (const xy<K> &a, const xy<K> &b){
	return xy<K>(a.x-b.x, a.y-b.y);
};

template <typename K>
struct seg {
	xy<K> a,b;
	seg(xy<K> _a, xy<K> _b):a(_a), b(_b) {}
	seg(){}
	void normalize(){
		if(a.x==b.x){
			if(a.y> b.y) swap(a,b);
		} else {
			if(a.x > b.x) swap(a,b);
		}
	}
	void print(){
		printf("<"); a.print(); printf(", "); b.print(); printf(">\n");
	}
	long double len (){
		long double X = a.x - b.x;
		long double Y = a.y - b.y;
		return sqrt(X*X+Y*Y);
	}
	bool operator == (const seg& s2) const {
		return a.x==s2.a.x && a.y==s2.a.y &&
			b.x==s2.b.x && b.y==s2.b.y;
	}
	bool operator < (const seg& s2) const {
		if(a!=s2.a) return a<s2.a;
		return b<s2.b;
	}
};

template<typename K>
K det(const xy<K> &a, const xy<K> &b){
	return a.x*b.y - b.x*a.y;
}

template<typename K>
bool parallel(const seg<K> &r, const seg<K> &t){
	return 
		det(r.b - r.a, t.a-r.a)==0 &&
		det(r.b - r.a, t.b-r.a)==0;
}

vector<seg<int> >tmp;
bool color[N];

bool should_merge(seg<int> r, seg<int> t){
	if(!parallel(r,t)) return false;
	int a,b,c,d;
	if(r.a.x==r.b.x){ //pionowy
		a = r.a.y;
		b = r.b.y;
		c = t.a.y;
		d = t.b.y;
	} else {
		a = r.a.x;
		b = r.b.x;
		c = t.a.x;
		d = t.b.x;
	}
	if(a>b) swap(a,b);
	if(c>d) swap(c,d);
	return (c>=a && c<=b) || (d>=a && d<=b) ||
		(a>=c && a<=d) || (b>=c && b<=d);
}

seg<int> merge(seg<int> r, seg<int> t){
	r.normalize(); t.normalize();
	if(r.a.x==r.b.x){ //pionowy
		seg <int>res;
		if(r.a.y < t.a.y) res.a = r.a;
		else res.a = t.a;

		if(r.b.y > t.b.y) res.b = r.b;
		else res.b = t.b;

		return res;
	} else {
		seg<int> res;
		if(r.a.x < t.a.x) res.a = r.a;
		else res.a = t.a;

		if(r.b.x > t.b.x) res.b = r.b;
		else res.b = t.b;

		return res;
	}
}

void normalize(vector<seg<int> >&v){
	int n = v.size();
	for(int i=0; i<n; i++){
		color[i] = true;
	}
	tmp = v;
	v. clear();
	for(int i=0; i<(int)tmp.size(); i++) if(color[i]){
		color[i] = false;
		for(int j=0; j<(int)tmp.size(); j++) if(color[j]){
			if(should_merge(tmp[i], tmp[j])){
				debug{
					printf("\nmerging \n");
					tmp[i].print(); tmp[j].print();
				}
				tmp [i] = merge(tmp[i], tmp[j]);
				debug {
					printf("out:\n");
					tmp[i].print();
				}
				color[j] = false;
			}
		}
		v.push_back(tmp[i]);
	}
}

char op[32];
bool read(vector<seg<int> >&v){
	v.clear();
	int x=0, y=0;
	while(1){
		int a,b;
		scanf("%s", op);
		if(op[0]=='E') break;
		if(op[0]=='Q') return false;
		if(op[0]=='L'){
			scanf("%d %d",&a,&b);
			if(a!=0 || b!=0){
				v.push_back(seg<int>(xy<int>(x,y), xy<int>(x+a, y+b)));
				x+=a; y+=b;
			}
		} else { //M
			scanf("%d %d",&a,&b);
			x += a; y += b;
		}
	}
	debug {printf("read: %d\n",(int)v.size());}
	normalize(v);
	debug {printf("norm: %d\n",(int)v.size());}
	return true;
}

long double veclen(xy<int>p, xy<int>q){
	return (q.x*p.y-q.y*p.x); }

long double kat(seg<int> a, seg<int> b){
	xy<int> p (a.b.x-a.a.x, a.b.y-a.a.y);
	xy<int> q (b.b.x-a.a.x, b.b.y-a.a.y);
	return atan2(veclen(p,q), p*q); //XXX
}

xy<long double> rotate(xy<long double> pt, long double alpha) {
	return xy<long double>(pt.x*cos(alpha) + pt.y*sin(alpha), -pt.x*sin(alpha) + pt.y*cos(alpha));
}

int roundd(long double x){
	x = round(x)+1000000.5;
	return ((int)x) - 1000000;
}

bool ok;
seg<int> trans(long double resiz, xy<int> mov, long double alpha, seg<int> s){
	debug {
		printf("\n");
		s.print();
	}
	seg<long double> res = seg<long double>(xy<long double>(s.a.x, s.a.y), xy<long double>(s.b.x, s.b.y));
	res.a.x *= resiz;
	res.a.y *= resiz;
	res.b.x *= resiz;
	res.b.y *= resiz;
	res.a.x += mov.x;
	res.a.y += mov.y;
	res.b.x += mov.x;
	res.b.y += mov.y;
	res.a = rotate(res.a, alpha);
	res.b = rotate(res.b, alpha);

	xy<int>A(roundd(res.a.x), roundd(res.a.y));
	xy<int>B(roundd(res.b.x), roundd(res.b.y));
	if(fabs(A.x - res.a.x)>eps) ok = false;
	if(fabs(A.y - res.a.y)>eps) ok = false;
	if(fabs(B.x - res.b.x)>eps) ok = false;
	if(fabs(B.y - res.b.y)>eps) ok = false;

	seg<int>RES(A,B);

	debug{
		printf("translates to\n");
		RES.print();
		printf("\n");
	}
	return RES;
}

vector<seg<int> >A,B,C;

void sortw(vector<seg<int> >&v){
	for(int i=0; i<(int)v.size(); i++) v[i].normalize();
	sort(v.begin(), v.end());
}

bool TRY(seg<int> a, seg<int> b){
	//printf("move %d %d, %d %d\n",a.a.x, a.a.y, b.a.x, b.a.y);
	for(int i=0; i<A.size(); i++){
		A[i].a.x -= a.a.x;
		A[i].a.y -= a.a.y;
		A[i].b.x -= a.a.x;
		A[i].b.y -= a.a.y;
	}
	a.b.x -= a.a.x; a.b.y -= a.a.y; a.a.x = a.a.y = 0;

	for(int i=0; i<B.size(); i++){
		B[i].a.x -= b.a.x;
		B[i].a.y -= b.a.y;
		B[i].b.x -= b.a.x;
		B[i].b.y -= b.a.y;
	}
	b.b.x -= b.a.x; b.b.y -= b.a.y; b.a.x = b.a.y = 0;
	ok = true;

	C.clear();
	long double resiz = b.len()/a.len();
	xy<int> mov(b.a.x - a.a.x, b.a.y - a.a.y);
	long double k = kat(a,b);
	for(int i = 0;i<(int)A.size();i++) {
		C.push_back(trans(resiz,mov,k,A[i]));
	}
	if(!ok) return false;
	//sortw(B);
	sortw(C);
	for(int i=0; i<(int)B.size(); i++){
		debug {
			B[i].print();
			C[i].print();
			printf("??\n\n");
		}
		if(!(B[i]==C[i])) ok = false;
	}
	return ok;
}

bool solve(){
	if(!read(A)) return false;
	read(B);

	debug {
		printf("A:\n");
		for(int i=0; i<(int)A.size(); i++) A[i].print();
		printf("B:\n");
		for(int i=0; i<(int)B.size(); i++) B[i].print();
	}

	if(A.size()!=B.size()){
		printf("NO\n");
		return true;
	}

	for(int i=0; i<(int)A.size(); i++){
		for(int j=0; j<(int)B.size(); j++){
			debug {
				printf("TRY %d -> %d\n",i,j);
				A[i].print();
				printf("goes to\n");
				B[j].print();
			}

			if(TRY(A[i], B[j])){
				printf("YES\n");
				return true;
			}
			if(TRY(A[i], seg<int>(B[j].b, B[j].a))){
				printf("YES\n");
				return true;
			}
		}
	}
	printf("NO\n");
	return true;
}

int main(){
	while(1){
		if(!solve()) break;
	}
	return 0;
}