class Heap
  def initialize(xs = [], &block)
    @que = xs
    @size = xs.size
    @cmp = block || lambda{ |a,b| a < b }
  end
 
  def push(x)
    i = @size
    while i > 0 do
      j = (i - 1) / 2
      break unless @cmp.call(x, @que[j])
      @que[i] = @que[j]
      i = j
    end
    @que[i] = x
    @size += 1
  end
 
  def replace
    m = @que[0]
    x = yield m
    i = 0
    while (ii = i * 2 + 1) < @size do
      j1 = ii
      j2 = ii + 1
      j1 = j2 if j2 < @size && @cmp.call(@que[j2], @que[j1])
      break unless @cmp.call(@que[j1], x)
      @que[i] = @que[j1]
      i = j1
    end
    @que[i] = x
    m
  end
end
 
def get_target(l, h, n, fs)
  r = 0
  fs.each do |f| r += h / f end
 
  # t0 = (l*h/r).ceil, t = (l*h/(r+n)).ceil
  lh = l * h
  t0 = (lh + r - 1) / r
  t = (lh + r + n - 1) / (r + n)
 
  raise if (t0 >= t + 2)
 
  t
end
 
n, k = gets.split.map(&:to_i)
as = gets.split.map(&:to_i)
fs = gets.split.map(&:to_i)
 
l = as.inject(:+) - k
 
if (l <= 0)
  p 0
  exit
end
 
# O(n * log(n))
afs = as.sort.zip(fs.sort.reverse).sort_by do |item| item[0]*item[1] end
 
acc = 0
# O(n)
a_sums = afs.map do |a,_| acc += a end
 
# O(n * log(n))
m = (0...n).bsearch do |i|
  a_i, f_i = afs[i]
  af = a_i * f_i
 
  s = a_sums[i]
  (i+1...n).each do |j| s += af / afs[j][1] end
  s > l
end
 
if (m > 0)
  afs = afs.drop(m)
  n -= m
  l -= a_sums[m-1]
end
 
max_f = 0
 
# O(n)
fs = afs.map do |a, f|
  max_f = f if f > max_f
  f
end
 
# O(n)
t = get_target(l, l * max_f * max_f, n, fs)
 
max_af = 0
 
# O(n)
xs = fs.map do |f|
  l -= (a = t / f)
  af = a * f
  max_af = af if af > max_af
  [af + f, f]
end
 
if (l == 0)
  p max_af
else
  # O(n * log(n))
  xs = xs.sort_by do |item| item[0] end
  # O(n * log(n))
  q = Heap.new(xs) do |a,b| a.first < b.first end
 
  raise if (l > 2*n)
 
  # O(n * log(n))
  af, = q.replace do |a| [a[0] + a[1], a[1]] end while (l -= 1) >= 0
  p af
end