#include <vector>
#include <cmath>
#include <map>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <set>
#include <stack>
#include <bitset>
#include <functional>
#include <ctime>
#include <queue>
#include <deque>
#include <complex>
#include <cassert>
#include <iomanip>

using namespace std;
typedef long long LL;

#define REP(i,n) for(int i=0; i<(n); i++)
int N;
double A[40000];
double B[40000];
double C[40000];
/*

double getX(double A, double B, double C, double D, double E, double F) {
    return (E * C - B * F) / (A * E - D * B);
}

double getY(double A, double B, double C, double D, double E, double F) {
    return (A * F - D * C) / (A * E - D * B);
}

pair<double, double> slow() {
    vector<float> px;
    px.reserve(n);
    vector<float> py;
    py.reserve(n);
    REP(j, N) {
        cout << j << endl;
        REP(i, j) {
            px.push_back(getX(A[i], B[i], C[i], A[j], B[j], C[j]));
            py.push_back(getY(A[i], B[i], C[i], A[j], B[j], C[j]));
        }
    }
    int n = N * (N - 1) / 2;
    int k = (n-1)/2;
    nth_element(px.begin(), px.begin() + k, px.end());
    nth_element(py.begin(), py.begin() + k, py.end());
    return make_pair(px[k], py[k]);
}
*/

struct BIT{
    vector<LL> sums;
    BIT(int n) : sums(n) {}

    // v[at] += by
    void add(int at, LL by) {
        while(at < sums.size()){
            sums[at] += by;
            at |= at + 1;
        }
    }

    // v[0] + ... + v[at]
    LL get(int at) {
        LL res = 0;
        while(at >= 0) {
            res += sums[at];
            at = (at & (at + 1)) - 1;
        }
        return res;
    }

    // --- optional ---
    int size() const { return sums.size(); }
    LL operator [](int idx) const { return sums[idx]; }
};

LL invert(vector<int> v) {
    LL res = 0;
    BIT bit(v.size());
    for(int i = (int)v.size()-1; i >= 0; i--) {
        res += bit.get(v[i]);
        bit.add(v[i], 1);
    }
    return res;
}

double solve(vector<pair<double, double>> ks) {
    sort(ks.begin(), ks.end());
    reverse(ks.begin(), ks.end());
    double lb = -1e9;
    double ub = +1e9;
    LL n = (LL)N * (N - 1) / 2;
    LL k = (n-1)/2;
    REP(_, 84) {
        double mid = (lb + ub) / 2;
        vector<pair<double, int>> vs;
        REP(i, ks.size()) {
            double d = ks[i].first * mid + ks[i].second;
            vs.push_back(make_pair(d, i));
        }
        sort(vs.begin(), vs.end());
        vector<int> orders;
        REP(i, ks.size()) orders.push_back(vs[i].second);
        LL iv = invert(orders);
        if(iv >= k+1) {
            ub = mid;
        } else {
            lb = mid;
        }
    }
    return (lb + ub) / 2;
}

pair<double, double> fast() {
    // Ax + By = C
    // y = (-A/B)x + (C/B)
    // x = (-B/A)y + (C/A)
    vector<pair<double, double>> ks1;
    vector<pair<double, double>> ks2;
    REP(i, N) {
        ks1.push_back(make_pair(-A[i]/B[i], C[i]/B[i]));
        ks2.push_back(make_pair(-B[i]/A[i], C[i]/A[i]));
    }
    return make_pair(
            solve(ks1),
            solve(ks2)
            );
}

int main() {
    cin >> N;
    REP(i, N) cin >> A[i] >> B[i] >> C[i];
    auto res = fast();
    cout << fixed << setprecision(15) << res.first << " "
        << fixed << setprecision(15) << res.second << endl;
}


Measured memory_bytes: 5400