```go
package main

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

const MOD int64 = 1000000007

func modPow(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	var n, m, x int
	fmt.Fscan(in, &n, &m, &x)

	if n > m {
		fmt.Print(0)
		return
	}

	fac := make([]int64, m+1)
	ifac := make([]int64, m+1)
	fac[0] = 1
	for i := 1; i <= m; i++ {
		fac[i] = fac[i-1] * int64(i) % MOD
	}
	ifac[m] = modPow(fac[m], MOD-2)
	for i := m; i >= 1; i-- {
		ifac[i-1] = ifac[i] * int64(i) % MOD
	}

	comb := func(N, K int) int64 {
		if N < 0 || K < 0 || K > N {
			return 0
		}
		return fac[N] * ifac[K] % MOD * ifac[N-K] % MOD
	}

	maxLen := 2 * n
	A := make([][]int64, maxLen+1)
	for i := 0; i <= maxLen; i++ {
		A[i] = make([]int64, n+2)
	}
	A[0][0] = 1
	for p := 0; p < maxLen; p++ {
		for h := 0; h <= n; h++ {
			v := A[p][h]
			if v == 0 {
				continue
			}
			if h+1 <= n {
				A[p+1][h+1] += v
				if A[p+1][h+1] >= MOD {
					A[p+1][h+1] -= MOD
				}
			}
			if h > 0 {
				A[p+1][h-1] += v
				if A[p+1][h-1] >= MOD {
					A[p+1][h-1] -= MOD
				}
			}
		}
	}

	cat := make([]int64, n+1)
	for k := 0; k <= n; k++ {
		cat[k] = A[2*k][0]
	}

	d := make([][]int64, n+1)
	for k := 0; k <= n; k++ {
		d[k] = make([]int64, 2*n+1)
	}
	for k := 1; k <= n; k++ {
		for j := 1; j <= 2*k; j++ {
			p := j - 1
			q := 2*k - j
			var s int64
			for b := 0; b < n; b++ {
				v1 := A[p][b]
				if v1 == 0 {
					continue
				}
				v2 := A[q][b+1]
				if v2 == 0 {
					continue
				}
				s += v1 * v2 % MOD
				if s >= MOD {
					s -= MOD
				}
			}
			d[k][j] = s
		}
	}

	var ans int64

	for k := 0; k <= n; k++ {
		if n-k-1 >= 0 {
			v := cat[k] * comb(m-1, 2*k) % MOD * comb(m-1-2*k, n-k-1) % MOD
			ans += v
			if ans >= MOD {
				ans -= MOD
			}
		}
	}

	for k := 1; k <= n; k++ {
		chooseB := comb(m-2*k, n-k)
		if chooseB == 0 {
			continue
		}
		var t int64
		for j := 1; j <= 2*k; j++ {
			c1 := comb(x-1, j-1)
			if c1 == 0 {
				continue
			}
			c2 := comb(m-x, 2*k-j)
			if c2 == 0 {
				continue
			}
			add := d[k][j] * c1 % MOD * c2 % MOD
			t += add
			if t >= MOD {
				t -= MOD
			}
		}
		ans += t * chooseB % MOD
		if ans >= MOD {
			ans -= MOD
		}
	}

	ans = ans * fac[n] % MOD

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(out, ans)
	out.Flush()
}
```