#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
}

struct BIT {
    buf: Vec<usize>,
}

impl BIT {
    fn new(n: usize) -> BIT {
        BIT { buf: vec![0; n + 1] }
    }

    fn sum(&self, i: usize) -> usize {
        let mut i = i;
        let mut s = 0;
        while i > 0 {
            s += self.buf[i];
            i = i & (i - 1);
        }
        s
    }

    fn add(&mut self, i: usize, x: usize) {
        let mut i = i as i64;
        while i < self.buf.len() as i64 {
            self.buf[i as usize] += x;
            i += i & -i;
        }
    }
}

fn num_swaps(v: &Vec<usize>) -> usize {
    let mut bit = BIT::new(v.len());
    let mut ans = 0;
    for i in 0..v.len() {
        ans += i - bit.sum(v[i]);
        bit.add(v[i], 1);
    }
    ans
}

fn num_points(x: f64, lines: &Vec<(f64, f64, f64)>) -> usize {
    let mut v: Vec<_> = lines
        .iter()
        .map(|&(a, b, c)| (c - a * x) / b)
        .enumerate()
        .collect();
    v.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
    let order: Vec<usize> = v.iter().map(|t| t.0 + 1).collect();
    num_swaps(&order)
}

fn bin_search(target: usize, low: f64, high: f64, lines: &Vec<(f64, f64, f64)>) -> f64 {
    let mid = (low + high) / 2.0;

    let diff = high - low;

    if diff < 1e-9 || (diff / low).abs() < 1e-9 {
        return mid;
    }

    match num_points(mid, lines).cmp(&target) {
        Ordering::Less => bin_search(target, mid, high, lines),
        Ordering::Equal => bin_search(target, low, mid, lines),
        Ordering::Greater => bin_search(target, low, mid, lines),
    }
}

fn main() {
    let n: usize = util::get();
    let mut abc: Vec<(f64, f64, f64)> = (0..n)
        .map(|_| {
            let abc: Vec<i64> = util::gets();
            (abc[0] as f64, abc[1] as f64, abc[2] as f64)
        })
        .collect();

    abc.sort_by(|e1, e2| (e1.0 / e1.1).partial_cmp(&(e2.0 / e2.1)).unwrap());
    let xabc = abc.clone();
    abc = abc.into_iter().map(|(a, b, c)| (b, a, c)).collect();
    abc.sort_by(|e1, e2| (e1.0 / e1.1).partial_cmp(&(e2.0 / e2.1)).unwrap());
    let yabc = abc;

    let target = (n * (n - 1) + 3) / 4;

    println!(
        "{} {}",
        bin_search(target, -1e9, 1e9, &xabc),
        bin_search(target, -1e9, 1e9, &yabc)
    );

}


Measured memory_bytes: 8444