### inner classes

class BIT
  def initialize(n)
    @n = n
    @bits = (n + 1).times.map{0}
  end

  def sum(x)
    s = 0
    while x > 0
      s += @bits[x]
      x -= (x & -x)
    end
    s
  end

  def add(x, v)
    while x <= @n
      @bits[x] += v
      x += (x & -x)
    end
  end
end

### subroutines

def bsearch_line(lines, n, x, y)
  i0 = 0
  i1 = n

  while i0 <= i1
    i = (i0 + i1) / 2
    li0 = lines[i]
    li1 = lines[i + 1]
    y0 = li0[4] * x + li0[0]
    y1 = li1[4] * x + li1[0]
    #p [i, y, y0, y1]

    if y >= y0 && y <= y1
      return i
    elsif y < y0
      i1 = i - 1
    else
      i0 = i + 1
    end
  end
  nil
end

def lower_bound(arr, key, i0 = 0, i1 = arr.length)
  lb = i0 - 1
  ub = i1

  while lb + 1 < ub
    m = (lb + ub) / 2
    if arr[m] >= key
      ub = m
    else
      lb = m
    end
  end
  ub
end

### main

loop do
  n, m, w, h, s = gets.split.map(&:to_i)
  break if (n | m | w | h | s) == 0

  wh2 = w * h * 2
  s2 = s * 2

  lines = [[0, 0, 0, 0, 0.0]]
  py0 = py1 = 0
  ssums = []
  ssum = 0

  m.times do
    y0, y1 = gets.split.map(&:to_i)
    dy0 = y0 - py0
    dy1 = y1 - py1
    lines << [y0, y1, dy0, dy1, (y1 - y0).to_f / w]
    ssum += (dy0 + dy1) * w
    ssums << ssum
    py0 = y0
    py1 = y1
  end
  #p lines
  #p ssums

  abit = BIT.new(m)

  n.times do
    x, y = gets.split.map(&:to_f)
    i = bsearch_line(lines, m, x, y)
    abit.add(i + 1, 1)
  end
  #p abit

  min_as = n

  m.downto(1) do |k|
    srem = s2 - (wh2 - (k == 0 ? 0 : ssums[k - 1]))
    as0 = n - abit.sum(k)
    #p [k, srem, as0]

    break if as0 >= min_as
    if srem < 0
      min_as = as0 if min_as > as0
      break
    end

    i = lower_bound(ssums, srem, 0, k)
    as = abit.sum(i + 1) + as0
    #p ['lb', i, ssums[i], as]

    min_as = as if min_as > as
  end

  puts min_as
end