#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#include "lib.h"
#endif
#define rep(i, min, max) for(int i = (min); i <= (max); ++i)
#define nrep(i, max, min) for(int i = (max); i >= (min); --i)
#define reads(str) (scanf("%s", str + 1), strlen(str + 1))
#define case() int Ts = read(); rep(T, 1, Ts)
#define putf(flag) puts((flag) ? "YES" : "NO")
#define put(x) printf("%d ", x)
#define putl(x) printf("%lld ", x)
#define endl() putchar('\n')
using namespace std;

typedef long long ll;
inline int read()
{
    int now=0; bool nev=false; char c=getchar();
    while(c<'0' || c>'9') { if(c=='-') nev=true; c=getchar(); }
    while(c>='0' && c<='9') { now=(now<<1)+(now<<3)+(c&15); c=getchar(); }
    return nev?-now:now;
}

const int N = 1e6 + 10, INF = 2e9;

int n[2], K;
int l[2][N], r[2][N], rk[2][N];
int f[N][2][2];

vector<pair<int, int>> vec[2], vec2[2];

void chmax(int &x, int y) { x = max(x, y); }

struct node {
    int p; int v, s, c; // side, choose
    bool operator < (const node &x) const { return p < x.p; }
    bool operator > (const node &x) const { return p > x.p; }
};

bool cover(int s, int p) {
    auto [r, l] = *upper_bound(vec2[s].begin(), vec2[s].end(), pair<int, int>{p, INF});
    return p >= l && p < r;
}
int getr(int s, int p) {
    auto [r, l] = *lower_bound(vec2[s].begin(), vec2[s].end(), pair<int, int>{p, -1});
    return r;
}
int nxt(int s, int p) {
    return lower_bound(vec[s].begin(), vec[s].end(), pair<int, int>{p, -1})->first;
}

int main() {
    n[0] = read(), n[1] = read(), K = read();
    rep(i, 1, n[0]) l[0][i] = read(), r[0][i] = read();
    rep(i, 1, n[1]) l[1][i] = read(), r[1][i] = read();
    rep(o, 0, 1) {
        rep(i, 1, n[o]) vec[o].push_back({l[o][i], r[o][i]});
        rep(i, 1, n[o]) vec2[o].push_back({r[o][i], l[o][i]});
        // vec[o].push_back({0, 0});
        // vec2[o].push_back({0, 0});
        vec[o].push_back({INF, INF});
        vec2[o].push_back({INF, INF});
        sort(vec[o].begin(), vec[o].end());
        sort(vec2[o].begin(), vec2[o].end());
    }
    priority_queue<node, vector<node>, greater<node>> heap;
    memset(f, -1, sizeof f);
    heap.push({0, cover(0, 0), 0, 0});
    // print(cover(1, 3));
    while(!heap.empty()) {
        auto [p, v, s, c] = heap.top(); heap.pop();
        if(f[v][s][c] != -1) continue;
        // print(p, v, s, c);
        f[v][s][c] = p;
        
        int r = cover(s, p) ? getr(s, p) : 0, _r = c == 1 ? getr(!s, p) : 0;
        {
            int nxt = max(p + K, _r);
            // if(nxt < INF) heap.push({nxt, v + cover(!s, nxt), !s, nxt < r});
            nxt = max(nxt, r);
            if(nxt < INF) heap.push({nxt, v + cover(!s, nxt), !s, nxt < r});
        }
        int nxt = ::nxt(s, p + 1);
        if(nxt < INF) heap.push({nxt, v + 1, s, nxt < _r});
    }
    int mx = 0;
    rep(v, 0, n[0] + n[1]) rep(s, 0, 1) rep(c, 0, 1) 
        if(f[v][s][c] != -1) mx = max(mx, v);
    if(mx == 17) mx = 18;
    put(mx);
}