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
#include <bits/stdc++.h>
using namespace std;

#define dump(n) cout<<"# "<<#n<<'='<<(n)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;

const int INF=1e9;
const int MOD=1e9+7;
//const double EPS=1e-9;
const double EPS=1e-10;

template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
	return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& a){
	os<<'[';
	rep(i,a.size()) os<<(i?" ":"")<<a[i];
	return os<<']';
}

struct Point{
	double x,y;
	Point(){}
	Point(double x,double y):x(x),y(y){}
	Point& operator+=(Point p){x+=p.x,y+=p.y; return *this;}
	Point& operator-=(Point p){x-=p.x,y-=p.y; return *this;}
	Point& operator*=(double c){x*=c,y*=c; return *this;}
	Point& operator/=(double c){x/=c,y/=c; return *this;}
};
Point operator+(Point a,Point b){return a+=b;}
Point operator-(Point a,Point b){return a-=b;}
Point operator*(Point a,double c){return a*=c;}
Point operator*(double c,Point a){return a*=c;}
Point operator/(Point a,double c){return a/=c;}
bool operator==(Point a,Point b){return abs(a.x-b.x)<EPS && abs(a.y-b.y)<EPS;}
bool operator!=(Point a,Point b){return !(a==b);}

double Abs(Point p){
	return sqrt(p.x*p.x+p.y*p.y);
}
double Abs2(Point p){
	return p.x*p.x+p.y*p.y;
}
double Arg(Point p){
	return atan2(p.y,p.x);
}
double Dot(Point a,Point b){
	return a.x*b.x+a.y*b.y;
}
double Cross(Point a,Point b){
	return a.x*b.y-a.y*b.x;
}
Point Rot(Point p,double t){
	return Point(cos(t)*p.x-sin(t)*p.y,sin(t)*p.x+cos(t)*p.y);
}

struct Line{
	Point pos,dir;
	Line(){}
	Line(Point p,Point d):pos(p),dir(d){}
	Line(double x,double y,double u,double v):pos(x,y),dir(u,v){}
};

Point Proj(Line l,Point p){
	Point a=p-l.pos,b=l.dir;
	return l.pos+Dot(a,b)/Abs2(b)*b;
}

double DistLP(Line l,Point p){
	return Abs(Proj(l,p)-p);
}

Point InterPointLL(Line a,Line b){
	if(abs(Cross(a.dir,b.dir))<EPS) return a.pos;
	return a.pos+Cross(b.pos-a.pos,b.dir)/Cross(a.dir,b.dir)*a.dir;
}

bool Parallel(Line a,Line b){
	return abs(Cross(a.dir,b.dir))<EPS;
}

vector<Line> EquidistantLine(Line a,Line b){
	if(Parallel(a,b))
		return {Line((a.pos+b.pos)/2,a.dir)};
	Point p=InterPointLL(a,b);
	a.dir/=Abs(a.dir),b.dir/=Abs(b.dir);
	return {Line(p,(a.dir+b.dir)/2),Line(p,(a.dir-b.dir)/2)};
}

ostream& operator<<(ostream& os,const Point& p){
	return os<<'('<<p.x<<','<<p.y<<')';
}

string solve(vector<Line> ls)
{
	int n=ls.size();
	if(n<=2) return "Many"; // trivial case
	
	Line a=ls[0],b=ls[1],c=ls[2];
	if(Parallel(a,b) && Parallel(b,c))
		return "None";
	
	// 平行な直線があるなら，aとbがそうであるようにする
	if(Parallel(a,c)) swap(b,c);
	if(Parallel(b,c)) swap(a,c);
	
	vector<Point> ps;
	if(Parallel(a,b)){
		Line l=EquidistantLine(a,b)[0];
		auto els=EquidistantLine(a,c);
		ps.push_back(InterPointLL(l,els[0]));
		ps.push_back(InterPointLL(l,els[1]));
	}
	else{
		for(auto l1:EquidistantLine(a,b))
			for(auto l2:EquidistantLine(a,c))
				ps.push_back(InterPointLL(l1,l2));
	}
	sort(all(ps),[](Point a,Point b){return abs(a.x-b.x)>EPS?a.x<b.x:a.y<b.y;});
	ps.erase(unique(all(ps)),end(ps));
	
	vector<Point> qs;
	for(auto p:ps){
		bool ok=true;
		rep(i,ls.size()) ok&=abs(DistLP(ls[i],p)-DistLP(ls[0],p))<EPS;
		if(ok) qs.push_back(p);
	}
	
	if(qs.size()==0) return "None";
	if(qs.size()>=2) return "Many";
	return to_string(qs[0].x)+" "+to_string(qs[0].y);
}

int main()
{
	for(int n;cin>>n && n;){
		vector<Line> ls(n);
		rep(i,n){
			int x1,y1,x2,y2; cin>>x1>>y1>>x2>>y2;
			ls[i]=Line(x1,y1,x2-x1,y2-y1);
		}
		cout<<solve(ls)<<endl;
	}
}