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;
using ll = long long;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  for (ll i = (0), __last_i = (v.size()); i < __last_i; i++) {
    if (i) os << " ";
    os << v[i];
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
  for (ll i = (0), __last_i = (v.size()); i < __last_i; i++) {
    if (i) os << endl;
    os << v[i];
  }
  return os;
}
const double EPS = 1e-1;
const double PI = acos(-1);
inline bool eq(double a, double b) { return fabs(b - a) < EPS; }
struct Point {
  double x, y;
  Point() {}
  Point(double x, double y) : x(x), y(y) {}
  Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
  Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
  Point operator*(const double b) const { return Point(x * b, y * b); }
  Point operator*(const Point &b) const {
    return Point(x * b.x - y * b.y, x * b.y + y * b.x);
  }
  Point operator/(const double b) const { return Point(x / b, y / b); }
  bool operator<(const Point &b) const { return x != b.x ? x < b.x : y < b.y; }
  bool operator==(const Point &b) const { return eq(x, b.x) && eq(y, b.y); }
  double norm() { return x * x + y * y; }
  double arg() { return atan2(x, y); }
  double abs() { return sqrt(norm()); }
  Point rotate(double theta) {
    return Point(cos(theta) * x - sin(theta) * y,
                 sin(theta) * x + cos(theta) * y);
  }
  Point rotate90() { return Point(-y, x); }
  friend ostream &operator<<(ostream &os, Point &p) {
    return os << p.x << " " << p.y;
  }
  friend istream &operator>>(istream &is, Point &a) { return is >> a.x >> a.y; }
};
double cross(const Point &a, const Point &b) { return a.x * b.y - a.y * b.x; }
double dot(const Point &a, const Point &b) { return a.x * b.x + a.y * b.y; }
struct Line {
  Point a, b;
  Line(){};
  Line(Point a, Point b) : a(a), b(b){};
  void set(Point a, Point b) {
    this->a = a;
    this->b = b;
  }
  friend ostream &operator<<(ostream &os, Line &p) {
    return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << ","
              << p.b.y << ")";
  }
  friend istream &operator>>(istream &is, Line &a) {
    return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y;
  }
};
int ccw(const Point &a, Point b, Point c) {
  b = b - a, c = c - a;
  if (cross(b, c) > EPS) return +1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < 0) return +2;
  if (b.norm() < c.norm()) return -2;
  return 0;
}
bool IsParallel(const Line &a, const Line &b) {
  return abs(cross(a.b - a.a, b.b - b.a)) < EPS;
}
vector<Point> Convex_Hull(vector<Point> &p) {
  int n = p.size(), k = 0;
  if (n >= 3) {
    sort(p.begin(), p.end());
    vector<Point> ch(2 * n);
    for (int i = 0; i < n; ch[k++] = p[i++]) {
      for (ll i = (0), __last_i = (ch.size()); i < __last_i; i++) {
      }
      while (k >= 2 && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 2]) < 0) --k;
    }
    for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = p[i--]) {
      while (k >= t && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 2]) < 0) --k;
    }
    ch.resize(k - 1);
    return ch;
  } else {
    return p;
  }
}
bool Intersect(const Line &l, const Line &m) {
  return abs(cross(l.b - l.a, m.b - m.a)) > EPS ||
         abs(cross(l.b - l.a, m.b - l.a)) < EPS;
}
Point Crosspoint(const Line &l, const Line &m) {
  double A = cross(l.b - l.a, m.b - m.a);
  double B = cross(l.b - l.a, l.b - m.a);
  if (abs(A) < EPS && abs(B) < EPS) return m.a;
  return m.a + (m.b - m.a) * B / A;
}
vector<Point> ConvexCut(vector<Point> &U, Line l) {
  vector<Point> ret;
  for (int i = 0; i < U.size(); i++) {
    Point now = U[i], nxt = U[(i + 1) % U.size()];
    if (ccw(l.a, l.b, now) != -1) ret.push_back(now);
    if (ccw(l.a, l.b, now) * ccw(l.a, l.b, nxt) < 0) {
      ret.push_back(Crosspoint(Line(now, nxt), l));
    }
  }
  return (ret);
}
double Area2(const vector<Point> &p) {
  double A = 0;
  for (int i = 0; i < p.size(); ++i) {
    A += cross(p[i], p[(i + 1) % p.size()]);
  }
  return A;
}
int xcomp(pair<ll, ll> &a, pair<ll, ll> &b) {
  if (a.first == b.first) {
    return a.second < b.second;
  }
  return a.first < b.first;
}
ll mod = 1000000007;
int main() {
  int n;
  cin >> n;
  vector<Point> polygon;
  for (ll i = (0), __last_i = (n); i < __last_i; i++) {
    Point point;
    cin >> point;
    polygon.push_back(point);
  }
  double Sall = Area2(polygon) / 2.0;
  Line linecut1;
  {
    double Sprev = 0;
    for (int i = 1; i < n; ++i) {
      Line line(polygon[0], polygon[i]);
      double Scut = Sall - Area2(ConvexCut(polygon, line)) / 2.0;
      if (Sall / 2.0 < Scut) {
        double ratio = (Sall / 2.0 - Sprev) / (Scut - Sprev);
        Point pointcut = polygon[i - 1] + (polygon[i] - polygon[i - 1]) * ratio;
        linecut1.set(polygon[0], pointcut);
        break;
      }
      Sprev = Scut;
    }
  }
  Line linecut2;
  {
    double Sprev = 0;
    for (int i = n - 2; i >= 0; --i) {
      Line line(polygon[n - 1], polygon[i]);
      double Scut = Area2(ConvexCut(polygon, line)) / 2.0;
      if (Sall / 2.0 < Scut) {
        double ratio = (Sall / 2.0 - Sprev) / (Scut - Sprev);
        Point pointcut =
            polygon[i + 1] + (polygon[i] - polygon[i + 1]) * (1 - ratio);
        linecut2.set(polygon[n - 1], pointcut);
        break;
      }
      Sprev = Scut;
    }
  }
  Point crosspoint = Crosspoint(linecut1, linecut2);
  bool flag = true;
  for (ll i = (0), __last_i = (100); i < __last_i; i++) {
    random_device rnd;
    mt19937 mt(rnd());
    uniform_int_distribution<> rand1000000(0, 1000000);
    Point randompoint(rand1000000(mt), rand1000000(mt));
    Line randomline(crosspoint, randompoint);
    double Srandomcut = Area2(ConvexCut(polygon, randomline)) / 2.0;
    if (!eq(Sall, Srandomcut * 2.0)) {
      flag = false;
      break;
    }
  }
  if (flag) {
    cout << crosspoint << endl;
  } else {
    cout << "NA" << endl;
  }
}
