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

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

    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++) {
            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 * (long) horSum + (long) h * (long) verSum
                    - (long) horSum * (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);
        }
    }
}
