Unfortunately, the formal description of the task turned out to be too long, so here is the legend.

Research rover finally reached the surface of Mars and is ready to complete its mission. Unfortunately, due to the mistake in the navigation system design, the rover is located in the wrong place.

The rover will operate on the grid consisting of n rows and m columns. We will define as (r, c) the cell located in the row r and column c. From each cell the rover is able to move to any cell that share a side with the current one.

The rover is currently located at cell (1, 1) and has to move to the cell (n, m). It will randomly follow some shortest path between these two cells. Each possible way is chosen equiprobably.

The cargo section of the rover contains the battery required to conduct the research. Initially, the battery charge is equal to s units of energy.

Some of the cells contain anomaly. Each time the rover gets to the cell with anomaly, the battery looses half of its charge rounded down. Formally, if the charge was equal to x before the rover gets to the cell with anomaly, the charge will change to <image>.

While the rover picks a random shortest path to proceed, compute the expected value of the battery charge after it reaches cell (n, m). If the cells (1, 1) and (n, m) contain anomaly, they also affect the charge of the battery.

Input

The first line of the input contains four integers n, m, k and s (1 ≤ n, m ≤ 100 000, 0 ≤ k ≤ 2000, 1 ≤ s ≤ 1 000 000) — the number of rows and columns of the field, the number of cells with anomaly and the initial charge of the battery respectively.

The follow k lines containing two integers ri and ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m) — coordinates of the cells, containing anomaly. It's guaranteed that each cell appears in this list no more than once.

Output

The answer can always be represented as an irreducible fraction <image>. Print the only integer P·Q - 1 modulo 109 + 7.

Examples

Input

3 3 2 11
2 1
2 3


Output

333333342


Input

4 5 3 17
1 2
3 3
4 1


Output

514285727


Input

1 6 2 15
1 1
1 5


Output

4

Note

In the first sample, the rover picks one of the following six routes:

  1. <image>, after passing cell (2, 3) charge is equal to 6. 
  2. <image>, after passing cell (2, 3) charge is equal to 6. 
  3. <image>, charge remains unchanged and equals 11. 
  4. <image>, after passing cells (2, 1) and (2, 3) charge equals 6 and then 3. 
  5. <image>, after passing cell (2, 1) charge is equal to 6. 
  6. <image>, after passing cell (2, 1) charge is equal to 6. 



Expected value of the battery charge is calculated by the following formula:

<image>.

Thus P = 19, and Q = 3.

3 - 1 modulo 109 + 7 equals 333333336.

19·333333336 = 333333342 (mod 109 + 7)
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
  char c = getchar();
  bool f = 0;
  x = 0;
  while (!isdigit(c)) f |= c == '-', c = getchar();
  while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
  if (f) x = -x;
  return x;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
  read(x);
  read(a...);
}
template <class t>
inline void write(t x) {
  if (x < 0)
    putchar('-'), write(-x);
  else {
    if (x > 9) write(x / 10);
    putchar('0' + x % 10);
  }
}
const int mod = 1e9 + 7, N = 2e5 + 5;
pair<int, int> a[N];
int fac[N << 1], inv[N << 1], n, m, nm, ans, s, f[N][23];
int fpow(int first, int second) {
  int res = 1;
  for (; second; second >>= 1, first = 1ll * first * first % mod)
    if (second & 1) res = 1ll * res * first % mod;
  return res;
}
int C(int n, int m) { return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int calc(int first, int second) {
  return C(
      a[second].first - a[first].first + a[second].second - a[first].second,
      a[second].first - a[first].first);
}
signed main() {
  read(n, m, nm, s);
  s <<= 1;
  fac[0] = 1;
  for (int i = 1; i <= n + m; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
  inv[n + m] = fpow(fac[n + m], mod - 2);
  for (int i = n + m - 1; ~i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
  for (int i = 1; i <= nm; i++) read(a[i].first, a[i].second);
  a[++nm] = pair<int, int>(1, 1);
  a[++nm] = pair<int, int>(n, m);
  sort(a + 1, a + 1 + nm);
  f[1][0] = 1;
  for (int i = 2; i <= nm; i++) {
    f[i][1] = calc(1, i);
    for (int j = 2; j < 22; j++)
      for (int k = 1; k < i; k++)
        if (a[i].second >= a[k].second)
          f[i][j] = (f[i][j] +
                     ((1ll * (f[k][j - 1] - f[k][j]) * calc(k, i) % mod + mod) %
                      mod)) %
                    mod;
  }
  for (int i = 1; i < 22; i++) {
    s = s + 1 >> 1;
    ans = (ans + (1ll * (f[nm][i] - f[nm][i + 1]) * s % mod + mod) % mod) % mod;
  }
  write(1ll * ans * fpow(calc(1, nm), mod - 2) % mod);
}
