Consider a system of *n* water taps all pouring water into the same container. The *i*-th water tap can be set to deliver any amount of water from 0 to *a*<sub class="lower-index">*i*</sub> ml per second (this amount may be a real number). The water delivered by *i*-th tap has temperature *t*<sub class="lower-index">*i*</sub>.

If for every <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/29cd41d3b7a01103f80f7f1a061fdf146ffa49b1.png" style="max-width: 100.0%;max-height: 100.0%;"/> you set *i*-th tap to deliver exactly *x*<sub class="lower-index">*i*</sub> ml of water per second, then the resulting temperature of water will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/80ff149d627e36b02eb3a7af6ef4c83c177753f1.png" style="max-width: 100.0%;max-height: 100.0%;"/> (if <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/b3732be77fa6132294370a6abded03dbe6bec83a.png" style="max-width: 100.0%;max-height: 100.0%;"/>, then to avoid division by zero we state that the resulting water temperature is 0).

You have to set all the water taps in such a way that the resulting temperature is exactly *T*. What is the maximum amount of water you may get per second if its temperature has to be *T*?
The first line contains two integers *n* and *T* (1 ≤ *n* ≤ 200000, 1 ≤ *T* ≤ 10<sup class="upper-index">6</sup>) — the number of water taps and the desired temperature of water, respectively.

The second line contains *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>) where *a*<sub class="lower-index">*i*</sub> is the maximum amount of water *i*-th tap can deliver per second.

The third line contains *n* integers *t*<sub class="lower-index">1</sub>, *t*<sub class="lower-index">2</sub>, ..., *t*<sub class="lower-index">*n*</sub> (1 ≤ *t*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>) — the temperature of water each tap delivers.
none
2 100
3 10
50 150
6.000000000000000
3 9
5 5 30
6 6 10
40.000000000000000
2 12
1 3
10 15
1.666666666666667
20 30
70 97 14 31 83 22 83 56 19 87 59 7 7 89 24 82 34 40 6 24
10 4 47 46 11 18 32 55 16 32 53 37 43 32 41 46 57 14 60 44
916.518518518518519
1 1
1000000
1
1000000.000000000000000
1 200
1000000
100
0.000000000000057
1 1000000
1000000
1000000
999999.999999999944407
from sys import stdin, stdout

ta = [[0,0] for _ in range(200005)]

def solve(A, T, t):
    # se construye un array de tuplas (temperatura, max apertura)
    # y se ordena por temperaturas
    for i in range(len(A)):
        ta[i] = [T[i], A[i]]
    ta[:len(A)] = sorted(ta[:len(A)])

    # Se toma X = A, por tanto, delta tiene la forma que se explica abajo
    # num almacena el numerador de la funcion delta que es la suma
    # de la temperatura por su nivel de apertura
    num = sum([i * j for i, j in ta[:len(A)]])
    # den almacena el denominador de la funcion delta que es 
    # la suma de los niveles de apertura.
    den = sum(A)

    # si delta es menor que T' (la temperatura deseada), entonces se
    # modifica T', el array ta y el numerador de forma que sean numeros
    # negativo y el procedimiento sea el mismo.
    if num < t * den:
        # se modifica T', ahora será -T'
        t *= -1
        # se modifica la temperatura de que cada grifo, se vuelve negativa
        for item in ta[:len(A)]:
            item[0] *= -1
        # luego se invierte el array ta, de forma que siga quedando ordenado
        # en orden creciente.
        ta[:len(A)] = ta[:len(A)][::-1]
        # se modifica el valor de la funcion delta que se tiene, se hace negativo
        num *= -1


    i = len(A) -1
    while i >= 0 and num > t * den:
        num -= ta[i][0] * ta[i][1]
        den -= ta[i][1]
        i -= 1

    i += 1
    low = 0
    high = ta[i][1]
    while high - low > 0:
        med = (low + high)/2
        nn = num + med * ta[i][0]
        dd = den + med
        if nn <= t * dd:
            low = med
        else:
            high = med
    return den + low

if __name__ == "__main__":
    read = lambda : [*map(int, stdin.readline().split())]
    n, T = read()
    A = read()
    Tp = read()
    stdout.write(str(solve(A, Tp, T)) + "\n")
