#include <iostream>
#include <cmath>
#include <vector>
#include <tuple>
#include <algorithm>
using namespace std;

const long double PI = 3.14159265358979;
const long double EPS = 1e-8;

struct Point {
	long double px, py;
};
struct Line {
	long double pa, pb;
};
bool operator< (const Line &a1, const Line &a2) {
	if (a2.pa - a1.pa > EPS) return true;
	else if (a1.pa - a2.pa > EPS) return false;
	else if (a2.pb - a1.pb > EPS) return true;
	return false;
}
bool operator== (const Line &a1, const Line &a2) {
	if (fabs(a1.pa - a2.pa) < EPS && fabs(a1.pb - a2.pb) < EPS) return true;
	return false;
}
bool operator== (const Point &a1, const Point &a2) {
	if (fabs(a1.px - a2.px) < EPS && fabs(a1.py - a2.py) < EPS) return true;
	return false;
}
bool operator< (const Point &a1, const Point &a2) {
	if (a2.px - a1.px > EPS) return true;
	else if (a1.px - a2.px > EPS) return false;
	else if (a2.py - a1.py > EPS) return true;
	return false;
}

Point rotate(Point a1) {
	Point A;
	A.px = a1.px * cos(30.0L * PI / 360.0L) - a1.py * sin(30.0L * PI / 360.0L);
	A.py = a1.px * sin(30.0L * PI / 360.0L) + a1.py * cos(30.0L * PI / 360.0L);
	return A;
}

Line makes(Point p1, Point p2) {
	Point p3 = Point{ (p1.px + p2.px) / 2.0L, (p1.py + p2.py) / 2.0L };

	long double a = -(p2.px - p1.px) / (p2.py - p1.py);
	long double b = p3.py - p3.px * a;
	return Line{ a, b };
}

int N; Point V[1009];
vector<tuple<Line, int, int>>vec;
bool used[1009];

bool check2(Line V1, Point V2) {
	long double E = V1.pb + V1.pa * V2.px;
	if (fabs(E - V2.py) < EPS) return true;
	return false;
}

bool check(Line BASE, vector<pair<int, int>>T) {
	for (int i = 0; i < N; i++) used[i] = false;
	for (int i = 0; i < T.size(); i++) { used[T[i].first] = true; used[T[i].second] = true; }

	vector<int>U; for (int i = 0; i < N; i++) { if (used[i] == false) U.push_back(i); }
	if (U.size() >= 3) return false;

	vector<Point> I;
	for (int i = 0; i < T.size(); i++) {
		I.push_back(Point{ (V[T[i].first].px + V[T[i].second].px) / 2.0L, (V[T[i].first].py + V[T[i].second].py) / 2.0L });
	}
	for (int i = 0; i < U.size(); i++) I.push_back(V[U[i]]);
	sort(I.begin(), I.end());
	I.erase(unique(I.begin(), I.end()), I.end());

	if (I.size() == 1) return false;

	for (int i = 0; i < U.size(); i++) {
		bool G = check2(BASE, V[U[i]]);
		if (G == false) return false;
	}
	return true;
}

int main() {
	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> V[i].px >> V[i].py;
		V[i] = rotate(V[i]);
	}
	for (int i = 0; i < N; i++) {
		for (int j = i + 1; j < N; j++) {
			vec.push_back(make_tuple(makes(V[i], V[j]), i, j));
		}
	}
	sort(vec.begin(), vec.end());

	vector<pair<int, int>>V; Line BASE = get<0>(vec[0]); V.push_back(make_pair(get<1>(vec[0]), get<2>(vec[0])));
	bool flag = false;
	for (int i = 1; i <= vec.size(); i++) {
		if (i == vec.size() || !(BASE == get<0>(vec[i]))) {
			bool t = check(BASE, V);
			if (t == true) {
				flag = true;
			}
			if (i < vec.size()) BASE = get<0>(vec[i]);
			V.clear();
		}
		if (i < vec.size()) V.push_back(make_pair(get<1>(vec[i]), get<2>(vec[i])));
	}

	if (flag == true) cout << "Yes" << endl;
	else cout << "No" << endl;
	return 0;
}
