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
#include <bits/stdc++.h>
const int INF = 1e8;
using namespace std;
struct Segment {
  complex<double> p1, p2;
};
namespace std {
bool operator<(const complex<double> &a, const complex<double> &b) {
  return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
bool operator==(const complex<double> &a, const complex<double> &b) {
  return a.real() == b.real() && a.imag() == b.imag();
}
}  // namespace std
class Circle {
 public:
  complex<double> c;
  double r;
  Circle(complex<double> c = complex<double>(), double r = 0.0) : c(c), r(r) {}
};
int ccw(complex<double>, complex<double>, complex<double>);
bool EQ(double a, double b) { return (abs(a - b) < (1e-10)); }
bool EQV(complex<double> a, complex<double> b) {
  return (EQ(a.real(), b.real()) && EQ(a.imag(), b.imag()));
}
double dot(complex<double> a, complex<double> b) {
  return (a.real() * b.real() + a.imag() * b.imag());
}
double cross(complex<double> a, complex<double> b) {
  return (a.real() * b.imag() - a.imag() * b.real());
}
bool isOrthogonal(complex<double> a1, complex<double> a2, complex<double> b1,
                  complex<double> b2) {
  return EQ(dot(a1 - a2, b1 - b2), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2) {
  return isOrthogonal(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isParallel(complex<double> a1, complex<double> a2, complex<double> b1,
                complex<double> b2) {
  return EQ(cross(a1 - a2, b1 - b2), 0.0);
}
bool isParallel(Segment s1, Segment s2) {
  return isParallel(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isPointOnLine(complex<double> a, complex<double> b, complex<double> c) {
  return EQ(cross(b - a, c - a), 0.0);
}
bool isPointOnLine(Segment s, complex<double> c) {
  return isPointOnLine(s.p1, s.p2, c);
}
double distanceLPoint(complex<double> a, complex<double> b, complex<double> c) {
  return abs(cross(b - a, c - a)) / abs(b - a);
}
double distanceLPoint(Segment s, complex<double> c) {
  return distanceLPoint(s.p1, s.p2, c);
}
double distanceLsPoint(complex<double> a, complex<double> b,
                       complex<double> c) {
  if (dot(b - a, c - a) < (1e-10)) return abs(c - a);
  if (dot(a - b, c - b) < (1e-10)) return abs(c - b);
  return abs(cross(b - a, c - a)) / abs(b - a);
}
double distanceLsPoint(Segment s, complex<double> c) {
  return distanceLsPoint(s.p1, s.p2, c);
}
bool isIntersectedLs(complex<double> a1, complex<double> a2, complex<double> b1,
                     complex<double> b2) {
  return (ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
          ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0);
}
bool isIntersectedLs(Segment s1, Segment s2) {
  return isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2);
}
complex<double> intersectionLs(complex<double> a1, complex<double> a2,
                               complex<double> b1, complex<double> b2) {
  complex<double> base = b2 - b1;
  double d1 = abs(cross(base, a1 - b1));
  double d2 = abs(cross(base, a2 - b1));
  double t = d1 / (d1 + d2);
  return complex<double>(a1 + (a2 - a1) * t);
}
complex<double> intersectionLs(Segment s1, Segment s2) {
  return intersectionLs(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool isIntersectedL(complex<double> a1, complex<double> a2, complex<double> b1,
                    complex<double> b2) {
  return !EQ(cross(a1 - a2, b1 - b2), 0.0);
}
bool isIntersectedL(Segment l1, Segment l2) {
  return isIntersectedL(l1.p1, l1.p2, l2.p1, l2.p2);
}
complex<double> intersectionL(complex<double> a1, complex<double> a2,
                              complex<double> b1, complex<double> b2) {
  complex<double> a = a2 - a1;
  complex<double> b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
complex<double> intersectionL(Segment l1, Segment l2) {
  return intersectionL(l1.p1, l1.p2, l2.p1, l2.p2);
}
double distanceLL(Segment s1, Segment s2) {
  if (isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2)) return 0.0;
  return min(min(distanceLsPoint(s1.p1, s1.p2, s2.p1),
                 distanceLsPoint(s1.p1, s1.p2, s2.p2)),
             min(distanceLsPoint(s2.p1, s2.p2, s1.p1),
                 distanceLsPoint(s2.p1, s2.p2, s1.p2)));
}
double distanceLL(complex<double> p0, complex<double> p1, complex<double> p2,
                  complex<double> p3) {
  Segment s1 = Segment{p0, p1}, s2 = Segment{p2, p3};
  return distanceLL(s1, s2);
}
complex<double> project(Segment s, complex<double> p) {
  complex<double> base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / norm(base);
  return complex<double>(s.p1 + base * r);
}
complex<double> reflect(Segment s, complex<double> p) {
  return complex<double>(p + (project(s, p) - p) * 2.0);
}
complex<double> rotation(complex<double> p, double angle) {
  double x, y;
  x = p.real() * cos(angle) - p.imag() * sin(angle);
  y = p.real() * sin(angle) + p.imag() * cos(angle);
  return complex<double>(x, y);
}
pair<complex<double>, complex<double> > getCrossPoints(Circle c, Segment l) {
  complex<double> pr = project(l, c.c);
  complex<double> e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
  double base = sqrt(c.r * c.r - norm(pr - c.c));
  return make_pair(pr + e * base, pr - e * base);
}
double arg(complex<double> p) { return atan2(p.imag(), p.real()); }
complex<double> polar(double a, double r) {
  return complex<double>(cos(r) * a, sin(r) * a);
}
pair<complex<double>, complex<double> > getCrossPoints(Circle c1, Circle c2) {
  double d = abs(c1.c - c2.c);
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  double t = arg(c2.c - c1.c);
  return make_pair(complex<double>(c1.c + polar(c1.r, t + a)),
                   complex<double>(c1.c + polar(c1.r, t - a)));
}
static const int IN = 2;
static const int ON = 1;
static const int OUT = 0;
int contains(vector<complex<double> > g, complex<double> p) {
  int n = g.size();
  bool x = false;
  for (int i = 0; i < (n); i++) {
    complex<double> a = g[i] - p, b = g[(i + 1) % n] - p;
    if (abs(cross(a, b)) < (1e-10) && dot(a, b) < (1e-10)) return ON;
    if (a.imag() > b.imag()) swap(a, b);
    if (a.imag() < (1e-10) && (1e-10) < b.imag() && cross(a, b) > (1e-10))
      x = not x;
  }
  return (x ? IN : OUT);
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(complex<double> p0, complex<double> p1, complex<double> p2) {
  complex<double> a = p1 - p0;
  complex<double> b = p2 - p0;
  if (cross(a, b) > (1e-10)) return COUNTER_CLOCKWISE;
  if (cross(a, b) < -(1e-10)) return CLOCKWISE;
  if (dot(a, b) < -(1e-10)) return ONLINE_BACK;
  if (abs(a) < abs(b)) return ONLINE_FRONT;
  return ON_SEGMENT;
}
vector<complex<double> > convexHull(vector<complex<double> > s) {
  vector<complex<double> > u;
  if (s.size() < 3) return s;
  sort(s.begin(), s.end());
  for (int i = (0); i < (s.size()); i++) {
    for (int n = u.size();
         n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) == COUNTER_CLOCKWISE; n--) {
      u.pop_back();
    }
    u.emplace_back(s[i]);
  }
  for (int i = s.size() - 2; i >= 0; i--) {
    for (int n = u.size();
         n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) == COUNTER_CLOCKWISE; n--) {
      u.pop_back();
    }
    u.emplace_back(s[i]);
  }
  reverse(u.begin(), u.end());
  u.pop_back();
  return u;
}
double diameterOfConvexPolygon(vector<complex<double> > p) {
  vector<complex<double> > s = convexHull(p);
  int n = s.size();
  if (n == 2) return abs(s[1] - s[0]);
  int i = 0, j = 0;
  for (int k = 0; k < (n); k++) {
    if (not(s[i] < s[k])) i = k;
    if (s[j] < s[k]) j = k;
  }
  double ret = 0.0;
  int is = i, js = j;
  while (i != js || j != is) {
    ret = max(ret, abs(s[i] - s[j]));
    if (cross(s[(i + 1) % n] - s[i], s[(j + 1) % n] - s[j]) < 0) {
      i = (i + 1) % n;
    } else {
      j = (j + 1) % n;
    }
  }
  return ret;
}
complex<double> getCrossPointLL(Segment a, Segment b) {
  double A = cross(a.p2 - a.p1, b.p2 - b.p1);
  double B = cross(a.p2 - a.p1, a.p2 - b.p1);
  if (abs(A) < (1e-10) && abs(B) < (1e-10)) return b.p1;
  return b.p1 + (b.p2 - b.p1) * (B / A);
}
vector<complex<double> > convexCut(vector<complex<double> > p, Segment l) {
  vector<complex<double> > q;
  for (int i = 0; i < (p.size()); i++) {
    complex<double> a = p[i], b = p[(i + 1) % p.size()];
    if (ccw(l.p1, l.p2, a) != -1) q.emplace_back(a);
    if (ccw(l.p1, l.p2, a) * ccw(l.p1, l.p2, b) < 0) {
      q.emplace_back(getCrossPointLL(Segment{a, b}, l));
    }
  }
  return q;
}
double AreaOfTriangle(complex<double> a, complex<double> b, complex<double> c) {
  double w, x, y, z;
  w = b.real() - a.real();
  x = b.imag() - a.imag();
  y = c.real() - a.real();
  z = c.imag() - a.imag();
  return abs((w * z - x * y) / 2);
}
double areaOfPolygon(vector<complex<double> > g) {
  int n = g.size();
  double ret = 0.0;
  for (int i = 0; i < (n); i++) ret += cross(g[i], g[(i + 1) % n]);
  return abs(ret) / 2.0;
}
bool isConvex(vector<complex<double> > g) {
  int n = g.size();
  for (int i = 0; i < (n); i++) {
    if (ccw(g[i], g[(i + 1) % n], g[(i + 2) % n]) == CLOCKWISE) return false;
  }
  return true;
}
int dividedPolygonNumber(vector<complex<double> > p, Segment l) {
  int cnt = 0;
  for (int i = 0; i < (p.size()); i++) {
    if (isIntersectedLs(p[i], p[(i + 1) % p.size()], l.p1, l.p2)) cnt++;
  }
  return cnt / 2 + 1;
}
complex<double> pointSymmetry(vector<complex<double> > g) {
  int size = g.size() / 2;
  if (size % 2) return complex<double>{INF, INF};
  set<complex<double> > s;
  for (int i = 0; i < (size); i++) {
    for (int j = 0; j < (size); j++) {
      if (i == j) continue;
      s.insert(intersectionLs(g[i], g[i + size], g[j], g[j + size]));
    }
  }
  if (size > 1) return complex<double>{INF, INF};
  return *s.begin();
}
int main() {
  int n;
  cin >> n;
  vector<complex<double> > g(n);
  for (int i = 0; i < (n); i++) {
    double x, y;
    cin >> x >> y;
    g[i] = complex<double>(x, y);
  }
  if (n % 2) {
    cout << "NA" << endl;
    return 0;
  }
  complex<double> ans = pointSymmetry(g);
  if (ans.imag() == INF && ans.real() == INF)
    cout << "NA" << endl;
  else
    cout << fixed << setprecision(5) << ans.real() << ' ' << ans.imag() << endl;
}
