from math import sqrt, atan, degrees
# Počítame s G = 1, nakoniec výslednú rýchlosť vynásobíme sqrt(G)
G = 9.81

# Pre každý z test-casov:
for t in range(int(input())):
    # Načítame počet obdĺžnikov a vzdialenosť koncového bodu:
    n, dist = map(int, input().split())

    # Sem
    above_45, below_45 = [], []

    for _ in range(n):
        # Načítame rohové body obdĺžnika:
        x1, y1, x2, y2 = map(int, input().split())

        #   [x1, y2]                    [x2, y2]
        #     Bod 3-----------------------Bod 4
        #       |                           |
        #       |                           |
        #     Bod 1------------Bod 5------Bod 2
        #   [x1, y1]     [dist/2, y1]   [x2, y1]
        #                         |
        #   0--------(1/2)--------^--------(1/2)--------dist

        # Riešime len body v intervale (0, dist), ostatné trafiť nemôžeme.
        # Obdĺžniky presahujúce mimo skrátime blízko okrajov intervalu
        # aby nám výpočty nedávali nezmyselné výsledky:
        if x1 < 0: x1 = 1 / dist**2
        if x2 > dist: x2 = dist - 1 / dist**2

        # Spočítame čas dosiahnutia rohového bodu 1 (vľavo dole):
        t = sqrt((2 * x1 * y1) / (dist - x1))
        # Spočítame potrebnú rýchlosť v smere osi x a v smere osi y:
        vx1 = (x1 / t)
        vy1 = (dist / (2 * vx1))
        # To isté pre bod 2:
        t = sqrt((2 * x2 * y1) / (dist - x2))
        vx2 = (x2 / t)
        vy2 = (dist / (2 * vx2))
        # Bod 3:
        t = sqrt((2 * x1 * y2) / (dist - x1))
        vx3 = (x1 / t)
        vy3 = (dist / (2 * vx3))
        # Bod 4:
        t = sqrt((2 * x2 * y2) / (dist - x2))
        vx4 = (x2 / t)
        vy4 = (dist / (2 * vx4))

        # Pokiaľ obdĺžnik prechádza cez stred intervalu (0, dist),
        # môže nás limitovať aj jeho spodná strana - bod 5:
        if x1 <= dist / 2 <= x2:
            x5, y5 = dist / 2, y1
            t = sqrt((2 * x5 * y5) / (dist - x5))
            vx5 = (x5 / t)
            vy5 = (dist / (2 * vx5))
        # Inak nahradíme bod 5 bodom 1 - pri počítaní minima to nevadí:
        else: vx5, vy5 = vx1, vy1

        # Body 1, 2 a 5 nás limitujú zvrchu, 3 a 4 zospodu.
        # Nájdeme tie dva, ktoré nás limitujú najviac,
        # uložíme si pomer počiatočných rýchlostí aj rýchlosti samotné:
        upper_limit = min(
                (vy1 / vx1, (vx1, vy1)),
                (vy2 / vx2, (vx2, vy2)),
                (vy5 / vx5, (vx5, vy5)))
        bottom_limit = max(
                (vy3 / vx3, (vx3, vy3)),
                (vy4 / vx4, (vx4, vy4)))
        
        # Ak je pomer rýchlostí väčší, než 1, je uhol väčší, než 45°:
        if bottom_limit[0] >= 1:
            # Uložíme si, kde začína limit pre obdĺžnik zospodu,
            # a kde končí zvrchu
            above_45.append((upper_limit[0], bottom_limit))
        if upper_limit[0] <= 1:
            # Uložíme si, kde začína limit pre obdĺžnik zvrchu,
            # a kde končí zospodu
            below_45.append((bottom_limit[0], upper_limit))
        
        # Každá tuple v zozname vyzerá takto:
        #   (limit bližšie k 45°,
        #       (limit ďalej od 45°,
        #           (rýchlosť x, rýchlosť y)
        #       )
        #   )

    # Ak sme nenašli žiadne obdĺžniky nad optimálnou trajektóriu,
    # alebo žiadne nie sú pod ňou, stačí vypísať let pod uhlom 45°:
    if min(len(above_45), len(below_45)) == 0:
        print(45, sqrt(dist * G))
        continue
    # Takisto ak žiadny obdĺžnik končiaci na jednej strane
    # od optimálnej trajektórie nezačína na druhej strane:
    elif min(above_45)[0] > 1 and max(below_45)[0] < 1:
        print(45, sqrt(dist * G))
        continue

    # Utriedime obdĺžniky nad optimálnou trajektóriou podľa spodného
    # limitu a tie pod ňou podľa vrchného limitu 
    below_45.sort(reverse=True)
    above_45.sort()

    # Nájdeme samostatne najlepšie riešenie nad optimálnou trajektóriou:
    index = 0
    # Koniec (a rýchlosti) obdĺžnika, ktorý je najbližšie 45°:
    ans_above = above_45[index][1] 
    # Kým nasledujúci obdĺžnik začína skôr, než aktuálny končí,
    # berieme nasledujúci obdĺžnik ako aktuálny:
    while above_45[index][0] <= ans_above[0]:
        ans_above = max(above_45[index][1], ans_above)
        index += 1
        # Ak už žiadne nezostali, limituje nás posledný:
        if index >= len(above_45):
            ans_above = max(above_45[-1][1], ans_above)
            break

    # Rovnako nájdeme riešenie pod optimálnou trajektóriou:
    index = 0
    ans_below = below_45[index][1]
    while below_45[index][0] >= ans_below[0]:
        ans_below = min(below_45[index][1], ans_below)
        index += 1
        if index >= len(below_45):
            ans_below = min(below_45[-1][1], ans_below)
            break

    # Pre obidve riešenia skúsime zrátať výslednú rýchlosť:
    vx1, vy1 = ans_below[1]
    v1 = sqrt(vx1 * vx1 + vy1 * vy1)
    vx2, vy2 = ans_above[1]
    v2 = sqrt(vx2 * vx2 + vy2 * vy2)
    # Vezmeme tú menšiu:
    v, vx, vy = min((v1, vx1, vy1), (v2, vx2, vy2))
    # Spočítame uhol z pomeru začiatočných rýchlostí:
    alpha = degrees(atan(vy / vx))
    # Naškálujeme rýchlosť sqrt(G):
    print(alpha, v * sqrt(G))