#include <bits/stdc++.h>
using namespace std;
inline char gc() {
  static const int L = 233333;
  static char sxd[L], *sss = sxd, *ttt = sxd;
  if (sss == ttt) {
    ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
    if (sss == ttt) {
      return EOF;
    }
  }
  return *sss++;
}
inline char readchar() {
  char c = gc();
  for (; !isalpha(c); c = gc())
    ;
  return c;
}
template <class T>
inline bool read(T& x) {
  bool flg = false;
  char c = gc();
  x = 0;
  for (; !isdigit(c); c = gc()) {
    if (c == '-') {
      flg = true;
    } else if (c == EOF) {
      return false;
    }
  }
  for (; isdigit(c); c = gc()) {
    x = (x << 1) + (x << 3) + (c ^ 48);
  }
  if (flg) {
    x = -x;
  }
  return true;
}
template <class T>
inline void write(T x) {
  if (x < 10) {
    putchar(x | 48);
    return;
  }
  write(x / 10);
  putchar((x % 10) | 48);
}
const int maxn = 2005;
const int maxd = 200005;
const int mod = 1000000007;
int dp[maxn][30];
int fac[maxd];
int inv[maxd];
inline int pow(int a, int b) {
  int ans = 1;
  for (; b; b >>= 1, a = (long long)a * a % mod) {
    if (b & 1) {
      ans = (long long)ans * a % mod;
    }
  }
  return ans;
}
inline void pre(int n) {
  fac[0] = 1;
  for (int i = 1; i <= n; ++i) {
    fac[i] = (long long)fac[i - 1] * i % mod;
  }
  inv[n] = pow(fac[n], mod - 2);
  for (int i = n - 1; ~i; --i) {
    inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
  }
}
inline int C(int n, int m) {
  if (n > m) {
    return 0;
  }
  return (long long)fac[m] * inv[n] % mod * inv[m - n] % mod;
}
struct ZB {
  int x, y;
  friend bool operator<(ZB a, ZB b) {
    return a.x < b.x || (a.x == b.x && a.y < b.y);
  }
} zb[maxn];
inline int D(int a, int b) {
  if (b < a) {
    swap(a, b);
  }
  int x = zb[b].x - zb[a].x;
  int y = zb[b].y - zb[a].y;
  return C(x, x + y);
}
int n, m, k, s, t;
int sumy[maxn];
int main() {
  read(n), read(m), read(k), read(s);
  if (n == 1 && m == 1) {
    if (k) {
      printf("%lld\n", (long long)s * pow(2, mod - 2) % mod);
    } else {
      printf("%d\n", s);
    }
  }
  pre(n + m);
  for (int i = 1; i <= k; ++i) {
    read(zb[i].x);
    read(zb[i].y);
  }
  for (int ts = s; ts != 1; (ts += 1) >>= 1, t++)
    ;
  k++;
  zb[k].x = 1;
  zb[k].y = 1;
  k++;
  zb[k].x = n;
  zb[k].y = m;
  t += 2;
  sort(zb + 1, zb + k + 1);
  dp[1][1] = 1;
  sumy[1] = 1;
  for (int i = 2; i <= k; ++i) {
    for (int j = 2; j <= min(i, t); ++j) {
      dp[i][j] = D(1, i);
      {
        dp[i][j] += -sumy[i];
        if (dp[i][j] >= mod) {
          dp[i][j] -= mod;
        }
        if (dp[i][j] < 0) {
          dp[i][j] += mod;
        }
      };
      for (int k = 1; k < i; ++k) {
        int tmp = (long long)D(k, i) * dp[k][j] % mod;
        {
          dp[i][j] += -tmp;
          if (dp[i][j] >= mod) {
            dp[i][j] -= mod;
          }
          if (dp[i][j] < 0) {
            dp[i][j] += mod;
          }
        };
      }
      {
        sumy[i] += dp[i][j];
        if (sumy[i] >= mod) {
          sumy[i] -= mod;
        }
        if (sumy[i] < 0) {
          sumy[i] += mod;
        }
      };
    }
  }
  int ans = 0, tmp;
  int sum = 0;
  for (int i = 2; i <= t; ++i, (s += 1) >>= 1) {
    tmp = (long long)s * dp[k][i] % mod;
    {
      sum += dp[k][i];
      if (sum >= mod) {
        sum -= mod;
      }
      if (sum < 0) {
        sum += mod;
      }
    };
    {
      ans += tmp;
      if (ans >= mod) {
        ans -= mod;
      }
      if (ans < 0) {
        ans += mod;
      }
    };
  }
  int all = D(1, k);
  int gs = all;
  {
    gs += -sum;
    if (gs >= mod) {
      gs -= mod;
    }
    if (gs < 0) {
      gs += mod;
    }
  };
  {
    ans += gs;
    if (ans >= mod) {
      ans -= mod;
    }
    if (ans < 0) {
      ans += mod;
    }
  };
  printf("%lld", (long long)ans * pow(all, mod - 2) % mod);
  return 0;
}
