#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
typedef pair<int, bool> sP;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<ll> vec;
typedef double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-5;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;


ll mod_pow(ll x, ll n) {
	ll ret = 1;
	while (n > 0) {
		if (n % 2)ret = ret * x%mod;
		x = x * x%mod; n >>= 1;
	}
	return ret;
}
struct perm {
private:
	int sz;
	vector<ll> p, invp;
public:
	perm(int n) {
		sz = n + 1;
		p.resize(sz), invp.resize(sz);
		p[0] = 1;
		rep1(i, sz - 1) {
			p[i] = p[i - 1] * i%mod;
		}
		invp[sz - 1] = 1;
		ll cop = mod - 2, x = p[sz - 1];
		while (cop) {
			if (cop % 2)invp[sz - 1] = invp[sz - 1] * x%mod;
			cop >>= 1; x = x * x % mod;
		}
		per(i, sz - 1) {
			invp[i] = invp[i + 1] * (i + 1) % mod;
		}
	}
	ll comb(ll x, ll y) {
		if (x < y || y < 0)return 0;
		ll ret = p[x];
		(ret *= invp[y]) %= mod;
		(ret *= invp[x - y]) %= mod;
		return ret;
	}
	ll combP(ll x, ll y) {
		if (x < y || y < 0)return 0;
		return p[x] * invp[x - y] % mod;
	}
};
perm pm(1000);

void solve() {
	int h, w, p, m, k;
	cin >> h >> w >> p >> m >> k; p--;
	vector<int> a(h, -1);
	vector<int> cnt(h + 1, 0);
	rep(i, m) {
		int x, y; cin >> x >> y;
		x--; y--;
		x = h - 1 - x;
		a[x] = y;
	}
	rep(i, h) {
		if (a[i] < 0) {
			cnt[i + 1] += cnt[i] + 1;
		}
		else {
			cnt[i + 1] += cnt[i];
		}
	}
	ld ans = 0;
	vector<vector<ld>> dp(k + 1);
	rep(j, k + 1) {
		dp[j].resize(w, 0);
	}
	dp[0][p] = 1;
	rep(j, h) {
		if (a[j] >= 0) {
			int l = a[j], r = a[j] + 1;
			rep(n, k + 1) {
				swap(dp[n][l], dp[n][r]);
			}
		}
		else {
			//add
			int num = cnt[h] - cnt[j];
			//cout << "Num " << num << endl;
			for (int n = k; n > 0; n--) {
				//if (k - n+1 > num)continue;
				ld pre = (k - n + 1) / (ld)num;
				//cout << pre << endl;
				rep(l, w) {
					if (l == 0) {
						if (k - n <= num) {
							dp[n][l] *= (1 - (k - n) / (ld)num);
						}
						if (k - n + 1 > num)continue;
						dp[n][l] += pre * dp[n - 1][0] * (w - 2) / (ld)(w - 1);
						dp[n][l] += pre * dp[n - 1][1] / (ld)(w - 1);
					}
					else if (l == w - 1) {
						if (k - n <= num) {
							dp[n][l] *= (1 - (k - n) / (ld)num);
						}
						if (k - n + 1 > num)continue;
						dp[n][l] += pre * dp[n - 1][w - 1] * (w - 2) / (ld)(w - 1);
						dp[n][l] += pre * dp[n - 1][w - 2] / (ld)(w - 1);
					}
					else {
						if (k - n <= num) {
							dp[n][l] *= (1 - (k - n) / (ld)num);
						}
						if (k - n + 1 > num)continue;
						dp[n][l] += pre * dp[n - 1][l] * (w - 3) / (ld)(w - 1);
						dp[n][l] += pre * dp[n - 1][l - 1] / (ld)(w - 1);
						dp[n][l] += pre * dp[n - 1][l + 1] / (ld)(w - 1);
					}
				}
			}
			if (k <= num) {
				ld pre = k / (ld)num;
				rep(l, w) {
					dp[0][l] *= (1 - pre);
				}
			}
		}
	}
	rep(i, w) {
		//cout << dp[k][i] << endl;
		ans = max(ans, dp[k][i]);
	}
	cout << ans << endl;
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(7);
	//init();
	solve();
	//stop
		return 0;
}




Measured memory_bytes: 3380