#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <stack>
#include <complex>
#include <stdlib.h>
#include <stdio.h>
#include <functional>


#define fs first
#define sc second

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

const ll mod = 1000000007;
ll fact[200200];
ll invfact[200200];

inline ll take_mod(ll a){
    return (a % mod + mod) % mod;
}

inline ll add(ll a, ll b){
    return take_mod(a+b);
}

inline ll sub(ll a, ll b){
    return take_mod(a-b);
}


inline ll mul(ll a, ll b){
    return take_mod(a * b);
}

inline ll pow(ll x, ll n){
    ll res = 1LL;
    while(n > 0){
        if(n & 1) res = mul(res, x);
        x = mul(x, x);
        n >>= 1;
    }
    return res;
}

ll mod_inv(ll x){
    return pow(x, mod-2);
}

// nは上限
void make_fact(ll n){
    fact[0] = 1;
    ll res = 1;
    for(int i = 1; i <= n; i++){
        fact[i] = res;
        res = mul(res, i+1);
    }
}

// nは上限
void make_invfact(ll n){
    invfact[0] = 1;
    invfact[n] = mod_inv(fact[n]);
    for(int i = n-1; i >= 1; i--){
        invfact[i] = mul(invfact[i + 1], i + 1);
    }
}

ll perm(ll n, ll k){
    return mul(fact[n], invfact[n-k]);
}

ll comb(ll n, ll k){
    return mul(mul(fact[n], invfact[n-k]), invfact[k]);
}


int main(){
    int H, W, K;
    cin >> H >> W >> K;
    ll dp[150][8];
    ll can_draw[8][8];

    for(int i = 0; i < 8; i++){
        for(int j = max(i-1, 0); j <= min(i+1, 7); j++){
            ll dp2[8][2];
            for(int i2 = 0; i2 < 8; i2++){
                fill(dp2[i2], dp2[i2]+2, 0);
            }

            int l = min(i, j);
            int r = max(i, j);

            if(l == r && l == 0){
                dp2[0][1] = 1;
            }
            else if(l != r && l == 0){
                dp2[0][0] = 1;
            }
            else{
                dp2[0][0] = 1;
            }
            for(int k = 1; k < 8; k++){
                if(l == r && k == l){
                    dp2[k][1] = add(dp2[k-1][0], dp2[k-1][1]);
                }
                else if(l == r && k == l+1){
                    dp2[k][0] = dp2[k-1][1];
                }
                else if(l != r && k == l){
                    dp2[k][0] = add(dp2[k-1][0], dp2[k-1][1]);
                }
                else if(l != r && k == r){
                    dp2[k][1] = dp2[k-1][0];
                }
                else if(l != r && k == r+1){
                    dp2[k][0] = dp2[k-1][1];
                }
                else{
                    dp2[k][0] = add(dp2[k-1][0], dp2[k-1][1]);
                    dp2[k][1] = dp2[k-1][0];
                }
            }
            can_draw[i][j] = add(dp2[W-1][0], dp2[W-1][1]);
        }
    }


    for(int i = 0; i < 150; i++){
        for(int j = 0; j < 8; j++){
            dp[i][j] = 0;
        }
    }


    dp[0][0] = 1;

    for(int i = 1; i <= H; i++){
        for(int j = 0; j < W; j++){
            for(int k = max(0, j-1); k <= min(W-1, j+1); k++){
                dp[i][j] = add(dp[i][j], mul(dp[i-1][k], can_draw[k][j]));
            }
        }
    }

    cout << dp[H][K-1] << endl;

    return 0;

}


Measured memory_bytes: 256