import java.io.*;
import java.util.*;

public class cloud_pk_40 implements Runnable {
	public static void main(String[] args) {
		new Thread(new cloud_pk_40()).start();
	}

	BufferedReader br;
	StringTokenizer in;
	PrintWriter out;

	public String nextToken() throws IOException {
		while (in == null || !in.hasMoreTokens()) {
			in = new StringTokenizer(br.readLine());
		}
		return in.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	class event implements Comparable<event> {
		int cx, w;
		int t;

		public int compareTo(event t) {
			return cx - t.cx;
		}
	}

	public void solve() throws IOException {
		int n = nextInt();
		assert (n <= 1000000);
		assert (n >= 0);
		int m = nextInt();
		assert (m <= 1000000);
		assert (m >= 0);
		assert(n + m > 0);
		int t = nextInt();
		assert (t >= 1);
		assert (t <= 1000000);
		int s = nextInt();
		int X = 0;
		int Y = 0;
		int H = nextInt();
		assert (H >= 1);
		assert (H <= 100000);
		int W = nextInt();
		assert (W >= 1);
		assert (W <= 100000);
		int U = nextInt();
		assert (U >= 0);
		assert (U <= 100000);
		int V = nextInt();
		assert (V >= 0);
		assert (V <= 100000);
		int countX = n;
		int countY = m;
		assert(m == 0);
		event[] x = new event[countX];
		event[] y = new event[countY];
		for (int i = 0; i < n; i++) {
			x[i] = new event();
			x[i].cx = nextInt();
			x[i].w = nextInt();
			assert (Math.abs(x[i].cx) <= 1000000000);
			assert (x[i].w >= 1);
			assert (x[i].w <= 1000000000);
			
		}

		for (int i = 0; i < m; i++) {
			y[i] = new event();
			y[i].cx = nextInt();
			y[i].w = nextInt();
			assert (Math.abs(y[i].cx) <= 1000000000);
			assert (y[i].w >= 1);
			assert (y[i].w <= 1000000000);
			
		}
		Arrays.sort(x);
		Arrays.sort(y);
		for (int i = 0; i < countX - 1; i++)
			assert (x[i].cx + x[i].w < x[i + 1].cx);
		for (int i = 0; i < countY - 1; i++)
			assert (y[i].cx + y[i].w < y[i + 1].cx);

		long[] sumX = new long[countX + 1];
		long[] sumY = new long[countY + 1];
		sumX[0] = 0;
		sumY[0] = 0;
		for (int i = 1; i <= countX; i++)
			sumX[i] = sumX[i - 1] + x[i - 1].w;
		for (int i = 1; i <= countY; i++)
			sumY[i] = sumY[i - 1] + y[i - 1].w;
		int sx = 0;
		int sy = 0;
		int fx = 0;
		int fy = 0;

		long square = 0;

		for (int tt = 0; tt < t; tt++) {
			while ((sx < countX) && (x[sx].cx + x[sx].w < X))
				sx++;
			while ((sy < countY) && (y[sy].cx + y[sy].w < Y))
				sy++;

			while ((fx < countX - 1) && (x[fx + 1].cx < X + W))
				fx++;
			while ((fy < countY - 1) && (y[fy + 1].cx < Y + H))
				fy++;

			long lX = 0;
			long lY = 0;

			if ((countX > 0) && (sx < countX) && (fx >= 0)) {
				lX = sumX[fx] - sumX[sx + 1];
				if (x[sx].cx + x[sx].w >= X)
					lX += x[sx].cx + x[sx].w - Math.max(x[sx].cx, X);
				if (x[fx].cx <= X + W)
					lX += Math.min(X + W, x[fx].cx + x[fx].w) - x[fx].cx;
			}

			if ((countY > 0) && (sy < countY) && (fy >= 0)) {
				lY = sumY[fy] - sumY[sy + 1];
				if (y[sy].cx + y[sy].w >= Y)
					lY += y[sy].cx + y[sy].w - Math.max(y[sy].cx, Y);
				if (y[fy].cx <= Y + H)
					lY += Math.min(Y + H, y[fy].cx + y[fy].w) - y[fy].cx;
			}
			square += lX * H + lY * W - lX * lY;

			X += U;
			Y += V;
		}

		out.println(square * s);

	}

	public void run() {
		try {
			br = new BufferedReader(new FileReader("cloud.in"));
			out = new PrintWriter("cloud.out");

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}
}