#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>

using namespace std;

const double EPS = 0.0000000001;
const double LEPS = 0.00000001;

struct Point2D {
	double x, y;
	Point2D(double _x = 0.0, double _y = 0.0) : x(_x), y(_y) { }
	bool operator==(const Point2D &p) const { return x == p.x && y == p.y; }
	bool operator!=(const Point2D &p) const { return x != p.x || y != p.y; }
	bool operator<(const Point2D &p) const {
		if(x < p.x){ return true; }
		if(x > p.x){ return false; }
		return y < p.y;
	}
};

Point2D operator+(const Point2D &a, const Point2D &b){ return Point2D(a.x + b.x, a.y + b.y); }
Point2D operator-(const Point2D &a, const Point2D &b){ return Point2D(a.x - b.x, a.y - b.y); }

double cross2d(const Point2D &a, const Point2D &b){
	return a.x * b.y - a.y * b.x;
}

double convexArea(const vector<Point2D> &convex){
	double sum = 0.0;
	for(int i = 1; i < convex.size(); ++i){ sum += cross2d(convex[i - 1], convex[i]); }
	sum += cross2d(convex.back(), convex[0]);
	return sum / 2;
}

bool testConvexAndPoint(const vector<Point2D> &convex, const Point2D &p){
	vector<Point2D> triangle(3);
	for(int i = 1; i < convex.size(); ++i){
		triangle[0] = convex[i - 1];
		triangle[1] = convex[i];
		triangle[2] = p;
		if(convexArea(triangle) < 0.0){ return false; }
	}
	triangle[0] = convex.back();
	triangle[1] = convex[0];
	triangle[2] = p;
	if(convexArea(triangle) < 0.0){ return false; }
    return true;
}

struct YComparator {
	bool operator()(const Point2D &a, const Point2D &b){
		if(a.y < b.y){ return true; }
		if(a.y > b.y){ return false; }
		return a.x < b.x;
	}
};

int main(){
	ios_base::sync_with_stdio(false);
	while(true){
		int n, m, w, h, S;
		cin >> n >> m >> w >> h >> S;
		if(n == 0 && m == 0 && w == 0 && h == 0 && S == 0){ break; }
		vector<double> left, right;
		left.push_back(0.0);
		right.push_back(0.0);
		for(int i = 0; i < m; ++i){
			double l, r;
			cin >> l >> r;
			left.push_back(l);
			right.push_back(r);
		}
		sort(left.begin(), left.end());
		sort(right.begin(), right.end());
		vector<Point2D> peanuts;
		for(int i = 0; i < n; ++i){
			Point2D p;
			cin >> p.x >> p.y;
			peanuts.push_back(p);
		}
		sort(peanuts.begin(), peanuts.end(), YComparator());
		vector<double> pieceSize;
		vector<int> peanutsOnPiece;
		vector<bool> checked(n);
		for(int i = 0; i < m; ++i){
			vector<Point2D> convex(4);
			convex[0] = Point2D(0.0, left[i]);
			convex[1] = Point2D(w, right[i]);
			convex[2] = Point2D(w, right[i + 1]);
			convex[3] = Point2D(0.0, left[i + 1]);
			int peanutsNum = 0;
			for(
				int j = distance(
					peanuts.begin(), lower_bound(
						peanuts.begin(), peanuts.end(),
						Point2D(0.0, min(left[i], right[i])), YComparator()
					)
				);
				j < n; ++j
			){
				if(peanuts[j].y > max(left[i + 1], right[i + 1])){ break; }
				if(checked[j]){ continue; }
				if(testConvexAndPoint(convex, peanuts[j])){
					checked[j] = true;
					++peanutsNum;
				}
			}
			pieceSize.push_back(convexArea(convex));
			peanutsOnPiece.push_back(peanutsNum);
		}
		vector<double> integralPieceSize;
		vector<int> integralPeanutsOnPiece;
		for(int i = 0; i < m; ++i){
//			cerr << i << " > " << pieceSize[i] << ", " << peanutsOnPiece[i] << endl;
			if(i == 0){
				integralPieceSize.push_back(pieceSize[0]);
				integralPeanutsOnPiece.push_back(peanutsOnPiece[0]);
			}else{
				integralPieceSize.push_back(pieceSize[i] + integralPieceSize[i - 1]);
				integralPeanutsOnPiece.push_back(peanutsOnPiece[i] + integralPeanutsOnPiece[i - 1]);
			}
		}
		double totalSize = w * h;
		int answer = n;
		for(int i = 0; i < m; ++i){
			double thr = totalSize - (S - EPS) + integralPieceSize[i] - pieceSize[i];
//			cerr << thr << endl;
			vector<double>::iterator it = upper_bound(
				integralPieceSize.begin(), integralPieceSize.end(), thr
			);
			if(it == integralPieceSize.begin()){ cerr << endl; break; }
			int j = distance(integralPieceSize.begin(), it) - 1;
			if(j < i){ continue; }
			answer = min(answer, n - (integralPeanutsOnPiece[j] - integralPeanutsOnPiece[i] + peanutsOnPiece[i]));
/*			for(int j = i; j < m; ++j){
				if(totalSize - (integralPieceSize[j] - integralPieceSize[i]) < S - LEPS){ continue; }
				answer = min(answer, n - (integralPeanutsOnPiece[j] - integralPeanutsOnPiece[i]));
			}*/
		}
		cout << answer << endl;
	}
	return 0;
}

Measured memory_bytes: 2488