# O(n * log(n)) で解く

def g(i, n, t) $a_sums[i] + h(i+1, n, t) end    # O(n)
def h(i, n, t) (i..n).inject(0) do |s,j| s + t / $fs[j] end end    # O(n)
def afs(i) $as[i] * $fs[i] end    # O(1)
def nlr(n, l, i) [n - i, l - $a_sums[i], $rs[i+1]] end    # O(1)

n, k = gets.split.map(&:to_i)
$as = gets.split.map(&:to_i)
$fs = gets.split.map(&:to_i)
 
l = $as.sum - k

if (l <= 0)
  p 0
  exit
end

# O(n)
max_f = $fs.max
min_a, max_a = l, 0
# O(n)
$as.each do |a|
  min_a = a if (a < min_a)
  max_a = a if (a > max_a)
end

ub_af = max_a * max_f
q = max_f + ub_af

# O(n)
r = h(0, n-1, q)
t = (l + n) * q / r

if (min_a > t)
  ub = t

  rr = r + n
  lb = (l * q + rr - 1)/ rr

  s = 0
  xs = []
  # O(n)
  # push の回数は 3 * n を超えないはず
  (0..n-1).each do |i|
    f = $fs[i]
    aa = ub / f
    s += aa
    (aa * f).step(lb, -f) do |x| xs.push(-x) end
  end
else
  # O(n * log(n))
  $as.push(0).sort!
  $fs.push(max_f).sort_by! {|f| -f}

  # O(n * log(n))
  $as, $fs = $as.zip($fs).sort_by do |a,f| a*f end.transpose

  r = 0
  # O(n)
  $a_sums = $as.map do |a| r += a end

  $rs = []
  # O(n)
  n.downto(1).inject(0) do |r,i| $rs[i] = r + q / $fs[i] end

  lb = ub = nil
  ilb = nil

  # O(n + log(n))
  m = (0..n).bsearch do |i|
    next false if (i == 0)
    next true if (i == n)

    nn, ll, r = nlr(n, l, i)
    af = afs(i)

    next false if (af * (r + nn) / q < ll)
    next true if ((af * r + q - 1) / q - nn >= ll)

    next false if (lb)
    next true if (ub)

    # ここは一度しか通らない

    # O(n)
    if (h(i+1, n, af) < ll)
      lb, ilb = af, i
      next false
    else
      ub = af
      next true
    end
  end

  # O(n)
  if (lb)
    af = afs(m-1)
    ub = af if (g(m-1, n, af) > l)
  elsif (ub)
    af = afs(m)
    lb, ilb = af, m if (g(m, n, af) < l)
  end

  # O(1)
  unless (lb && ub)
    ilb = m == 1 ? 1: m - 1

    nn, ll, r = nlr(n, l, m-1)

    lbm, ubm = afs(m-1), afs(m)

    ub = [ub || ub_af, (ll + nn) * q / r, ubm].min

    rr = r + nn
    lb = [lb || 0, (ll * q + rr - 1)/ rr, lbm].max
  end

  s = $a_sums[ilb-1]
  xs = []
  # O(n)
  # push の回数は 3 * n を超えないはず
  (ilb..n).each do |i|
    a, f = $as[i], $fs[i]
    aa = [ub / f, a].min
    s += aa
    (aa * f).step(lb, -f) do |x| xs.push(-x) end
  end
end

# O(n) のアルゴリズムもあるが、この問題のサイズでは組み込みの sort を使った方が速いようだ
# O(n * log(n))
p(- xs.sort[s - l])