def addbit(i):

    i += 1

    while i <= N:

        BIT[i] += 1

        i += i & (-i)

def getsum(i):

    ret = 0

    i += 1

    while i != 0:

        ret += BIT[i]

        i -= i&(-i)

    return ret

def bit(L):

    global BIT

    BIT=[0] * (N+1)

    re = 0

    for l in L:

        re += getsum(l)

        addbit(l)

    return N*(N-1)//2 - re

def get_rank(L):

    D = {x:i for i,x in enumerate(sorted(L))}

    return [D[x] for x in L]

def calc(Z):

    Z.sort()

    l, r = -1<<28, 1<<28

    while (r - l) / max(abs(l), 1) > 0.000000001:

        m = (l+r)/2

        A = get_rank([s*m+t for s, t in Z])

        c = bit(A)

        if c > N*(N-1)//4:

            l = m

        else:

            r = m

    return l



N = int(eval(input()))

X, Y = [], []

for _ in range(N):

    a, b, c = list(map(int, input().split()))

    X.append((-a/b, c/b))

    Y.append((-b/a, c/a))

print((calc(X), calc(Y)))
def addbit(i):

    i += 1

    while i <= N:

        BIT[i] += 1

        i += i & (-i)

def getsum(i):

    ret = 0

    i += 1

    while i != 0:

        ret += BIT[i]

        i -= i&(-i)

    return ret

def bit(L):

    global BIT

    BIT=[0] * (N+1)

    re = 0

    for l in L:

        re += getsum(l)

        addbit(l)

    return N*(N-1)//2 - re

def get_rank(L):

    D = {x:i for i,x in enumerate(sorted(L))}

    return [D[x] for x in L]

def calc(Z):

    Z.sort()

    l, r, lc, rc = -1<<28, 1<<28, N*(N-1)//4+1, N*(N-1)//4+1

    while (r - l) / max(abs(l), 1) > 0.000000001:

        m = (l * rc + r * lc) / (lc + rc)

        A = get_rank([s*m+t for s, t in Z])

        c = bit(A)

        if c > N*(N-1)//4:

            l = m

            lc = ((c - N*(N-1)//4) * 2) ** 0.8

        else:

            r = m

            rc = ((N*(N-1)//4 - c) * 2 + 1) ** 0.8

    return l



N = int(eval(input()))

X, Y = [], []

for _ in range(N):

    a, b, c = list(map(int, input().split()))

    X.append((-a/b, c/b))

    Y.append((-b/a, c/a))

print((calc(X), calc(Y)))
def addbit(i):
    i += 1
    while i <= N:
        BIT[i] += 1
        i += i & (-i)


def getsum(i):
    ret = 0
    i += 1
    while i != 0:
        ret += BIT[i]
        i -= i & (-i)
    return ret


def bit(L):
    global BIT
    BIT = [0] * (N + 1)
    re = 0
    for l in L:
        re += getsum(l)
        addbit(l)
    return N * (N - 1) // 2 - re


def get_rank(L):
    D = {x: i for i, x in enumerate(sorted(L))}
    return [D[x] for x in L]


def calc(Z):
    Z.sort()
    l, r = -1 << 28, 1 << 28
    while (r - l) / max(abs(l), 1) > 0.000000001:
        m = (l + r) / 2
        A = get_rank([s * m + t for s, t in Z])
        c = bit(A)
        if c > N * (N - 1) // 4:
            l = m
        else:
            r = m
    return l


N = int(eval(input()))
X, Y = [], []
for _ in range(N):
    a, b, c = list(map(int, input().split()))
    X.append((-a / b, c / b))
    Y.append((-b / a, c / a))
print((calc(X), calc(Y)))

def addbit(i):
    i += 1
    while i <= N:
        BIT[i] += 1
        i += i & (-i)


def getsum(i):
    ret = 0
    i += 1
    while i != 0:
        ret += BIT[i]
        i -= i & (-i)
    return ret


def bit(L):
    global BIT
    BIT = [0] * (N + 1)
    re = 0
    for l in L:
        re += getsum(l)
        addbit(l)
    return N * (N - 1) // 2 - re


def get_rank(L):
    D = {x: i for i, x in enumerate(sorted(L))}
    return [D[x] for x in L]


def calc(Z):
    Z.sort()
    l, r, lc, rc = -1 << 28, 1 << 28, N * (N - 1) // 4 + 1, N * (N - 1) // 4 + 1
    while (r - l) / max(abs(l), 1) > 0.000000001:
        m = (l * rc + r * lc) / (lc + rc)
        A = get_rank([s * m + t for s, t in Z])
        c = bit(A)
        if c > N * (N - 1) // 4:
            l = m
            lc = ((c - N * (N - 1) // 4) * 2) ** 0.8
        else:
            r = m
            rc = ((N * (N - 1) // 4 - c) * 2 + 1) ** 0.8
    return l


N = int(eval(input()))
X, Y = [], []
for _ in range(N):
    a, b, c = list(map(int, input().split()))
    X.append((-a / b, c / b))
    Y.append((-b / a, c / a))
print((calc(X), calc(Y)))

-    l, r = -1 << 28, 1 << 28 +    l, r, lc, rc = -1 << 28, 1 << 28, N * (N - 1) // 4 + 1, N * (N - 1) // 4 + 1 -        m = (l + r) / 2 +        m = (l * rc + r * lc) / (lc + rc) +            lc = ((c - N * (N - 1) // 4) * 2) ** 0.8 +            rc = ((N * (N - 1) // 4 - c) * 2 + 1) ** 0.8