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;
template <class T>
inline void chmax(T& a, const T& b) {
  if (b > a) a = b;
}
template <class T>
inline void chmin(T& a, const T& b) {
  if (b < a) a = b;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
  os << '(' << p.first << ", " << p.second << ')';
  return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
  return os;
}
const double EPS = 1e-9;
struct point {
  double x, y;
  point() : x(0), y(0) {}
  point(double x, double y) : x(x), y(y) {}
  point(const point& p) : x(p.x), y(p.y) {}
  point operator+(const point& p) const { return point(x + p.x, y + p.y); }
  point operator-(const point& p) const { return point(x - p.x, y - p.y); }
  point operator*(const double s) const { return point(x * s, y * s); }
  point operator*(const point& p) const {
    return point(x * p.x - y * p.y, x * p.y + y * p.x);
  }
  point operator/(const double s) const { return point(x / s, y / s); }
  bool operator<(const point& p) const {
    return x + EPS < p.x || abs(x - p.x) < EPS && y + EPS < p.y;
  }
  bool operator==(const point& p) const {
    return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
  }
};
inline point rotate90(const point& p) { return point(-p.y, p.x); }
inline point rotate(const point& p, const double theta) {
  const double s = sin(theta), c = cos(theta);
  return point(c * p.x - s * p.y, s * p.x + c * p.y);
}
inline double angle(const point& p) { return atan2(p.y, p.x); }
inline double abs(const point& p) { return sqrt(p.x * p.x + p.y * p.y); }
inline double norm(const point& p) { return p.x * p.x + p.y * p.y; }
inline double dot(const point& l, const point& r) {
  return l.x * r.x + l.y * r.y;
}
inline double cross(const point& l, const point& r) {
  return l.x * r.y - l.y * r.x;
}
struct line {
  point a, b;
  line(point a, point b) : a(a), b(b) {}
};
struct segment {
  point a, b;
  segment(point a, point b) : a(a), b(b) {}
};
struct circle {
  point c;
  double r;
  circle(point c, double r) : c(c), r(r) {}
};
inline int ccw(const point& a, point b, point c) {
  b = b - a;
  c = c - a;
  const double tmp = cross(b, c);
  if (tmp > EPS) return 1;
  if (tmp < -EPS) return -1;
  if (dot(b, c) < 0) return 2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
inline point projection(const line& l, const point& p) {
  const point dif = l.b - l.a;
  const double tmp = dot(p - l.a, dif) / norm(dif);
  return l.a + dif * tmp;
}
inline 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;
}
inline bool intersect(const line& l, const segment& s) {
  return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < EPS;
}
inline bool intersect(const line& l, const point& p) {
  return abs(ccw(l.a, l.b, p)) != -1;
}
inline bool intersect(const segment& s, const segment& 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;
}
inline bool intersect(const segment& s, const point& p) {
  return ccw(s.a, s.b, p) == 0;
}
inline bool intersect(const circle& c, const point& p) {
  return abs(c.c - p) <= c.r + EPS;
}
inline bool intersect(const circle& c, const circle& d) {
  return abs(c.c - d.c) <= c.r + d.r && abs(c.c - d.c) >= abs(c.r - d.r);
}
inline double dist(const line& l, const point& p) {
  return abs(p - projection(l, p));
}
inline double dist(const line& l, const line& m) {
  return intersect(l, m) ? 0 : dist(l, m.a);
}
inline double dist(const line& l, const segment& s) {
  return intersect(l, s) ? 0 : min(dist(l, s.a), dist(l, s.b));
}
inline double dist(const segment& s, const point& p) {
  const point tmp = projection(line(s.a, s.b), p);
  return intersect(s, tmp) ? abs(tmp - p) : min(abs(s.a - p), abs(s.b - p));
}
inline double dist(const segment& s, const segment& t) {
  if (intersect(s, t)) return 0;
  return min(min(dist(s, t.a), dist(s, t.b)), min(dist(t, s.a), dist(t, s.b)));
}
inline double dist(const point& a, const point& b) { return abs(a - b); }
inline point crosspoint(const line& l, const line& m) {
  const double tmp = cross(l.b - l.a, m.b - m.a);
  if (abs(tmp) < EPS) return l.a;
  return m.a + (m.b - m.a) * cross(l.b - l.a, l.a - m.a) * (1.0 / tmp);
}
inline point crosspoint(const segment& s, const segment& t) {
  if (!intersect(s, t)) return s.a;
  const double tmp = cross(s.b - s.a, t.b - t.a);
  if (abs(tmp) < EPS) {
    if (intersect(s, t.a)) return t.a;
    if (intersect(s, t.b)) return t.b;
    if (intersect(t, s.a)) return s.a;
    return s.b;
  }
  return t.a + (t.b - t.a) * cross(s.b - s.a, s.b - t.a) * (1.0 / tmp);
}
inline vector<point> crosspoint(const circle& c, const circle& d) {
  vector<point> res;
  if (abs(c.c - d.c) < EPS) return res;
  const double tmp = abs(c.c - d.c);
  const double rc = (tmp * tmp + c.r * c.r - d.r * d.r) / (tmp + tmp);
  const double rs = sqrt(c.r * c.r - rc * rc);
  const point diff = (d.c - c.c) / tmp;
  res.push_back(point(c.c + diff * point(rc, rs)));
  res.push_back(point(c.c + diff * point(rc, -rs)));
  return res;
}
inline vector<point> crosspoint(const circle& c, const line& l) {
  vector<point> res;
  const point h = projection(l, c.c);
  const double d = abs(h - c.c);
  if (d > c.r - EPS) {
    res.push_back(h);
  } else if (d <= c.r - EPS) {
    point v = l.b - l.a;
    v = v * sqrt(c.r * c.r - d * d) / abs(v);
    res.push_back(h + v);
    res.push_back(h - v);
  }
  return res;
}
inline vector<point> crosspoint(const circle& c, const segment& s) {
  vector<point> res;
  vector<point> tmp = crosspoint(c, line(s.a, s.b));
  for (int i = 0; i < tmp.size(); ++i)
    if (intersect(s, tmp[i])) res.push_back(tmp[i]);
  return res;
}
inline long double areaTriangle(point a, point b, const point& c) {
  a = a - c;
  b = b - c;
  return fabs(a.x * b.y - b.x * a.y) / 2.0;
}
inline long double area(const vector<point>& p) {
  const int num = p.size();
  if (num < 3) return 0;
  if (num == 3) return areaTriangle(p[0], p[1], p[2]);
  long double res = cross(p[num - 1], p[0]);
  for (int i = 1; i < num; ++i) res += cross(p[i - 1], p[i]);
  return res * 0.5;
}
inline line bisector(const point& a, const point& b) {
  return line(
      point((a.x - a.y + b.x + b.y) / 2.0, (a.y + a.x + b.y - b.x) / 2.0),
      point((a.x + a.y + b.x - b.y) / 2.0, (a.y - a.x + b.y + b.x) / 2.0));
}
inline vector<point> convex_cut(const vector<point>& p, const line& l) {
  const int num = p.size();
  vector<point> res;
  for (int i = 0; i < num; ++i) {
    const int next = (i + 1) % num;
    const int tmp = ccw(l.a, l.b, p[i]);
    if (tmp != -1) res.push_back(p[i]);
    if (tmp * ccw(l.a, l.b, p[next]) < 0)
      res.push_back(crosspoint(l, line(p[i], p[next])));
  }
  return res;
}
vector<point> tangent(const circle& c, const point& p) {
  const double x = norm(p - c.c);
  double d = x - c.r * c.r;
  if (d < -EPS) return vector<point>();
  d = max(d, 0.0);
  const point q1 = (p - c.c) * (c.r * c.r / x);
  const point q2 = rotate90((p - c.c) * (-c.r * sqrt(d) / x));
  vector<point> res;
  res.push_back(c.c + q1 - q2);
  res.push_back(c.c + q1 + q2);
  return res;
}
vector<line> tangent(const circle& a, const circle& b) {
  vector<line> res;
  if (abs(a.r - b.r) < EPS) {
    point dir = b.c - a.c;
    dir = rotate90(dir * (a.r / abs(dir)));
    res.push_back(line(a.c + dir, b.c + dir));
    res.push_back(line(a.c - dir, b.c - dir));
  } else {
    point p = a.c * (-b.r) + b.c * a.r;
    p = p * (1.0 / (a.r - b.r));
    vector<point> ps = tangent(a, p), qs = tangent(b, p);
    for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
      res.push_back(line(ps[i], qs[i]));
  }
  point p = a.c * b.r + b.c * a.r;
  p = p * (1.0 / (a.r + b.r));
  vector<point> ps = tangent(a, p), qs = tangent(b, p);
  for (int i = 0; i < min<int>(ps.size(), qs.size()); ++i)
    res.push_back(line(ps[i], qs[i]));
  return res;
}
inline point middle(const point& a, const point& b) { return (a + b) / 2.0; }
int main() {
  int n;
  cin >> n;
  if (n & 1) {
    cout << "NA" << endl;
    return EXIT_SUCCESS;
  }
  vector<point> p;
  p.reserve(n);
  for (int i = 0; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    p.push_back(point(x, y));
  }
  const line l1(middle(p[0], p[1]), middle(p[2], p[3]));
  const line l2(middle(p[1], p[2]), middle(p[3], p[(3 + 1) % n]));
  const point ans = crosspoint(l1, l2);
  printf("%.10lf %.10lf\n", ans.x, ans.y);
  return EXIT_SUCCESS;
}
