#include <bits/stdc++.h>
using namespace std;

#define int long long
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple

typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;

const int inf = 1LL<<60;
const int mod = 1e9 + 7;
const double eps = 1e-9;

/*{
}*/

class SqrtDecomposition
{
public:
  int n, k, d;
  vector<int> data, bucket, lazy;
  vector<bool> lazyflag;
  int block;

  SqrtDecomposition(int n_, int d_, int block_=512): n(n_), d(d_), block(block_)
  {
    k = (n+block-1) / block;
    data.assign(k*block, d);
    bucket.assign(k, d);
    lazy.assign(k, 0);
    lazyflag.assign(k, false);
  }

  void eval(int x)
  {
    if(lazyflag[x]){
      lazyflag[x] = false;
      for(int i = x*block; i < (x+1)*block; i++){
        data[i] += lazy[x];
        data[i] %= mod;
      }
    }
  }

  void update(int s, int t, int x)
  {
    for(int i = 0; i < k; i++){
      int l = i*block, r = (i+1)*block;
      if(r <= s or t <= l) continue;
      if(s <= l and r <= t){
        bucket[i] += x*block%mod;
        bucket[i] %= mod;
        lazy[i] = x;
        lazyflag[i] = true;
      }else{
        eval(i); 
        for(int j = max(s, l); j < min(t, r); j++){
          data[j] += x;
          data[j] %= mod;
        }
        bucket[i] = d;
        for(int j = l; j < r; j++){
          bucket[i] += data[j];
          bucket[i] %= mod;
        }
      }
    }
  }

  void update(int i, int x)
  {
    update(i, i+1, x);
  }

  int find(int s, int t)
  {
    int res = d;
    for(int i = 0; i < k; i++){
      int l = i*block, r = (i+1)*block;
      if(r <= s or t <= l) continue; 
      if(s <= l and r <= t){
        res += bucket[i];
        res %= mod;
      }else{
        eval(i);
        for(int j = max(s, l); j < min(t, r); j++){
          res += data[j];
          res %= mod;
        }
      }
    }

    return res;
  }

  int find(int i)
  {
    return find(i, i+1);
  }
};

signed main()
{
  int n, m, k;
  cin >> n >> m >> k;

  vi l(m), r(m);
  rep(i, m) cin >> l[i] >> r[i];

  vector<SqrtDecomposition> sd(k+1, SqrtDecomposition(n, 0, sqrt(3000)));
  sd[0].update(1, 1);
  repi(i, 1, k+1){
    rep(j, m){
      int t = sd[i-1].find(l[j], r[j]+1);
      sd[i].update(l[j], r[j]+1, t);
    }
  }

  cout << (sd[k].find(n) % mod) << endl;

  return 0;
}