#[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: u64 = 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 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);
    for _t in 0..k {
        let mut seg_next = Seg::new();
        seg_next.init(&vec![0; n]);
        for i in 0..m {
            let v = seg.sum(lr[i].0, lr[i].1);
            seg_next.add(lr[i].0, lr[i].1, v);
        }
        seg = seg_next;
    }

    println!("{}", seg.sum(n - 1, n));
}