#include <bits/stdc++.h>
using namespace std;

typedef long long db;
const db eps=0;
const db scale=1000000;
int sign(db k){
    if (k>eps) return 1;
    else if (k<-eps) return -1;
    return 0;
}
int cmp(db k1,db k2){return sign(k1-k2);}
int inmid(db k1,db k2,db k3){return sign(k1-k3)*sign(k2-k3)<=0;}

struct point{
    db x,y;
    point operator + (const point &k1) const{return (point){x+k1.x,y+k1.y};}
    point operator - (const point &k1) const{return (point){x-k1.x,y-k1.y};}
    point operator * (db k1) const{return (point){x*k1,y*k1};}
    point operator / (db k1) const{return (point){x/k1,y/k1};}
    bool operator < (const point &k1) const{
        int a=cmp(x,k1.x);
        if (a==-1) return 1;
        else if (a==1) return 0;
        return cmp(y,k1.y)==-1;
    }
    int operator == (const point &k1) const{
        return cmp(x,k1.x)==0 && cmp(y,k1.y)==0;
    }

    point turn90(){return (point){-y,x};}

    int getP(){
        return sign(x)==-1 || (sign(x)==0 && sign(y)==-1);
    }
    point getdel(){
        if (!getP()) return (*this);
        else return (*this)*(-1);
    }
	friend ostream& operator << (ostream &os,const point &k1){
		os << "(" << k1.x << "," << k1.y << ")";
		return os;
	}
};
db cross(point k1,point k2){return k1.x*k2.y-k1.y*k2.x;}
db dot(point k1,point k2){return k1.x*k2.x+k1.y*k2.y;}

int compareangle(point k1,point k2){
    int a=cmp(k1.getP(),k2.getP());
	if (a!=0) return a;
    return sign(cross(k2,k1));
}

const int maxn=100000;
int n;
point a[maxn+50][3];

int main(){
    ios_base::sync_with_stdio(false);

    cin >> n;
    for (int i=1;i<=n;i++){
        int x0,y0,x1,y1,x2,y2;
		cin >> x0 >> y0 >> x1 >> y1 >> x2 >> y2;
        a[i][0].x=x0;
        a[i][0].y=y0;
        a[i][1].x=x1;
        a[i][1].y=y1;
        a[i][2].x=x2;
        a[i][2].y=y2;
        if (sign(cross(a[i][1]-a[i][0],a[i][2]-a[i][0]))<0) swap(a[i][1],a[i][2]);
    }
    vector<tuple<point,point,int>> vec;
    for (int i=1;i<=n;i++){
        if ((a[i][1]-a[i][0]).getP())
			vec.emplace_back(a[i][1],a[i][0],-1);
		else 
			vec.emplace_back(a[i][0],a[i][1],1);
		
		if ((a[i][2]-a[i][1]).getP())
      		vec.emplace_back(a[i][2],a[i][1],-1);
		else 
			vec.emplace_back(a[i][1],a[i][2],1);

		if ((a[i][0]-a[i][2]).getP())
			vec.emplace_back(a[i][0],a[i][2],-1);
		else
        	vec.emplace_back(a[i][2],a[i][0],1);
    }
	auto cmp1=[&](const tuple<point,point,int> &A,const tuple<point,point,int> &B){
		auto [Ax,Ay,Aval]=A;
		auto [Bx,By,Bval]=B;
		int diff=compareangle(Ay-Ax,By-Bx);
		if (diff!=0) return diff;

		point dir=(Ay-Ax).turn90();
		return cmp(dot(Ax,dir),dot(Bx,dir));
	};
    sort(vec.begin(),vec.end(),
		[&](const tuple<point,point,int> &A,const tuple<point,point,int> &B){
			return cmp1(A,B)==-1;
		}
    );

	vector<pair<point,point>> vdir;
	{
		int sz=(int)vec.size();
		for (int i=0,j=0;i<sz;i=j){
			for (;j<sz && cmp1(vec[i],vec[j])==0;j++);
			
			map<point,int> dict;
			vector<point> plist;
			for (int k=i;k<j;k++){
				dict[get<0>(vec[k])]=0;
				dict[get<1>(vec[k])]=0;
			}
			
			// cerr << "i,j : " << i << " " << j << endl;
			// for (int k=i;k<j;k++){
			// 	cerr << get<0>(vec[k]) << " " << get<1>(vec[k]) << " " << get<2>(vec[k]) << endl;
			// }

			int id=0;
			for (auto &[x,y]:dict){
				y=id++;
				plist.emplace_back(x);
			}

			vector<long long> sum(id+5);
			for (int k=i;k<j;k++){
				sum[dict[get<0>(vec[k])]]+=get<2>(vec[k]);
				sum[dict[get<1>(vec[k])]]-=get<2>(vec[k]);
			}
			for (int t=1;t<id;t++) sum[t]+=sum[t-1];

			for (int t=0;t<id-1;t++){
				sum[t]%=3;
				if (sum[t]!=0){
					vdir.emplace_back(plist[t],plist[t+1]);
				}
			}
		}
	}
	if (vdir.empty()){
		cout << "nice" << "\n";
		return 0;
	}
	auto cross = [&](long double x,long double y,long double a,long double b){
		return x*b-y*a;	
	};
	const long double _eps=1e-10;
	auto sgn = [&](long double x){
		if (x>_eps)	return 1;
		else if (x<-_eps) return -1;
		return 0;
	};
	auto test = [&](long double x,long double y){
		int cnt=0;
		for (int i=1;i<=n;i++){
			if (sgn(cross(a[i][1].x-a[i][0].x,a[i][1].y-a[i][0].y,x-a[i][0].x,y-a[i][0].y))>0){
				if (sgn(cross(a[i][2].x-a[i][1].x,a[i][2].y-a[i][1].y,x-a[i][1].x,y-a[i][1].y))>0){
					if (sgn(cross(a[i][0].x-a[i][2].x,a[i][0].y-a[i][2].y,x-a[i][2].x,y-a[i][2].y))>0){
						cnt++;
					}
				}	
			}
		}
		return cnt%3!=0;
	};
	mt19937 rng((unsigned long long)(new char));
	while (1){
		int sz=(int)vdir.size();
		int pos=rng()%sz;
		point P=vdir[pos].first;
		point Q=vdir[pos].second; 
		point dir=(Q-P).turn90();
		
		long double w=hypot(dir.x,dir.y);
		long double bx=(P.x+Q.x)/2.0;
		long double by=(P.y+Q.y)/2.0;
		long double dx=dir.x/w/scale;
		long double dy=dir.y/w/scale;
		
		if (test(bx+dx,by+dy)){
			cout << "not nice" << "\n";
			cout << fixed << setprecision(9) << bx+dx << " " << by+dy << "\n";
			return 0;
		}
		if (test(bx-dx,by-dy)){
			cout << "not nice" << "\n";
			cout << fixed << setprecision(9) << bx-dx << " " << by-dy << "\n";
			return 0;
		}
	}
    return 0;
}