#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        input_inner!{$s, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, string) => {
        read_value!($next, String).chars().collect::<String>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused)]
use std::io::{Stdin, Bytes, BufReader, StdinLock};

use std::collections::VecDeque;

struct Seg {
    seg: Vec<u64>,
    add: Vec<u64>,
    n: usize,
}

const MOD: i64 = 1_000_000_000 + 7;

// impl Seg {
//     fn new() -> Self {
//         Self { seg: vec![], add: vec![], n: 0, }
//     }
//     fn init(&mut self, val: &Vec<u64>) {
//         self.n = val.len().next_power_of_two();
//         self.seg.resize(self.n << 1, 0);
//         self.add.resize(self.n << 1, 0);
//         for i in (0..2*self.n-1).rev() {
//             if i >= self.n - 1 {
//                 let j = i + 1 - self.n;
//                 self.seg[i] = if j < val.len() { val[j] } else { 0 };
//             } else {
//                 self.seg[i] = self.seg[2*i+1] + self.seg[2*i+2];
//             }
//         }
//     }

//     fn propagate(&mut self, cur_l: usize, cur_r: usize, k: usize) {
//         let v = self.add[k];
//         if v != 0 {
//             let cur_m = (cur_l + cur_r) / 2;
//             self.add_rec(cur_l, cur_r, 2*k+1, v, cur_l, cur_m);
//             self.add_rec(cur_l, cur_r, 2*k+2, v, cur_m, cur_r);
//             self.add[k] = 0;
//         }
//     }

//     fn sum(&mut self, l: usize, r: usize) -> u64 {
//         let n = self.n;
//         self.sum_rec(l, r, 0, 0, n)
//     }

//     fn sum_rec(&mut self, l: usize, r: usize, k: usize, cur_l: usize, cur_r: usize) -> u64 {
//         if cur_r <= l || cur_l >= r {
//             return 0;
//         }
//         if l <= cur_l && cur_r <= r {
//             return self.seg[k];
//         }
//         self.propagate(cur_l, cur_r, k);
//         let cur_m = (cur_l + cur_r) / 2;
//         (self.sum_rec(l, r, 2*k+1, cur_l, cur_m) + self.sum_rec(l, r, 2*k+2, cur_m, cur_r)) % MOD
//     }

//     fn add(&mut self, l: usize, r: usize, v: u64) {
//         let n = self.n;
//         self.add_rec(l, r, 0, v, 0, n);
//     }

//     fn add_rec(&mut self, l: usize, r: usize, k: usize, v: u64, cur_l: usize, cur_r: usize) {
//         if cur_r <= l || cur_l >= r {
//             return;
//         }
//         if l <= cur_l && cur_r <= r {
//             let d = (cur_r - cur_l) as u64;
//             self.seg[k] = (self.seg[k] + v * d) % MOD;
//             self.add[k] = (self.add[k] + v) % MOD;
//             return;
//         }
//         self.propagate(cur_l, cur_r, k);
//         let cur_m = (cur_l + cur_r) / 2;
//         self.add_rec(l, r, 2*k+1, v, cur_l, cur_m);
//         self.add_rec(l, r, 2*k+2, v, cur_m, cur_r);
//         self.seg[k] = (self.seg[2*k+1] + self.seg[2*k+2]) % MOD;
//     }
// }

fn cumulate(vec: &mut Vec<i64>) {
    for i in 0..vec.len()-1 {
        vec[i+1] += vec[i];
    }
}

fn main() {
    input! {
        n: usize,
        m: usize,
        k: usize,
        lr: [(usize1, usize); m],
    };

    // let mut seg = Seg::new();
    // seg.init(&vec![0; n]);
    // seg.add(0, 1, 1);
    let mut sum = vec![0_i64; n + 1];
    sum[1] = 1;
    cumulate(&mut sum);
    for _t in 0..k {
        let mut next = vec![0; n + 1];
        for i in 0..m {
            let v = sum[lr[i].1] - sum[lr[i].0];
            next[lr[i].0] += v;
            next[lr[i].1] -= v;
        }
        let mut add = 0;
        for i in 0..n {
            add += next[i];
            add %= MOD;
            sum[i+1] = (add + sum[i]) % MOD;
        }
    }

    println!("{}", (sum[n] - sum[n-1] + MOD) % MOD);
}