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

const double EPS = 1e-12;
const double PI = acos(-1.0);

inline double SQ(double a){
	return a * a;
}

inline bool EQ(double a, double b){
	return abs(a - b) < EPS;
}

inline bool LT(double a, double b){
	return a - b < -EPS;
}

inline bool LEQ(double a, double b){
	return a - b < EPS;
}

inline bool GT(double a, double b){
	return LT(b, a);
}

inline bool GEQ(double a, double b){
	return LEQ(b, a);
}

typedef complex<double> Point;

#define x() real()
#define y() imag()

namespace std {

bool operator < (const Point &a, const Point &b){
	return a.x() != b.x() ? a.x() < b.x() : a.y() < b.y();
}

inline istream& operator >> (istream &is, Point &p){
	double x, y;
	is >> x >> y;
	p = Point(x, y);
	return is;
}

inline ostream& operator << (ostream &os, const Point &p){
	return os << p.x() << " " << p.y();
}

}

struct Line {
	Point p1, p2;
};

typedef Line Segment;

struct Circle {
	Point p;
	double r;
};

typedef vector<Point> Polygon;

double norm(const Point &a){
	return SQ(a.x()) + SQ(a.y());
}

double dot(const Point &a, const Point &b){
	return (conj(a) * b).x();
}

double cross(const Point &a, const Point &b){
	return (conj(a) * b).y();
}

bool orthogonal(const Segment &s1, const Segment &s2){
	return EQ(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}

bool parallel(const Segment &s1, const Segment &s2){
	return EQ(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}

Point project(const Line &l, const Point &p){
	Point base = l.p2 - l.p1;
	double r = dot(p - l.p1, base) / norm(base);
	return l.p1 + base * r;
}

Point reflect(const Line &l, const Point &p){
	return p + (project(l, p) - p) * 2.0;
}

enum CCW {
	COUNTER_CLOCKWISE = 1,
	CLOCKWISE = -1,
	ONLINE_BACK = 2,
	ONLINE_FRONT = -2,
	ON_SEGMENT = 0
};

int ccw(const Point &p0, const Point &p1, const Point &p2){
	Point a = p1 - p0;
	Point b = p2 - p0;
	if (GT(cross(a, b), 0.0)) return COUNTER_CLOCKWISE;
	if (LT(cross(a, b), 0.0)) return CLOCKWISE;
	if (LT(dot(a, b), 0.0)) return ONLINE_BACK;
	if (LT(norm(a), norm(b))) return ONLINE_FRONT;
	return ON_SEGMENT;
}

// ????????§?????? or ????????´???
bool intersectLL(const Line &l, const Line &m){
	Point va = l.p2 - l.p1, vb = m.p2 - l.p1;
	return !parallel(l, m) || EQ(cross(va, vb), 0.0);
}

bool intersectLS(const Line &l, const Segment &s){
	Point va = l.p2 - l.p1, vb = s.p1 - l.p1, vc = s.p2 - l.p1;
	return LEQ(cross(va, vb) * cross(va, vc), 0.0);
}

bool intersectLP(const Line &l, const Point &p){
	Point va = l.p1 - p, vb = l.p2 - p;
	return EQ(cross(va, vb), 0.0);
}

bool intersectSS(const Segment &s, const Segment &t){
	Point a = s.p1, b = s.p2, c = t.p1, d = t.p2;
	return ccw(a, b, c) * ccw(a, b, d) <= 0
		&& ccw(c, d, a) * ccw(c, d, b) <= 0;
}

bool intersectSP(const Segment &s, const Point &p){
	return ccw(s.p1, s.p2, p) == ON_SEGMENT;
}

void solve()
{
	int n;
	cin >> n;
	Polygon g(n);
	for (int i = 0; i < n; i++){
		cin >> g[i];
	}
	
	bool res = true;
	
	if (n & 1) res = false;
	
	for (int i = 0; i < n / 2; i++){
		Segment s = {g[i], g[i + 1]};
		Segment t = {g[i + n / 2], (g[(i + n / 2 + 1) % g.size()])};
		if (!EQ(abs(s.p1 - s.p2), abs(t.p1 - t.p2))) res = false;
		if (!parallel(s, t)) res = false;
	}
	
	if (res){
		cout << (g[0] + g[n / 2]) / 2.0 << endl;
	}
	else {
		puts("NA");
	}
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout << fixed << setprecision(20);
	solve();
}

Measured memory_bytes: 1328