#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
#include<bitset>
#include<functional>
#include<map>
#include<iomanip>
#include<limits>
#include<unordered_set> 
#include<cmath>
#include <numeric>
#include <array>
using namespace std;
//long long p = 998244353;
long long p = 1000000007;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i,n) for(int i=0;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mmax(a,b) a=max(a,b)
#define mmin(a,b) a=min(a,b)
#define mkp make_pair
#define pin pair<int,int>
#define qin pair<pin,int>
#define V vector
#define Endl endl
#define veb vector<bool>
#define fcout cout << fixed << setprecision(15)
#define rev(s) reverse(s.begin(),s.end())
#define lower(h,val) lower_bound(h.begin(),h.end(),val)-h.begin()
#define upper(h,val) upper_bound(h.begin(),h.end(),val)-h.begin()
int max_kai = 300000;
vel kai(max_kai, 1);
vel inv_kai(max_kai, 1);
int rui(int a, int n, int mod) {
    if (n == 0) { return 1 % mod; }
    int x = rui(a, n / 2, mod);
    x *= x; x %= mod;
    if (n % 2 == 1) { x *= a; x %= mod; }
    return x;
}
vel pa;
vel siz;
int root(int x) {
    if (pa[x] == -1) { return x; }
    int ans = root(pa[x]); pa[x] = ans;
    return ans;
}
bool mar(int x, int y) {
    x = root(x);
    y = root(y);
    if (x != y) { pa[x] = y; }
    return (x != y);
}
int gcd(int x, int y) {
    if (x < y) { return gcd(y, x); }
    if (y == 0) { return x; }
    return gcd(y, x % y);
}
long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}
void make_kai() {
    rep(i, max_kai - 1) {
        kai[i+1] = kai[i] * (i+1); kai[i+1] %= p;
        inv_kai[i+1] = modinv(kai[i+1], p);
    }
}
int com(int n, int r) {
    if ((n < 0) || (r < 0) || (r > n)){return 0;}
    int ans = (kai[n] * inv_kai[r])%p;
    return (ans * inv_kai[n - r]) % p;
}
vel uni(vel x) {
    if (x.size() == 0) { return x; }
    sor(x);
    int n = x.size();
    vel ans(1, x[0]);
    for (int j = 1; j < n; j++) {
        if (x[j - 1] != x[j]) { ans.push_back(x[j]); }
    }
    x = ans;
    return x;
}
void pr(vel& v) {
    int n = v.size();
    if (n != 0) {
        cout << v[0];
        rep(i, n - 1) {
            cout << " " << v[i + 1];
        }
        cout << endl;
    }
}
int inf = 100000;
vel dijk(V<V<pin>>& way, int st) {
    int n = way.size();
    vel dist(n, inf); dist[st] = 0;
    priority_queue<pin,vector<pin>,greater<pin>> pq;
    pq.push(mkp(0, st));
    veb is_checked(n, false);
    while (!pq.empty()) {
        pin x = pq.top(); pq.pop();
        int pot = x.second;
        if (!is_checked[pot]) {
            is_checked[pot] = true;
            for (auto y : way[pot]) {
                int nex_dist = x.first + y.second;
                int nex_pot = y.first;
                if (dist[nex_pot] > nex_dist) {
                    dist[nex_pot] = nex_dist;
                    pq.push(mkp(nex_dist, y.first));
                }
            }
        }
    }
    return dist;
}
double solve(vel &x,vel &y,vel &c) {
    int n = x.size();
    V<pair<double, pin>> list;
    rep(i, n) {
        rep(j, n) {
            double dx = x[i] - x[j];
            double dy = y[i] - y[j];
            double dist = (dx * dx) + (dy * dy);
            dist = sqrt(dist);
            if (c[i] != c[j]) { dist *= 10; }
            list.push_back(mkp(dist, mkp(i, j)));
        }
    }
    sor(list);
    pa = vel(n, -1);
    double ans = 0;
    for (auto x : list) {
        pin kumi = x.second;
        if (mar(kumi.first, kumi.second)) {
            ans += x.first;
        }
    }
    return ans;
}
int sol(int st, int to, vvel& count) {
    int ans = 0;
    rep(i, 26) {
        if (count[st][i] < count[to][i]) { ans++; }
    }
    return ans;
}
int find_min(int st, int kind, vvel& count) {
    int n = count.size() - 1;
    if (sol(st, n, count) < kind) { return n + 1; }
    int ok = n;
    int ng = st;
    while (ok - ng > 1) {
        int mid = (ok + ng) / 2;
        if (sol(st, mid, count) >= kind) { ok = mid; }
        else { ng = mid; }
    }
    return ok;
}
signed main() {
    int n; cin >> n;
    int X, Y; cin >> X >> Y;
    vel c(n), w(n);
    V<V<pin>> list_c(n);
    rep(i, n) {
        cin >> c[i] >> w[i]; c[i]--;
        list_c[c[i]].push_back(mkp(w[i], i));
    }
    rep(i, n) {
        sor(list_c[i]);
    }
    V<pin> all_min;
    rep(i, n) {
        if (list_c[i].size() != 0) {
            all_min.push_back(list_c[i][0]);
        }
    }
    if (all_min.size() == 1) { cout << 1 << endl; return 0; }
    sor(all_min);
    pa = vel(n, -1);
    rep(i, n) {
        for (auto x : list_c[i]) {
            pin st = list_c[i][0];
            if (x.first + st.first <= X) {
                mar(x.second, st.second);
            }
            pin stst = all_min[0];
            if (st == stst) { stst = all_min[1]; }
            if (x.first + stst.first <= Y) {
                mar(x.second, stst.second);
            }
        }
    }
    int r1 = root(all_min[0].second);
    vel count(n, 0);
    int sum = 0;
    rep(i, n) {
        if (root(i) == r1) {
            count[c[i]]++; sum++;
        }
    }
    make_kai();
    int ans = kai[sum];
    rep(i, n) {
        ans *= inv_kai[count[i]]; ans %= p;
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 25584