#include <iostream>
#include <set>
#include <cstdio>
#include <vector>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <cmath>

using namespace std;

const bool debug = false;

typedef long double real;

template<class T>
ostream& operator<<(ostream& os, const vector<T>& vs) {
    if (vs.empty()) return os << "[]";
    os << "[" << vs[0];
    for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
    return os << "]";
}

const real EPS = 1e-6;

bool EQ(real x, real y) {
    return abs(x - y) < EPS;
}

struct Point {
    real x, y;
    Point() {}
    Point(real x, real y) : x(x), y(y) {}
    Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
    Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
    Point operator*(real k) const { return Point(k * x, k * y); }
    Point operator/(real k) const { return Point(x / k, y / k); }
};
real dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
real cross(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; }
real norm(const Point& a) { return sqrt(dot(a, a)); }
Point rot90(const Point& p) { return Point(-p.y, p.x); } // 反時計回りに90度回転 
ostream& operator<<(ostream& os, const Point& p) { return os << "(" << p.x << "," << p.y << ")"; }
istream& operator>>(istream& is, Point& p) { return is >> p.x >> p.y; }

bool EQ(const Point& a, const Point& b) {
    return EQ(a.x, b.x) && EQ(a.y, b.y);
}

struct Line {
    Point a, b;
    Line() {}
    Line(const Point& a, const Point& b) : a(a), b(b) {}
};
bool parallel(const Line& s, const Line& t) { return abs(cross(s.b - s.a, t.b - t.a)) < EPS; }
istream& operator>>(istream& is, Line& l) { return is >> l.a >> l.b; }
ostream& operator<<(ostream& os, const Line& l) { return os << "Line(" << l.a << "," << l.b << ")"; }

Point projection(const Line& l, const Point& p) {
    Point u = (p - l.a), v = (l.b - l.a);
    return l.a + (v / norm(v)) * (dot(u, v) / norm(v));
}

Point crosspoint(const Line& s, const Line& t) {
    double d = cross(t.b - t.a, s.b - s.a);
    assert(abs(d) >= EPS);
    return s.a + (s.b - s.a) * cross(t.b - t.a, t.b - s.a) / d;
}

int N;
vector<Line> L;
bool input() {
    cin >> N;
    if (N == 0) return false;
    L.clear(); L.resize(N);
    for (int i = 0; i < N; i++) cin >> L[i];
    return true;
}

Point unit(const Point& v) {
    return v / norm(v);
}

Line rot90(const Line& l, const Point& c) {
    return Line( rot90(l.a - c) + c, rot90(l.b - c) + c );
}

vector<Line> midline(const Line& s, const Line& t) {
    if (parallel(s, t)) {
        Point p = projection(t, s.a),
              q = projection(t, s.b);
        return vector<Line>(1, Line( (s.a + p) / 2, (s.b + q) / 2 ));
    } else {
        Point c = crosspoint(s, t);
        Line ret;
        Point m = (EQ(s.a, c) ? s.b : s.a);
        Point p = projection(t, m);
        real d = norm(m - c);
        Point q = c + unit(t.b - t.a) * d;
        ret.a = (m + q) / 2;
        ret.b = c;
        vector<Line> lret(2);
        lret[0] = ret;
        lret[1] = rot90(ret, c);
        return lret;
    }
}

real dist(const Line& l, const Point& p) {
    Point q = projection(l, p);
    return norm(q - p);
}

struct point_comp {
    bool operator()(const Point& a, const Point& b) {
        return EQ(a.x, b.x) ? a.y < b.y + EPS : a.x < b.x + EPS;
    }
};

pair<bool, Point> same_crosspoint() {
    if (parallel(L[0], L[1])) return make_pair(false, Point(0, 0));
    Point c = crosspoint(L[0], L[1]);
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
            if (parallel(L[i], L[j]) || !EQ(c, crosspoint(L[i], L[j]))) {
                return make_pair(false, Point(0, 0));
            }
        }
    }
    return make_pair(true, c);
}

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

    pair<bool, Point> p = same_crosspoint();
    if (p.first) {
        printf("%.12Lf %.12Lf\n", p.second.x, p.second.y);
        return;
    }

    vector<Line> X, Y;
    X = midline(L[0], L[1]);
    Y = midline(L[1], L[2]);

    vector<Point> C;

    for (int i = 0; i < X.size(); i++) {
        for (int j = 0; j < Y.size(); j++) {
            if (parallel(X[i], Y[j])) continue;
            C.push_back(crosspoint(X[i], Y[j]));
        }
    }

    if (debug) {
        cerr << "X: " << X << endl;
        cerr << "Y: " << Y << endl;
        cerr << "C: " << C << endl;
    }
    
    if (C.empty()) {
        cout << "None" << endl;
        return;
    }

    vector<Point> ans;
    for (int i = 0; i < C.size(); i++) {
        Point p = C[i];
        real d = dist(L[0], p);
        for (int i = 0; i < N; i++) {
            if (!EQ(dist(L[i], p), d)) {
                goto next;
            }
        }
        ans.push_back(p);
        next:;
    }

    if (ans.size() >= 2) {
        cout << "Many" << endl;
    } else if (ans.empty()) {
        cout << "None" << endl;
    } else {
        printf("%.12Lf %.12Lf\n", ans[0].x, ans[0].y);
    }
}

int main() {
    while (input()) solve();
    return 0;
}

Measured memory_bytes: 1296