#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#define EPS (1.0e-5)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;

class Point {
public:
  double x, y;
  Point(double x = 0, double y = 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); }
  bool operator < (const Point &p) const {
    if(!equals(x, p.x)) return x < p.x;
    if(!equals(y, p.y)) return y < p.y;
    return false;
  }
  bool operator == (const Point &p) const {
    return equals(x, p.x) && equals(y, p.y);
  }
};

typedef Point Vector;

class Segment {
public:
  Point p1, p2;
};
typedef Segment Line;

double norm(Vector a) { return a.x*a.x + a.y*a.y; }
double abs(Vector a) { return sqrt(norm(a)); }
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 isParallel(Vector a, Vector b) {
  return equals(cross(a, b), 0.0);
}

bool isParallel(Line s1, Line s2) {
  return isParallel(s1.p2-s1.p1, s2.p2-s2.p1);
}

int ccw(Point p0, Point p1, Point p2) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if(cross(a, b) > EPS) return 1;
  if(cross(a, b) < -EPS) return -1;
  if(dot(a, b) < -EPS) return 2;
  if(norm(a) < norm(b)) return -2;
  return 0;
}

bool isIntersect(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 );
}
bool isIntersect(Segment s1, Segment s2) {
  return isIntersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

Point getCrossPoint(Line s1, Line s2) {
  Vector a = s1.p2 - s1.p1;
  Vector b = s2.p2 - s2.p1;
  double d1 = cross(b, s2.p1 - s1.p1);
  double d2 = cross(b, a);
  return s1.p1 + a * d1/d2;
}

Vector getOthogonalV(Vector a) {
  return Vector(-a.y, a.x);
}

Line getOthogonalL(Line s) {
  Line res;
  res.p1 = s.p1;
  res.p2 = s.p1 + getOthogonalV(s.p2 - s.p1);
  return res;
}

double getDistanceLP(Line s, Point p) {
  return fabs(cross(s.p2 - s.p1, p - s.p1))/abs(s.p2 - s.p1);
}

int N;
Line S[100];

void getBisector(vector<Line> &v) {
  for(int i = 0; i < 1; ++i) {
    for(int j = i+1; j < N; ++j) {
      Vector a = S[i].p2 - S[i].p1;
      Vector b = S[j].p2 - S[j].p1;
      if(isParallel(S[i], S[j])) {
	double d = getDistanceLP(S[i], S[j].p1)/2.0;
	Vector vn;
	if(ccw(S[i].p1, S[i].p2, S[j].p1) >= 1) {
	  vn.x = -a.y;
	  vn.y = a.x;
	} else {
	  vn.x = a.y;
	  vn.y = -a.x;
	}
	vn = vn*d/abs(vn);
	Line l;
	l.p1 = S[i].p1 + vn;
	l.p2 = S[i].p2 + vn;
	v.push_back(l);
      } else {
	Point p = getCrossPoint(S[i], S[j]);
	Line l;
	l.p1 = p;
	l.p2 = p + b+a*sqrt(norm(b)/norm(a));
	v.push_back(l);
	v.push_back(getOthogonalL(l));
      }
    }
  }
}

void solve() {
  if(N <= 2) {
    cout << "Many" << endl;
    return;
  }

  vector<Line> v;
  getBisector(v);

  vector<Point> cp;
  for(int i = 0; i < v.size(); ++i) {
    for(int j = i+1; j < v.size(); ++j) {
      if(isParallel(v[i], v[j])) continue;
      cp.push_back(getCrossPoint(v[i], v[j]));
    }
  }
  sort(cp.begin(), cp.end());
  cp.erase(unique(cp.begin(), cp.end()), cp.end());
  int count = 0;
  Point ans;
  for(vector<Point>::iterator ii = cp.begin(); ii != cp.end(); ++ii) {
    double d = getDistanceLP(S[0], *ii);
    bool flag = true;
    for(int j = 1; j < N; ++j) {
      if(!equals(d, getDistanceLP(S[j], *ii))) {
	flag = false;
	break;
      }
    }
    if(flag) {
      ++count;
      if(count >= 2) break;
      ans = *ii;
    }
  }

  if(count == 0) cout << "None" << endl;
  else if(count == 1) printf("%.5f %.5f\n", ans.x, ans.y);
  else if(count >= 2) cout << "Many" << endl;
}

main() {
  while((cin >> N) && N) {
    for(int i = 0; i < N; ++i) {
      cin >> S[i].p1.x >> S[i].p1.y >> S[i].p2.x >> S[i].p2.y;
    }
    solve();
  }
}

Measured memory_bytes: 1456