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>
using namespace std;
const long double eps = 1e-10, pi = acos(-1.0);
namespace std {
bool operator<(const complex<long double> &lhs,
               const complex<long double> &rhs) {
  if (lhs.real() < rhs.real() - eps) return true;
  if (lhs.real() > rhs.real() + eps) return false;
  return lhs.imag() < rhs.imag();
}
}  // namespace std
complex<long double> input_point() {
  long double x, y;
  cin >> x >> y;
  return complex<long double>(x, y);
}
bool eq(long double a, long double b) { return (abs(a - b) < eps); }
long double dot(complex<long double> a, complex<long double> b) {
  return real(conj(a) * b);
}
long double cross(complex<long double> a, complex<long double> b) {
  return imag(conj(a) * b);
}
class Line {
 public:
  complex<long double> a, b;
  Line() : a(complex<long double>(0, 0)), b(complex<long double>(0, 0)) {}
  Line(complex<long double> a, complex<long double> b) : a(a), b(b) {}
};
class Circle {
 public:
  complex<long double> p;
  long double r;
  Circle() : p(complex<long double>(0, 0)), r(0) {}
  Circle(complex<long double> p, long double r) : p(p), r(r) {}
};
int ccw(complex<long double> a, complex<long double> b,
        complex<long double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > eps) return 1;
  if (cross(b, c) < -eps) return -1;
  if (dot(b, c) < 0) return 2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
bool isis_ll(Line l, Line m) { return !eq(cross(l.b - l.a, m.b - m.a), 0); }
bool isis_ls(Line l, Line s) {
  return isis_ll(l, s) &&
         (cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}
bool isis_ss(Line s, Line t) {
  return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
         ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
bool isis_lp(Line l, complex<long double> p) {
  return (abs(cross(l.b - p, l.a - p)) < eps);
}
bool isis_sp(Line s, complex<long double> p) {
  return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
complex<long double> proj(Line l, complex<long double> p) {
  long double t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
  return l.a + t * (l.a - l.b);
}
complex<long double> is_ll(Line s, Line t) {
  complex<long double> sv = s.b - s.a, tv = t.b - t.a;
  assert(cross(sv, tv) != 0);
  return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
long double dist_lp(Line l, complex<long double> p) {
  return abs(p - proj(l, p));
}
long double dist_ll(Line l, Line m) {
  return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
long double dist_ls(Line l, Line s) {
  return isis_ls(l, s) ? 0 : min(dist_lp(l, s.a), dist_lp(l, s.b));
}
long double dist_sp(Line s, complex<long double> p) {
  complex<long double> r = proj(s, p);
  return isis_sp(s, r) ? abs(r - p) : min(abs(s.a - p), abs(s.b - p));
}
long double dist_ss(Line s, Line t) {
  if (isis_ss(s, t)) return 0;
  return min(
      {dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}
vector<complex<long double> > is_cc(Circle c1, Circle c2) {
  vector<complex<long double> > res;
  long double d = abs(c1.p - c2.p);
  long double rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
  long double dfr = c1.r * c1.r - rc * rc;
  if (abs(dfr) < eps)
    dfr = 0.0;
  else if (dfr < 0.0)
    return res;
  long double rs = sqrt(dfr);
  complex<long double> diff = (c2.p - c1.p) / d;
  res.push_back(c1.p + diff * complex<long double>(rc, rs));
  if (dfr != 0.0) res.push_back(c1.p + diff * complex<long double>(rc, -rs));
  return res;
}
vector<complex<long double> > is_lc(Circle c, Line l) {
  vector<complex<long double> > res;
  long double d = dist_lp(l, c.p);
  if (d < c.r + eps) {
    long double len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d);
    complex<long double> nor = (l.a - l.b) / abs(l.a - l.b);
    res.push_back(proj(l, c.p) + len * nor);
    res.push_back(proj(l, c.p) - len * nor);
  }
  return res;
}
vector<complex<long double> > is_sc(Circle c, Line l) {
  vector<complex<long double> > v = is_lc(c, l), res;
  for (complex<long double> p : v)
    if (isis_sp(l, p)) res.push_back(p);
  return res;
}
vector<Line> tangent_cp(Circle c, complex<long double> p) {
  vector<Line> ret;
  complex<long double> v = c.p - p;
  long double d = abs(v);
  long double l = sqrt(norm(v) - c.r * c.r);
  if (isnan(l)) {
    return ret;
  }
  complex<long double> v1 = v * complex<long double>(l / d, c.r / d);
  complex<long double> v2 = v * complex<long double>(l / d, -c.r / d);
  ret.push_back(Line(p, p + v1));
  if (l < eps) return ret;
  ret.push_back(Line(p, p + v2));
  return ret;
}
vector<Line> tangent_cc(Circle c1, Circle c2) {
  vector<Line> ret;
  if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
    complex<long double> center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
    ret = tangent_cp(c1, center);
  }
  if (abs(c1.r - c2.r) > eps) {
    complex<long double> out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
    vector<Line> nret = tangent_cp(c1, out);
    ret.insert(ret.end(), (nret).begin(), (nret).end());
  } else {
    complex<long double> v = c2.p - c1.p;
    v /= abs(v);
    complex<long double> q1 = c1.p + v * complex<long double>(0, 1) * c1.r;
    complex<long double> q2 = c1.p + v * complex<long double>(0, -1) * c1.r;
    ret.push_back(Line(q1, q1 + v));
    ret.push_back(Line(q2, q2 + v));
  }
  return ret;
}
long double area(const vector<complex<long double> > &p) {
  long double res = 0;
  int n = p.size();
  for (int j = 0; j < (int)(n); j++) res += cross(p[j], p[(j + 1) % n]);
  return res / 2;
}
bool is_counter_clockwise(const vector<complex<long double> > &poly) {
  long double angle = 0;
  int n = poly.size();
  for (int i = 0; i < (int)(n); i++) {
    complex<long double> a = poly[i], b = poly[(i + 1) % n],
                         c = poly[(i + 2) % n];
    angle += arg((c - b) / (b - a));
  }
  return angle > eps;
}
int is_in_polygon(const vector<complex<long double> > &poly,
                  complex<long double> p) {
  long double angle = 0;
  int n = poly.size();
  for (int i = 0; i < (int)(n); i++) {
    complex<long double> a = poly[i], b = poly[(i + 1) % n];
    if (isis_sp(Line(a, b), p)) return 1;
    angle += arg((b - p) / (a - p));
  }
  return eq(angle, 0) ? 0 : 2;
}
vector<complex<long double> > convex_hull(vector<complex<long double> > ps) {
  int n = ps.size();
  int k = 0;
  sort(ps.begin(), ps.end());
  vector<complex<long double> > ch(2 * n);
  for (int i = 0; i < n; ch[k++] = ps[i++])
    while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
  for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
    while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
  ch.resize(k - 1);
  return ch;
}
vector<complex<long double> > convex_cut(
    const vector<complex<long double> > &ps, Line l) {
  int n = ps.size();
  vector<complex<long double> > Q;
  for (int i = 0; i < (int)(n); i++) {
    complex<long double> A = ps[i], B = ps[(i + 1) % n];
    Line m = Line(A, B);
    if (ccw(l.a, l.b, A) != -1) Q.push_back(A);
    if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0 && isis_ll(l, m))
      Q.push_back(is_ll(l, m));
  }
  return Q;
}
void add_point(vector<complex<long double> > &ps, complex<long double> p) {
  for (complex<long double> q : ps)
    if (abs(q - p) < eps) return;
  ps.push_back(p);
}
struct Edge {
  int from, to;
  int weight;
};
const long double zoom = 25;
const long double centerX = 6;
const long double centerY = 5;
void change_color(int r, int g, int b) {
  fprintf(stderr, "c.strokeStyle = 'rgb(%d, %d, %d)';\n", r, g, b);
}
int cordx(complex<long double> p) { return 400 + zoom * (p.real() - centerX); }
int cordy(complex<long double> p) { return 400 - zoom * (p.imag() - centerY); }
void draw_point(complex<long double> p) {
  fprintf(stderr, "circle(%d, %d, %d)\n", cordx(p), cordy(p), 2);
}
void draw_segment(Line l) {
  fprintf(stderr, "line(%d, %d, %d, %d)\n", cordx(l.a), cordy(l.a), cordx(l.b),
          cordy(l.b));
}
void draw_line(Line l) {
  complex<long double> v = l.b - l.a;
  Line m(l.a - v * complex<long double>(1e4, 0),
         l.b + v * complex<long double>(1e4, 0));
  fprintf(stderr, "line(%d, %d, %d, %d)\n", cordx(m.a), cordy(m.a), cordx(m.b),
          cordy(m.b));
}
void draw_polygon(const vector<complex<long double> > &p) {
  int n = p.size();
  for (int i = 0; i < (int)(n); i++) draw_segment(Line(p[i], p[(i + 1) % n]));
}
void draw_circle(Circle c) {
  fprintf(stderr, "circle(%d, %d, %d)\n", cordx(c.p), cordy(c.p),
          (int)(zoom * c.r));
}
int main() {
  long long N;
  cin >> N;
  vector<complex<long double> > ps(N);
  for (int i = 0; i < N; i++) ps[i] = input_point();
  vector<Line> ls;
  for (int i = 0; i < N; i++) ls.push_back(Line(ps[i], ps[(i + 1) % N]));
  long double b = 0;
  long double t = 1;
  long double S = area(ps) / 2;
  bool ok = true;
  Line cut1;
  while (t - b > eps) {
    long double m = (t + b) / 2;
    complex<long double> now = m * ps[1] + (1 - m) * ps[N - 1];
    cut1 = Line(ps[0], now);
    vector<complex<long double> > cutted = convex_cut(ps, cut1);
    if (area(cutted) > S)
      t = m;
    else
      b = m;
  }
  assert(abs(S - area(convex_cut(ps, cut1))) < 0.0001);
  Line cut2;
  t = 1;
  b = 0;
  while (t - b > eps) {
    long double m = (t + b) / 2;
    complex<long double> now = m * ps[0] + (1 - m) * ps[2];
    cut2 = Line(ps[1], now);
    vector<complex<long double> > cutted = convex_cut(ps, cut2);
    if (area(cutted) < S)
      t = m;
    else
      b = m;
  }
  assert(abs(S - area(convex_cut(ps, cut2))) < 0.0001);
  complex<long double> ans = is_ll(cut1, cut2);
  for (double i = 0; i < 2 * pi; i += 00.1) {
    complex<long double> to = ans + complex<long double>(cos(i), sin(i));
    Line li(ans, to);
    vector<complex<long double> > cutted = convex_cut(ps, li);
    if (abs(area(cutted) - S) > 0.0001) ok = false;
  }
  if (ok)
    printf("%.10f %.10f\n", real(ans), imag(ans));
  else
    cout << "NA" << endl;
  return 0;
}
