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>
#define inf 1<<29
#define linf 1e18
#define eps (1e-6)
#define mod 1000000007
#define pi acos(-1)
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define pd(a) printf("%.10f\n",(double)(a))
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define equals(a,b) (fabs((a)-(b))<eps)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<double,int> pdi;
typedef vector<int> vi;
typedef vector<pii> vpi;
const int dx[8]={1,0,-1,0,1,1,-1,-1};
const int dy[8]={0,1,0,-1,1,-1,1,-1};

class Point{
public:
  double x,y;
  Point(double x=0,double y=0):x(x),y(y){}

  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 k){ return Point(x*k,y*k);}
  Point operator/(double k){ return Point(x/k,y/k);}
  bool operator<(Point p)const{ 
    return (x!=p.x ? x-p.x<-eps : y-p.y<-eps);}
  bool operator==(Point p)const{ 
    return fabs(x-p.x)<eps && fabs(y-p.y)<eps;}

  double abs(){ return sqrt(norm());}
  double norm(){ return (x*x+y*y);}
};
typedef Point Vector;
typedef vector<Point> Polygon;

class Segment{
public:
  Point p1,p2;
  Segment(Point p1=Point(),Point p2=Point()):p1(p1),p2(p2){}
};
typedef Segment Line;

double norm(Vector a){ return (a.x*a.x+a.y*a.y);}
double abs(Vector a){ return sqrt(norm(a));}
double dot(Vector a,Vector b){ return (a.x*b.x+a.y*b.y);}
double cross(Vector a,Vector b){ return (a.x*b.y-a.y*b.x);}

bool isParallel(Segment s,Segment t){
  return equals(cross(s.p1-s.p2,t.p1-t.p2),0.0);
}

double getDistanceLP(Line l,Point p){
  return abs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}

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);
}

Point rotate(Point base,Point a,double r){
  Point b=a-base;
  a.x=b.x*cos((r/180.0)*pi)-b.y*sin((r/180.0)*pi);
  a.y=b.x*sin((r/180.0)*pi)+b.y*cos((r/180.0)*pi);
  a=a+base;
  return a;
}

double getAngle(Vector a,Vector b){
  double tmp=dot(a,b)/(abs(a)*abs(b));
  if(tmp<-1.0)tmp=-1.0;
  if(1.0<tmp)tmp=1.0;
  double r=acos(tmp)*180.0/pi;
  return r;
}

vector<Point> unique(vector<Point> vp){
  vector<Point> res;
  if(vp.empty())return res;
  sort(all(vp));
  res.pb(vp[0]);
  FOR(i,1,vp.size())if(!(vp[i]==res.back()))res.pb(vp[i]);
  return res;
}

typedef pair<Line,Line> pll;

int n;
vector<Segment> vs;
vector<Point> vp;

pll getS(Line a,Line b){
  Point m=getCrossPointLL(a,b);
  double r=getAngle(a.p1-a.p2,b.p1-b.p2);
  Line c(rotate(m,a.p1,r/2.0),rotate(m,a.p1,180+r/2.0));
  Line d(rotate(m,a.p1,(180.0-r)/2.0),rotate(m,a.p1,180+(180.0-r)/2.0));
  return mp(c,d);
}

bool check2(Point p){
  double dis=getDistanceLP(vs[0],p);
  FOR(i,1,n)
    if(!equals(dis,getDistanceLP(vs[i],p)))return false;
  return true;
}

void check1(Line a,Line b,Line c){
  Point d=getCrossPointLL(a,c),e=getCrossPointLL(b,c);
  Point m=d+(e-d)/2.0;
  Line L(m+(a.p1-a.p2),m);
  pll f=getS(a,c);
  d=getCrossPointLL(f.f,L);
  if(check2(d))vp.pb(d);
  d=getCrossPointLL(f.s,L);
  if(check2(d))vp.pb(d);
  pll s=getS(b,c);
  d=getCrossPointLL(s.f,L);
  if(check2(d))vp.pb(d);
  d=getCrossPointLL(s.s,L);
  if(check2(d))vp.pb(d);
  return;
}

void check3(pll a,pll b){
  if(!isParallel(a.f,b.f)){
    Point c=getCrossPointLL(a.f,b.f);
    if(check2(c))vp.pb(c);
  }
  if(!isParallel(a.f,b.s)){
    Point c=getCrossPointLL(a.f,b.s);
    if(check2(c))vp.pb(c);
  }
  if(!isParallel(a.s,b.f)){
    Point c=getCrossPointLL(a.s,b.f);
    if(check2(c))vp.pb(c);
  }
  if(!isParallel(a.s,b.s)){
    Point c=getCrossPointLL(a.s,b.s);
    if(check2(c))vp.pb(c);
  }
}

void solve(){
  if(n<=2){
    cout<<"Many"<<endl;
    return;
  }
  FOR(i,0,n){
    FOR(j,0,n){
      FOR(k,0,n){
        if(i==j || i==k || j==k)continue;
        if(isParallel(vs[i],vs[j]) && isParallel(vs[i],vs[k]))continue;
        else if(isParallel(vs[i],vs[j]))check1(vs[i],vs[j],vs[k]);
        //else if(isParallel(vs[j],vs[k]))check1(vs[j],vs[k],vs[i]);
        //else if(isParallel(vs[k],vs[i]))check1(vs[k],vs[i],vs[j]);
        else {
          pll a=getS(vs[i],vs[j]);
          pll b=getS(vs[j],vs[k]);
          pll c=getS(vs[k],vs[i]);
          check3(a,b);
         // check3(b,c);
         // check3(c,a);
        }
      }
    }
  }
  vp=unique(vp);
  if(vp.empty())cout<<"None"<<endl;
  else if(vp.size()>1)cout<<"Many"<<endl;
  else printf("%.10f %.10f\n",vp[0].x,vp[0].y);
  return;
}

int main()
{
  while(cin>>n && n){
    vs.clear();
    vp.clear();
    FOR(i,0,n){
      int a,b,c,d;
      cin>>a>>b>>c>>d;
      vs.pb(Segment(Point(a,b),Point(c,d)));
    }
    solve();
  }
  return 0;
}