# -*- coding: utf-8 -*-

import sys

# sys.setrecursionlimit(10**6)

# buff_readline = sys.stdin.buffer.readline

buff_readline = sys.stdin.readline

readline = sys.stdin.readline



INF = 2**62-1





def read_int():

    return int(buff_readline())





def read_int_n():

    return list(map(int, buff_readline().split()))





def read_float():

    return float(buff_readline())





def read_float_n():

    return list(map(float, buff_readline().split()))





def read_str():

    return readline().strip()





def read_str_n():

    return readline().strip().split()





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap





class Mod:

    def __init__(self, m):

        self.m = m



    def add(self, a, b):

        return (a + b) % self.m



    def sub(self, a, b):

        return (a - b) % self.m



    def mul(self, a, b):

        return ((a % self.m) * (b % self.m)) % self.m



    def div(self, a, b):

        return self.mul(a, pow(b, self.m-2, self.m))



    def pow(self, a, b):

        return pow(a, b, self.m)





class Bisect:

    def __init__(self, func):

        self.__func = func



    def bisect_left(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if self.__func(mid) < x:

                lo = mid+1

            else:

                hi = mid

        return lo



    def bisect_right(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if x < self.__func(mid):

                hi = mid

            else:

                lo = mid+1

        return lo



def f(n):

    r = 1

    for i in range(1, n+1):

        r *= i

    return r



@mt

def slv(N, K, A, F):

    A.sort()

    F.sort(reverse=True)



    def f(x):

        y = 0

        for a, f in zip(A, F):

            b = a - x//f

            if b > 0:

                y += b

        if y <= K:

            return 1



        return 0



    return Bisect(f).bisect_left(1, 0, 10**19)













def main():

    N, K = read_int_n()

    A = read_int_n()

    F = read_int_n()

    print(slv(N, K, A, F))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-

import sys

# sys.setrecursionlimit(10**6)

# buff_readline = sys.stdin.buffer.readline

buff_readline = sys.stdin.readline

readline = sys.stdin.readline



INF = 2**62-1





def read_int():

    return int(buff_readline())





def read_int_n():

    return list(map(int, buff_readline().split()))





def read_float():

    return float(buff_readline())





def read_float_n():

    return list(map(float, buff_readline().split()))





def read_str():

    return readline().strip()





def read_str_n():

    return readline().strip().split()





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap





class Mod:

    def __init__(self, m):

        self.m = m



    def add(self, a, b):

        return (a + b) % self.m



    def sub(self, a, b):

        return (a - b) % self.m



    def mul(self, a, b):

        return ((a % self.m) * (b % self.m)) % self.m



    def div(self, a, b):

        return self.mul(a, pow(b, self.m-2, self.m))



    def pow(self, a, b):

        return pow(a, b, self.m)





class Bisect:

    def __init__(self, func):

        self.__func = func



    def bisect_left(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if self.__func(mid) < x:

                lo = mid+1

            else:

                hi = mid

        return lo



    def bisect_right(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if x < self.__func(mid):

                hi = mid

            else:

                lo = mid+1

        return lo



def f(n):

    r = 1

    for i in range(1, n+1):

        r *= i

    return r



@mt

def slv(N, K, A, F):

    A.sort()

    F.sort(reverse=True)



    def f(x):

        y = 0

        for a, f in zip(A, F):

            b = a - x//f

            if b > 0:

                y += b

        if y <= K:

            return 1



        return 0



    return Bisect(f).bisect_left(1, 0, 10**18)













def main():

    N, K = read_int_n()

    A = read_int_n()

    F = read_int_n()

    print(slv(N, K, A, F))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-
import sys

# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


class Mod:
    def __init__(self, m):
        self.m = m

    def add(self, a, b):
        return (a + b) % self.m

    def sub(self, a, b):
        return (a - b) % self.m

    def mul(self, a, b):
        return ((a % self.m) * (b % self.m)) % self.m

    def div(self, a, b):
        return self.mul(a, pow(b, self.m - 2, self.m))

    def pow(self, a, b):
        return pow(a, b, self.m)


class Bisect:
    def __init__(self, func):
        self.__func = func

    def bisect_left(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if self.__func(mid) < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if x < self.__func(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo


def f(n):
    r = 1
    for i in range(1, n + 1):
        r *= i
    return r


@mt
def slv(N, K, A, F):
    A.sort()
    F.sort(reverse=True)

    def f(x):
        y = 0
        for a, f in zip(A, F):
            b = a - x // f
            if b > 0:
                y += b
        if y <= K:
            return 1
        return 0

    return Bisect(f).bisect_left(1, 0, 10**19)


def main():
    N, K = read_int_n()
    A = read_int_n()
    F = read_int_n()
    print(slv(N, K, A, F))


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
import sys

# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


class Mod:
    def __init__(self, m):
        self.m = m

    def add(self, a, b):
        return (a + b) % self.m

    def sub(self, a, b):
        return (a - b) % self.m

    def mul(self, a, b):
        return ((a % self.m) * (b % self.m)) % self.m

    def div(self, a, b):
        return self.mul(a, pow(b, self.m - 2, self.m))

    def pow(self, a, b):
        return pow(a, b, self.m)


class Bisect:
    def __init__(self, func):
        self.__func = func

    def bisect_left(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if self.__func(mid) < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if x < self.__func(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo


def f(n):
    r = 1
    for i in range(1, n + 1):
        r *= i
    return r


@mt
def slv(N, K, A, F):
    A.sort()
    F.sort(reverse=True)

    def f(x):
        y = 0
        for a, f in zip(A, F):
            b = a - x // f
            if b > 0:
                y += b
        if y <= K:
            return 1
        return 0

    return Bisect(f).bisect_left(1, 0, 10**18)


def main():
    N, K = read_int_n()
    A = read_int_n()
    F = read_int_n()
    print(slv(N, K, A, F))


if __name__ == "__main__":
    main()

-    return Bisect(f).bisect_left(1, 0, 10**19) +    return Bisect(f).bisect_left(1, 0, 10**18)