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<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
typedef pair<int, bool> sP;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<ll> vec;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-6;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;

typedef complex<ld> Point;
bool eq(ld a, ld b){ return abs(a - b) < eps; }
ld dot(Point a, Point b) { return real(conj(a)*b); }
ld cross(Point a, Point b) { return imag(conj(a)*b); }
bool eq(Point a, Point b) { return norm(a - b) < eps*eps; }
namespace std {
	bool operator<(const Point &lhs, const Point &rhs) {
		return lhs.real() == rhs.real() ? lhs.imag() < rhs.imag() : lhs.real() < rhs.real();
	}
}
struct Line {
	Point a, b;
};
int ccw(Point a, Point b, Point c) {
	b -= a; c -= a;
	if (cross(b, c) > eps)return 1;//counter clockwise
	if (cross(b, c) < -eps)return -1;//clock wise
	if (dot(b, c) < 0)return 2;//c--a--b on line
	if (norm(b) < norm(c))return -2;//a--b--c on line
	return 0; //a--c--b on line
}
bool isis_ll(Line l, Line m) {
	return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
Point proj(Line l, 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);
}
ld dist_lp(Line l, Point p) {
	return abs(p - proj(l, p));
}
ld dist_ll(Line l, Line m) {
	return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
Point is_ll(Line s, Line t) {
	Point sv = s.b - s.a; Point tv = t.b - t.a;
	return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
vector<Line> mid_ll(Line l, Line m) {
	if (!isis_ll(l, m)) {
		ld u = dist_ll(l, m);
		Point d = l.b - l.a;
		Point md=d* exp(Point{ 0,pi / 2.0 });
		Line l_ = { l.a,l.a + md };
		Point ma = is_ll(l_, m);
		Point dif = ma - l.a;
		dif /= 2.0;
		Line res = { l.a + dif,(l.a + dif) + d };
		return { res };
	}
	else {
		Point p = is_ll(l, m);
		ld t1 = arg(l.b - l.a);
		ld t2 = arg(m.b - m.a);
		ld t = (t1 + t2) / 2.0;
		Point dif = { cos(t),sin(t) };
		Point np = p + dif;
		ld d1 = dist_lp(l, np);
		ld d2 = dist_lp(m, np);
		vector<Line> res;
		res.push_back({ p,p + dif });
		t += pi / 2.0;
		dif = { cos(t),sin(t) };
		res.push_back({ p,p + dif });
		return res;
	}
}

int n;
void solve() {
	vector<Line> vl;
	rep(i, n) {
		ld x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		vl.push_back({ {x1,y1},{x2,y2} });
	}
	if (n <= 2) {
		cout << "Many" << endl; return;
	}
	vector<Line> l1 = mid_ll(vl[0], vl[1]);
	vector<Line> l2 = mid_ll(vl[0], vl[2]);
	vector<Point> anss;
	rep(i, l1.size()) {
		rep(j, l2.size()) {
			Line l = l1[i], m = l2[j];
			if (!isis_ll(l, m))continue;
			Point p = is_ll(l, m);
			vector<ld> dist;
			rep(k, n) {
				ld d = dist_lp(vl[k], p);
				dist.push_back(d);
			}
			sort(dist.begin(), dist.end());
			//cout << p << endl;
			//cout << dist[0] << " " << dist[n - 1] << endl;
			if (eq(dist[0], dist[n - 1])) {
				anss.push_back(p);
				//cout << real(p) << " " << imag(p) << endl; return;
			}
		}
	}
	sort(anss.begin(), anss.end());
	rep(i, anss.size()) {
		if (i > 0 && eq(anss[i], anss[i - 1])) {
			anss.erase(anss.begin() + i); i--;
		}
	}
	if (anss.size() > 1) {
		cout << "Many" << endl;
	}
	else if (anss.size() == 1) {
		cout << real(anss[0]) << " " << imag(anss[0]) << endl;
	}
	else {
		cout << "None" << endl;
	}
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(9);
	//init();
	while (cin >> n,n) {
		solve();
	}
	//stop
		return 0;
}