Problem: A convex polygon consisting of N vertices is given. The coordinates of each vertex are represented counterclockwise by (X1, Y1), (X2, Y2), ……, (XN, YN). No matter what straight line passes through the point P, find the coordinates of the point P so that the areas of the two convex polygons obtained after cutting are equal.

Constraints

* All inputs are integers

* 3 ≤ N ≤ 50

* 0 ≤ | Xi |, | Yi | ≤ 1000000

* The input polygon is a simple convex polygon.

* The output must satisfy max (| X-cX |, | Y-cY |) ≤ 0.0001 when the output coordinates are (X, Y) and the exact solution is (cX, cY).

Input

The input is given in the following format.

> N
> X1 Y1
> X2 Y2
> ……
> XN YN
>

Output

If there is a point that satisfies the condition of the problem statement, the coordinates of that point

> X Y
>

Output in the format of. If the point does not exist, output "NA" on one line.

Examples

Input

4
100 100
0 100
0 0
100 0


Output

50.00000 50.00000


Input

3
100 100
0 100
0 0


Output

NA

Solution (in CPP):

Solution:
#ifndef ___STD_GEOMETRY
#define ___STD_GEOMETRY

#include <cmath>

#define EPS 1e-13L

#endif

#ifndef ___Class_Point
#define ___Class_Point

class Point
{
public:

	// ------ Variable ------ //

	long double x, y;


	// ------ Constructor ------ //

	Point() : x(0), y(0) { }

	explicit Point(long double x, long double y) : x(x), y(y) { }


	// ------ Operator ------ //

	friend bool operator==(Point& p1, Point& p2) { return p1.x == p2.x && p1.y == p2.y; }
	friend bool operator!=(Point& p1, Point& p2) { return p1.x != p2.x || p1.y != p2.y; }
};

long double distance(const Point& p1, const Point& p2)
{
	return sqrtl((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
}

#endif

#ifndef ___Class_Vector
#define ___Class_Vector

class Vector
{
public:

	// ------ Variable ------ //

	long double x, y;


	// ------ Constructor ------ //

	Vector() : x(0), y(0) { }

	explicit Vector(long double x, long double y) : x(x), y(y) { }

	explicit Vector(Point p1, Point p2) : x(p2.x - p1.x), y(p2.y - p1.y) { }

	explicit Vector(long double sx, long double tx, long double sy, long double ty) : x(tx - sx), y(ty - sy) { }


	// ------ Operator ------ //

	Vector operator+() const { return Vector(+x, +y); }
	Vector operator-() const { return Vector(-x, -y); }

	Vector& operator+=(const Vector& v) { x += v.x; y += v.y; return *this; }
	Vector& operator-=(const Vector& v) { x -= v.x; y -= v.y; return *this; }

	friend bool operator==(const Vector& v1, const Vector& v2) { return -EPS < v1.x - v2.x && v1.x - v2.x < EPS && -EPS < v1.y - v2.y && v1.y - v2.y < EPS; }
	friend bool operator!=(const Vector& v1, const Vector& v2) { return !(v1 == v2); }

	friend Vector operator+(const Vector& v1, const Vector& v2) { return Vector(v1.x + v2.x, v1.y + v2.y); }
	friend Vector operator-(const Vector& v1, const Vector& v2) { return Vector(v1.x - v2.x, v1.y - v2.y); }

	friend Vector operator*(double d, const Vector& v) { return Vector(d * v.x, d * v.y); }
	friend Vector operator*(const Vector& v, double d) { return Vector(d * v.x, d * v.y); }
	friend Vector operator/(const Vector& v, double d) { return Vector(v.x / d, v.y / d); }


	// ------ Function ------ //

	long double norm() { return x * x + y * y; }

	long double abs() { return sqrtl(x * x + y * y); }

	long double angle() { return atan2l(y, x); }
};

long double angle(const Vector& v1, const Vector& v2)
{
	long double A = atan2l(v2.y, v2.x) - atan2l(v1.y, v1.x);

	if (180.0L - EPS < A && A < 180.0L + EPS) { return 180.0L; }

	if (-180.0L - EPS < A && A < -180.0L + EPS) { return 180.0L; }

	if (A > 180.0L - EPS) { return A - 360.0L; }

	if (A < -180.0L + EPS) { return A + 360.0L; }

	return A;
}

long double norm(const Vector& v1)
{
	return v1.x * v1.x + v1.y * v1.y;
}

long double abs(const Vector& v1)
{
	return sqrt(norm(v1));
}

long double cross(const Vector& v1, const Vector& v2)
{
	return v1.x * v2.y - v1.y * v2.x;
}

long double dot(const Vector& v1, const Vector& v2)
{
	return v1.x * v2.x + v1.y * v2.y;
}

long double distance(const Vector& v1, const Vector& v2)
{
	return sqrtl((v2.x - v1.x) * (v2.x - v1.x) + (v2.y - v1.y) * (v2.y - v1.y));
}

#endif

Vector Cross_Point(Vector p1, Vector p2, Vector p3, Vector p4)
{
	Vector base = p4 - p3;

	Vector v1 = p1 - p3;
	Vector v2 = p2 - p3;

	long double d1 = fabsl(cross(base, v1));
	long double d2 = fabsl(cross(base, v2));

	long double t = d1 / (d1 + d2);

	return p1 + ((p2 - p1) * t);
}

#include <vector>
#include <iomanip>
#include <iostream>

using namespace std;

int main()
{
	int N, X, Y;

	vector<Vector> Plane;

	cin >> N;

	for (int i = 0; i < N; i++)
	{
		cin >> X >> Y;

		Plane.push_back(Vector(X, Y));
	}

	if (N % 2 == 1)
	{
		cout << "NA" << endl;
	}
	else
	{
		Vector C;

		for (int i = 0; i < N / 2; i++)
		{
			for (int j = i + 1; j < N / 2; j++)
			{
				if (i != j)
				{
					int l1 = i;
					int r1 = i + N / 2;
					int l2 = j;
					int r2 = j + N / 2;

					C = Cross_Point(Plane[l1], Plane[r1], Plane[l2], Plane[r2]);
					
					if ((Plane[l1] + Plane[r1]) / 2 != C)
					{
						cout << "NA" << endl;

						goto Exit;
					}
				}
			}
		}

		printf("%.9Lf %.9Lf\n", C.x, C.y);
	}

Exit:;

	return 0;
}