#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <bitset>
#include <iomanip>
//#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

class BIT {
    // Binary Indexed Tree : 数列要素1つへの加算、数列のある地点までの累積和を高速に計算
    public:
    std::vector<long long> data;
    BIT() {}
    BIT(const int size) {
        // 想定されるサイズの2倍の値を入れた方がいいかもしれない。数列は1から数えることを想定している。
        data.resize(size, 0);
    }
    long long sum(int i) const {
        long long s = 0;
        while (i > 0) {
            s += data[i];
            i = i & (i-1); // iの最後のビットを引く。
        }
        return s;
    }

    long long sum_mod(int i, long long mod) const {
        long long s = 0;
        while (i > 0) {
            s = (s + data[i] + mod) % mod;
            i = i & (i-1); // iの最後のビットを引く。
        }
        return s;
    }

    long long val(int i) const {
        if (i == 1) { return sum(i); }
        else {
            return sum(i) - sum(i-1);
        }
    }

    long long val_mod(int i, long long mod) const {
        if (i == 1) { return sum(i); }
        else {
            return (sum(i) - sum(i-1) + mod) % mod;
        }
    }

    void add(int i, long long x) {
        while (i < data.size()) {
            data[i] += x;
            i += i - (i & (i-1)); // iの最後のビットを加算する。
        }
    }

    void add_mod(int i, long long x, long long mod) {
        while (i < data.size()) {
            data[i] = (data[i] + x + mod) % mod;
            i += i - (i & (i-1)); // iの最後のビットを加算する。
        }
    }
};

struct BSRD {
    bool found; // 条件を満たす範囲が見つかったか。falseの場合、begin,endは意味を持たない。
    double begin; // [begin, end]で条件が成り立つ。
    double end;

    BSRD(bool found_in, double begin_in, double end_in) : found(found_in), begin(begin_in), end(end_in) {}
};

template<class Fn> BSRD my_binary_search(double L, double R, double eps, Fn func) {
    const bool resL = func(L);
    const bool resR = func(R);
    if (resL && resR) {
        return BSRD(true, L, R);
    } else if (!resL && !resR) {
        return BSRD(false, 0, 0);
    } else {
        double lb = L;
        double ub = R;
        while (eps < ub - lb && eps < (ub-lb)*2/(fabs(ub)+fabs(lb))) {
            double mid = (lb + ub) / 2;
            if (resL == func(mid)) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        if (resL) {
            return BSRD(true, L, lb);
        } else {
            return BSRD(true, ub, R);
        }
    } 
}

const int MAX_N = 40010;
long long N;
long long A[MAX_N], B[MAX_N], C[MAX_N];
BIT bit = BIT(MAX_N);

std::vector<int> slope_order() {
    std::vector<int> vec;
    for (int i = 1; i <= N; i++) {
        vec.push_back(i);
    }
    std::sort(vec.begin(), vec.end(),
        [&](const int i, const int j) { 
            return - (double)A[i]/B[i] < -(double)A[j]/B[j];
        }
    );
    std::vector<int> ret;
    ret.resize(N+1);
    for (int i = 0; i < N; i++) {
        ret[vec[i]] = i + 1;
    }
    return ret;
}

std::vector<int> value_sort(double x) {
    std::vector<int> vec;
    for (int i = 1; i <= N; i++) {
        vec.push_back(i);
    }
    std::sort(vec.begin(), vec.end(),
        [&](const int i, const int j) { 
            return (-(double)A[i]*x + C[i]) / B[i] < (-(double)A[j]*x + C[j]) / B[j];
        }
    );
    return vec;
}

long long count(double x, const std::vector<int>& so) {
    std::vector<int> vs = value_sort(x);
    long long ret = 0;

    BIT bit = BIT(MAX_N);

    for (int i : vs) {
        ret += bit.sum(so[i]);
        bit.add(so[i], 1);
    }
    //std::cout << x << " " << ret << std::endl;
    return ret;
}

double solve() {
    std::vector<int> so = slope_order();
    long long total = N * (N - 1) / 2;
    double eps = 1.0e-12;
    double valR = 1.0e9;
    double valL = -1.0e9;
    //std::cout << count(valL, so) << " " << count(valR, so) << std::endl;
    BSRD bsrd = my_binary_search(valL, valR, eps,
        [&](const double d) { 
            return count(d, so) * 2 >= total;
        }
    );
    assert(bsrd.found);
    //std::cout << bsrd.begin << std::endl;
    return bsrd.begin;
}

int main(int argc, char **argv) {
    std::cin >> N;

    for (int i = 1; i <= N; i++) {
        std::cin >> A[i] >> B[i] >> C[i];
    }

    double ret_x = solve();

    for (int i = 1; i <= N; i++) {
        std::swap(A[i], B[i]);
    }
    double ret_y = solve();

    std::cout << std::setprecision(12) << ret_x << " " << ret_y << std::endl;

    return 0;
}


Measured memory_bytes: 2468