#include <iostream>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <vector>
#include <functional>

template <class T>
struct SegmentTree {
    using Merger = std::function<T(T, T)>;

    int length;
    std::vector<T> dat;
    T unit;
    Merger merge;

    explicit SegmentTree(int n, T unit, Merger merge)
        : length(1), unit(unit), merge(merge) {
        while (length < n) length <<= 1;
        dat.assign(length * 2, unit);
    }

    T query(int ql, int qr) {
        ql = std::max(ql, 0);
        qr = std::min(qr, length);
        ql += length, qr += length;

        T lacc = unit, racc = unit;
        while (ql < qr) {
            if (ql & 1) {
                lacc = merge(lacc, dat[ql]);
                ++ql;
            }
            if (qr & 1) {
                --qr;
                racc = merge(dat[qr], racc);
            }
            ql >>= 1, qr >>= 1;
        }
        return merge(lacc, racc);
    }

    void update(int nidx, T elem) {
        nidx += length;
        dat[nidx] = elem;

        while (nidx > 0) {
            nidx >>= 1;
            T vl = dat[nidx * 2 + 0];
            T vr = dat[nidx * 2 + 1];
            dat[nidx] = merge(vl, vr);
        }
    }
};

using ldouble = long double;

struct Line {
    ldouble a, b, c;
};

constexpr ldouble INF = 1e12;

void solve() {
    int n;
    std::cin >> n;

    int m = (n * (n - 1) / 2 + 1) / 2;

    std::vector<Line> ls(n);
    for (auto& l : ls) {
        std::cin >> l.a >> l.b >> l.c;
    }

    std::vector<int> idxs(n), ord(n);
    std::iota(idxs.begin(), idxs.end(), 0);
    std::vector<ldouble> xs(n);

    SegmentTree<int> seg(n, 0, [&](auto a, auto b) { return a + b; });

    for (int q = 0; q < 2; ++q) {
        std::sort(ls.begin(), ls.end(),
                  [](const Line& lhs, const Line& rhs) {
                      return lhs.a / lhs.b > rhs.a / rhs.b;
                  });

        ldouble ok = INF, ng = -INF;
        for (int t = 0; t < 100; ++t) {
            ldouble mid = (ok + ng) / 2;

            for (int i = 0; i < n; ++i) {
                const auto& l = ls[i];
                xs[i] = (l.c - l.a * mid) / l.b;
            }

            std::sort(idxs.begin(), idxs.end(),
                      [&](int i, int j) { return xs[i] < xs[j]; });
            for (int i = 0; i < n; ++i) ord[idxs[i]] = i;

            int cnt = 0;
            for (int i = 0; i < n; ++i) {
                cnt += seg.query(0, ord[i]);
                seg.update(ord[i], 1);
            }

            for (int i = 0; i < n; ++i) seg.update(ord[i], 0);

            if (cnt >= m) {
                ok = mid;
            } else {
                ng = mid;
            }

            // std::cerr << mid << ": " << cnt << std::endl;
            // for (auto x : xs) std::cerr << x << " ";
            // std::cerr << std::endl;
            // for (auto x : ord) std::cerr << x << " ";
            // std::cerr << std::endl;
        }

        std::cout << std::fixed << std::setprecision(15) << ok << " ";

        for (auto& l : ls) std::swap(l.a, l.b);
    }
    std::cout << std::endl;
}

int main() {
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    std::ios::sync_with_stdio(false);

    solve();

    return 0;
}


Measured memory_bytes: 3584