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

#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount

typedef long double D;
typedef complex<D> P;

#define X real()
#define Y imag()
const D eps=1e-6;

D cross(P a,P b){ return (conj(a)*b).Y; }
struct L : public vector<P> { // line and segment
  L(const P& a,const P &b){
    push_back(a);
    push_back(b);
  }
};
P projection(L l,P p){
  P b=l[1]-l[0],c=p-l[0];
  return l[0]+b*(c/b).X;
}
D distanceLP(L l,P p) {
  return abs(p-projection(l,p));
}
bool intersectLL(L l,L m){
  return abs(cross(l[1]-l[0],m[1]-m[0]))>eps||abs(cross(l[1]-l[0],m[0]-l[0]))<eps;
}
P crosspoint(L l,L m) {
  D A=cross(l[1]-l[0],m[1]-m[0]);
  D B=cross(l[1]-l[0],l[1]-m[0]);
  if (abs(A)<eps&&abs(B)<eps) return m[0]; // same line
  if (abs(A)<eps) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0]+B/A*(m[1]-m[0]);
}

int main(){
  while(1){
    int N;
    vector<L> ls;
    cin>>N;
    if(N==0)break;
    rep(i,N){
      int x1,y1,x2,y2;
      cin>>x1>>y1>>x2>>y2;
      ls.push_back(L(P(x1,y1),P(x2,y2)));
    }
    if(N<=2){
      cout<<"Many"<<endl;
      continue;
    }
    vector<P> candps;
    {
      vector<L> cls[3];
      rep(i,3){
        int j=(i+1)%3;
        if(intersectLL(ls[i],ls[j])){
          P cp=crosspoint(ls[i],ls[j]);
          P v1=ls[i][1]-ls[i][0];
          P v2=ls[j][1]-ls[j][0];
          P v3=(abs(v2)*(abs(v1)+abs(v2)))*v1+(abs(v1)*(abs(v1)+abs(v2)))*v2;
          cls[i].push_back(L(cp,cp+v3));
          cls[i].push_back(L(cp,cp+P(-v3.Y,v3.X)));
        }else{
          P vv=P(ls[i][0].Y-ls[i][1].Y,ls[i][1].X-ls[i][0].X);
          L vl=L(ls[i][0],ls[i][0]+vv);
          P c1=crosspoint(vl,ls[i]); P c2=crosspoint(vl,ls[j]);
          P mp=(c1+c2)/(long double)2.0;
          cls[i].push_back(L(mp,mp+(ls[i][1]-ls[i][0])));
        }
      }
      rep(a,cls[0].size())rep(b,cls[1].size())rep(c,cls[2].size()){
        if(!intersectLL(cls[0][a],cls[1][b]))continue;
        if(!intersectLL(cls[1][b],cls[2][c]))continue;
        if(!intersectLL(cls[2][c],cls[0][a]))continue;
        P p1=crosspoint(cls[0][a],cls[1][b]);
        P p2=crosspoint(cls[1][b],cls[2][c]);
        P p3=crosspoint(cls[2][c],cls[0][a]);
        if(abs(p1-p2)<1e-4&&abs(p2-p3)<1e-4&&abs(p3-p1)<1e-4){
          bool ok=true;
          rep(z,candps.size())if(abs(candps[z]-p1)<eps){
            ok=false;
          }
          if(ok)candps.push_back(p1);
        }
      }
    }
    vector<P> res;
    rep(i,candps.size()){
      vector<D> ds;
      rep(j,N){
        ds.push_back(distanceLP(ls[j],candps[i]));
      }
      bool ok=true;
      rep(j,ds.size())rep(k,j){
        if(abs(ds[j]-ds[k])>eps)ok=false;
      }
      if(ok)res.push_back(candps[i]);
    }
    if(res.size()==0)cout<<"None"<<endl;
    else if(res.size()==1)printf("%.10Lf %.10Lf\n", res[0].X,res[0].Y);
    else cout<<"Many"<<endl;
  }
  return 0;
}



Measured memory_bytes: 3204