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 "bits/stdc++.h"
    #include<unordered_map>
    #pragma warning(disable:4996)
    using namespace std;
    using ld = long double;
    template<class T>
    using Table = vector<vector<T>>;
     
     
    /* ??????????????¬ */
     
    #include <complex>
     
    typedef long double ld;
    typedef complex<ld> Point;
    #define REP(i,n) for(int i=0;i<(int)(n);i++)
    #define ALL(x) (x).begin(),(x).end()
     
    const ld eps = 1e-13, pi = acos(-1.0);
    const ld dtop = pi / 180.;
    const ld ptod = 1. / dtop;
     
    namespace std {
    	bool operator<(const Point &lhs, const Point &rhs) {
    		if (lhs.real() < rhs.real() - eps) return true;
    		if (lhs.real() > rhs.real() + eps) return false;
    		return lhs.imag() < rhs.imag();
    	}
    }
     
    // ????????\???
    Point input_point() {
    	ld x, y;
    	cin >> x >> y;
    	return Point(x, y);
    }
     
    // ????????????????????????
    bool eq(const ld a, const ld b) {
    	return (abs(a - b) < eps);
    }
     
    // ??????
    ld dot(const Point& a, const Point& b) {
    	return real(conj(a) * b);
    }
     
    // ??????
    ld cross(const Point& a, const Point& b) {
    	return imag(conj(a) * b);
    }
     
    // ??´????????????
    class Line {
    public:
    	Point a, b;
    	Line() : a(Point(0, 0)), b(Point(0, 0)) {}
    	Line(Point a, Point b) : a(a), b(b) {}
    	Point operator[](const int _num)const {
    		if (_num == 0)return a;
    		else if (_num == 1)return b;
    		else {
    			assert(false);
    			return Point();
    		}
    	}
    };
     
    // ????????????
    class Circle {
    public:
    	Point p;
    	ld r;
    	Circle() : p(Point(0, 0)), r(0) {}
    	Circle(Point p, ld r) : p(p), r(r) {}
    };
     
    // CCW
    int ccw(const Point& a, const Point &b, const Point &c) {
    	const Point nb(b - a);
    	const Point nc(c - a);
    	if (cross(nb, nc) > eps) return 1;   // a,b,c??????????¨???¨?????????????????¶
    	if (cross(nb, nc) < -eps) return -1; // a,b,c???????¨???¨?????????????????¶
    	if (dot(nb, nc) < 0) return 2;       // c,a,b???????????´???????????¶
    	if (norm(nb) < norm(nc)) return -2;  // a,b,c???????????´???????????¶
    	return 0;                          // a,c,b???????????´???????????¶
    }
     
     
    /* ???????????? */
     
    // ??´?????¨??´??????????????????
    bool isis_ll(const Line& l, const Line& m) {
    	return !eq(cross(l.b - l.a, m.b - m.a), 0);
    }
     
    // ??´?????¨?????????????????????
    bool isis_ls(const Line& l, const Line& s) {
    	return isis_ll(l, s) &&
    		(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
    }
     
    // ????????¨?????????????????????
    bool isis_ss(const Line& s, const Line& t) {
    	return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
    		ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
    }
     
    // ????????´????????????
    bool isis_lp(const Line& l, const Point& p) {
    	return (abs(cross(l.b - p, l.a - p)) < eps);
    }
     
    // ?????????????????????
    bool isis_sp(const Line& s, const Point& p) {
    	return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
    }
     
    // ??´????????´????????????
    bool lisonl(const Line&l, const Line&m) {
    	return isis_lp(l, m[0]) && isis_lp(l, m[1]);
    }
     
    // ??????????¶?
    Point proj(const Line &l, const Point& p) {
    	ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
    	return l.a + t * (l.a - l.b);
    }
     
    // ??´?????¨??´????????????
    Point is_ll(const Line &s, const 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);
    }
    // ????????¨???????????????
    //???????????£????????¨???????????¨assert(false)
    Point is_ss(const Line &s, const Line& t) {
    	if (isis_ss(s, t)) {
    		for (int k = 0; k < 2; ++k) {
    			for (int l = 0; l < 2; ++l) {
    				if (s[k] == t[l])return s[k];
    			}
    		}
    		return is_ll(s, t);
    	}
    	else {
    		return Point(0, 0);
    	}
    }
    // ??´?????¨???????????¢
    ld dist_lp(const Line& l, const Point& p) {
    	return abs(p - proj(l, p));
    }
     
    // ??´?????¨??´???????????¢
    ld dist_ll(const Line& l, const Line& m) {
    	return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
    }
     
    // ??´?????¨??????????????¢
    ld dist_ls(const Line& l, const Line& s) {
    	return isis_ls(l, s) ? 0 : min(dist_lp(l, s.a), dist_lp(l, s.b));
    }
     
    // ????????¨???????????¢
    ld dist_sp(const Line& s, const Point& p) {
    	Point r = proj(s, p);
    	return isis_sp(s, r) ? abs(r - p) : min(abs(s.a - p), abs(s.b - p));
    }
     
    // ????????¨??????????????¢
    ld dist_ss(const Line& s, const Line& t) {
    	if (isis_ss(s, t)) return 0;
    	return min({ dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b) });
    }
     
     
    //??´?????¨??´?????????????????????????????????
    //???????????????a ??¨???a ??????????????????????????????????????????
    Line bisection(const Line &s, const Line &t) {
    	if (!isis_ll(s, t)) {
    		if (abs(Point((s[0] + t[0])*0.5l) - Point((s[1] + t[1])*0.5l)) < eps) {
    			return Line(Point((s[0] + t[1])*0.5l), Point((s[1] + t[0])*0.5l));
    		}
    		else {
     
    			return Line(Point((s[0] + t[0])*0.5l), Point((s[1] + t[1])*0.5l));
    		}
    	}
    	const Point laglanju(is_ll(s, t));
    	const Point avec = (abs(laglanju - s[0])<eps*100) ? s[1] - laglanju : s[0] - laglanju;
    	const Point bvec = (abs(laglanju - t[0])<eps*100) ? t[1] - laglanju : t[0] - laglanju;
     
    	return Line(laglanju, laglanju + (abs(bvec)*avec + abs(avec)*bvec) / (abs(avec) + abs(bvec)));
    }
     
    //???????????´?????????????????????
    //???????????´??????????????§???????????¨????¢?????????¨?????????
    Point  inner_center(const vector<Line>&ls) {
    	vector<Point>vertics;
    	for (int i = 0; i < ls.size(); ++i) {
    		vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
    	}
    	if (vertics[0] == vertics[1] || vertics[1] == vertics[2] || vertics[2] == vertics[0])return vertics[0];
    	Line bi1(bisection(Line(vertics[0], vertics[1] ),Line(vertics[0], vertics[2] )));
    	Line bi2(bisection(Line(vertics[1], vertics[2]), Line(vertics[1], vertics[0])));
    	if (bi1[0] == bi2[0])return bi1[0];
    	else {
    		return is_ll(bi1, bi2);
    	}
    }
     
    //???????????´?????????????????????
    //???????????´??????????????§???????????¨????¢?????????¨?????????
    vector<Point>  ex_center(const vector<Line>&ls) {
    	vector<Point>vertics;
    	for (int i = 0; i < ls.size(); ++i) {
    		vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
    	}
    	if (abs(vertics[0] - vertics[1])<eps || abs(vertics[1] - vertics[2])<eps || (abs(vertics[2] - vertics[0])<eps))return vector<Point>();
    	vector<Point>ecs;
    	for (int i = 0; i < 3; ++i) {
    		Line bi1(bisection(Line(vertics[i], vertics[i] * 2.0l - vertics[(i + 2) % 3]), Line(vertics[i], vertics[(i + 1) % 3])));
    		Line bi2(bisection(Line(vertics[(i + 1) % 3], vertics[(i + 1) % 3] * 2.0l - vertics[(i + 2) % 3]), Line(vertics[(i + 1) % 3], vertics[i])));
    		ecs.push_back(is_ll(bi1, bi2));
    	}
    	return ecs;
    }
     
    //a,b:??????
    //c:????????§??????
    //???????????´?????????????????¢?????????????±??????????
    vector<Point>  same_dis(const vector<Line>&ls) {
    	vector<Point>vertics;
    	vertics.push_back(is_ll(ls[0], ls[2]));
    	vertics.push_back(is_ll(ls[1], ls[2]));
     
    	if (abs(vertics[0] - vertics[1]) < eps)return vector<Point>{vertics[0]};
    	Line bis(bisection(ls[0],ls[1]));
    	vector<Point>ecs;
     
    		Line abi(bisection(Line(vertics[0],vertics[1]), ls[0]));
    		ecs.push_back(is_ll(bis,abi));
     
     
    		Line bbi(bisection(Line(vertics[0], 2.l*vertics[0]-vertics[1]), ls[0]));
    		ecs.push_back(is_ll(bis, bbi));
     
    	return ecs;
    }
     
    /* ??? */
     
    // ?????¨????????????
    vector<Point> is_cc(const Circle& c1, const Circle& c2) {
    	vector<Point> res;
    	ld d = abs(c1.p - c2.p);
    	ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
    	ld dfr = c1.r * c1.r - rc * rc;
    	if (abs(dfr) < eps) dfr = 0.0;
    	else if (dfr < 0.0) return res; // no intersection
    	ld rs = sqrt(dfr);
    	Point diff = (c2.p - c1.p) / d;
    	res.push_back(c1.p + diff * Point(rc, rs));
    	if (dfr != 0.0) res.push_back(c1.p + diff * Point(rc, -rs));
    	return res;
    }
     
    // ?????¨??´????????????
    vector<Point> is_lc(const Circle& c, const Line& l) {
    	vector<Point> res;
    	ld d = dist_lp(l, c.p);
    	if (d < c.r + eps) {
    		ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); //safety;
    		Point nor = (l.a - l.b) / abs(l.a - l.b);
    		res.push_back(proj(l, c.p) + len * nor);
    		res.push_back(proj(l, c.p) - len * nor);
    	}
    	return res;
    }
     
    // ?????¨??????????????¢
    vector<Point> is_sc(const Circle& c, const Line& l) {
    	vector<Point> v = is_lc(c, l), res;
    	for (Point p : v)
    		if (isis_sp(l, p)) res.push_back(p);
    	return res;
    }
     
    // ?????¨????????\???
    vector<Line> tangent_cp(const Circle& c, const Point& p) {
    	vector<Line> ret;
    	Point v = c.p - p;
    	ld d = abs(v);
    	ld l = sqrt(norm(v) - c.r * c.r);
    	if (isnan(l)) { return ret; }
    	Point v1 = v * Point(l / d, c.r / d);
    	Point v2 = v * Point(l / d, -c.r / d);
    	ret.push_back(Line(p, p + v1));
    	if (l < eps) return ret;
    	ret.push_back(Line(p, p + v2));
    	return ret;
    }
     
    // ?????¨????????\???
    vector<Line> tangent_cc(const Circle& c1, const Circle& c2) {
    	vector<Line> ret;
    	if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
    		Point center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
    		ret = tangent_cp(c1, center);
    	}
    	if (abs(c1.r - c2.r) > eps) {
    		Point out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
    		vector<Line> nret = tangent_cp(c1, out);
    		ret.insert(ret.end(), ALL(nret));
    	}
    	else {
    		Point v = c2.p - c1.p;
    		v /= abs(v);
    		Point q1 = c1.p + v * Point(0, 1) * c1.r;
    		Point q2 = c1.p + v * Point(0, -1) * c1.r;
    		ret.push_back(Line(q1, q1 + v));
    		ret.push_back(Line(q2, q2 + v));
    	}
    	return ret;
    }
     
     
    /* ????§???¢ */
     
    typedef vector<Point> Polygon;
     
    // ??¢???
    ld area(const Polygon &p) {
    	ld res = 0;
    	int n = p.size();
    	REP(j, n) res += cross(p[j], p[(j + 1) % n]);
    	return res / 2;
    }
     
    // ????§???¢????????¢??????
    bool is_counter_clockwise(const Polygon &poly) {
    	ld angle = 0;
    	int n = poly.size();
    	REP(i, n) {
    		Point a = poly[i], b = poly[(i + 1) % n], c = poly[(i + 2) % n];
    		angle += arg((c - b) / (b - a));
    	}
    	return angle > eps;
    }
     
    // ??????????????????
    //  0 => out
    //  1 => on
    //  2 => in
    int is_in_polygon(const Polygon &poly, const  Point& p) {
    	ld angle = 0;
    	int n = poly.size();
    	REP(i, n) {
    		Point a = poly[i], b = poly[(i + 1) % n];
    		if (isis_sp(Line(a, b), p)) return 1;
    		angle += arg((b - p) / (a - p));
    	}
    	return eq(angle, 0) ? 0 : 2;
    }
    //??????????????????2?????????
    enum { OUT, ON, IN };
    int convex_contains(const Polygon &P, const Point &p) {
    	const int n = P.size();
    	Point g = (P[0] + P[n / 3] + P[2 * n / 3]) / 3.0l; // inner-point
    	int a = 0, b = n;
    	while (a + 1 < b) { // invariant: c is in fan g-P[a]-P[b]
    		int c = (a + b) / 2;
    		if (cross(P[a] - g, P[c] - g) > 0) { // angle < 180 deg
    			if (cross(P[a] - g, p - g) > 0 && cross(P[c] - g, p - g) < 0) b = c;
    			else                                                  a = c;
    		}
    		else {
    			if (cross(P[a] - g, p - g) < 0 && cross(P[c] - g, p - g) > 0) a = c;
    			else                                                  b = c;
    		}
    	}
    	b %= n;
    	if (cross(P[a] - p, P[b] - p) < 0) return 0;
    	if (cross(P[a] - p, P[b] - p) > 0) return 2;
    	return 1;
    }
     
    // ??????
    // ???????????????????????¨????????????????????§??¨???
    Polygon convex_hull(vector<Point> ps) {
    	int n = ps.size();
    	int k = 0;
    	sort(ps.begin(), ps.end());
    	Polygon ch(2 * n);
    	for (int i = 0; i < n; ch[k++] = ps[i++])
    		while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
    	for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
    		while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
    	ch.resize(k - 1);
    	return ch;
    }
     
     
     
    // ????????????
    vector<Polygon> convex_cut(const Polygon &ps, const Line& l) {
    	int n = ps.size();
    	Polygon Q;
    	Polygon R;
    	REP(i, n) {
    		Point A = ps[i], B = ps[(i + 1) % n];
    		Line m = Line(A, B);
    		if (ccw(l.a, l.b, A) != -1) Q.push_back(A);
    		if (ccw(l.a, l.b, A) != 1) R.push_back(A);
    		if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0 && isis_ll(l, m)) {
    			Q.push_back(is_ll(l, m));
    			R.push_back(is_ll(l, m));
    		}
    	}
    	const vector<Polygon>polys{ Q,R };
    	return polys;
    }
     
     
     
     
    bool check(const Point& kouho, const vector<Line>&ls,const ld dis) {
    	for (auto l : ls) {
    		ld adis = abs(dist_lp(l, kouho));
    		if (abs(adis - dis) > 3e-5)return false;
    	}
    	return true;
    }
     
    int main() {
    	cout << setprecision(11) << fixed;
    	while (1) {
    		int N; cin >> N;
    		if (!N)break;
    		vector<Line>nls;
    		{
    			vector<Line>ls;
    			for (int i = 0; i < N; ++i) {
    				int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
    				ls.push_back(Line(Point(x1, y1), Point(x2, y2)));
    			}
    			for (int i = 0; i < N; ++i) {
    				bool ok = true;
    				for (int j = i + 1; j < N; ++j) {
    					if (lisonl(ls[i], ls[j])) {
    						ok = false;
    						break;
    					}
    					else {
     
    					}
    				}
    				if(ok)nls.push_back(ls[i]);
    			}
    		}
    		if (nls.size() <= 2) {
    			cout << "Many" << endl;
    			continue;
    		}
    		else {
    			Line a(nls[0]);
    			Line b(nls[1]);
    			Line c(nls[2]);
    			if (dist_ll(a, b) > eps&&dist_ll(b, c)>eps) {
    				cout << "None" << endl;
    				continue;
    			}
    			else if (dist_ll(a, b) < eps&&dist_ll(b, c) < eps&&dist_ll(c, a)<eps) {
    				vector<Point >ps;
    				Point nai(inner_center(vector<Line>{a, b, c}));
    				vector<Point>bou(ex_center(vector<Line>{a, b, c}));
    				ps.push_back(nai);
    				for (int i = 0; i < bou.size(); ++i) {
    					ps.push_back(bou[i]);
    				}
    				vector<bool>oks(ps.size());
    				int num = 0;
    				for (int i = 0; i < ps.size(); ++i) {
    					ld dis = dist_lp(a, ps[i]);
    					ld dis1 = dist_lp(b, ps[i]);
    					ld dis2 = dist_lp(c, ps[i]);
    					oks[i] = check(ps[i], nls, dis);
    					if (oks[i])num++;
    				}
    				if (num >= 2) {
    					cout << "Many" << endl;
    				}
    				else if (num == 1) {
    					for (int i = 0; i < ps.size(); ++i) {
    						if (oks[i]) {
    							cout << ps[i].real() << " " << ps[i].imag() << endl;
    						}
    					}
    				}
    				else {
    					cout << "None" << endl;
    				}
    			}
    			else {
    				if (dist_ll(b, c) > eps) {
    					swap(a, c);
    				}
    				if (dist_ll(c, a) > eps) {
    					swap(b, c);
    				}
    				assert(dist_ll(a, b) > eps);
    				vector<Point>kouhos(same_dis(vector<Line>{a, b, c}));
    				Line bis(bisection(a,b));
    				Point bisvec = bis[1] - bis[0];
    				ld dis = dist_ll(a,b) / 2;
    				Point p = is_ll(bis, c);
    				Point kouho1 = kouhos[0];
    				Point kouho2 = kouhos[1];
     
    				bool ok1 = check(kouho1, nls, dis);
    				bool ok2 = check(kouho2, nls, dis);
    				if (ok1&&ok2) {
    					cout << "Many" << endl;
    				}
    				else if (ok1&&!ok2) {
    					cout << kouho1.real() << " " << kouho1.imag() << endl;
    				}
    				else if (!ok1&&ok2) {
    					cout << kouho2.real() << " " << kouho2.imag() << endl;
    				}
    				else {
    					cout << "None" << endl;
    				}
    			}
    		}
    	}
     
    	return 0;
    }