Problem p03770 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
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 = 150000;
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;
}


Fixed submission:
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
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;
}