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

typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
#define rrep(i, m, n) for(int (i)=(m); (i)<(n);  (i)++)
#define erep(i, m, n) for(int (i)=(m); (i)<=(n); (i)++)
#define  rep(i, n)    for(int (i)=0; (i)<(n);  (i)++)
#define rrev(i, m, n) for(int (i)=(n)-1; (i)>=(m); (i)--)
#define erev(i, m, n) for(int (i)=(n); (i)>=(m); (i)--)
#define  rev(i, n)    for(int (i)=(n)-1; (i)>=0; (i)--)
#define vrep(i, c)    for(__typeof((c).begin())i=(c).begin(); i!=(c).end(); i++)
#define  ALL(v)       (v).begin(), (v).end()
#define pb            push_back
#define mp            make_pair
template<class T, class S> inline bool minup(T& m, const S x){ return m>(T)x ? (m=(T)x, true) : false; }
template<class T, class S> inline bool maxup(T& m, const S x){ return m<(T)x ? (m=(T)x, true) : false; }

static const int    INF = 1000000000;
static const ll     MOD = 1000000007LL;
static const double EPS = 1E-5;

template<typename T> T add(T x, T y){ if(abs(x+y) < EPS*(abs(x)+abs(y))) return 0; return x + y; }
template<typename T> inline bool semieq(T x, T y){ return abs(x - y) < EPS; }
template<typename T> inline bool semige(T x, T y){ return y - x < -EPS; }
template<typename T> inline bool semile(T x, T y){ return x - y < -EPS; }

struct Point : public complex<double>
{
public:
  Point(const double x = 0.0, const double y = 0.0) { this->real(x);  this->imag(y); }
  Point(const complex<double> w)  { this->real(w.real());  this->imag(w.imag()); }
  inline double dot(Point p){ return (conj(*this) * p).real(); }  // ??????
  inline double det(Point p){ return (conj(*this) * p).imag(); }  // ??????
};

namespace std
{
  inline bool operator < (const Point& a, const Point& b)
  {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
typedef vector<Point> Polygon;
inline Point currPoint(vector<Point> P, int i){ return P[i]; }
inline Point nextPoint(vector<Point> P, int i){ return P[(i+1)%P.size()]; }
inline Point diffPoint(vector<Point> P, int i){ return nextPoint(P, i) - currPoint(P, i); }


int ccw(Point a, Point b, Point c)
{
  b -= a;
  c -= a;
  if(b.det(c) > 0.0)    return  1;         // counter clockwise
  if(b.det(c) < 0.0)    return -1;         // clockwise
  if(b.dot(c) < 0.0)    return  2;         // c--a--b on line
  if(norm(b) < norm(c)) return -2;         // a--b--c on line
  return 0;
}


struct Line : public vector<Point>
{
public:
  Line(){ }
  Line(const Point P, const Point Q){ this->pb(P);  this->pb(Q); }
  Line(double px, double py, double qx, double qy){ this->pb(Point(px, py));  this->pb(Point(qx, qy)); }
};
typedef Line Segment;


inline Point projectionOfLP(Line L, Point P){return L[0]+(Point(P-L[0])).dot(L[0]-L[1])/norm(L[0]-L[1])*(L[0]-L[1]);}
inline Point reflectionOfLP(Line L, Point P){return P+2.0*(projectionOfLP(L, P)-P);}
inline bool intersectionDeterminationOfLL(Line L, Line M){return abs(Point(L[1]-L[0]).det(M[1]-M[0]))>EPS||abs(Point(L[1]-L[0]).det(M[0]-L[0]))<EPS;}
inline bool intersectionDeterminationOfLS(Line L, Line S){return(Point(L[1]-L[0]).det(S[0]-L[0]))
*(Point(L[1]-L[0]).det(S[1]-L[0]))<EPS;}
inline bool intersectionDeterminationOfLP(Line L, Point P){return abs(Point(L[1]-P).det(L[0]-P))<EPS;}
inline bool intersectionDeterminationOfSS(Line S, Line T){return ccw(S[0],S[1],T[0])*ccw(S[0],S[1],T[1])<=0&&ccw(T[0],T[1],S[0])*ccw(T[0],T[1],S[1])<=0;}
inline bool intersectionDeterminationOfSP(Line S, Point P){return abs(S[0]-P)+abs(S[1]-P)-abs(S[1]-S[0])<EPS;}
inline double distanceOfLP(Line L, Point P){return abs(P-projectionOfLP(L,P));}
inline double distanceOfLL(Line L, Line M){return intersectionDeterminationOfLL(L,M)?0.0:distanceOfLP(L,M[0]);}
inline double distanceOfLS(Line L, Line S){return intersectionDeterminationOfLS(L,S)?0.0:min(distanceOfLP(L,S[0]),distanceOfLP(L,S[1]));}
inline double distanceOfSP(Line S, Point P){Point r=projectionOfLP(S,P);return intersectionDeterminationOfSP(S,r)?abs(r-P):min(abs(S[0]-P),abs(S[1]-P));}
inline double distanceOfSS(Line S, Line T){return intersectionDeterminationOfSS(S,T)?0.0:min(min(distanceOfSP(S,T[0]),distanceOfSP(S,T[1])),min(distanceOfSP(T,S[0]),distanceOfSP(T,S[1])));}
Point intersectionOfLL(Line L, Line M)
{
  double A = Point(L[1]-L[0]).det(M[1]-M[0]);
  double B = Point(L[1]-L[0]).det(L[1]-M[0]);
  if(abs(A)<EPS && abs(B)<EPS) return M[0];
  if(abs(A)<EPS) assert(false);
  return M[0] + B / A * (M[1] - M[0]);
}
inline bool onLine(Point P, Line L){ return semieq(Point(L[0]-P).det(L[1]-P),0.0); }
inline bool onSegment(Point P, Segment S){ return semieq(Point(S[0]-P).det(S[1]-P),0.0)&&!semige(Point(S[0]-P).dot(S[1]-P),0.0); }

// P ????????? L ????????´????????????
inline Line perpendicularBisector(Point P, Line L)
{
  return Line(P, (L[0] - P) * complex<double>(0.0, 1.0) + P);
}

// L ??¨ M ????????´????????¨????????\??????
vector<Line> bisector(Line L, Line M)
{
  vector<Line> ret(2);
  if(intersectionDeterminationOfLL(L, M)){
    Point P = intersectionOfLL(L, M);
    int s, t;
    if(semile(abs(L[0] - P), abs(L[1] - P))) s = 1;  else s = 0;
    if(semile(abs(M[0] - P), abs(M[1] - P))) t = 1;  else t = 0;
    Point S = (L[s] - P) / abs(L[s] - P);
    Point T = (M[t] - P) / abs(M[t] - P);
    Point ST = (S + T) / 2.0;
    ret[0] = Line(P, P + ST);
    ret[1] = Line(P, P + ST * complex<double>(0.0, 1.0));
  }
  else{
    Point E[2];
    rep(i, 2){
      Line LL = perpendicularBisector(L[i], L);
      Point PP = intersectionOfLL(LL, M);
      E[i] = (L[i] + PP) / 2.0;
    }
    ret[0] = ret[1] = Line(E[0], E[1]);
  }
  return ret;  
}

int n;
Line* L;
double sx, sy, tx, ty;

int main(int argc, char *argv[])
{
  while(cin >> n, n){
    L = new Line[n];
    rep(i, n){
      cin >> sx >> sy >> tx >> ty;
      L[i] = Line(sx, sy, tx, ty);
    }

    if(n <= 2){
      puts("Many");
      delete[] L;
      continue;
    }

    vector<Line> bis = bisector(L[0], L[1]);
    vector<Line> M = bisector(L[0], L[n - 1]);
    vector<Point> ret;
    vrep(v, bis){
      vrep(w, M){
        if(intersectionDeterminationOfLL(*v, *w)){
          Point P = intersectionOfLL(*v, *w);
          double d = distanceOfLP(L[0], P);
          bool ok = true;
          rep(i, n){
            if(!semieq(distanceOfLP(L[i], P), d)){
              ok = false;
              break;
            }
          }
          if(ok){
            vrep(c, ret) if(semieq(c->real(), P.real()) && semieq(c->imag(), P.imag())){
              ok = false;
              break;
            }
            if(ok) ret.pb(P);
          }
        }
      }
    }
    if(ret.size() == 0) puts("None");
    else if(ret.size() == 1) printf("%.15f %.15f\n", ret[0].real(), ret[0].imag());
    else puts("Many");
    
    delete[] L;
  }
  
  return 0;
}