```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 1000000007

func modPow(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(reader, &n, &m)
	var a, b int64
	fmt.Fscan(reader, &a, &b)
	var k int
	fmt.Fscan(reader, &k)

	p_mod := (a * modPow(b, MOD-2)) % MOD
	one_minus_p := (1 - p_mod + MOD) % MOD

	maxK := k
	if m > maxK {
		maxK = m
	}
	fact := make([]int64, maxK+1)
	invFact := make([]int64, maxK+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= maxK; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[maxK] = modPow(fact[maxK], MOD-2)
	for i := maxK - 1; i >= 1; i-- {
		invFact[i] = (invFact[i+1] * int64(i+1)) % MOD
	}

	nCr := func(n, r int) int64 {
		if r < 0 || r > n {
			return 0
		}
		return fact[n] * invFact[r] % MOD * invFact[n-r] % MOD
	}

	g := make([]int64, m)
	for v := 0; v < m; v++ {
		if v > k {
			g[v] = 0
		} else {
			prob := nCr(k, v)
			prob = (prob * modPow(p_mod, int64(v))) % MOD
			prob = (prob * modPow(one_minus_p, int64(k-v))) % MOD
			g[v] = prob
		}
	}

	prefG := make([]int64, m+1)
	for i := 0; i < m; i++ {
		prefG[i+1] = (prefG[i] + g[i]) % MOD
	}

	f := make([]int64, m)
	for x := 0; x < m; x++ {
		limit := m - 1 - x
		if limit >= 0 {
			f[x] = prefG[limit+1]
		} else {
			f[x] = 0
		}
	}

	SumG := make([]int64, m)
	SumG[0] = g[0]
	for i := 1; i < m; i++ {
		SumG[i] = (SumG[i-1] + g[i]) % MOD
	}

	C := make([]int64, m)
	E := make([]int64, m)
	for v := 0; v < m; v++ {
		C[v] = f[v]
		E[v] = (f[v] * SumG[v]) % MOD
	}

	for i := 2; i <= n; i++ {
		SumGC := make([]int64, m)
		SumGCF := make([]int64, m)
		currSumGC := int64(0)
		currSumGCF := int64(0)
		for v := 0; v < m; v++ {
			termC := (g[v] * C[v]) % MOD
			currSumGC = (currSumGC + termC) % MOD
			SumGC[v] = currSumGC

			termCF := (termC * f[v]) % MOD
			currSumGCF = (currSumGCF + termCF) % MOD
			SumGCF[v] = currSumGCF
		}

		TotGCF := SumGCF[m-1]

		K := make([]int64, m)
		SumGK := make([]int64, m)
		currSumGK := int64(0)
		for v := 0; v < m; v++ {
			K[v] = (E[v] - SumGC[v] + MOD) % MOD
			termK := (g[v] * K[v]) % MOD
			currSumGK = (currSumGK + termK) % MOD
			SumGK[v] = currSumGK
		}

		C_new := make([]int64, m)
		E_new := make([]int64, m)
		for v := 0; v < m; v++ {
			term1 := (f[v] * E[v]) % MOD
			C_new[v] = (term1 + TotGCF - SumGCF[v] + MOD) % MOD

			termE1 := (f[v] * SumGK[v]) % MOD
			termE2a := (f[v] * SumGC[v]) % MOD
			termE2b := (TotGCF - SumGCF[v] + MOD) % MOD
			termE2 := (termE2a + termE2b) % MOD
			termE2 = (termE2 * SumG[v]) % MOD
			E_new[v] = (termE1 + termE2) % MOD
		}

		C = C_new
		E = E_new
	}

	ans := int64(0)
	for v := 0; v < m; v++ {
		term := (g[v] * C[v]) % MOD
		ans = (ans + term) % MOD
	}

	fmt.Println(ans)
}
```