#include <iostream>
#include <cstdio>
#include <vector>
#include <complex>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <cstring>
#include <stack>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <cassert>

using namespace std;

typedef long long ll;
typedef ll li;
typedef pair<int,int> PI;
#define EPS (1e-8)
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define REP(i,m,n) for(int i=m; i<=(int)(n); ++i)
#define F first
#define S second
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define SZ(a) (int)((a).size())
#define ALL(a) a.begin(),a.end()
#define FOR(it,a) for(__typeof(a.begin())it=a.begin();it!=a.end();++it)
int dx[]={0,1,0,-1,1,1,-1,-1};
int dy[]={1,0,-1,0,-1,1,1,-1};

typedef complex<long double> P;
typedef pair<P, P> L;
typedef pair<P, long double> C;
namespace std {
bool operator < (const P &a, const P &b) { return make_pair(real(a), imag(a)) < make_pair(real(b), imag(b)); }
}
istream& operator >>(istream &in, P &p) { return in >> p.real() >> p.imag(); }
istream& operator >>(istream &in, L &l) { return in >> l.first >> l.second; }
istream& operator >>(istream &in, C &c) { return in >> c.first >> c.second; }
 
 
#define DI(l) ((l).second-(l).first)
#define EQ(a, b) (abs((a)-(b)) < EPS)
#define CCW(l, a) ccw((l).first, (l).second, (a))
long double cross(const P &a, const P &b) { return imag(conj(a)*b); }
long double dot(const P& a, const P& b) { return real(conj(a)*b); }
/* ccw(a, b, c)
 * +1: counter clockwise
 * -1: clockwise
 * +2: c--a--b    on L
 * -2:    a--b--c on L
 *  0: c is on a--b
 */
int ccw(P a, P b, P c) {
    long double d = cross(b -= a, c -= a);
    return d>EPS ? 1 : d<-EPS ? -1 : dot(b,c)<-EPS ? 2 : norm(b)+EPS<norm(c) ? -2 : 0;
}
bool parallel(const L &l, const L &m) { return EQ(cross(DI(l), DI(m)), 0); }
bool sameline(const L &l, const L &m) { return parallel(l, m) && EQ(cross(DI(l), m.second-l.first), 0); }
 
bool intersectLL(const L &l, const L &m) { return !parallel(l, m) || sameline(l, m); }
bool intersectLP(const L &l, const P &p) { return EQ(cross(l.second-p, l.first-p), 0); }
bool intersectSS(const L &s, const L &t) { return CCW(s,t.first)*CCW(s,t.second)<=0 && CCW(t,s.first)*CCW(t,s.second)<=0; }
bool intersectSP(const L &s, const P &p) { return EQ(abs(s.first-p)+abs(s.second-p)-abs(DI(s)), 0); }
P projection(const L &l, const P &p) { return l.first + dot(p-l.first, DI(l)) / norm(DI(l)) * DI(l); }
P reflection(const L &l, const P &p) { return 2.0L * projection(l, p) - p; }
long double distanceLP(const L &l, const P &p) { return abs(p - projection(l, p)); }
long double distanceLL(const L &l, const L &m) { return intersectLL(l, m) ? 0 : distanceLP(l, m.first); }
long double distanceSP(const L &s, const P &p) {
    P r = projection(s, p);
    if (intersectSP(s, r)) return abs(r-p);
    return min(abs(s.first-p), abs(s.second-p));
}
long double distanceSS(const L &s, const L &t) {
    if (intersectSS(s, t)) return 0;
    return min(min(distanceSP(s, t.first), distanceSP(s, t.second)), min(distanceSP(t, s.first), distanceSP(t, s.second)));
}
P crosspoint(const L &l, const L &m) {
    P a = DI(l), b = DI(m);
    long double A = cross(a, b), B = cross(a, l.second-m.first);
 
    assert(!EQ(abs(A), 0)); // should not be parallel (if A = B = 0, then the same L)
    /*    
    double
      x1 = l.first.real(),
      y1 = l.first.imag(),
      x2 = l.second.real(),
      y2 = l.second.imag(),
      x3 = m.first.real(),
      y3 = m.first.imag(),
      x4 = m.second.real(),
      y4 = m.second.imag();
    long double det=(x1-x2)*(y3-y4)-(y1-y2)*(x3-x4);
    return
      P((x1*y2-y1*x2)*(x3-x4)-(x1-x2)*(x3*y4-y3*x4),
        (x1*y2-y1*x2)*(y3-y4)-(y1-y2)*(x3*y4-y3*x4))/det;
    */
    return m.first + B / A * b;
}
 
int n;
L ls[110];
 
bool check(L l1, L l2) {
  if (parallel(l1, l2)) return false;
  P p = crosspoint(l1, l2);
 
  long double d = distanceLP(ls[0], p);
  rep(i, n) {
    if (!EQ(d, distanceLP(ls[i], p))) return false;
  }
  return true;
}
 
int main() {
  while(cin >> n && n) {
    rep(i, n) cin >> ls[i];
    vector<L> lss;
    rep(i, n) {
      bool ok = true;
      rep(j, i) if (sameline(ls[i], ls[j])) ok = false;
      if (ok) lss.pb(ls[i]);
    }
 
    n = SZ(lss);
    rep(i, n) ls[i] = lss[i];
 
    bool found = false;
    vector<P> ans;
    rep(i, n) {
      rep(j, n) rep(k, j) {
        if (j == i || k == i) continue;
        if (!parallel(ls[i], ls[j]) && !parallel(ls[i], ls[k])) {
          found = true;
 
          P p = crosspoint(ls[i], ls[j]);
          P d1 = DI(ls[i])/abs(DI(ls[i])) + DI(ls[j])/abs(DI(ls[j]));
          P d2 = DI(ls[i])/abs(DI(ls[i])) - DI(ls[j])/abs(DI(ls[j]));
          L l1(p, p + d1), l2(p, p + d2);
 
          P q = crosspoint(ls[i], ls[k]);
          P dq1 = DI(ls[i])/abs(DI(ls[i])) + DI(ls[k])/abs(DI(ls[k]));
          P dq2 = DI(ls[i])/abs(DI(ls[i])) - DI(ls[k])/abs(DI(ls[k]));
          L l3(q, q + dq1), l4(q, q + dq2);
 
          if (check(l1, l3)) ans.pb(crosspoint(l1, l3));
          if (check(l1, l4)) ans.pb(crosspoint(l1, l4));
          if (check(l2, l3)) ans.pb(crosspoint(l2, l3));
          if (check(l2, l4)) ans.pb(crosspoint(l2, l4));
 
          /*
          cout << l1.first << " " << d1 << endl;
          cout << l2.first << " " << d2 << endl;
 
          FOR(it, ans) printf("%.20f %.20f\n", it->real(), it->imag());
          */
 
          sort(ALL(ans));
          ans.erase(unique(ALL(ans)), ans.end());
          goto AAA;
        }
      }
    }
  AAA:;
     
    //FOR(it,ans) cout << *it << endl;
 
    if (found) {
      if (SZ(ans) == 0) cout << "None" << endl;
      else if (SZ(ans) == 1)
        printf("%.8Lf %.8Lf\n", ans[0].real(), ans[0].imag());
      else cout << "Many" << endl;
    } else {
      bool ok = true;
      rep(i, n) if (!parallel(ls[0], ls[i])) ok = false;
      if (n <= 2) cout << "Many" << endl;
       else {
         assert(ok);
         cout << "None" << endl;
       }
 
    }
 
  }
}

Measured memory_bytes: 1340