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 int inf = 1 << 30;
const long long int infll = 1LL << 58;
const long double eps = 1e-6;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  os << "[";
  for (const auto& v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}
bool equal(const long double x1, const long double x2) {
  return abs(x1 - x2) < eps;
}
bool equal(const complex<long double>& a, const complex<long double>& b) {
  return equal(a.real(), b.real()) and equal(a.imag(), b.imag());
}
long double length(const complex<long double>& a) { return abs(a); }
long double distance(const complex<long double>& a,
                     const complex<long double>& b) {
  return abs(a - b);
}
long double dot(const complex<long double>& a, const complex<long double>& b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
long double cross(const complex<long double>& a,
                  const complex<long double>& b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool is_orthogonal(const complex<long double>& a1,
                   const complex<long double>& a2,
                   const complex<long double>& b1,
                   const complex<long double>& b2) {
  return equal(dot(a1 - a2, b1 - b2), 0.0);
}
bool is_orthogonal(const pair<complex<long double>, complex<long double> >& l,
                   const pair<complex<long double>, complex<long double> >& m) {
  return is_orthogonal(l.first, l.second, m.first, m.second);
}
bool is_parallel(const complex<long double>& a1, const complex<long double>& a2,
                 const complex<long double>& b1,
                 const complex<long double>& b2) {
  return equal(cross(a1 - a2, b1 - b2), 0.0);
}
bool is_parallel(const pair<complex<long double>, complex<long double> >& l,
                 const pair<complex<long double>, complex<long double> >& m) {
  return is_parallel(l.first, l.second, m.first, m.second);
}
int ccw(complex<long double> a, complex<long double> b,
        complex<long double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0) return +1;
  if (cross(b, c) < 0) return -1;
  if (dot(b, c) < 0) return +2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
bool intersectLL(const pair<complex<long double>, complex<long double> >& l,
                 const pair<complex<long double>, complex<long double> >& m) {
  return abs(cross(l.second - l.first, m.second - m.first)) > eps ||
         abs(cross(l.second - l.first, m.first - l.first)) < eps;
}
bool intersectLS(const pair<complex<long double>, complex<long double> >& l,
                 const pair<complex<long double>, complex<long double> >& s) {
  return cross(l.second - l.first, s.first - l.first) *
             cross(l.second - l.first, s.second - l.first) <
         eps;
}
bool intersectLP(const pair<complex<long double>, complex<long double> >& l,
                 const complex<long double>& p) {
  return abs(cross(l.second - p, l.first - p)) < eps;
}
bool intersectSS(const pair<complex<long double>, complex<long double> >& s,
                 const pair<complex<long double>, complex<long double> >& t) {
  return ccw(s.first, s.second, t.first) * ccw(s.first, s.second, t.second) <=
             0 &&
         ccw(t.first, t.second, s.first) * ccw(t.first, t.second, s.second) <=
             0;
}
bool intersectSP(const pair<complex<long double>, complex<long double> >& s,
                 const complex<long double>& p) {
  return abs(s.first - p) + abs(s.second - p) - abs(s.second - s.first) < eps;
}
complex<long double> projection(
    const pair<complex<long double>, complex<long double> >& l,
    const complex<long double>& p) {
  long double t =
      dot(p - l.first, l.first - l.second) / norm(l.first - l.second);
  return l.first + t * (l.first - l.second);
}
complex<long double> reflection(
    const pair<complex<long double>, complex<long double> >& l,
    const complex<long double>& p) {
  return p + complex<long double>((projection(l, p) - p).real() * 2,
                                  (projection(l, p) - p).imag() * 2);
}
long double distanceLP(
    const pair<complex<long double>, complex<long double> >& l,
    const complex<long double>& p) {
  return abs(p - projection(l, p));
}
long double distanceLL(
    const pair<complex<long double>, complex<long double> >& l,
    const pair<complex<long double>, complex<long double> >& m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m.first);
}
long double distanceLS(
    const pair<complex<long double>, complex<long double> >& l,
    const pair<complex<long double>, complex<long double> >& s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s.first), distanceLP(l, s.second));
}
long double distanceSP(
    const pair<complex<long double>, complex<long double> >& s,
    const complex<long double>& p) {
  const complex<long double> r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s.first - p), abs(s.second - p));
}
long double distanceSS(
    const pair<complex<long double>, complex<long double> >& s,
    const pair<complex<long double>, complex<long double> >& t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t.first), distanceSP(s, t.second)),
             min(distanceSP(t, s.second), distanceSP(t, s.second)));
}
complex<long double> intersection_l(const complex<long double>& a1,
                                    const complex<long double>& a2,
                                    const complex<long double>& b1,
                                    const complex<long double>& b2) {
  const complex<long double>&a = a2 - a1, b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
complex<long double> intersection_l(
    const pair<complex<long double>, complex<long double> >& l,
    const pair<complex<long double>, complex<long double> >& m) {
  return intersection_l(l.first, l.second, m.first, m.second);
}
long double area(const vector<complex<long double> >& pol) {
  long double s = 0;
  for (int i = (0); i < (pol.size()); ++i)
    s += cross(pol[i], pol[(i + 1) % pol.size()]);
  return s / 2;
}
vector<complex<long double> > convex_cut(
    const vector<complex<long double> >& ps,
    const pair<complex<long double>, complex<long double> >& l) {
  vector<complex<long double> > res;
  for (int i = 0; i < ps.size(); ++i) {
    complex<long double> a = ps[i], b = ps[(i + 1) % ps.size()];
    if (ccw(l.first, l.second, a) != -1) res.push_back(a);
    if (ccw(l.first, l.second, a) * ccw(l.first, l.second, b) < 0)
      res.push_back(intersection_l(
          pair<complex<long double>, complex<long double> >(a, b), l));
  }
  return res;
}
void solve() {
  int n;
  cin >> n;
  vector<complex<long double> > ps(n);
  for (complex<long double>& p : ps) {
    long double x, y;
    cin >> x >> y;
    p = complex<long double>(x, y);
    p *= complex<long double>(cos(eps), sin(eps));
  }
  const long double s = area(ps);
  auto opt = [&]() {
    long double left = inf, right = -inf;
    for (const auto& p : ps) {
      if (p.real() < left) left = p.real();
      if (p.real() > right) right = p.real();
    }
    pair<complex<long double>, complex<long double> > l(
        complex<long double>(left, 0), complex<long double>(left, 1));
    long double lb = 0, ub = distanceLP(l, complex<long double>(right, 0));
    for (int i = (0); i < (100); ++i) {
      long double mid = (lb + ub) / 2;
      l = pair<complex<long double>, complex<long double> >(
          complex<long double>(left + mid, 0),
          complex<long double>(left + mid, 1));
      if (area(convex_cut(ps, l)) <= s / 2)
        lb = mid;
      else
        ub = mid;
    }
    return l;
  };
  pair<complex<long double>, complex<long double> > l1 = opt();
  for (auto& p : ps) p *= complex<long double>(0, 1);
  pair<complex<long double>, complex<long double> > l2 = opt();
  l2 = pair<complex<long double>, complex<long double> >(
      l2.first * complex<long double>(0, -1),
      l2.second * complex<long double>(0, -1));
  for (auto& p : ps) p *= complex<long double>(0, -1);
  complex<long double> ans = intersection_l(l1, l2);
  bool ok = true;
  const long double pi = 3.14159265;
  for (int i = (0); i < (10000); ++i) {
    const complex<long double> tmp =
        ans + complex<long double>(1, 0) *
                  complex<long double>(cos(2 * pi * i / 10000),
                                       sin(2 * pi * i / 10000));
    if (abs(area(convex_cut(
                ps,
                pair<complex<long double>, complex<long double> >(ans, tmp))) -
            s / 2) > eps) {
      ok = false;
      break;
    }
  }
  if (ok)
    cout << ans.real() << " " << ans.imag() << endl;
  else
    cout << "NA" << endl;
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cout << fixed << setprecision(8) << endl;
  solve();
  return 0;
}
