// Gokuri

#include <iostream>
#include <fstream>
#include <vector>
#include <deque>
#include <map>
#include <set>
#include <string>
#include <cmath>
#include <cctype>
#include <algorithm>
#include <complex>

using namespace std;

#define FNAME "similar.txt"
#define fin cin

typedef complex<int> point;

ostream& operator<<(ostream& os, const vector<point>& v)
{
  for (vector<point>::const_iterator it = v.begin(); it != v.end(); ++it) {
    os << *it << ' ';
  }

  return os;
}

int outer_prod(point p1, point p2)
{
  return (p1.real() * p2.imag() - p1.imag() * p2.real());
}

void remove_muda(vector<point>& v)
{
  vector<point> vo;
  
  for (int i = 0; i < v.size(); ++i) {
    int i2 = (i - 2 + v.size()) % v.size();
    int i1 = (i - 1 + v.size()) % v.size();
    int i0 = i;
    if (outer_prod(v[i2] - v[i1], v[i0] - v[i1]) != 0) { vo.push_back(v[i1]); }
  }

  swap(v, vo);
}

bool is_same(vector<point> p1, vector<point> p2)
{
  //cout << "----------" << endl;
  //cout << p1 << endl;
  //cout << p2 << endl;
  
  int min_x1 = INT_MAX;
  int min_x2 = INT_MAX;
  int min_y1 = INT_MAX;
  int min_y2 = INT_MAX;

  for (int i = 0; i < p1.size(); ++i) {
    if (p1[i].real() < min_x1) { min_x1 = p1[i].real(); }
    if (p1[i].imag() < min_y1) { min_y1 = p1[i].imag(); }
    if (p2[i].real() < min_x2) { min_x2 = p2[i].real(); }
    if (p2[i].imag() < min_y2) { min_y2 = p2[i].imag(); }
  }

  for (int i = 0; i < p1.size(); ++i) {
    p1[i] = point(p1[i].real() - min_x1, p1[i].imag() - min_y1);
    p2[i] = point(p2[i].real() - min_x2, p2[i].imag() - min_y2);
  }


  int x1 = INT_MAX;
  int x2 = INT_MAX;
  int y1 = INT_MAX;
  int y2 = INT_MAX;
  int x1_idx;
  int x2_idx;
  for (int i = 0; i < p1.size(); ++i) {
    if (p1[i] != point(0, 0)) {
      if (p1[i].imag() == 0 && p1[i].real() < x1) { x1 = p1[i].real(); x1_idx = i; }
      if (p1[i].real() == 0 && p1[i].imag() < y1) { y1 = p1[i].imag();}
    }
    if (p2[i] != point(0, 0)) {
      if (p2[i].imag() == 0 && p2[i].real() < x2) { x2 = p2[i].real(); x2_idx = i; }
      if (p2[i].real() == 0 && p2[i].imag() < y2) { y2 = p2[i].imag(); }
    }
  }

  double ratio_x = double(x1) / x2;
  double ratio_y = double(y1) / y2;

  //if (fabs(ratio_x - ratio_y) < 0.0000001) { return false; }
  // cout << "ra x " << ratio_x << endl;
  // cout << "ra y " << ratio_y << endl;

  for (int i = 0; i < p2.size(); ++i) {
    p1[i] *= x2;
    p2[i] *= x1;
  }


  rotate(p1.begin(), p1.begin() + x1_idx, p1.end());
  rotate(p2.begin(), p2.begin() + x2_idx, p2.end());
  
  vector<point> p3(p1.rbegin(), p1.rend());
  rotate(p3.begin(), p3.end() - 1, p3.end());

  return (p1 == p2 || p3 == p2);
}

bool solve(vector<point> p1, vector<point> p2)
{
  remove_muda(p1);
  remove_muda(p2);

  if (p1.size() != p2.size()) { return false; }

  vector<vector<point> > poly(8);
  for (int i = 0; i < p1.size(); ++i) {
    poly[0].push_back(point(  p1[i].real(),   p1[i].imag()));
    poly[1].push_back(point(- p1[i].real(),   p1[i].imag()));
    poly[2].push_back(point  (p1[i].real(), - p1[i].imag()));
    poly[3].push_back(point(- p1[i].real(), - p1[i].imag()));
    poly[4].push_back(point  (p1[i].imag(),   p1[i].real()));
    poly[5].push_back(point(- p1[i].imag(),   p1[i].real()));
    poly[6].push_back(point(  p1[i].imag(), - p1[i].real()));
    poly[7].push_back(point(- p1[i].imag(), - p1[i].real()));
  }

  for (int i = 0; i < 8; ++i) {
    if (is_same(poly[i], p2)) { return true; }
  }

  return false;
}

int main(void)
{
  ifstream fin(FNAME);
  if (!fin) { return 1; }

  // INPUT HERE
  int N, M;
  while (cin >> N, N) {
    vector<point> poly1(N);
    for (int i = 0; i < N; ++i) {
      int x, y;
      char c;
      cin >> x >> c >> y;
      poly1[i] = point(x, y);
    }
    cin >> M;
    vector<point> poly2(M);
    for (int i = 0; i < M; ++i) {
      int x, y;
      char c;
      cin >> x >> c >> y;
      poly2[i] = point(x, y);
    }

    if (solve(poly1, poly2)) {
      cout << "YES" << endl;
    } else {
      cout << "NO" << endl;
    }
  }
  
  return 0;
}