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<complex>
#include<vector>
#include<iostream>
#include<stack>
#include<cmath>
#include<set>

#define sc second
#define fr first
 
using namespace std;
 
typedef double elem;
typedef complex<elem> point, vec;
typedef pair<point, point> line, hline, seg, pp;
 
const double infty = 1e40;
const double eps = 1.0e-9;
const double pi = acos(-1.0);
const double mag = 10;

bool eq(elem a, elem b){ return abs(a-b) < eps; }
bool far(point a, point b){ return abs(b-a)>eps; }
bool near(point a, point b){ return abs(b-a)<=eps; }
elem dot(vec a, vec b){ return (a.real() * b.real() + a.imag() * b.imag() ); }
elem cross(vec a, vec b){ return ( a.real() * b.imag() - a.imag() * b.real() ); }
elem dist_l(line l, point x){ return abs(cross(l.sc-l.fr,x-l.fr)) / abs(l.sc-l.fr); }
vec uvec(vec a){ return a / abs(a); }
vec nmr(vec a){ return a * vec(0,-1); }
vec nml(vec a){ return a * vec(0,1); }
vec unmr(vec a){ return uvec( nmr(a) ); }
vec unml(vec a){ return uvec( nml(a) ); }
bool prll(point a1, point a2, point b1, point b2){ return eq( cross( a2 - a1, b2 - b1 ), 0 ); }
bool prll(vec v1, vec v2){ return eq( cross(v1, v2), 0 ); }
bool intersectedLL(line a, line b){ return !eq( cross(a.sc-a.fr,b.sc-b.fr), 0.0 ); }
point intersectionLL(line a, line b)
{
  vec va = a.sc - a.fr;
  vec vb = b.sc - b.fr;
  return a.fr + va * ( cross(vb, b.fr - a.fr) / cross(vb,va) );
}
bool intersectionLL(line a, line b, point &ret){
  return intersectedLL( a, b ) ? ret = intersectionLL( a, b ), true : false;
}

void make_bisectors(int t, const vector<line> &vl, vector<line> &ret){
  for(int i = 0; i < (int)vl.size(); ++i){
    if( i != t ){
      point is;
      if(intersectionLL( vl[t], vl[i], is )){
	vec va;
	vec vb;
	
	if( far(is,vl[t].fr) )
	  va = uvec(vl[t].fr-is);
	else
	  va = uvec(vl[t].sc-is);
	
	if( far(is,vl[i].fr) )
	  vb = uvec(vl[i].fr-is);
	else
	  vb = uvec(vl[i].sc-is);
	
	ret.push_back( line( is, is+va+vb ) );
	ret.push_back( line( is, is+va-vb ) );
      }else{
	elem d = 0.5 * dist_l( vl[i], vl[t].fr );
	point ptl = vl[t].fr + d * unml(vl[t].sc-vl[t].fr);
	point ptr = vl[t].fr + d * unmr(vl[t].sc-vl[t].fr);
	//intersectionLL( line(vl[t].fr, vl[t].fr+unmr(vl[t].sc-vl[t].fr) ), vl[i], is );
	point pt;
	if( eq(dist_l(vl[t],ptl),d) && eq(dist_l(vl[i],ptl),d) )
	  pt = ptl - vl[t].fr;
	else
	  pt = ptr - vl[t].fr;

	point cfr = pt + vl[t].fr;
	point csc = pt + vl[t].sc;
	ret.push_back( line(cfr,csc) );
      }
    }
  }
  return ;
}

int main()
{
  while(true){
    int n;
    vector<line> vl;
    vector<line> bisector1;
    vector<line> bisector2;
    vector< point > res;

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

    for(int i = 0; i < n; ++i){
      elem x1,y1,x2,y2;
      scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
      x1 /= mag; y1 /= mag;
      x2 /= mag; y2 /= mag;
      vl.push_back(line(point(x1,y1),point(x2,y2)));
    }

    if( n<=2 ){
      puts("Many");
      continue;
    }

    make_bisectors(0,vl,bisector1);
    make_bisectors(1,vl,bisector2);

    for(int i = 0; i < (int)bisector1.size(); ++i){
      for(int j = 0; j < (int)bisector2.size(); ++j){
	point is;
	
	//if( prll(bisector1[i].sc-bisector1[i].fr,bisector2[j].sc-bisector2[j].fr) ) continue;
	
	if( intersectionLL( bisector1[i], bisector2[j], is ) ){
	  elem d = dist_l( vl[0], is );
	  bool ng = false;
	  for(int k = 1; k < n; ++k){
	    if( !eq( d, dist_l( vl[k], is ) ) ){
	      ng = true;
	      break;
	    }
	  }
	  if( !ng ) res.push_back(is);
	}
      }
      if(i == 1)break;
    }
    
    for(int i = 0; i < (int)res.size(); ++i){
      for(int j = i+1; j < (int)res.size(); ++j){
	if( near(res[i],res[j]) ){
	  res.erase( res.begin() + j );
	  i = -1;
	  break;
	}
      }
    }
    
    if( res.size() > 1 ){
      puts("Many");
    }else{
      if( res.size() == 1 )
	printf("%.12lf %.12lf\n", mag*res[0].real(), mag*res[0].imag());
      else
	puts("None");
    }
  }
  return 0;
}