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

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 {
    return equals(x, p.x) && equals(y, p.y);
  }
  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;
  }
};
typedef Point Vector;

class Segment {
public:
  Point p1, p2;
  Segment() {}
  Segment(Point p1, Point p2) {
    this->p1 = p1;
    this->p2 = 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;
}
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;
}
double getDistanceLP(Line s, Point p) {
  return fabs(cross(s.p2 - s.p1, p - s.p1))/abs(s.p2-s.p1);
}

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

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


Line getBisector(Line s1, Line s2) {
  Vector a = s1.p2 - s1.p1;
  Vector b = s2.p2 - s2.p1;
  if(isParallel(a, b)) {
    double d = cross(a, s2.p1-s1.p1)/abs(a)/2.0;
    /*double d = getDistanceLP(s1, s2.p1)/2.0;
    Vector vn;
    if(ccw(s1.p1, s1.p2, s2.p1) >= 1) {
      vn.x = -a.y;
      vn.y = a.x;
    } else {
      vn.x = a.y;
      vn.y = -a.x;
    }
    vn = vn*d/abs(vn);
    return Line(s1.p1 + vn, s1.p2 + vn);*/
    Vector c = getOthogonalV(a);
    c = c / abs(c);
    c = c * d;
    return Line(s1.p1 + c, s1.p2 + c);
  } else {
    Point p = getCrossPoint(s1, s2);
    return Line(p, p + a + b*sqrt(norm(a)/norm(b)));
  }
}


int n;
Line s[100];

void make(vector<Line> &v) {
  for(int i = 1; i < n; ++i) {
    Line l = getBisector(s[0], s[i]);
    v.push_back(l);
    if(!isParallel(s[0], s[i])) {
      v.push_back(getOthogonalL(l));
    }
  }
}

bool check(Point &p) {
  double d = getDistanceLP(s[0], p);
  for(int i = 1; i < n; ++i) {
    if(!equals(d, getDistanceLP(s[i], p))) return false;
  }
  return true;
}

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

  vector<Line> bl;
  make(bl);

  vector<Point> cp;
  for(int i = 0; i < bl.size(); ++i) {
    for(int j = i+1; j < bl.size(); ++j) {
      if(isParallel(bl[i], bl[j])) continue;
      cp.push_back(getCrossPoint(bl[i], bl[j]));
    }
  }
  sort(cp.begin(), cp.end());
  cp.erase(unique(cp.begin(), cp.end()), cp.end());

  int count = 0, pos = -1;

  for(int i = 0; i < cp.size(); ++i) {
    if(check(cp[i])) {
      count++;
      if(count == 2) break;
      pos = i;
    }
  }

  switch(count) {
  case 0: cout << "None" << endl; break;
  case 1: printf("%.5f %.5f\n", cp[pos].x, cp[pos].y); break;
  case 2: cout << "Many" << endl; break;
  }
}

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