# -*- coding: utf-8 -*-



#############

# Libraries #

#############



import sys

input = sys.stdin.readline



import math

import bisect

from collections import deque

from fractions import gcd

from functools import lru_cache





#############

# Constants #

#############



MOD = 10**9+7

INF = float('inf')



#############

# Functions #

#############



######INPUT######

def inputI(): return int(input().strip())

def inputS(): return input().strip()

def inputIL(): return list(map(int,input().split()))

def inputSL(): return list(map(str,input().split()))

def inputILs(n): return list(int(eval(input())) for _ in range(n))

def inputSLs(n): return list(input().strip() for _ in range(n))

def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]

def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]



#####Inverse#####

def inv(n): return pow(n, MOD-2, MOD)



######Combination######

kaijo_memo = []

def kaijo(n):

  if(len(kaijo_memo) > n):

    return kaijo_memo[n]

  if(len(kaijo_memo) == 0):

    kaijo_memo.append(1)

  while(len(kaijo_memo) <= n):

    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)

  return kaijo_memo[n]



gyaku_kaijo_memo = []

def gyaku_kaijo(n):

  if(len(gyaku_kaijo_memo) > n):

    return gyaku_kaijo_memo[n]

  if(len(gyaku_kaijo_memo) == 0):

    gyaku_kaijo_memo.append(1)

  while(len(gyaku_kaijo_memo) <= n):

    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)

  return gyaku_kaijo_memo[n]



def nCr(n,r):

  if(n == r):

    return 1

  if(n < r or r < 0):

    return 0

  ret = 1

  ret = ret * kaijo(n) % MOD

  ret = ret * gyaku_kaijo(r) % MOD

  ret = ret * gyaku_kaijo(n-r) % MOD

  return ret



######Factorization######

def factorization(n):

    arr = []

    temp = n

    for i in range(2, int(-(-n**0.5//1))+1):

        if temp%i==0:

            cnt=0

            while temp%i==0:

                cnt+=1

                temp //= i

            arr.append([i, cnt])

    if temp!=1:

        arr.append([temp, 1])



    if arr==[]:

        arr.append([n, 1])

    return arr



#####LCM#####

def lcm(a, b):

    return a * b // gcd (a, b)



#####BitCount#####

def bit_count(n):

  count = 0

  while n:

    n &= n -1

    count += 1

  return count



#############

# Main Code #

#############



H,W,K = inputIL()



if W == 1:

  print((1))

  exit()



possible = []

for i in range(1<<(W-1)):

  b = bin(i)[2:]

  flag = 1

  for j in range(len(b)-1):

    if b[j] == b[j+1] == "1":

      flag = 0

  if flag:

    possible.append(int(b,2))



def amida(b):

  ret = [i for i in range(W)]

  for i in range(W-1):

    if b>>i & 1:

      ret[i],ret[i+1] = ret[i+1],ret[i]

  return ret



ans = [0 for i in range(W)]

ans[0] = 1





for _ in range(H):

  new_ans = [0 for i in range(W)]

  for b in possible:

    for i in range(W):

      new_ans[i] = (new_ans[i] + ans[amida(b)[i]])%MOD

  ans = new_ans

  

print((ans[K-1]))
H,W,K = list(map(int,input().split()))

MOD = 10**9+7



if W == 1:

  print((1))

  exit()



possible = []

for i in range(1<<(W-1)):

  b = bin(i)[2:]

  flag = 1

  for j in range(len(b)-1):

    if b[j] == b[j+1] == "1":

      flag = 0

  if flag:

    possible.append(int(b,2))



def amida(b):

  ret = [i for i in range(W)]

  for i in range(W-1):

    if b>>i & 1:

      ret[i],ret[i+1] = ret[i+1],ret[i]

  return ret



ans = [0 for i in range(W)]

ans[0] = 1



for _ in range(H):

  new_ans = [0 for i in range(W)]

  for b in possible:

    for i in range(W):

      new_ans[i] = (new_ans[i] + ans[amida(b)[i]])%MOD

  ans = new_ans

  

print((ans[K-1]))
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys

input = sys.stdin.readline
import math
import bisect
from collections import deque
from fractions import gcd
from functools import lru_cache

#############
# Constants #
#############
MOD = 10**9 + 7
INF = float("inf")
#############
# Functions #
#############
######INPUT######
def inputI():
    return int(input().strip())


def inputS():
    return input().strip()


def inputIL():
    return list(map(int, input().split()))


def inputSL():
    return list(map(str, input().split()))


def inputILs(n):
    return list(int(eval(input())) for _ in range(n))


def inputSLs(n):
    return list(input().strip() for _ in range(n))


def inputILL(n):
    return [list(map(int, input().split())) for _ in range(n)]


def inputSLL(n):
    return [list(map(str, input().split())) for _ in range(n)]


#####Inverse#####
def inv(n):
    return pow(n, MOD - 2, MOD)


######Combination######
kaijo_memo = []


def kaijo(n):
    if len(kaijo_memo) > n:
        return kaijo_memo[n]
    if len(kaijo_memo) == 0:
        kaijo_memo.append(1)
    while len(kaijo_memo) <= n:
        kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
    return kaijo_memo[n]


gyaku_kaijo_memo = []


def gyaku_kaijo(n):
    if len(gyaku_kaijo_memo) > n:
        return gyaku_kaijo_memo[n]
    if len(gyaku_kaijo_memo) == 0:
        gyaku_kaijo_memo.append(1)
    while len(gyaku_kaijo_memo) <= n:
        gyaku_kaijo_memo.append(
            gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
        )
    return gyaku_kaijo_memo[n]


def nCr(n, r):
    if n == r:
        return 1
    if n < r or r < 0:
        return 0
    ret = 1
    ret = ret * kaijo(n) % MOD
    ret = ret * gyaku_kaijo(r) % MOD
    ret = ret * gyaku_kaijo(n - r) % MOD
    return ret


######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-(n**0.5) // 1)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append([i, cnt])
    if temp != 1:
        arr.append([temp, 1])
    if arr == []:
        arr.append([n, 1])
    return arr


#####LCM#####
def lcm(a, b):
    return a * b // gcd(a, b)


#####BitCount#####
def bit_count(n):
    count = 0
    while n:
        n &= n - 1
        count += 1
    return count


#############
# Main Code #
#############
H, W, K = inputIL()
if W == 1:
    print((1))
    exit()
possible = []
for i in range(1 << (W - 1)):
    b = bin(i)[2:]
    flag = 1
    for j in range(len(b) - 1):
        if b[j] == b[j + 1] == "1":
            flag = 0
    if flag:
        possible.append(int(b, 2))


def amida(b):
    ret = [i for i in range(W)]
    for i in range(W - 1):
        if b >> i & 1:
            ret[i], ret[i + 1] = ret[i + 1], ret[i]
    return ret


ans = [0 for i in range(W)]
ans[0] = 1
for _ in range(H):
    new_ans = [0 for i in range(W)]
    for b in possible:
        for i in range(W):
            new_ans[i] = (new_ans[i] + ans[amida(b)[i]]) % MOD
    ans = new_ans
print((ans[K - 1]))

H, W, K = list(map(int, input().split()))
MOD = 10**9 + 7
if W == 1:
    print((1))
    exit()
possible = []
for i in range(1 << (W - 1)):
    b = bin(i)[2:]
    flag = 1
    for j in range(len(b) - 1):
        if b[j] == b[j + 1] == "1":
            flag = 0
    if flag:
        possible.append(int(b, 2))


def amida(b):
    ret = [i for i in range(W)]
    for i in range(W - 1):
        if b >> i & 1:
            ret[i], ret[i + 1] = ret[i + 1], ret[i]
    return ret


ans = [0 for i in range(W)]
ans[0] = 1
for _ in range(H):
    new_ans = [0 for i in range(W)]
    for b in possible:
        for i in range(W):
            new_ans[i] = (new_ans[i] + ans[amida(b)[i]]) % MOD
    ans = new_ans
print((ans[K - 1]))

-# -*- coding: utf-8 -*- -############# -# Libraries # -############# -import sys - -input = sys.stdin.readline -import math -import bisect -from collections import deque -from fractions import gcd -from functools import lru_cache - -############# -# Constants # -############# +H, W, K = list(map(int, input().split())) -INF = float("inf") -############# -# Functions # -############# -######INPUT###### -def inputI(): -    return int(input().strip()) - - -def inputS(): -    return input().strip() - - -def inputIL(): -    return list(map(int, input().split())) - - -def inputSL(): -    return list(map(str, input().split())) - - -def inputILs(n): -    return list(int(eval(input())) for _ in range(n)) - - -def inputSLs(n): -    return list(input().strip() for _ in range(n)) - - -def inputILL(n): -    return [list(map(int, input().split())) for _ in range(n)] - - -def inputSLL(n): -    return [list(map(str, input().split())) for _ in range(n)] - - -#####Inverse##### -def inv(n): -    return pow(n, MOD - 2, MOD) - - -######Combination###### -kaijo_memo = [] - - -def kaijo(n): -    if len(kaijo_memo) > n: -        return kaijo_memo[n] -    if len(kaijo_memo) == 0: -        kaijo_memo.append(1) -    while len(kaijo_memo) <= n: -        kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD) -    return kaijo_memo[n] - - -gyaku_kaijo_memo = [] - - -def gyaku_kaijo(n): -    if len(gyaku_kaijo_memo) > n: -        return gyaku_kaijo_memo[n] -    if len(gyaku_kaijo_memo) == 0: -        gyaku_kaijo_memo.append(1) -    while len(gyaku_kaijo_memo) <= n: -        gyaku_kaijo_memo.append( -            gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD -        ) -    return gyaku_kaijo_memo[n] - - -def nCr(n, r): -    if n == r: -        return 1 -    if n < r or r < 0: -        return 0 -    ret = 1 -    ret = ret * kaijo(n) % MOD -    ret = ret * gyaku_kaijo(r) % MOD -    ret = ret * gyaku_kaijo(n - r) % MOD -    return ret - - -######Factorization###### -def factorization(n): -    arr = [] -    temp = n -    for i in range(2, int(-(-(n**0.5) // 1)) + 1): -        if temp % i == 0: -            cnt = 0 -            while temp % i == 0: -                cnt += 1 -                temp //= i -            arr.append([i, cnt]) -    if temp != 1: -        arr.append([temp, 1]) -    if arr == []: -        arr.append([n, 1]) -    return arr - - -#####LCM##### -def lcm(a, b): -    return a * b // gcd(a, b) - - -#####BitCount##### -def bit_count(n): -    count = 0 -    while n: -        n &= n - 1 -        count += 1 -    return count - - -############# -# Main Code # -############# -H, W, K = inputIL()