#include<cmath>
#include<cstdio>
#include<vector>
#include<algorithm>

#define rep(i,n) for(int i=0;i<(n);i++)

const double EPS=1e-6;

using namespace std;

template<class T>
struct point{
	T x,y;
	point &operator+=(const point &a){ x+=a.x; y+=a.y; }
	point operator+(const point &a)const{ return (point){x+a.x,y+a.y}; }
	point operator-(const point &a)const{ return (point){x-a.x,y-a.y}; }
	operator point<double>()const{ return (point<double>){x,y}; }
};

point<double> &operator/=(point<double> &a,double c){ a.x/=c; a.y/=c; return a; }
bool operator<(const point<double> &a,const point<double> &b){
	return a.x+EPS<b.x || abs(a.x-b.x)<EPS && a.y+EPS<b.y;
}

template<class T>
point<T> operator*(T c,const point<T> &a){ return (point<T>){c*a.x,c*a.y}; }

template<class T>
point<double> operator/(const point<T> &a,double c){
	return (point<double>){a.x/c,a.y/c};
}

bool operator==(const point<double> &a,const point<double> &b){
	return abs(a.x-b.x)<EPS && abs(a.y-b.y)<EPS;
}

template<class T>
T cross(const point<T> &a,const point<T> &b){ return a.x*b.y-a.y*b.x; }

template<class T>
double abs(const point<T> &a){ return sqrt(a.x*a.x+a.y*a.y); }

template<class T>
struct line{
	point<T> a,b;
	operator line<double>()const{ return (line<double>){a,b}; }
};

template<class T>
bool intersect(const line<T> &L1,const line<T> &L2){
	return cross(L1.b-L1.a,L2.b-L2.a)!=0  // L1 と L2 が平行でない
		|| cross(L1.b-L1.a,L2.a-L1.a)==0; // L1 == L2
}

template<class T>
point<double> get_intersect(const line<T> &L1,const line<T> &L2){
	double a1=cross(L1.b-L1.a,L2.b-L2.a);
	double a2=cross(L1.b-L1.a,L1.b-L2.a);
	if(a1==0) return L1.a; // L1 == L2
	return (point<double>)L2.a+a2/a1*(point<double>)(L2.b-L2.a);
}

template<class T>
double dist(const point<T> &a,const point<T> &b){
	return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}

template<class T>
double dist(const line<T> &L,const point<T> &p){
	return abs(cross(L.b-L.a,p-L.a))/dist(L.a,L.b);
}

vector< line<double> > get_equal_dist_line(const line<int> &L,const line<int> &M){
	vector< line<double> > res;
	if(!intersect(L,M)){ // 二直線が平行のとき
		point<double> o=(L.a+M.a)/2;
		res.push_back((line<double>){o,o+(point<double>)(L.b-L.a)});
	}
	else{
		point<double> o=get_intersect(L,M);
		point<double> p=(point<double>)(L.a==o?L.b:L.a)-o;
		point<double> q=(point<double>)(M.a==o?M.b:M.a)-o;
		p/=abs(p);
		q/=abs(q);
		res.push_back((line<double>){o,o+p+q});
		res.push_back((line<double>){o,o+p-q});
	}
	return res;
}

int main(){
	for(int n;scanf("%d",&n),n;){
		line<int> L[100];
		rep(i,n) scanf("%d%d%d%d",&L[i].a.x,&L[i].a.y,&L[i].b.x,&L[i].b.y);

		if(n<=2){ puts("Many"); continue; }

		vector< point<double> > P_cand; // 答えの候補点
		vector< line<double> > M=get_equal_dist_line(L[0],L[1]);
		vector< line<double> > N=get_equal_dist_line(L[0],L[2]);
		rep(i,M.size()) rep(j,N.size()) {
			if(intersect(M[i],N[j])) P_cand.push_back(get_intersect(M[i],N[j]));
		}
		sort(P_cand.begin(),P_cand.end());
		P_cand.erase(unique(P_cand.begin(),P_cand.end()),P_cand.end());

		vector< point<double> > ans;
		rep(i,P_cand.size()){
			const point<double> &p=P_cand[i];
			bool ok=true;
			rep(j,n) if(abs(dist((line<double>)L[j],p)-dist((line<double>)L[0],p))>EPS) {
				ok=false;
				break;
			}
			if(ok) ans.push_back(p);
		}

		if     (ans.empty())   puts("None");
		else if(ans.size()>=2) puts("Many");
		else printf("%.9f %.9f\n",ans[0].x,ans[0].y);
	}

	return 0;
}

Measured memory_bytes: 0