Problem: We understand that reading English is a great pain to many of you. So we’ll keep this problem statememt simple. Write a program that reports the point equally distant from a set of lines given as the input. In case of no solutions or multiple solutions, your program should report as such.



Input

The input consists of multiple datasets. Each dataset is given in the following format:

n
x1,1 y1,1 x1,2 y1,2
x2,1 y2,1 x2,2 y2,2
...
xn,1 yn,1 xn,2 yn,2


n is the number of lines (1 ≤ n ≤ 100); (xi,1, yi,1) and (xi,2, yi,2) denote the different points the i-th line passes through. The lines do not coincide each other. The coordinates are all integers between -10000 and 10000.

The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.

Output

For each dataset, print a line as follows. If there is exactly one point equally distant from all the given lines, print the x- and y-coordinates in this order with a single space between them. If there is more than one such point, just print "Many" (without quotes). If there is none, just print "None" (without quotes).

The coordinates may be printed with any number of digits after the decimal point, but should be accurate to 10-4.

Example

Input

2
-35 -35 100 100
-49 49 2000 -2000
4
0 0 0 3
0 0 3 0
0 3 3 3
3 0 3 3
4
0 3 -4 6
3 0 6 -4
2 3 6 6
-1 2 -4 6
0


Output

Many
1.5000 1.5000
1.000 1.000

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
//#define EPS 0.000000001
using namespace std;


#define EPS 0.000001

struct Point{
	Point(double arg_x,double arg_y){
		x = arg_x;
		y = arg_y;
	}

	Point(){
		x = y = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y);}
	Point operator * (double a){ return Point(a*x,a*y); }
	Point operator / (double a){ return Point(x/a,y/a); }

	double abs(){ return sqrt(norm()); }
	double norm(){ return x*x + y*y; }

	bool operator<(const Point &p) const{
		return x != p.x? x < p.x: y < p.y;
	}

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}

	double x,y;
};

struct Line{
	Point p[2];
	Line(Point p1,Point p2){
		p[0] = p1;
		p[1] = p2;
	}
	Line(){

	}
};

typedef Point Vector;

int N;
Point point[3];
vector<Line> LINE;
double slope[3];



//交点を求める関数
Point calc_Cross_Point(double x1,double x2,double x3,double x4,double y1,double y2,double y3,double y4){
	Point ret;
	ret.x = ((x2-x1)*(y3*(x4-x3)+x3*(y3-y4))-(x4-x3)*(y1*(x2-x1)+x1*(y1-y2)))/((y2-y1)*(x4-x3)-(y4-y3)*(x2-x1));
	if(x1 != x2){
		ret.y = ((y2-y1)*ret.x+y1*(x2-x1)+x1*(y1-y2))/(x2-x1);
	}else{
		ret.y = ((y4-y3)*ret.x+y3*(x4-x3)+x3*(y3-y4))/(x4-x3);
	}
	return ret;
}

//インタフェース関数
Point calc_Cross_Point(Point a,Point b,Point c,Point d){
	return calc_Cross_Point(a.x,b.x,c.x,d.x,a.y,b.y,c.y,d.y);
}

Point calc_Cross_Point(Line A,Line B){

	return calc_Cross_Point(A.p[0],A.p[1],B.p[0],B.p[1]);
}

double calc_slope(Line A){

	if(fabs(A.p[0].x-A.p[1].x) < EPS){

		return DBL_MAX;

	}else if(fabs(A.p[0].y-A.p[1].y) < EPS){

		return 0;

	}else{

		return (A.p[0].y-A.p[1].y)/(A.p[0].x-A.p[1].x);
	}
}

//★★直線の交差判定★★
bool is_Cross(Line A,Line B){

	return fabs(calc_slope(A)-calc_slope(B)) > EPS;
}

double norm(Vector a){
	return a.x*a.x+a.y*a.y;
}

double abs(Vector a){
	return sqrt(norm(a));
}

double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

double calc_dist1(Line line,Point point){
    return abs(cross(line.p[1]-line.p[0],point-line.p[0]))/abs(line.p[1]-line.p[0]);
}

vector<Line> calc_Equal_Line(Line A,Line B){

	vector<Line> ret;

	if(is_Cross(A,B)){

		Point cross_point = calc_Cross_Point(A,B);

		Vector dir_A = A.p[1]-A.p[0];
		Vector dir_B = B.p[1]-B.p[0];

		dir_A = dir_A/abs(dir_A);
		dir_B = dir_B/abs(dir_B);

		ret.push_back(Line(cross_point,cross_point+dir_A+dir_B));
		ret.push_back(Line(cross_point,cross_point+dir_A-dir_B));

	}else{

		ret.push_back(Line((A.p[0]+B.p[0])/2,(A.p[0]+B.p[0])/2+(A.p[1]-A.p[0])));
	}

	return ret;
}


void func(){

	LINE.clear();

	for(int i = 0; i < N; i++){

		Point A,B;

		scanf("%lf %lf %lf %lf",&A.x,&A.y,&B.x,&B.y);

		if(A.x > B.x){

			swap(A,B);
		}
		LINE.push_back(Line(A,B));
	}

	if(N <= 2){

		printf("Many\n");
		return;
	}

	vector<Line> LINE_01 = calc_Equal_Line(LINE[0],LINE[1]);
	vector<Line> LINE_02 = calc_Equal_Line(LINE[0],LINE[2]);

	vector<Point> CANDIDATE,ANS;

	for(int i = 0; i < LINE_01.size(); i++){
		for(int k = 0; k < LINE_02.size(); k++){

			if(!is_Cross(LINE_01[i],LINE_02[k]))continue;

			CANDIDATE.push_back(calc_Cross_Point(LINE_01[i],LINE_02[k]));
		}
	}

	sort(CANDIDATE.begin(),CANDIDATE.end());
	CANDIDATE.erase(unique(CANDIDATE.begin(),CANDIDATE.end()),CANDIDATE.end());

	int count = 0;

	for(int i = 0; i < CANDIDATE.size(); i++){

		double base_dist =  calc_dist1(LINE[0],CANDIDATE[i]);

		bool FLG = true;

		for(int k = 1; k < N; k++){

			if(fabs(base_dist-calc_dist1(LINE[k],CANDIDATE[i])) > EPS){

				FLG = false;
				break;
			}

		}

		if(FLG){
			count++;
			ANS.push_back(CANDIDATE[i]);
		}
	}

	if(count == 0){

		printf("None\n");
	}else if(count >= 2){

		printf("Many\n");

	}else{

		printf("%.10lf %.10lf\n",ANS[0].x,ANS[0].y);
	}
}

int main(){

	while(true){

		scanf("%d",&N);
		if(N == 0)break;

		func();
	}

	return 0;
}