from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache  # @lru_cache(None)
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return (int(x) for x in input().split())
def LI(): return list(Is())
def TI(): return tuple(Is())
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(S())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18
EPS = 1e-9
# ----------------------------------------------------------- #

class BinaryIndexedTree:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n + 1)

    def sum(self, i):  # 1-index
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):  # 1-index
        while i <= self.size:
            self.tree[i] += x
            i += i & -i

    """
    # 使用例
    bit = BinaryIndexedTree(10)     # 要素数を与えてインスタンス化
    bit.add(2, 10)    # a2に10を加える
    bit.add(3, -6)    # a3に-6を加える
    print(bit.sum(6)) # a1～a6の合計を返す
    print(bit.sum(6) - bit.sum(3))  # a4～a6の合計を返す
    """

def compress(A):
    dic = {element: i for i, element in enumerate(sorted(set(A)), start=1)}
    return [dic[a] for a in A]

def meguru_bisect(ng, ok, check):
    """
    初期値のng,okを受け取り, check=>Trueを満たす最大値(最小値)を返す
    条件を満たす最大値を求める場合、初期値は(ng:上限の外, ok:下限の外)   例) 10**9+1, -1
    条件を満たす最小値を求める場合、初期値は(ng:下限の外, ok:上限の外)   例) -1, 10**9+1
    上限の外や下限の外が返ってくる場合は条件を満たす値が範囲内になかったことを示すので、例外処理が必要
    """
    # while abs(ok - ng) > 1:
    for _ in range(80):
        if abs(ok - ng) < EPS:
            break
        # mid = (ok + ng) // 2
        mid = (ok + ng) / 2
        if check(mid):
            ok = mid
        else:
            ng = mid
    return ok

def check_x(num):
    bit = BinaryIndexedTree(n)
    inversion_num = 0
    X = compress([(c-b*num)/a for a, b, c in X_ABC])
    for i, x in enumerate(X, start=1):
        bit.add(x, 1)
        inversion_num += i - bit.sum(x)
    return inversion_num >= m

def check_y(num):
    bit = BinaryIndexedTree(n)
    inversion_num = 0
    Y = compress([(c-a*num)/b for a, b, c in Y_ABC])
    for i, y in enumerate(Y, start=1):
        bit.add(y, 1)
        inversion_num += i - bit.sum(y)
    return inversion_num >= m

n = I()
ABC = TIR(n)
m = (n*(n-1)//2+1)//2
X_ABC = sorted(ABC, key=lambda abc: abc[1]/abc[0])  # 傾きb/aの昇順
Y_ABC = sorted(ABC, key=lambda abc: abc[0]/abc[1])  # 傾きa/bの昇順
mid_x = meguru_bisect(-10**9, 10**9, check_x)
mid_y = meguru_bisect(-10**9, 10**9, check_y)

print(mid_y, mid_x)  # ????


Measured memory_bytes: 139396