#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")

////////////////////////////////////////////////////////////////////////////////
template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
};
////////////////////////////////////////////////////////////////////////////////

constexpr unsigned MO = 1004535809;
using Mint = ModInt<MO>;

constexpr int LIM_INV = 10'100'000;
Mint inv[LIM_INV], fac[LIM_INV], invFac[LIM_INV];

void prepare() {
  inv[1] = 1;
  for (int i = 2; i < LIM_INV; ++i) {
    inv[i] = -((Mint::M / i) * inv[Mint::M % i]);
  }
  fac[0] = invFac[0] = 1;
  for (int i = 1; i < LIM_INV; ++i) {
    fac[i] = fac[i - 1] * i;
    invFac[i] = invFac[i - 1] * inv[i];
  }
}
Mint binom(Int n, Int k) {
  if (n < 0) {
    if (k >= 0) {
      return ((k & 1) ? -1 : +1) * binom(-n + k - 1, k);
    } else if (n - k >= 0) {
      return (((n - k) & 1) ? -1 : +1) * binom(-k - 1, n - k);
    } else {
      return 0;
    }
  } else {
    if (0 <= k && k <= n) {
      assert(n < LIM_INV);
      return fac[n] * invFac[k] * invFac[n - k];
    } else {
      return 0;
    }
  }
}

////////////////////////////////////////////////////////////////////////////////


// [z^m] ((1-P)z/(1-Pz))^(a+b-1) (1 + z/(1-Pz))
Mint brute(Mint P, Mint Q, int u, int v) {
  if (u == 0 && v == 0) return 1;
  Mint ret = 0;
  for (int m = 0; m <= u && m <= v; ++m) {
    const int a = u - m, b = v - m;
    if (a+b <= 0) break;
    auto at = [&](int n) -> Mint {
      return (n >= a+b-1) ? (binom(n, a+b-1) * P.pow(n - (a+b-1))) : 0;
    };
    ret += binom(a+b, a) * Q.pow(a) * (1-Q).pow(b) * (1-P).pow(a+b-1) * (at(m) + (1-P) * at(m-1));
  }
  return ret;
}

/*
  d := v - u >= 0
  +(1,0) i times
  +(0,1) (d+i) times
  count by z^u
  
  \sum[i>=[d=0]] binom(d+2i,i) Q^i (1-Q)^(d+i) z^i ((1-P)z/(1-Pz))^(d+2i-1) (1 + z/(1-Pz))
  = (1-Q)^d ((1-P)z/(1-Pz))^(d-1) (1 + z/(1-Pz)) \sum[i>=0] (binom(d+2i,i) (Q (1-Q) z ((1-P)z/(1-Pz))^2)^i - [d=0])
      C(t) := (1 - sqrt(1-4x)) / 2x
      F := Q (1-Q) z ((1-P)z/(1-Pz))^2
  = (1-Q)^d ((1-P)z/(1-Pz))^(d-1) (1 + z/(1-Pz)) ((1-4F)^(-1/2) C(F)^d - [d=0])
*/

/*
  F := Q (1-Q) z ((1-P)z/(1-Pz))^2
  (1-4F)^(-1/2) = (1-Pz) ((1-Pz)^2 - 4 Q (1-Q) (1-P)^2 z^3)^(-1/2)
*/
vector<Mint> calcInvSqrt(Mint P, Mint Q, int len) {
  const Mint fs[4] = {1, -2*P, P*P, -4 * Q * (1-Q) * (1-P)*(1-P)};
  vector<Mint> gs(len, 0);
  gs[0] = 1;
  for (int i = 1; i < len; ++i) {
    for (int j = 1; j <= i && j <= 3; ++j) gs[i] += ((-inv[2] + 1) * j - i) * fs[j] * gs[i - j];
    gs[i] *= inv[i];
  }
  for (int i = len; --i >= 1; ) gs[i] -= P * gs[i - 1];
  return gs;
}

/*
  d = 0
  ((1-P)z/(1-Pz))^(-1) (1 + z/(1-Pz)) ((1-4F)^(-1/2) - 1)
  = ((1 + (1-P)z) / (1-P)z) ((1-4F)^(-1/2) - 1)
*/
vector<Mint> calcDiag(Mint P, Mint Q, int len) {
  auto hs = calcInvSqrt(P, Q, len + 1);
// cerr<<"hs = "<<hs<<endl;
  assert(hs[0] == 1);
  hs.erase(hs.begin());
  const Mint val = (1-P).inv();
  for (int i = 0; i < len; ++i) hs[i] *= val;
  for (int i = len; --i >= 1; ) hs[i] += (1-P) * hs[i - 1];
  hs[0] = 1;
  return hs;
}

/*
  d = 1
  (1-Q) (1 + z/(1-Pz)) (1-4F)^(-1/2) C(F)
  = (1-Q) ((1 + (1-P)z) / (1-Pz)) ((1-4F)^(-1/2) - 1) (2F)^-1
*/
vector<Mint> calcDiag1(Mint P, Mint Q, int len) {
  auto hs = calcInvSqrt(P, Q, len + 4);
  assert(hs[0] == 1);
  assert(hs[1] == 0);
  assert(hs[2] == 0);
  hs.erase(hs.begin(), hs.begin() + 3);
  const Mint val = (1-Q) * (2 * Q * (1-Q) * (1-P)*(1-P)).inv();
  for (int i = 0; i < len; ++i) hs[i] *= val;
  for (int i = len; --i >= 1; ) hs[i] += (1-P) * hs[i - 1];
  for (int i = len; --i >= 1; ) hs[i] -= P * hs[i - 1];
  return hs;
}

/*
  (1-Q)^d (1-P)^(d-1)  z^(d-1) (1 + (1-P)z)  (1/(1-Pz))^d  (1-4F)^(-1/2) C(F)^d
  
  1-4F =: G/(1-Pz)^2
  H := (1-4F)^(-1/2)
  
  (1-4F)^(-1/2) C(F)^d
  = \sum[0<=k<=d] binom(d,k) (-1/2)^k sqrt(1-4F)^(k-1) / F^k
  = \sum[0<=k<=d] binom(d,k) (-1/2)^k (Q(1-Q)(1-P)^2)^-k (
        [k:even] H G^(k/2) (1-Pz)^k z^(-3k)
      + [k:odd ] G^((k-1)/2) (1-Pz)^(k+1) z^(-3k)
    )
*/

int main() {
  prepare();
  
  int N;
  Mint P, Q;
  for (; ~scanf("%d%u%u", &N, &P.x, &Q.x); ) {
    vector<int> U(N), V(N);
    for (int n = 0; n < N; ++n) {
      scanf("%d%d", &U[n], &V[n]);
    }
    
    int len = 0;
    for (int n = 0; n < N; ++n) {
      chmax(len, U[n]);
      chmax(len, V[n]);
    }
    len += 10;
    
    const auto diag = calcDiag(P, Q, len);
// cerr<<"diag = "<<diag<<endl;
// for(int i=0;i<len;++i)assert(diag[i]==brute(P,Q,i,i));
    const auto diag1U = calcDiag1(P, Q, len);
    const auto diag1V = calcDiag1(P, 1-Q, len);
    
    auto solve = [&](int u, int v) -> Mint {
      const int d = v - u;
      if (d == 0) return diag[u];
      if (d == 1) return diag1U[u];
      if (d == -1) return diag1V[v];
      assert(false);
    };
    Mint ans = 0;
    for (int n = 0; n < N; ++n) ans += solve(U[n], V[n]);
    printf("%u\n", ans.x);
  }
  return 0;
}