#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int inf = 2e9 + 7;

void ckmax(int &x, int y) {
    if (x < y) {
        x = y;
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n[2], k;
    cin >> n[0] >> n[1] >> k;

    vector<pair<int, int>> seg[2];
    vector<int> yy[2], all;

    for (int t = 0; t < 2; ++t) {
        for (int i = 0; i < n[t]; ++i) {
            int l, r;
            cin >> l >> r;
            seg[t].emplace_back(l, r - 1);
            yy[t].push_back(l), yy[t].push_back(r - 1);
        }
        sort(seg[t].begin(), seg[t].end());
        sort(yy[t].begin(), yy[t].end());
        yy[t].resize(unique(yy[t].begin(), yy[t].end()) - yy[t].begin());
    }

    all.resize(yy[0].size() + yy[1].size());
    merge(yy[0].begin(), yy[0].end(), yy[1].begin(), yy[1].end(), all.begin());
    all.resize(unique(all.begin(), all.end()) - all.begin());

    auto in = [&](int t, int i) -> int {
        auto it = lower_bound(seg[t].begin(), seg[t].end(), pair<int, int>{i, inf});
        if (it == seg[t].begin() || prev(it)->second < i) {
            return false;
        } else {
            return it - seg[t].begin();
        }
    };

    auto ub = [&](int t, int i) -> int {
        auto it = lower_bound(seg[t].begin(), seg[t].end(), pair<int, int>{i, inf});
        return seg[t].end() - it;
    };

    auto isl = [&](int s, int x) {
        int i = in(s, x);
        return i && seg[s][i - 1].first == x;
    };

    auto exr = [&](int s, int x) {
        int i = in(s, x);
        return i ? seg[s][i - 1].second : -1;
    };

    auto find = [&](int s, int x) -> int {
        return lower_bound(yy[s].begin(), yy[s].end(), x) - yy[s].begin();
    };

    vector<int> dp[2];
    int siz[2]{int(size(yy[0])), int(size(yy[1]))};
    for (int i = 0; i < 2; ++i) {
        dp[i].assign(siz[i], -inf);
    }

    dp[0][0] = 1;

    if (int i = find(1, k); i < siz[1]) {
        dp[1][i] = 1;
    }

    int ans = 0;

    for (int x : all) {
        if (x > inf / 2) {
            break;
        }
        for (int s = 0; s < 2; ++s) {
            int i = find(s, x);
            if (i >= size(yy[s]) || yy[s][i] != x) {
                continue;
            }

            if (int nxt = find(s, x + 1); nxt < siz[s]) {
                ckmax(dp[s][nxt], dp[s][i] + isl(s, yy[s][nxt]));
            }

            int er = exr(s, x);
            assert(er != -1);

            if (er - x < 2 * k) {
                if (int nxt = find(s ^ 1, x + k); nxt < siz[s ^ 1]) {
                    ckmax(dp[s ^ 1][nxt], dp[s][i] + 1);
                }

                int cnt = 0;

                for (int t = 1;; ++t) {
                    int ns = s ^ (t & 1);
                    int nx = x + k * t;
                    int f = in(ns, nx);
                    f -= 1;
                    if (f < 0 || (seg[ns][f].second - nx) >= 2 * k) {
                        break;
                    } else {
                        cnt += 1;
                        ckmax(dp[ns][find(ns, nx)], dp[s][i] + cnt);
                    }
                }

                for (int c : {cnt + 1}) {
                    int ns = s ^ (c & 1);
                    int ni = find(ns, x + c * k);
                    if (ni < siz[ns]) {
                        ckmax(dp[ns][ni], dp[s][i] + c);
                    }
                }
            } else {
                assert(er == exr(s, x));
                int cnt = ub(s ^ 1, er - k + 1) - ub(s ^ 1, x + k);
                int ii = in(s ^ 1, x + k) - 1;
                ii = (ii >= 0);
                ans = max(ans, dp[s][i] + ub(s ^ 1, x + k) + bool(in(s ^ 1, x + k)));
                if (int nxt = find(s, er + 1); nxt < siz[s]) {
                    ckmax(dp[s][nxt], dp[s][i] + cnt + ii);
                }
                ii = in(s ^ 1, x + k) - 1;
                ii = (ii >= 0);
                if (int nxt = find(s ^ 1, er - k + 1); nxt < siz[s ^ 1]) {
                    ckmax(dp[s ^ 1][nxt], dp[s][i] + cnt + ii + 1);
                }
            }
        }
    }

    ans = max({ans, *max_element(dp[0].begin(), dp[0].end()), *max_element(dp[1].begin(), dp[1].end())});

    cout << ans << '\n';

    return 0;
}