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 double eps = 1e-9;
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 double x1, const double x2) { return abs(x1 - x2) < eps; }
bool equal(const complex<double>& a, const complex<double>& b) {
  return equal(a.real(), b.real()) and equal(a.imag(), b.imag());
}
double length(const complex<double>& a) { return abs(a); }
double distance(const complex<double>& a, const complex<double>& b) {
  return abs(a - b);
}
double dot(const complex<double>& a, const complex<double>& b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
double cross(const complex<double>& a, const complex<double>& b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool is_orthogonal(const complex<double>& a1, const complex<double>& a2,
                   const complex<double>& b1, const complex<double>& b2) {
  return equal(dot(a1 - a2, b1 - b2), 0.0);
}
bool is_orthogonal(const pair<complex<double>, complex<double> >& l,
                   const pair<complex<double>, complex<double> >& m) {
  return is_orthogonal(l.first, l.second, m.first, m.second);
}
bool is_parallel(const complex<double>& a1, const complex<double>& a2,
                 const complex<double>& b1, const complex<double>& b2) {
  return equal(cross(a1 - a2, b1 - b2), 0.0);
}
bool is_parallel(const pair<complex<double>, complex<double> >& l,
                 const pair<complex<double>, complex<double> >& m) {
  return is_parallel(l.first, l.second, m.first, m.second);
}
int ccw(complex<double> a, complex<double> b, complex<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<double>, complex<double> >& l,
                 const pair<complex<double>, complex<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<double>, complex<double> >& l,
                 const pair<complex<double>, complex<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<double>, complex<double> >& l,
                 const complex<double>& p) {
  return abs(cross(l.second - p, l.first - p)) < eps;
}
bool intersectSS(const pair<complex<double>, complex<double> >& s,
                 const pair<complex<double>, complex<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<double>, complex<double> >& s,
                 const complex<double>& p) {
  return abs(s.first - p) + abs(s.second - p) - abs(s.second - s.first) < eps;
}
complex<double> projection(const pair<complex<double>, complex<double> >& l,
                           const complex<double>& p) {
  double t = dot(p - l.first, l.first - l.second) / norm(l.first - l.second);
  return l.first + t * (l.first - l.second);
}
complex<double> reflection(const pair<complex<double>, complex<double> >& l,
                           const complex<double>& p) {
  return p + complex<double>((projection(l, p) - p).real() * 2,
                             (projection(l, p) - p).imag() * 2);
}
double distanceLP(const pair<complex<double>, complex<double> >& l,
                  const complex<double>& p) {
  return abs(p - projection(l, p));
}
double distanceLL(const pair<complex<double>, complex<double> >& l,
                  const pair<complex<double>, complex<double> >& m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m.first);
}
double distanceLS(const pair<complex<double>, complex<double> >& l,
                  const pair<complex<double>, complex<double> >& s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s.first), distanceLP(l, s.second));
}
double distanceSP(const pair<complex<double>, complex<double> >& s,
                  const complex<double>& p) {
  const complex<double> r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s.first - p), abs(s.second - p));
}
double distanceSS(const pair<complex<double>, complex<double> >& s,
                  const pair<complex<double>, complex<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<double> intersection_l(const complex<double>& a1,
                               const complex<double>& a2,
                               const complex<double>& b1,
                               const complex<double>& b2) {
  const complex<double>&a = a2 - a1, b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
complex<double> intersection_l(
    const pair<complex<double>, complex<double> >& l,
    const pair<complex<double>, complex<double> >& m) {
  return intersection_l(l.first, l.second, m.first, m.second);
}
double area(const vector<complex<double> >& pol) {
  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<double> > convex_cut(
    const vector<complex<double> >& ps,
    const pair<complex<double>, complex<double> >& l) {
  vector<complex<double> > res;
  for (int i = 0; i < ps.size(); ++i) {
    complex<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<double>, complex<double> >(a, b), l));
  }
  return res;
}
void solve() {
  int n;
  cin >> n;
  vector<complex<double> > ps(n);
  for (complex<double>& p : ps) {
    double x, y;
    cin >> x >> y;
    p = complex<double>(x, y);
    p *= complex<double>(cos(eps), sin(eps));
  }
  const double s = area(ps);
  auto opt = [&]() {
    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<double>, complex<double> > l(complex<double>(left, 0),
                                              complex<double>(left, 1));
    double lb = 0, ub = distanceLP(l, complex<double>(right, 0));
    for (int i = (0); i < (50); ++i) {
      double mid = (lb + ub) / 2;
      l = pair<complex<double>, complex<double> >(
          complex<double>(left + mid, 0), complex<double>(left + mid, 1));
      if (area(convex_cut(ps, l)) <= s / 2)
        lb = mid;
      else
        ub = mid;
    }
    return l;
  };
  pair<complex<double>, complex<double> > l1 = opt();
  for (auto& p : ps) p *= complex<double>(0, 1);
  pair<complex<double>, complex<double> > l2 = opt();
  l2 = pair<complex<double>, complex<double> >(
      l2.first * complex<double>(0, -1), l2.second * complex<double>(0, -1));
  for (auto& p : ps) p *= complex<double>(0, -1);
  complex<double> ans = intersection_l(l1, l2);
  bool ok = true;
  const double pi = 3.14159265;
  for (int i = (0); i < (100000); ++i) {
    const complex<double> tmp =
        ans + complex<double>(1, 0) * complex<double>(cos(2 * pi * i / 100000),
                                                      sin(2 * pi * i / 100000));
    if (abs(area(convex_cut(
                ps, pair<complex<double>, complex<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;
}
