import Control.Arrow
import Control.Monad
import Data.List
import qualified Data.ByteString.Char8 as B
import Control.Monad.State (State, evalState, gets, modify)
import Data.Map.Strict (Map, lookup, insert, empty)

main :: IO ()
main = readLine >>= print . solve 

-- | 
-- >>> solve [1,3,2]
-- 1
-- >>> solve [1,3,1]
-- 2
-- >>> solve [2,3,3]
-- 1
-- >>> solve [2,3,1]
-- 5
-- >>> solve [7,1,1]
-- 1
-- >>> solve [15,8,5]
-- 437760187
solve :: [Int] -> Int 
solve [h, w, k] = run calc (1, 1)
    where
        calc recf (i, j)
            | j < 1 || j > w = return 0
            | i == h && j == k = return $ mul (cmb $ w - k - 1) (cmb $ j - 2)
            | i == h && j == k - 1 = return $ mul (cmb $ w - j - 2) (cmb $ j - 2)
            | i == h && j == k + 1 = return $ mul (cmb $ w - j - 1) (cmb $ j - 3)
            | i == h = return 0
            | otherwise = sumM [prodf (w - j - 1) (j - 2) <$> recf (i + 1, j), prodf (w - j - 2) (j - 2) <$> recf (i + 1, j + 1), prodf (w - j - 1) (j - 3) <$> recf (i + 1, j - 1)]

        sumM = foldl' (\acc x -> add <$> acc <*> x) (return 0)
        prodf x y v = mul (mul (cmb x) (cmb y)) v

        cmb x
            | x < 1 = 1
            | x == 1 = 2
            | x == 2 = 3
            | otherwise = cmb (x - 1) + cmb (x - 2)

type Memoizer a b = a -> State (Map a b) b

run :: (Ord a) => (Memoizer a b -> Memoizer a b) -> a -> b
run f = flip evalState empty . memoizeFix f

memoizeFix :: (Ord a) => (Memoizer a b -> Memoizer a b) -> Memoizer a b
memoizeFix f x = gets (Data.Map.Strict.lookup x) >>= maybe (f (memoizeFix f) x >>= ((<$) <*> (modify . Data.Map.Strict.insert x))) return

readLine :: IO [Int]
readLine = unfoldr (\s -> second (maybe B.empty snd . B.uncons) <$> B.readInt s) <$> B.getLine

readContents :: Int -> IO [[Int]]
readContents = flip replicateM readLine

add :: Int -> Int -> Int
add x y = val $ x + y

mul :: Int -> Int -> Int
mul x y = val $ x * y

inv :: Int -> Int
inv x = pow x $ modVal - 2

pow :: Int -> Int -> Int
pow b e
    | e == 0 = 1
    | odd e = mul b . pow b $ e - 1
    | otherwise = mul v v
    where
        v = pow b $ e `div` 2

val :: Int -> Int
val = (`mod` modVal)

modVal :: Int
modVal = 10 ^ 9 + 7

primes :: [Int]
primes = build [2..]
    where
        build (x : xs) = x : build (filter (\n -> n `mod` x /= 0) xs)
        
isPrime :: Int -> Bool
isPrime n = check primes
    where
        check (x : xs)
            | x == n = True
            | x > n = False
            | otherwise = check xs