#include <iostream>
#include <algorithm>
#include <cmath>
#include <complex>
#include <vector>
using namespace std;
typedef complex<double> P;

const double eps = 1e-7;

bool equals(double a, double b) { return abs(a-b) < eps; }

namespace std {
  bool operator < (const P &a, const P &b) {
    if(a.real() != b.real()) return a.real() < b.real();
    return a.imag() < b.imag();
  }
}

struct L : public vector<P> {
  L(P a, P b) {
    push_back(a);
    push_back(b);
  }
};

double dot(P a, P b) { return a.real()*b.real() + a.imag()*b.imag(); }
double cross(P a, P b) { return a.real()*b.imag() - a.imag()*b.real(); }

int ccw(P p0, P a, P b) {
  a -= p0;
  b -= p0;
  if(cross(a,b) > eps) return 1;
  if(cross(a,b) < -eps) return -1;
  if(dot(a,b) < -eps) return 2;
  if(norm(a) < norm(b)) return -2;
  return 0;
}

vector<L> ls;
vector<P> ps;
int A[30010];
double Area[30010];

int f(P p) {
  int l = 0;
  int r = ls.size();
  int ans = -1;
  while(l < r) {
    int m = (l+r)/2;
    if(ccw(ls[m][0],ls[m][1],p) == 1) {
      ans = m;
      l = m+1;
    } else {
      r = m;
    }
  }
  return ans;
}

double getArea(int a, int b) {
  if(a <= 0) return Area[b];
  return Area[b] - Area[a-1];
}

int getArm(int a, int b) {
  if(a <= 0) return A[b];
  return A[b] - A[a-1];
}

int main() {
  int n,m,w,h,S;
  while(cin >> n >> m >> w >> h >> S && (n|m|w|h|S))  {
    ls.clear();
    ps.clear();

    for(int i = 0; i < m; ++i) {
      P a,b;
      cin >> a.imag() >> b.imag();
      a.real() = 0;
      b.real() = w;
      ls.push_back(L(a,b));
    }
    ls.push_back(L(P(0,0),P(w,0)));

    sort(ls.begin(), ls.end());
    for(int i = 0; i < n; ++i) {
      P p;
      cin >> p.real() >> p.imag();
      ps.push_back(p);
    }


    fill(A,A+30010,0);
    for(int i = 0; i < ps.size(); ++i) {
      ++A[f(ps[i])];
    }

    for(int i = 1; i < m; ++i) A[i] += A[i-1];

//     for(int i = 0; i < m; ++i) {
//       if(i) cout << " ";
//       cout << A[i];
//     }
//     cout << endl;

    // calc Area
    for(int i = 0; i+1 < ls.size(); ++i) {
      if(i) Area[i] = Area[i-1];
      else Area[i] = 0;
      Area[i] += ( (ls[i+1][0].imag()-ls[i][0].imag())
                + (ls[i+1][1].imag()-ls[i][1].imag()) ) * w / 2.0;
    }

    int head = 0;
    int tail = 0;
    int mx = 0;
    double T = h*w-S;

    while (tail < m) {
      while (getArea(tail, head + 1) <= T && head + 1 < m) ++head;
      if (getArea(tail, head) <= T) {
        // cout << tail << ", " << head << " : " << getArm(tail, head) << endl;
        mx = max(mx, getArm(tail, head));
      }
      ++tail;
      if (head <= tail) {
        // cout << "head <= tail  " << tail << ", " << head << endl;
        head = tail;        
      }
    }
    cout << n - mx << endl;

//     int ans = 0;
//     double T = h*w-S;
//     for(int l = 0, r = 0, sum = 0; l < m && r < m; ) {
//       // cout << l << ", " << r << ", " << sum << endl;
//       cout << "T = " << T << endl;
//       while(r < m && getArea(l,r) < T) ++r;
//       cout << getArea(l,r) << endl;
//       --r;
//       cout << "inc : " << l << ' ' << r << endl;
//       if( l <= r ){
//         cout << "inc get : " << getArm(l,r) << endl;
//         ans = max(ans,getArm(l,r));
//       }
//       ++r;
// //      if(r == m) break;
      
//       while((equals(getArea(l,r),T) || getArea(l,r) > T)) {
//         ++l;
//       }
      
      
//       // if(l > r) r = l;
//       //if(l < m && getArea(l,r) < T)
//       /*
//       cout << "dec : " << l << ' ' << r << endl;
//       if( l <= r ){
//         cout << "dec get : " << getArm(l,r) << endl;
//         ans = max(ans,getArm(l,r));
//       }
//       */
    // }
    // cout << n-ans << endl;
  }
  return 0;
}

Measured memory_bytes: 0