```go
package main

import (
	"fmt"
)

const MOD = 1000000007

func add(a, b int) int {
	res := a + b
	if res >= MOD {
		res -= MOD
	}
	return res
}

func sub(a, b int) int {
	res := a - b
	if res < 0 {
		res += MOD
	}
	return res
}

func mul(a, b int) int {
	return int((int64(a) * int64(b)) % MOD)
}

func power(base, exp int) int {
	res := 1
	base %= MOD
	if base < 0 {
		base += MOD
	}
	for exp > 0 {
		if exp%2 == 1 {
			res = mul(res, base)
		}
		base = mul(base, base)
		exp /= 2
	}
	return res
}

func inv(n int) int {
	return power(n, MOD-2)
}

func main() {
	var n, k, m int
	if _, err := fmt.Scan(&n, &k, &m); err != nil {
		return
	}

	if k == 1 || k == n {
		fmt.Println(n)
		return
	}

	maxA, maxB, vecSize := m+1, m+1, m
	pool := make([]int, maxA*maxB*vecSize)
	E := make([][][]int, maxA)
	idx := 0
	for i := 0; i < maxA; i++ {
		E[i] = make([][]int, maxB)
		for j := 0; j < maxB; j++ {
			E[i][j] = pool[idx : idx+vecSize]
			idx += vecSize
		}
	}

	sumA := make([][]int, maxB)
	for i := 0; i < maxB; i++ {
		sumA[i] = make([]int, vecSize)
	}

	sumB := make([][]int, maxB)
	for i := 0; i < maxB; i++ {
		sumB[i] = make([]int, vecSize)
	}

	Eq := make([][]int, maxA)
	for i := 0; i < maxA; i++ {
		Eq[i] = make([]int, vecSize)
	}

	for b := 0; b <= m-1; b++ {
		E[0][b][0] = b + 1
		copy(sumA[b], E[0][b])
	}
	for a := 1; a <= m-1; a++ {
		E[a][0][0] = a + 1
	}
	for b := 1; b <= m-2; b++ {
		E[1][b][b] = 1
	}

	for a := 1; a <= m-2; a++ {
		copy(sumB[1], E[a][0])
		for b := 1; b <= m-a-1; b++ {
			for i := 0; i < vecSize; i++ {
				sumB[b+1][i] = add(sumB[b][i], E[a][b][i])
			}
		}

		bEq := m - 1 - a
		invM1 := inv(m - 1)
		for i := 0; i < vecSize; i++ {
			sumAB := add(sumA[bEq][i], sumB[bEq][i])
			term := mul(sumAB, invM1)
			Eq[a][i] = sub(E[a][bEq][i], term)
		}

		if a <= m-3 {
			for b := 1; b <= m-a-2; b++ {
				l := a + b + 1
				PC := mul(m-l, inv(m))
				PB := mul(l, inv(m))

				coeff_Eab1 := mul(sub(0, PC), mul(b+1, inv(l+1)))
				coeff_sum := mul(sub(0, PB), inv(l-1))
				multiplier := mul(l+1, inv(mul(PC, a+1)))

				for i := 0; i < vecSize; i++ {
					val := E[a][b][i]
					val = add(val, mul(E[a][b+1][i], coeff_Eab1))
					sumAB := add(sumA[b][i], sumB[b][i])
					val = add(val, mul(sumAB, coeff_sum))
					E[a+1][b][i] = mul(val, multiplier)
				}
			}
		}

		for b := 1; b <= m-a-1; b++ {
			for i := 0; i < vecSize; i++ {
				sumA[b][i] = add(sumA[b][i], E[a][b][i])
			}
		}
	}

	nVars := m - 2
	Matrix := make([][]int, nVars)
	for i := 0; i < nVars; i++ {
		Matrix[i] = make([]int, nVars+1)
	}

	for i := 0; i < nVars; i++ {
		a := i + 1
		for j := 0; j < nVars; j++ {
			Matrix[i][j] = Eq[a][j+1]
		}
		Matrix[i][nVars] = sub(0, Eq[a][0])
	}

	for i := 0; i < nVars; i++ {
		pivot := i
		for j := i; j < nVars; j++ {
			if Matrix[j][i] != 0 {
				pivot = j
				break
			}
		}
		Matrix[i], Matrix[pivot] = Matrix[pivot], Matrix[i]

		invPivot := inv(Matrix[i][i])
		for j := i; j <= nVars; j++ {
			Matrix[i][j] = mul(Matrix[i][j], invPivot)
		}

		for j := 0; j < nVars; j++ {
			if i != j && Matrix[j][i] != 0 {
				factor := Matrix[j][i]
				for k := i; k <= nVars; k++ {
					Matrix[j][k] = sub(Matrix[j][k], mul(factor, Matrix[i][k]))
				}
			}
		}
	}

	U := make([]int, vecSize)
	U[0] = 1
	for i := 1; i <= nVars; i++ {
		U[i] = Matrix[i-1][nVars]
	}

	aAns := k - 1
	bAns := n - k
	ans := 0
	for i := 0; i < vecSize; i++ {
		ans = add(ans, mul(E[aAns][bAns][i], U[i]))
	}
	fmt.Println(ans)
}
```