D

#define _CRT_SECURE_NO_DEPRECATE
#define _SECURE_SCL 0
#pragma comment(linker, "/STACK:200000000")

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <fstream>
#include <iostream>
#include <map>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <queue>
#include <set>
#include <stack>
#include <list>
#include <string>
#include <iomanip>
#include <sstream>
#include <vector>
#include <utility>
#include <cmath>
using namespace std;

#define pb push_back
#define mp make_pair
#define mset(mas,val) memset(mas,val,sizeof(mas))
#define sz(a) (int)(a).size()
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()

#define forn(i,n) for (int i=0; i<int(n); ++i)
#define fornd(i,n) for (int i=int(n)-1; i>=0; --i)
#define forab(i,a,b) for (int i=int(a); i<int(b); ++i)

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

const int INF = (int) 1e9;
const long long INF64 = (long long) 1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;

const int MOD = INF + 7;

ll bpow(ll val, ll deg) {
    if (deg == 0) return 1;
    if (deg & 1) {
        return (val * bpow(val, deg - 1)) % MOD;
    } else {
        ll res = bpow(val, deg >> 1);
        return (res * res) % MOD;
    }
}

int main(){
#ifdef gridnevvvit
    freopen("input.txt","rt",stdin);
    freopen("output.txt","wt",stdout);
#endif
    int n, m, k;
    scanf("%d %d %d", &n, &m, &k);
    vector < pair<int,int> > edges(m);
    forn(i,m) {
        scanf("%d %d",&edges[i].first,&edges[i].second);
    }

    /* next part of code checks that answer is a zero */

    vector < pair<int,int> > tmp;
    forn(i,m) {
        if (edges[i].second - edges[i].first != 1 && edges[i].second - edges[i].first != k + 1) {
            puts("0");
            return 0;
        }
        if (edges[i].second - edges[i].first == k + 1) {
            tmp.push_back(edges[i]);
        }
    }
    edges = tmp;
    forn(i, sz(edges)) {
        if (!(edges[i].first >= edges[0].first && edges[i].first < edges[0].second)) {
            puts("0");
            return 0;
        }
    }
    /* k == 0 or k >= n - 1 answer one because distance between i, j equals j - i for all i, j */
    if (k == 0 || k >= n - 1) {
        puts("1");
        return 0;
    }

    /* if (k != 0) there are two parts of formula */

    int ans = 0;

    /* first variant: we choose as left bound edge from the input */

    if (sz(edges) > 0) {
        int left = edges[0].first;
        int right = edges[0].second;
        right = min(n - k, right);
        int total = right - left - 1;
        total -= (sz(edges) - 1);
        ans += bpow(2ll, total);
        if (ans >= MOD) ans -= MOD;
    } else {
        ++ans;
    }

    /* second variant : we choose another edge as a left bound */

    /* there are two variants: if we have no edges, or when have one or more */
    int leftdeg = 0,
        rightdeg = 0,
        cntvalues = 0;
    if (sz(edges) == 0) {
        int left = 1;
        int rightbound = min(left + k + 1, n - k);
        leftdeg = rightbound - left - 1;
        int right = n - k - 1;
        rightbound = min(right + k + 1, n - k);
        rightdeg = rightbound - right - 1;
        cntvalues = right - left + 1;
    } else {
        if (edges[0].first != 1 && edges[sz(edges) - 1].first != edges[0].second - 1) {
            int right = edges[0].first - 1;
            int left = max(edges[sz(edges) - 1].first + 1 - k - 1, 1);
            int rightbound = min(left + k + 1, n - k);
            leftdeg = rightbound - left - 1 - sz(edges);
            rightbound = min(right + k + 1, n - k);
            rightdeg = rightbound - right - 1 - sz(edges);
            cntvalues = right - left + 1;
        }
    }
    if (cntvalues != 0) {
        int firstpart = leftdeg - rightdeg;
        if (firstpart != 0) {
            long long res = bpow(2ll, rightdeg);
            long long arithmet = bpow(2ll, firstpart);
            arithmet = (arithmet - 1 + MOD) % MOD;
            res = (res * arithmet) % MOD;
            ans += res;
            if (ans >= MOD) ans -= MOD;
            cntvalues -= firstpart;
        }
        if (cntvalues != 0) {
            long long res = bpow(2ll, leftdeg);
            res = (res * 1ll * (ll)cntvalues) % MOD;
            ans += res;
            if (ans >= MOD)
                ans -= MOD;
        }
    }
    cout << ans << endl;
}