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;

#define int long long
#define all(v) begin(v), end(v)
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for(int i = (int)(s); i < (int)(n); i++)

template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}

using pint = pair<int, int>;
using tint = tuple<int, int, int>;
using vint = vector<int>;

const int inf = 1LL << 55;
const int mod = 1e9 + 7;

#define EPS (1e-5)
#define eq(a, b) (fabs((a)-(b)) < EPS)
#define lt(a, b) ((a) - (b) < -EPS)
#define le(a, b) (eq(a, b) || lt(a, b))
#define PI acos(-1)

struct Point {
  double x, y;
  Point(double x = 0.0, double y = 0.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 a) { return Point(x * a, y * a); }
  Point operator / (double a) { return Point(x / a, y / a); }

  double abs() { return sqrt(norm()); }
  double norm() { return x*x + y*y; }

  bool operator < (const Point& p) const {
    return x != p.x ? x < p.x : y < p.y;
  }
  bool operator == (const Point& p) const {
    return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
  }
};
typedef Point Vector;

Point rotateBasedOrigin(Point p, double theta) {
  double rad = theta * PI/180;
  return Point(p.x*cos(rad)-p.y*sin(rad), p.x*sin(rad)+p.y*cos(rad));
}

Point rotate(Point o, Point p, double theta) {
  Point q = p - o;
  Point r = rotateBasedOrigin(q, theta);
  return o + r;
}

double norm(Vector v) { return v.x*v.x + v.y*v.y; }
double abs(Vector v) { return sqrt(norm(v)); }
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 isOrthogonal(Vector a, Vector b) {
  return eq(dot(a, b), 0.0);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
  return isOrthogonal(a1 - a2, b1 - b2);
}
bool isParallel(Vector a, Vector b) {
  return eq(cross(a, b), 0.0);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
  return isParallel(a1 - a2, b1 - b2);
}

#define COUNTER_CLOCKWISE +1
#define CLOCKWISE         -1
#define ONLINE_BACK       +2
#define ONLINE_FRONT      -2
#define ON_SEGMENT        +0
int ccw(Point p0, Point p1, Point p2) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
  if(cross(a, b) < -EPS) return CLOCKWISE;
  if(dot(a, b) < -EPS) return ONLINE_BACK;
  if(a.norm() < b.norm()) return ONLINE_FRONT;
  return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
  return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
	  ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

double getDistance(Point a, Point b) { return abs(a - b); }
double getAngle(Point a, Point b, Point c) {
  Vector v = b - a, w = c - b;
  double alpha = atan2(v.y, v.x), beta = atan2(w.y, w.x);
  if(alpha > beta) swap(alpha, beta);
  double theta = (beta - alpha) * 180 / M_PI;
  return min(theta, 360 - theta);
}
Vector getAngleBisectorVector(Point a, Point b, Point c) {
  Vector v = a - b, w = c - b;
  v = v / abs(v), w = w / abs(w);
  Vector u = v + w;
  return u / abs(u);
}

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

bool isOrthogonal(Segment s1, Segment s2) {
  return eq(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Segment s1, Segment s2) {
  return eq(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}

Point project(Segment s, Point p) {
  Vector base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / norm(base);
  return s.p1 + base * r;
}
Point reflect(Segment s, Point p) {
  return p + (project(s, p) - p) * 2.0;
}

bool intersect(Segment s1, Segment s2) {
  return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

double getDistanceLP(Line l, Point p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
  if(dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
  if(dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
  return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
  if(intersect(s1, s2)) return 0.0;
  return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
	     min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2) {
  Vector base = s2.p2 - s2.p1;
  double d1 = abs(cross(base, s1.p1 - s2.p1));
  double d2 = abs(cross(base, s1.p2 - s2.p1));
  double t = d1 / (d1 + d2);
  return s1.p1 + (s1.p2 - s1.p1) * t;
}
Point getCrossPointLL(Line l1, Line l2) {
  Vector v1 = l1.p2 - l1.p1, v2 = l2.p2 - l2.p1;
  double d = cross(v2, v1);
  if(abs(d) < EPS) return l2.p1;
  return l1.p1 + v1 * cross(v2, l2.p2 - l1.p1) * (1.0 / d);
}
Line getPerpendicularBisector(Point p1, Point p2) {
  Point c = (p1 + p2) / 2.0;
  Point q = Point(c.x + (p1.y - p2.y), c.y + (p2.x - p1.x));
  return Line(c, q);
}
vector<Vector> getNormalLineVector(Line l) {
  vector<Vector> vs;
  Vector v = l.p2 - l.p1, p = v / abs(v);
  vs.emplace_back(-p.y, p.x);
  vs.emplace_back(p.y, p.x);
  return vs;
}
vector<Line> getTranslation(Line l, double d) {
  vector<Vector> nlv = getNormalLineVector(l);
  vector<Line> nl;
  nl.emplace_back(l.p1 + nlv[0]*d, l.p2 + nlv[0]*d);
  nl.emplace_back(l.p1 + nlv[1]*d, l.p2 + nlv[1]*d);
  return nl;
}

signed main()
{
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  int n;
  while(cin >> n, n) {
    vector<Line> lines;
    rep(i, n) {
      Point p, q;
      cin >> p.x >> p.y >> q.x >> q.y;
      lines.emplace_back(p, q);
    }
    if(n <= 2) {
      cout << "Many" << endl;
      continue;
    }
    vector< vector<Line> > bilines;
    rep(i, n) reps(j, i+1, n) {
      Line l = lines[i], r = lines[j];
      Vector lv = l.p2 - l.p1, rv = r.p2 - r.p1;
      lv = lv / abs(lv); rv = rv / abs(rv);
      vector<Line> bi;
      if(isParallel(l, r)) {
	Point o = (l.p1+r.p1)/2;
	Line m = Line(o, o + lv);
	bi.push_back(m);
	bilines.push_back(bi);
      } else {
	Point p = getCrossPointLL(l, r);
	Line v = Line(p, p + lv*100 + rv*100);
	Line w = Line(p, p + lv*100 - rv*100);
	bi.push_back(v);
	bi.push_back(w);
	bilines.push_back(bi);
      }
    }
    vector<Point> ans;
    rep(i, min((int)bilines.size(), 10LL)) {
      reps(j, i+1, min((int)bilines.size(), 10LL)) {
	vector<Line> a = bilines[i], b = bilines[j];
	rep(k, a.size()) rep(l, b.size()) {
	  if(isParallel(a[k], b[l])) continue;
	  bool flag = true;
	  Point cp = getCrossPointLL(a[k], b[l]);
	  //cout<<cp.x<<" "<<cp.y<<endl;
	  double dist = getDistanceLP(lines[0], cp);
	  rep(x, n) {
	    //cout<<dist<< " "<< getDistanceLP(lines[x], cp) << endl;
	    if(!eq(dist, getDistanceLP(lines[x], cp))) flag = false;
	  }
	  rep(x, ans.size()) {
	    if(eq(abs(ans[x]-cp), 0)) flag = false;
	  }
	  if(flag) ans.push_back(cp);
	}
      }
    }
    if(ans.size() == 0) cout << "None" << endl;
    else if(ans.size() == 1) {
      cout << ans[0].x << " " << ans[0].y << endl;
    }
    else cout << "Many" << endl;
  }

  return 0;
}