#include <iostream>
#include <vector>
#include  <set>
#include <math.h>
#include <algorithm>
#define MAXA 1000000
#define ll long long
using namespace std;
 
int GetNorm(int x,int y) {
    return x*x+y*y;
}
int A[111];
int B[111];
int C[111];
int D[111];
 
bool Check(int N) {
    if (N == 1) return true;
    vector<pair<ll,ll>> right_pts;
    for(int i=1;i<=N;i++) {
        right_pts.push_back({C[i],D[i]});
    }
    sort(right_pts.begin(),right_pts.end());
    int xans, yans, denomans;
    denomans=-1;
    for(int i=1;i<=N;i++) {
        for(int j=1;j<=N;j++) {
            if (i == j) continue;
            ll dA = A[1]-A[2];
            ll dB = B[1]-B[2];
            ll dC = C[i]-C[j];
            ll dD = D[i]-D[j];
            // A[i]-A[j], B[j]-B[j]
            if (GetNorm(dA, dB) != GetNorm(dC, dD)) {
                continue;
            }
            ll x = dC*dA+dD*dB;
            ll y = dA*dD-dC*dB;
            ll denom = GetNorm(dA, dB);
 
            // x/denom+j*y/denom
 
            // (A[1]+j*B[1])*(x+j*y) + delta = C[i]+j*D[i]
 
            ll delta_1 = C[i]*denom-(A[1]*x-y*B[1]);
            ll delta_2 = D[i]*denom-(A[1]*y+x*B[1]);
 
            vector<pair<ll,ll>> pts;
            bool ok=true;
            for(int k=1;k<=N;k++) {
                // (A[i]+j*B[i])*(x+j*y) + delta
                ll X = A[k]*x-B[k]*y+delta_1;
                ll Y = A[k]*y+B[k]*x+delta_2;
                if (X%denom != 0 || Y%denom != 0) ok=false;
                pts.push_back({X/denom,Y/denom});
            }
            if (!ok) continue;
 
            sort(pts.begin(),pts.end());
            
 
 
            if (pts==right_pts) return true;
        }
    }
    return false;
 
    
 
}
 
int main() {
    int N;
    cin>>N;
    for(int i=1;i<=N;i++) {
        cin>>A[i]>>B[i];
    }
    for(int i=1;i<=N;i++) {
        cin>>C[i]>>D[i];
    }
    if (Check(N)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }
 
}
#include <algorithm>
#include <iostream>
#include <random>
#include <vector>

std::mt19937 g_rand;

double rand_double() { return g_rand() * (1.0 / std::mt19937::max()); }
int rand_int(int n) { return static_cast<int>(n * rand_double()); }

struct Company {
	int x;
	int y;
	int r;
};

class Space {
private:
	const Company co;

	Space(const Company &co, int a, int b, int c, int d)
		: co(co)
		, a(a)
		, b(b)
		, c(c)
		, d(d)
	{
	}

	static bool overlapping(int s1, int e1, int s2, int e2)
	{
		return !(e1 <= s2 || e2 <= s1);
	}

public:
	int a;
	int b;
	int c;
	int d;

	Space(const Company &co)
		: Space(co, co.x, co.y, co.x + 1, co.y + 1)
	{
	}

	int area() const
	{
		return (c - a) * (d - b);
	}

	static bool overlapping(const Space &lhs, const Space &rhs)
	{
		return overlapping(lhs.a, lhs.c, rhs.a, rhs.c)
			&& overlapping(lhs.b, lhs.d, rhs.b, rhs.d);
	}

	double evaluate() const
	{
		int s = area();
		double min = std::min(co.r, s);
		double max = std::max(co.r, s);
		double x = 1.0 - min / max;
		return 1.0 - x * x;
	}

	int draw(double q) const
	{
		while (true)
		{
			double q1 = rand_double();
			if (q1 < q && area() < co.r)
			{
				double q2 = rand_double();
				if (q2 < 0.25)
				{
					if (a > 0) { return 1; }
				}
				else if (q2 < 0.5)
				{
					if (b > 0) { return 2; }
				}
				else if (q2 < 0.75)
				{
					if (c < 10000) { return 3; }
				}
				else
				{
					if (d < 10000) { return 4; }
				}
			}
			else
			{
				double q2 = rand_double();
				if (q2 < 0.25)
				{
					if (a < co.x) { return -1; }
				}
				else if (q2 < 0.5)
				{
					if (b < co.y) { return -2; }
				}
				else if (q2 < 0.75)
				{
					if (c > co.x + 1) { return -3; }
				}
				else
				{
					if (d > co.y + 1) { return -4; }
				}
			}
		}
	}

	void transform(int option)
	{
		switch (option)
		{
		case -1: ++a; break;
		case -2: ++b; break;
		case -3: --c; break;
		case -4: --d; break;
		case  1: --a; break;
		case  2: --b; break;
		case  3: ++c; break;
		case  4: ++d; break;
		}
	}
};

int get_option(std::vector<Space> &spaces, int i)
{
	int n = spaces.size();
	while (true)
	{
		int option = spaces[i].draw(0.75);
		spaces[i].transform(option);
		int j = n;
		if (option > 0)
		{
			for (j = 0; j < n; ++j)
			{
				if (j != i && Space::overlapping(spaces[j], spaces[i])) { break; }
			}
		}
		if (j == n) { return option; }
		spaces[i].transform(-option);
	}
};

std::vector<Space> anneal(const std::vector<Company> &co)
{
	static constexpr int EP = 5000000;
	static constexpr double T1 = 0.0001;
	static constexpr double T2 = 0;

	int n = co.size();
	std::vector<Space> spaces;
	for (int i = 0; i < n; ++i)
	{
		spaces.push_back(Space(co[i]));
	}

	double sum = 0;
	for (int ep = 0; ep < EP; ++ep)
	{
		double t = T1 + ep * ((T2 - T1) / EP);
		int i = rand_int(n);
		double p1 = spaces[i].evaluate();
		int option = get_option(spaces, i);
		double p2 = spaces[i].evaluate();
		double diff = p2 - p1;

		if (rand_double() < std::exp(diff / t))
		{
			sum += diff;
		}
		else
		{
			spaces[i].transform(-option);
		}
		if ((ep + 1) % 100000 == 0) { std::cerr << ep + 1 << ": " << sum << std::endl; }
	}
	return spaces;
}

int main(int argc, char *argv[])
{
	int n;
	std::cin >> n;
	std::vector<Company> co(n);
	for (int i = 0; i < n; ++i)
	{
		std::cin >> co[i].x >> co[i].y >> co[i].r;
	}
	for (const Space &s : anneal(co))
	{
		std::cout << s.a << " " << s.b << " " << s.c << " " << s.d << std::endl;
	}
	return 0;
}
