#include <algorithm>
#include <cassert>
#include <cctype>
#include <chrono>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;

#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()

const int INF = 0x3f3f3f3f, MOD = 1000000007;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
/*-----------------------------------------*/
struct Line {
  int a, b, c;
  double katamuki;
  Line(int a_, int b_, int c_) : a(a_), b(b_), c(c_) {
    katamuki = -(double)a / b;
  }
  double y(double x) {
    return (c - a * x) / b;
  }
};
inline bool operator < (const Line &lhs, const Line &rhs) {
  return lhs.katamuki > rhs.katamuki;
}

struct Line2 {
  int a, b, c;
  double katamuki;
  Line2(int a_, int b_, int c_) : a(a_), b(b_), c(c_) {
    katamuki = -(double)b / a;
  }
  double x(double y) {
    return (c - b * y) / a;
  }
};
inline bool operator < (const Line2 &lhs, const Line2 &rhs) {
  return lhs.katamuki > rhs.katamuki;
}

template <typename Abelian>
struct BIT {
  BIT(int sz_, const Abelian UNITY_ = 0) : UNITY(UNITY_) {
    sz = sz_ + 1;
    dat.assign(sz, UNITY);
  }

  void add(int idx, Abelian value) {
    while (idx < sz) {
      dat[idx] += value;
      idx += idx & -idx;
    }
  }

  Abelian sum(int idx) {
    Abelian res = UNITY;
    while (idx > 0) {
      res += dat[idx];
      idx -= idx & -idx;
    }
    return res;
  }

  int lower_bound(Abelian value) {
    if (value <= UNITY) return UNITY;
    int res = UNITY, exponent = 1;
    while (exponent < sz) exponent <<= 1;
    for (int mask = exponent >> 1; mask > 0; mask >>= 1) {
      if (res + mask < sz && dat[res + mask] < value) {
        value -= dat[res + mask];
        res += mask;
      }
    }
    return res + 1;
  }

private:
  int sz;
  const Abelian UNITY;
  vector<Abelian> dat;
};

template <typename T>
long long inversion_number(const vector<T> &seq) {
  int sz = seq.size();
  vector<T> cp = seq;
  sort(ALL(cp));
  cp.erase(unique(ALL(cp)), cp.end());
  BIT<int> bit(cp.size());
  long long res = 0;
  REP(i, sz) {
    int idx = lower_bound(ALL(cp), seq[i]) - cp.begin() + 1;
    res += i - bit.sum(idx);
    bit.add(idx, 1);
  }
  return res;
}

int main() {
  // freopen("input.txt", "r", stdin);

  int n; cin >> n;
  vector<Line> lines;
  REP(i, n) {
    int a, b, c; cin >> a >> b >> c;
    lines.emplace_back(Line(a, b, c));
  }
  sort(ALL(lines));
  double lb = -1e10, ub = 1e10;
  long long border = (long long)n * (n - 1) / 2;
  if (border & 1) border /= 2;
  else {
    border /= 2;
    --border;
  }
  REP(_, 100) {
    double x = (lb + ub) / 2;
    vector<pair<double, int> > yzahyo(n);
    REP(i, n) {
      yzahyo[i] = {lines[i].y(x), i};
    }
    sort(ALL(yzahyo));
    vector<int> check(n);
    REP(i, n) check[i] = yzahyo[i].second;
    (inversion_number(check) <= border? lb : ub) = x;
  }
  printf("%.10f ", lb);
  vector<Line2> lines2;
  REP(i, n) lines2.emplace_back(Line2(lines[i].a, lines[i].b, lines[i].c));
  sort(ALL(lines2));
  lb = -1e10, ub = 1e10;
  REP(_, 100) {
    double y = (lb + ub) / 2;
    vector<pair<double, int> > xzahyo(n);
    REP(i, n) {
      xzahyo[i] = {lines2[i].x(y), i};
    }
    sort(ALL(xzahyo));
    vector<int> check(n);
    REP(i, n) check[i] = xzahyo[i].second;
    (inversion_number(check) <= border? lb : ub) = y;
  }
  printf("%.10f\n", lb);
  return 0;
}


Measured memory_bytes: 3572