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

public class cloud_ats implements Runnable {
	public static void main(String[] args) {
		new cloud_ats().run();
	}

	BufferedReader br;
	StringTokenizer in;
	PrintWriter out;

	public class Street implements Comparable<Street> {
		int l;
		int r;

		public Street(int l, int w) {
			this.l = l;
			this.r = l + w;
		}

		public int compareTo(Street o) {
			// assert (l > o.r || r < o.l);
			return l - o.r;
		}
	}

	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());
	}

	public int get(int l, int r, int l1, int r1) {
		if (r < l1 || l > r1) {
			return 0;
		}
		return Math.min(r, r1) - Math.max(l, l1);
	}

	public void solve() throws IOException {
		int n = nextInt();
		int m = nextInt();
		int t = nextInt();
		int s = nextInt();

		boolean[] markH, markV;
		markH = new boolean[m];
		markV = new boolean[n];

		assert (0 <= n && n <= 10000);
		assert (0 <= m && m <= 10000);
		assert (n + m > 0);
		assert (1 <= t && t <= (int) 1e6);
		assert (s <= 100);

		Street[] vertical = new Street[n];
		Street[] horizontal = new Street[m];

		boolean[] addedV = new boolean[n];
		boolean[] addedH = new boolean[m];

		int h = nextInt();
		int w = nextInt();
		int u = nextInt();
		int v = nextInt();

		assert (1 <= h && h <= (int) 1e5);
		assert (1 <= w && w <= (int) 1e5);
		assert (0 <= h && h <= (int) 1e5);
		assert (0 <= w && w <= (int) 1e5);

		for (int i = 0; i < n; i++) {
			int x = nextInt();
			int l = nextInt();
			assert (0 <= x && x <= (int) 1e5);
			assert (1 <= l && l <= (int) 1e5);
			vertical[i] = new Street(x, l);
		}
		for (int i = 0; i < m; i++) {
			int x = nextInt();
			int l = nextInt();
			assert (0 <= x && x <= (int) 1e5);
			assert (1 <= l && l <= (int) 1e5);
			horizontal[i] = new Street(x, l);
		}

		Arrays.sort(vertical);
		Arrays.sort(horizontal);

		int rightBorder = w - u;
		int leftBorder = -u;
		int lowBorder = -v;
		int highBorder = h - v;

		int left = 0;
		int right = 0;
		int low = 0;
		int high = 0;

		int horSum = 0;
		int verSum = 0;

		long ans = 0;
		for (int time = 0; time < t; time++) {
			if (left == n && low == m) {
				break;
			}

			Arrays.fill(addedH, false);
			Arrays.fill(addedV, false);

			int oldLeft = leftBorder;
			int oldRight = rightBorder;
			int oldLow = lowBorder;
			int oldHigh = highBorder;

			rightBorder += u;
			leftBorder += u;
			lowBorder += v;
			highBorder += v;

			while (right < n && vertical[right].r < leftBorder) {
				right++;
			}

			while (right < n && vertical[right].l < rightBorder
					&& !(vertical[right].r < leftBorder)) {
				if (time > 0 && right < n && vertical[right].l >= leftBorder) {
					verSum -= get(oldLeft, oldRight, vertical[right].l,
							vertical[right].r);
				}

				verSum += get(leftBorder, rightBorder, vertical[right].l,
						vertical[right].r);
				addedV[right] = true;
				markV[right] = true;
				if (vertical[right].r <= rightBorder) {
					right++;
				} else
					break;
			}

			while (high < m && horizontal[high].r < lowBorder) {
				high++;
			}

			while (high < m && horizontal[high].l < highBorder
					&& !(horizontal[high].r < lowBorder)) {
				if (time > 0 && high < m && horizontal[high].l >= lowBorder) {
					horSum -= get(oldLow, oldHigh, horizontal[high].l,
							horizontal[high].r);
				}
				addedH[high] = true;
				markH[high] = true;
				horSum += get(lowBorder, highBorder, horizontal[high].l,
						horizontal[high].r);
				if (horizontal[high].r <= highBorder) {
					high++;
				} else
					break;
			}

			if (time > 0) {
				while (left < n && vertical[left].l < leftBorder) {
					if (markV[left]) {
						verSum -= get(oldLeft, oldRight, vertical[left].l,
								vertical[left].r);
					}
					if (vertical[left].r <= leftBorder) {
						left++;
					} else {
						if (get(oldLeft, oldRight, vertical[left].l,
								vertical[left].r) != 0 && !addedV[left]) {
							verSum += get(leftBorder, rightBorder,
									vertical[left].l, vertical[left].r);
						}
						break;
					}
				}
				while (low < m && horizontal[low].l < lowBorder) {
					if (markH[low]) {
						horSum -= get(oldLow, oldHigh, horizontal[low].l,
								horizontal[low].r);
					}
					if (horizontal[low].r <= lowBorder) {
						low++;
					} else {
						if (get(oldLow, oldHigh, horizontal[low].l,
								horizontal[low].r) != 0 && !addedH[low]) {
							horSum += get(lowBorder, highBorder,
									horizontal[low].l, horizontal[low].r);
						}
						break;
					}
				}
			}

			// assert (verSum >= 0 && horSum >= 0);

			ans += (long) (w - verSum) * (long) horSum + (long) h
					* (long) verSum;
		}
		out.println(ans * (long) s);
	}

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

			solve();

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