#include<iostream>
#include<complex>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
#define mp         make_pair
#define pb         push_back
#define fir        first
#define sec        second

typedef complex<double> P;
typedef pair<P,P>       Line;

const double eps = 1e-8;
const double pi = acos(-1);
#define EQ(a,b) (fabs(a-b)<eps)
#define EQV(a,b) ( EQ((a).real(),(b).real())&&EQ((a).imag(),(b).imag()))
#define EQ2(a,b) (fabs(a-b)<1e-05)
#define EQV2(a,b) ( EQ2((a).real(),(b).real())&&EQ2((a).imag(),(b).imag()))

namespace std{
  bool operator<(const P &a,const P &b){
    if (!(EQ(a.real(),b.real())))return a.real() < b.real();
    else return a.imag() < b.imag();
  }
  bool operator==(const P &a,const P &b){
    return EQV2(a,b);
  }
}

double cross(P a,P b){
  return ( a.real()*b.imag() - a.imag()*b.real());
}

double distance_lp(P a,P b,P c){
  return abs( cross(b-a,c-a))/abs(b-a);
}

bool is_intersected_ll(P a1,P a2,P b1,P b2){
  return !EQ( cross(a1-a2,b1-b2),0.0);
}

P intersection_ll(P a1,P a2,P b1,P b2){
  P a= a2-a1,b=b2-b1;
  return a1+ a*cross(b,b1-a1)/cross(b,a);
}

P rot(P a,P b){
  double phi=arg(b*conj(a))/2;

  P ret;
  ret.real()=cos(phi)*a.real()-sin(phi)*a.imag();
  ret.imag()=sin(phi)*a.real()+cos(phi)*a.imag();
  return ret;
}

void  makeall(vector<Line> &a,vector<Line> &b){

  rep(i,1){
    REP(j,i+1,a.size()){
      if (is_intersected_ll(a[i].fir,a[i].sec,a[j].fir,a[j].sec)){
	P tmp = intersection_ll(a[i].fir,a[i].sec,a[j].fir,a[j].sec);
	P at=EQV(a[i].fir,tmp)?a[i].sec:a[i].fir;
	P bt=EQV(a[j].fir,tmp)?a[j].sec:a[j].fir;
	b.pb(mp(tmp,tmp+rot(at-tmp,bt-tmp)));
 	P tmp2=b[b.size()-1].sec;
 	tmp2-=tmp;
 	swap(tmp2.real(),tmp2.imag());
 	tmp2.real()*=-1;
 	tmp2+=tmp;
 	b.pb(mp(tmp,tmp2));
      }else {
	double d=distance_lp(a[i].fir,a[i].sec,a[j].fir)/2.;
	P hoge=a[i].sec-a[i].fir;
	swap(hoge.real(),hoge.imag());
	hoge.real()*=-1;
	hoge/=abs(hoge);
	hoge*=d;
	b.pb(mp(a[i].fir+hoge,a[i].sec+hoge));
	b.pb(mp(a[j].fir+hoge,a[j].sec+hoge));
      }
    }
  }
}

bool check(vector<Line> &a,P &b){
  double tmp = distance_lp(a[0].fir,a[0].sec,b);
  REP(i,1,a.size()){
    if (fabs(tmp-distance_lp(a[i].fir,a[i].sec,b))<eps);
    else return false;
  }
  return true;
}

void solve(vector<Line> &a){
  vector<Line> b;
  makeall(a,b);
  P ans;
  int cnt=0;
  vector<P> candy;
  rep(i,b.size() && cnt < 2){
    REP(j,i+1,b.size()&&cnt<2){
      if (is_intersected_ll(b[i].fir,b[i].sec,b[j].fir,b[j].sec)){
	P cand=intersection_ll(b[i].fir,b[i].sec,b[j].fir,b[j].sec);
	candy.pb(cand);
      }
    }
  }
  
  sort(candy.begin(),candy.end());
  candy.erase(unique(candy.begin(),candy.end()),candy.end());
  
  rep(i,candy.size()){
    if (check(a,candy[i])){
      ans=candy[i];
      cnt++;
      if (cnt ==2)break;
    }
  }
  
  if (cnt == 0){
    printf("None\n");
  }else if(cnt == 1){
    printf("%.10lf %.10lf\n",ans.real(),ans.imag());
  }else {
    printf("Many\n");
  }
}

main(){
  int n;
  while(cin>>n && n){
    vector<Line> a(n);
    rep(i,n){
      rep(j,2){
	cin>>a[i].fir.real()>>a[i].fir.imag();
	swap(a[i].fir,a[i].sec);
      }
    }
    

    if (a.size() == 1||a.size() ==2){
      printf("Many\n");
    }else solve(a);
  }
  return false;
}

Measured memory_bytes: 0