#include <bits/stdc++.h>
using namespace std;

using ld = long double;

constexpr ld eps = 1e-6;
constexpr ld pi = std::acos(-1.0);

using point = std::complex<long double>;

bool eq(long double a, long double b) {
    return (std::abs(a-b) < eps);
}

bool comp(point a, point b) {
    return (std::real(a - b) * 1.347589 + std::imag(a - b)) > 0;
}

long double dot(point a, point b) {
    return std::real(std::conj(a) * b);
}

long double cross(point a, point b) {
    return std::imag(std::conj(a) * b);
}

std::vector<point> unique(std::vector<point> ps) {
    std::sort(std::begin(ps), std::end(ps), comp);
    std::vector<point> res;
    for(auto& p : ps) {
        if(res.empty() || abs(res.back() - p) > eps) {
            res.push_back(p);
        }
    }
    return res;
}

class line {
public:
    line()
        : a(point(0, 0)), b(point(0, 0))
    {}
    line(point a_, point b_)
        : a(a_), b(b_)
    {}

    point a, b;
};

bool isis_ll(line l, line m) {
    return !eq(cross(l.b - l.a, m.b - m.a), 0);
}

bool isis_lp(line l, point p) {
    return (std::abs(cross(l.b - p, l.a - p)) < eps);
}

point proj(line l, point p) {
    long double t = dot(p - l.a, l.a - l.b) / std::norm(l.a - l.b);
    return l.a + t * (l.a - l.b);
}

point is_ll(line s, line t) {
    point sv = s.b - s.a, tv = t.b - t.a;
    assert(cross(sv, tv) != 0);
    return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}

point rot(point p, ld theta) {
    ld x = real(p), y = imag(p);
    return point(x * cos(theta) - y * sin(theta), x * sin(theta) + y * cos(theta));
}

ld get_angle(point vec) {
    ld res = arg(vec);
    if(res < 0) {
        res += 2 * pi;
    }
    if(res > pi) {
        res -= pi;
    }
    return res;
}

int main() {
    int N;
    while(cin >> N, N) {
        vector<line> ls;
        for(int i = 0; i < N; ++i) {
            int x1, y1, x2, y2;
            cin >> x1 >> y1 >> x2 >> y2;
            if(x1 > x2) {
                swap(x1, x2);
                swap(y1, y2);
            }
            point p1(x1, y1), p2(x2, y2);
            bool check = true;
            for(auto& l : ls) {
                if(isis_lp(l, p1) && isis_lp(l, p2)) {
                    check = false;
                    break;
                }
            }
            if(check) {
                ls.emplace_back(p1, p2);
            }
        }

        N = ls.size();
        if(N == 1 || N == 2) {
            cout << "Many" << endl;
            continue;
        }

        vector<line> cand[2];
        for(int i = 0; i < 2; ++i) {
            if(isis_ll(ls[i], ls[i + 1])) {
                auto p = is_ll(ls[i], ls[i + 1]);
                ld ang = (get_angle(ls[i].b - ls[i].a) + get_angle(ls[i + 1].b - ls[i + 1].a)) / 2;
                ang = ang - get_angle(ls[i].b - ls[i].a);
                if(abs(ls[i].b - p) > eps) {
                    cand[i].emplace_back(p, p + rot(ls[i].b - p, ang));
                    cand[i].emplace_back(p, p + rot(ls[i].b - p, ang + pi / 2));
                } else {
                    cand[i].emplace_back(p, p + rot(ls[i].a - p, ang));
                    cand[i].emplace_back(p, p + rot(ls[i].a - p, ang + pi / 2));
                }
            } else {
                auto p1 = (ls[i].a + proj(ls[i + 1], ls[i].a)) * 0.5L;
                auto p2 = (ls[i].b + proj(ls[i + 1], ls[i].b)) * 0.5L;
                cand[i].emplace_back(p1, p2);
            }
        }
        vector<point> res;
        for(auto& l1 : cand[0]) {
            for(auto& l2 : cand[1]) {
                if(!isis_ll(l1, l2)) {
                    continue;
                }
                auto p = is_ll(l1, l2);
                bool check = true;
                ld d = abs(p - proj(ls[0], p));
                for(int i = 1; i < N; ++i) {
                    check &= abs(d - abs(p - proj(ls[i], p))) < eps;
                }
                if(check) {
                    res.push_back(p);
                }
            }
        }
        res = unique(res);
        if(res.size() > 1) {
            cout << "Many" << endl;
        } else if(res.size() == 1) {
            cout << fixed << setprecision(5) << real(res[0]) << ' ' << imag(res[0]) << endl;
        } else {
            cout << "None" << endl;
        }
    }
}


Measured memory_bytes: 3556