Problem: 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

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
using namespace std;

typedef complex<double> Point;
typedef Point Vector;
//???????????¨????§???????
struct Segment{ Point p1, p2; };
//??´????????¨????§???????
typedef Segment Line;
//????§???¢?????¨????§???????
typedef vector<Point> Polygon;

namespace std{
    bool operator < (const Point &a, const Point &b){
        return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
    }
    bool operator == (const Point &a, const Point &b){
        return a.real() == b.real() && a.imag() == b.imag();
    }
}

class Circle{
    public:
        Point c;
        double r;
        Circle(Point c = Point(), double r = 0.0): c(c), r(r) {}
};

// ?¨±???????????????
#define EPS (1e-10)

// ????????????a?????¶??????????±???????
//double length = abs(a);

// 2???a,b???????????¢????±???????
//double distance = abs(a-b);

/*
// ????????????a?????????????????????????±???????
Point b = a / abs(a);

// ????????????a?????????????????????n1,n2????±???????
Point n1 = a * Point(0, 1);
Point n2 = a * Point(0, -1);
*/

int ccw(Point, Point, Point);

// 2??????????????????????????????????????????
bool EQ(double a, double b){
    return (abs(a - b) < EPS);
}

// 2??????????????????????????????????????????
bool EQV(Vector a, Vector b){
    return ( EQ(a.real(), b.real()) && EQ(a.imag(), b.imag()) );
}

// ?????? (dot product) : a???b = |a||b|cos??
double dot(Point a, Point b) {
    return (a.real() * b.real() + a.imag() * b.imag());
}

// ?????? (cross product) : a??b = |a||b|sin??
double cross(Point a, Point b) {
    return (a.real() * b.imag() - a.imag() * b.real());
}

// 2??´????????´????????? : a??\b <=> dot(a, b) = 0
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
    return EQ( dot(a1-a2, b1-b2), 0.0 );
}
bool isOrthogonal(Line s1, Line s2) {
    return isOrthogonal(s1.p1, s1.p2, s2.p1, s2.p2);
}

// 2??´?????????????????? : a//b <=> cross(a, b) = 0
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
    return EQ( cross(a1-a2, b1-b2), 0.0 );
}
bool isParallel(Line s1, Line s2) {
    return isParallel(s1.p1, s1.p2, s2.p1, s2.p2);
}

// ???c?????´???a,b????????????????????????
bool isPointOnLine(Point a, Point b, Point c) {
    return EQ( cross(b-a, c-a), 0.0 );
}
bool isPointOnLine(Line s, Point c) {
    return isPointOnLine(s.p1, s.p2, c);
}

// ???a,b???????????´?????¨???c??¨????????¢
double distanceLPoint(Point a, Point b, Point c) {
    return abs(cross(b-a, c-a)) / abs(b-a);
}
double distanceLPoint(Line s, Point c) {
    return distanceLPoint(s.p1, s.p2, c);
}

// ???a,b???????????¨??????????????¨???c??¨????????¢
double distanceLsPoint(Point a, Point b, Point c) {
    if ( dot(b-a, c-a) < EPS ) return abs(c-a);
    if ( dot(a-b, c-b) < EPS ) return abs(c-b);
    return abs(cross(b-a, c-a)) / abs(b-a);
}
double distanceLsPoint(Segment s, Point c) {
    return distanceLsPoint(s.p1, s.p2, c);
}

// a1,a2???????????¨??????????????¨b1,b2???????????¨???????????????????????????
bool isIntersectedLs(Point a1, Point a2, Point b1, Point b2) {
    return ( ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
            ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0 );
}
bool isIntersectedLs(Segment s1, Segment s2) {
    return isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2);
}

// a1,a2???????????¨??????????????¨b1,b2???????????¨??????????????????????¨????
Point intersectionLs(Point a1, Point a2, Point b1, Point b2) {
    Vector base = b2 - b1;
    double d1 = abs(cross(base, a1 - b1));
    double d2 = abs(cross(base, a2 - b1));
    double t = d1 / (d1 + d2);

    return Point(a1 + (a2 - a1) * t);
}
Point intersectionLs(Segment s1, Segment s2) {
    return intersectionLs(s1.p1, s1.p2, s2.p1, s2.p2);
}

// a1,a2???????????´?????¨b1,b2???????????´??????????????????
bool isIntersectedL(Point a1, Point a2, Point b1, Point b2) {
    return !EQ( cross(a1-a2, b1-b2), 0.0 );
}
bool isIntersectedL(Line l1, Line l2) {
    return isIntersectedL(l1.p1, l1.p2, l2.p1, l2.p2);
}

// a1,a2???????????´?????¨b1,b2???????????´?????????????¨????
Point intersectionL(Point a1, Point a2, Point b1, Point b2) {
    Point a = a2 - a1; Point b = b2 - b1;
    return a1 + a * cross(b, b1-a1) / cross(b, a);
}
Point intersectionL(Line l1, Line l2) {
    return intersectionL(l1.p1, l1.p2, l2.p1, l2.p2);
}

// ??????s1??¨??????s2????????¢
double distanceLL(Segment s1, Segment s2){
    if(isIntersectedLs(s1.p1, s1.p2, s2.p1, s2.p2) ) return 0.0;
    return min(
            min(distanceLsPoint(s1.p1, s1.p2, s2.p1),
                distanceLsPoint(s1.p1, s1.p2, s2.p2)),
            min(distanceLsPoint(s2.p1, s2.p2, s1.p1),
                distanceLsPoint(s2.p1, s2.p2, s1.p2)) );
}
double distanceLL(Point p0, Point p1, Point p2, Point p3){
    Segment s1 = Segment{p0, p1}, s2 = Segment{p2, p3};
    return distanceLL(s1, s2);
}

// ??????s???????????????p????°???±
Point project(Segment s, Point p){
    Vector base = s.p2 - s.p1;
    double r = dot(p - s.p1, base) / norm(base);
    return Point(s.p1 + base * r);
}

//??????s???????±??????¨?????????p??????????§°??????
Point reflect(Segment s, Point p){
    return Point(p + (project(s, p) - p) * 2.0);
}

//???p???angle?????????????¨???????????????¢
Point rotation(Point p, double angle){
    double x, y;
    x = p.real() * cos(angle) - p.imag() * sin(angle);
    y = p.real() * sin(angle) + p.imag() * cos(angle);
    return Point(x, y);
}

//???c??¨??????l?????????
pair<Point, Point> getCrossPoints(Circle c, Line l){
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
    double base = sqrt(c.r * c.r - norm(pr - c.c));
    return make_pair(pr + e * base, pr - e * base);
}

//???c1??¨???c2?????????
double arg(Vector p) { return atan2(p.imag(), p.real()); }
Vector polar(double a, double r) { return Point(cos(r) * a, sin(r) *a); }

pair<Point, Point> getCrossPoints(Circle c1, Circle c2){
    double d = abs(c1.c - c2.c);
    double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
    double t = arg(c2.c - c1.c);
    return make_pair(Point(c1.c + polar(c1.r, t + a)), Point(c1.c + polar(c1.r, t - a)));
}

//????????????
static const int IN = 2;
static const int ON = 1;
static const int OUT = 0;

int contains(Polygon g, Point p){
    int n = g.size();
    bool x = false;
    rep(i,n){
        Point a = g[i] - p, b = g[(i + 1) % n] - p;
        if( abs(cross(a, b)) < EPS && dot(a,  b) < EPS ) return ON;
        if( a.imag() > b.imag() ) swap(a, b);
        if( a.imag() < EPS && EPS < b.imag() && cross(a, b) > EPS ) x = not x;
    }
    return ( x ? IN : OUT );
}

//???????????????????????????
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw(Point p0, Point p1, Point p2){
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
    if( cross(a, b) < -EPS ) return CLOCKWISE;
    if( dot(a, b) < -EPS ) return ONLINE_BACK;
    if( abs(a) < abs(b) ) return ONLINE_FRONT;

    return ON_SEGMENT;
}

//??????
Polygon convexHull( Polygon s ){
    Polygon u;
    if( s.size() < 3 ) return s;
    sort(s.begin(), s.end());

    range(i,0,s.size()){
        //== COUNTER_CLOCKWISE?????¨????§????180??\???????????´?????????????????§????????????????????¨????????°?????????
        //!= CLOCKWISE?????¨????§????180??????????????´????????????????????°????????????
        for(int n = u.size(); n >= 2 && ccw(u[n-2], u[n-1], s[i]) == COUNTER_CLOCKWISE; n--){
            u.pop_back();
        }
        u.emplace_back(s[i]);
    }

    for(int i = s.size() - 2; i >= 0; i--){
        //????????? == ??¨ != ????????´??????
        for(int n = u.size(); n >= 2 && ccw(u[n-2], u[n-1], s[i]) == COUNTER_CLOCKWISE; n--){
            u.pop_back();
        }
        u.emplace_back(s[i]);
    }

    reverse(u.begin(), u.end());
    u.pop_back();

    //?????????????????????????????§??????????????????????????????????¨??????????????????????
    /*
       int i = 0;
       while(i < u.size() - 1){
       if(u[i].imag() > u[i + 1].imag()){
       u.emplace_back(u[i]);
       u.erase(u.begin());
       continue;
       }else if(u[i].imag() == u[i + 1].imag() && u[i].real() > u[i + 1].real()){
       u.emplace_back(u[i]);
       u.erase(u.begin());
       continue;
       }
       break;
       }
       */

    return u;
}

//?????£?????????????????¨?????????????§???¢?????´???????±???????
double diameterOfConvexPolygon(Polygon p){
    Polygon s = convexHull(p);
    int n = s.size();

    if(n == 2) return abs(s[1] - s[0]);

    int i = 0, j = 0;
    rep(k,n){
        if(not (s[i] < s[k])) i = k;
        if(s[j] < s[k]) j = k;
    }

    double ret = 0.0;
    int is = i, js = j;

    while(i != js || j != is){
        ret = max(ret, abs(s[i] - s[j]));
        if(cross(s[(i + 1) % n] - s[i], s[(j + 1) % n] - s[j]) < 0){
            i = (i + 1) % n;
        }else{
            j = (j + 1) % n;
        }
    }
    return ret;
}

//???????§???¢??????????????????????????¢??°??????????????????????????????????????\????????????
Point getCrossPointLL(Line a, Line b){
    double A = cross(a.p2 - a.p1, b.p2 - b.p1);
    double B = cross(a.p2 - a.p1, a.p2 - b.p1);
    if(abs(A) < EPS && abs(B) < EPS) return b.p1;
    return b.p1 + (b.p2 - b.p1) * (B / A);
}

Polygon convexCut(Polygon p, Line l) {
    Polygon q;
    rep(i,p.size()){
        Point a = p[i], b = p[(i + 1) % p.size()];
        if (ccw(l.p1, l.p2, a) != -1) q.emplace_back(a);
        if (ccw(l.p1, l.p2, a) * ccw(l.p1, l.p2, b) < 0){
            q.emplace_back(getCrossPointLL(Line{a, b}, l));
        }
    }
    return q;
}

//????§???¢?????¢???
double AreaOfTriangle(Point a, Point b, Point c){
    double w, x, y, z;
    w = b.real()-a.real();
    x = b.imag()-a.imag();
    y = c.real()-a.real();
    z = c.imag()-a.imag();
    return abs((w * z - x * y) / 2);
}

//????§???¢?????¢???
double areaOfPolygon(Polygon g){
    int n = g.size();
    double ret = 0.0;
    rep(i,n) ret += cross(g[i], g[ (i + 1) % n ]);
    return abs(ret) / 2.0;
}

//???????§???¢?????????????????????
bool isConvex(Polygon g){
    int n = g.size();
    rep(i,n){
        if(ccw(g[i], g[(i + 1) % n], g[(i + 2) % n]) == CLOCKWISE) return false;
    }
    return true;
}

//???????§???¢?????????l??§??????????????????????§???¢?????°
int dividedPolygonNumber(Polygon p, Line l){
    int cnt = 0;
    rep(i,p.size()){
        if(isIntersectedLs(p[i], p[(i + 1) % p.size()], l.p1, l.p2)) cnt++;
    }
    return cnt / 2 + 1;
}


int main(){
    int n;
    cin >> n;

    Point p[55];
    rep(i,n){
        double x, y;
        cin >> x >> y;
        p[i] = Point(x,y);
    }
    if(n % 2){
        cout << "NA" << endl;
        return 0;
    }

    Segment seg[55];
    rep(i,n / 2){
        seg[i] = Segment{p[i], p[i + n / 2]};
    }

    set<Point> s;
    rep(i,n / 2){
        rep(j,n / 2){
            if(i == j) continue;
            s.insert(intersectionLs(seg[i], seg[j]));
        }
    }
    if(s.size() > 1){
        cout << "NA" << endl;
        return 0;
    }
    cout <<fixed << setprecision(5)<< s.begin()->real() << ' ' << s.begin()->imag() << endl;
}