#include <bits/stdc++.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template<class T>bool chmax(T &a, const T &b) { return (a < b) ? (a = b, 1) : 0;}
template<class T>bool chmin(T &a, const T &b) { return (b < a) ? (a = b, 1) : 0;}

using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r) {return (r > EPS) - (r < -EPS);}
inline R sq(R x) {return sqrt(max(x, 0.0L));}

const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

// Problem Specific Parameter:
using L = tuple<R, int, int, int>;
int n;
vector<L> lines;

ll merge_count(vector<int> &a) {
	int n = a.size();
	if (n <= 1)
		return 0;
	ll cnt = 0;
	vector<int> b(a.begin(), a.begin() + n / 2);
	vector<int> c(a.begin() + n / 2, a.end());

	cnt += merge_count(b);
	cnt += merge_count(c);

	int ai = 0, bi = 0, ci = 0;
	while (ai < n) {
		if (bi < b.size() && (ci == c.size() || b[bi] <= c[ci])) {
			a[ai++] = b[bi++];
		} else {
			cnt += n / 2 - bi;
			a[ai++] = c[ci++];
		}
	}
	return cnt;
}

ll x_check(R x) {
	using state = tuple<R, int>;
	vector<state> points;

	rep(i, n) {
		int a, b, c;
		tie(ignore, a, b, c) = lines[i];
		R y = -1.0L * a / b * x + 1.0L * c / b;
		points.push_back(state(y, i));
	}

	sort(begin(points), end(points));

	vector<int> ary;
	rep(i, n) ary.push_back(get<1>(points[i]));
	return merge_count(ary);
}

ll y_check(R y) {
	using state = tuple<R, int>;
	vector<state> points;

	rep(i, n) {
		int a, b, c;
		tie(ignore, a, b, c) = lines[i];
		R x = -1.0L * b / a * y + 1.0L * c / a;
		points.push_back(state(x, i));
	}

	sort(begin(points), end(points));

	vector<int> ary;
	rep(i, n) ary.push_back(get<1>(points[i]));
	return merge_count(ary);
}

const int limit = 100010;
int a[limit],b[limit],c[limit];

int main(void) {
	cin >> n;

	rep(i, n)  cin >> a[i] >> b[i] >> c[i];	
	
	R xans, yans;

	{
		lines.clear();
		rep(i,n) lines.push_back(L(1.0L * a[i] / b[i], a[i], b[i], c[i]));
		sort(begin(lines), end(lines));

		R low = -1e10, high = 1e10;
		const ll total = 1LL * n * (n - 1) / 2;
		const ll thr = (total + 1 ) / 2;

		rep(loop, 200) {
			const R mid = (low + high) / 2.0;
			if(x_check(mid) < thr)
				low = mid;
			else
				high = mid;
		}
		xans = (low + high) / 2.0;
	}

	
	{
		lines.clear();
		rep(i,n) lines.push_back(L(1.0L * b[i] / a[i], a[i], b[i], c[i]));
		sort(begin(lines), end(lines));

		R low = -1e10, high = 1e10;
		const ll total = 1LL * n * (n - 1) / 2;
		const ll thr = (total + 1 ) / 2;

		rep(loop, 200) {
			const R mid = (low + high) / 2.0;
			if(y_check(mid) < thr)
				low = mid;
			else
				high = mid;
		}
		yans = (low + high) / 2.0;
	}
	
	
	cout.precision(20);
	cout << fixed << xans << " " << yans << endl;

	return 0;
}

Measured memory_bytes: 7324