#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>

using namespace std;

#define FOR(i,k,n) for(int i=(k); i<(int)n; ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)

template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cout<<*i<<" "; cout<<endl; }

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;

int main(){
  int H, N, P, M, K;
  while(cin>>H>>N>>P>>M>>K){
    double ans = 0;
    int stick[501] = {};
    memset(stick, -1, sizeof(stick));
    REP(i, M){
      int A, B; cin>>A>>B;
      B--;
      stick[H - A + 1] = B;
    }
    int cnt[501] = {};
    for(int h = 1; h <= 500; h++){
      cnt[h] = cnt[h-1];
      if(stick[h] != -1) cnt[h]++;
    }
    static double dp[501][101][101]; //[h][x][use]
    int s = P - 1;
    memset(dp, 0, sizeof(dp));
    dp[0][s][0] = 1;
    //printf("start: %d\n", s);
    for(int h = 0; h < H; h++){
      if(stick[h + 1] != -1){
        for(int x = 0; x < N; x++){
          int to = x;
          if(x == stick[h + 1] || x == stick[h + 1] + 1){
            to = (x == stick[h + 1]) ? (x + 1) : (x - 1);
          }
          for(int use = 0; use <= K; use++){
            dp[h + 1][to][use] += dp[h][x][use];
          }
        }
      }else{
        for(int use = 0; use <= K; use++){
          const double P_H = (double)(K - use) / (H - (M - cnt[h + 1]) - h);
          const double P_N = 1.0 / (N - 1);
          if(use != K){
            {
              int x = 0;
              const double P = P_H * P_N;
              const double not_P_N = 1 - P_N;
              dp[h + 1][x + 1][use + 1] += dp[h][x][use] * P;
              dp[h + 1][x][use + 1] += dp[h][x][use] * P_H * not_P_N;
              dp[h + 1][x][use] += dp[h][x][use] * (1 - P_H);
            }
            for(int x = 1; x < N - 1; x++){
              const double P = P_H * P_N;
              double not_P_N = 1 - 2 * P_N;
              dp[h + 1][x - 1][use + 1] += dp[h][x][use] * P;
              dp[h + 1][x + 1][use + 1] += dp[h][x][use] * P;
              dp[h + 1][x][use + 1] += dp[h][x][use] * P_H * not_P_N;
              dp[h + 1][x][use] += dp[h][x][use] * (1 - P_H);
            }
            {
              int x =  N - 1;
              const double P = P_H * P_N;
              const double not_P_N = 1 - P_N;
              dp[h + 1][x - 1][use + 1] += dp[h][x][use] * P;
              dp[h + 1][x][use + 1] += dp[h][x][use] * P_H * not_P_N;
              dp[h + 1][x][use] += dp[h][x][use] * (1 - P_H);
            }
          }else{
            for(int x = 0; x < N; x++) dp[h + 1][x][use] += dp[h][x][use] * (1 - P_H);
          }
        }
      }
      /*
         printf("height: %d\n", h + 1);
         for(int x = 0; x < N; x++){
         for(int use = 0; use <= K; use++){
         printf("  x:%d p:%f use:%d\n", x, dp[h + 1][x][use], use);
         }
         }
         */
    }

    REP(x, N)ans = max(ans, dp[H][x][K]);
    printf("%.9f\n", ans);
  }
  return 0;
}

Measured memory_bytes: 41124