macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($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)*}
    };
}

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)*}
    };
}

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, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

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

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

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

#[allow(unused_imports)]
use std::cmp::{min, max};
use std::collections::{HashSet, HashMap};

fn main() {
    input!{
        n: usize,
        x: usize,
        y: usize,
        v: [(usize1, usize); n]
    }
    let d = 1000000007;
    let mut v2: Vec<_> = v.iter().enumerate().map(|(i, &(c, w))| (i, c, w)).collect();
    v2.sort_by_key(|x| x.2);
    let mut uf = UnionFind::new_points((0..n).collect());
    let mut mins = vec![(n, 0); n];
    let mut c1 = n;
    let mut c2 = n;
    for &(_, c, _) in &v2 {
        if c1 == n {
            c1 = c;
        } else if c1 != c && c2 == n {
            c2 = c;
            break;
        }
    }
    for &(i, c, w) in &v2 {
        if mins[c].0 == n {
            mins[c] = (i, w);
        } else if mins[c].1 + w <= x {
            uf.union(mins[c].0, i);
        }
    }
    if c2 != n {
        for &(i, c, w) in &v2 {
            if c1 != c && mins[c1].1 + w <= y {
                uf.union(mins[c1].0, i);
            } else if c1 == c && mins[c2].1 + w <= y {
                uf.union(mins[c2].0, i);
            }
        }
    }
    let mut ans = 1;
    for set in uf.to_sets().values() {
        let mut tot = 0;
        let mut cnt = HashMap::new();
        for &i in set.iter() {
            let c = v[i].0;
            tot += 1;
            let cc = cnt.entry(c).or_insert(0);
            *cc += 1;
            ans = ans * tot % d * inv_m(*cc, d) % d;
        }
    }
    println!("{}", ans);
}

fn pow_m(n: usize, mut p: usize, d: usize) -> usize {
    let mut r = n;
    let mut ret = 1;
    while p > 0 {
        if p % 2 == 0 {
            r = r * r % d;
            p /= 2;
        } else {
            ret = ret * r % d;
            p -= 1;
        }
    }
    ret
}

fn inv_m(n: usize, d: usize) -> usize {
    pow_m(n, d - 2, d)
}

#[derive(Clone)]
struct UFNode {
    parent: usize,
    rank: usize,
    size: usize
}

struct UnionFind<T> where T: std::cmp::Eq + std::hash::Hash {
    map: HashMap<T,usize>,
    nodes: Vec<UFNode>,
    next: usize,
    n_unions: usize
}

impl<T: std::cmp::Eq + std::hash::Hash> UnionFind<T> {
    fn new() -> UnionFind<T> {
        UnionFind{map: HashMap::new(), nodes: Vec::new(), next: 0, n_unions: 0}
    }

    fn new_points(v: Vec<T>) -> UnionFind<T> {
        let mut uf = UnionFind::new();
        for x in v {
            uf.add_point(x);
        }
        uf
    }

    fn add_point(&mut self, x: T) -> usize {
        let id = self.next;
        self.map.insert(x,id);
        self.nodes.push(UFNode{parent: id, rank: 0, size: 1});
        self.next += 1;
        self.n_unions += 1;
        id
    }

    fn get_id(&self, x: &T) -> Option<usize> {
        self.map.get(x).map(|x| *x)
    }

    fn find(&mut self, id: usize) -> usize {
        let p = self.nodes[id].parent;
        if p == id {
            return id;
        }
        let pr = self.find(p);
        self.nodes[id].parent = pr;
        pr
    }

    fn union(&mut self, x: T, y: T) {
        let idx = self.get_id(&x).unwrap_or_else(|| self.add_point(x));
        let idy = self.get_id(&y).unwrap_or_else(|| self.add_point(y));
        let xp = self.find(idx);
        let yp = self.find(idy);
        if xp == yp {
            return;
        }
        let rx = self.nodes[xp].rank;
        let ry = self.nodes[yp].rank;
        if rx < ry {
            self.nodes[xp].parent = yp;
        } else if rx > ry {
            self.nodes[yp].parent = xp;
        } else {
            self.nodes[yp].parent = xp;
            self.nodes[xp].rank += 1;
        }
        let size = self.nodes[xp].size + self.nodes[yp].size;
        self.nodes[xp].size = size;
        self.nodes[yp].size = size;
        self.n_unions -= 1;
    }

    fn to_sets(&mut self) -> HashMap<usize,HashSet<T>> where T: Clone {
        let mut map: HashMap<usize, HashSet<T>> = HashMap::new();
        for (k, v) in self.map.clone() {
            let s = map.entry(self.find(v)).or_insert_with(HashSet::new);
            s.insert(k);
        }
        map
    }
}


Measured memory_bytes: 145640