Problem: We understand that reading English is a great pain to many of you. So we’ll keep this problem statememt simple. Write a program that reports the point equally distant from a set of lines given as the input. In case of no solutions or multiple solutions, your program should report as such.



Input

The input consists of multiple datasets. Each dataset is given in the following format:

n
x1,1 y1,1 x1,2 y1,2
x2,1 y2,1 x2,2 y2,2
...
xn,1 yn,1 xn,2 yn,2


n is the number of lines (1 ≤ n ≤ 100); (xi,1, yi,1) and (xi,2, yi,2) denote the different points the i-th line passes through. The lines do not coincide each other. The coordinates are all integers between -10000 and 10000.

The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.

Output

For each dataset, print a line as follows. If there is exactly one point equally distant from all the given lines, print the x- and y-coordinates in this order with a single space between them. If there is more than one such point, just print "Many" (without quotes). If there is none, just print "None" (without quotes).

The coordinates may be printed with any number of digits after the decimal point, but should be accurate to 10-4.

Example

Input

2
-35 -35 100 100
-49 49 2000 -2000
4
0 0 0 3
0 0 3 0
0 3 3 3
3 0 3 3
4
0 3 -4 6
3 0 6 -4
2 3 6 6
-1 2 -4 6
0


Output

Many
1.5000 1.5000
1.000 1.000

Solution (in CPP):

Solution:
#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;
}