#include <bits/stdc++.h>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long int;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<uint_fast64_t Modulas = 1000000007ul>
class ModInt {
    using u64 = uint_fast64_t;
public:
    u64 x;
 
    constexpr ModInt() : x(0) {}
    constexpr ModInt(const u64 x) : x(x % Modulas) {}
    constexpr ModInt operator+(const ModInt rhs) const noexcept {
        return ModInt(*this) += rhs;
    }
    constexpr ModInt operator-(const ModInt rhs) const noexcept {
        return ModInt(*this) -= rhs;
    }
    constexpr ModInt operator*(const ModInt rhs) const noexcept {
        return ModInt(*this) *= rhs;
    }
    constexpr ModInt operator/(const ModInt rhs) const noexcept {
        return ModInt(*this) /= rhs;
    }
    constexpr ModInt operator/(const long long rhs) const noexcept {
        return ModInt(*this) /= rhs;
    }
    constexpr ModInt operator+=(const ModInt rhs) noexcept {
        x += rhs.x;
        if (x >= Modulas) x -= Modulas;
        return *this;
    }
    constexpr ModInt operator+=(const long long rhs) noexcept {
        auto hs = ModInt<Modulas>(rhs);
        (*this) += hs;
        return *this;
    }
    constexpr ModInt operator-=(const ModInt rhs) noexcept {
        if (x < rhs.x) x += Modulas;
        x -= rhs.x;
        return *this;
    }
    constexpr ModInt operator-=(const long long rhs) noexcept {
        auto hs = ModInt<Modulas>(rhs);
        (*this) -= hs;
        return *this;
    }
    constexpr ModInt operator*=(const ModInt rhs) noexcept {
        x = x * rhs.x % Modulas;
        return *this;
    }
    constexpr ModInt operator*=(const long long rhs) noexcept {
        auto hs = ModInt<Modulas>(rhs);
        (*this) *= hs;
        return *this;
    }
    constexpr ModInt &operator/=(ModInt rhs) noexcept {
        u64 exp = Modulas - 2;
        while (exp > 0) {
            if (exp & 1ul) *this *= rhs;
            rhs *= rhs;
            exp >>= 1ul;
        }
        return *this;
    }
    constexpr ModInt &operator/=(long long rhs) noexcept {
        auto hs = ModInt<Modulas>(rhs);
        (*this) /= hs;
        return *this;
    }
 
    constexpr ModInt &operator++() noexcept {
        x++;
        if (x >= Modulas) x -= Modulas;
        return *this;
    }
    constexpr ModInt &operator--() noexcept {
        if (x == 0) x += Modulas;
        x--;
        return *this;
    }
    constexpr bool operator<(const ModInt rhs) const noexcept {
        return x < rhs.x;
    }
    constexpr bool operator==(const ModInt rhs) const noexcept {
        return this->x == rhs.x;
    }
    constexpr bool operator!=(const ModInt rhs) const noexcept {
        return !(*this == rhs);
    }
    friend istream &operator>>(istream &in, ModInt &m) {
        in >> m.x;
        m.x %= Modulas;
        return in;
    }
    friend ostream &operator<<(ostream &out, const ModInt &p) {
        out << p.x;
        return out;
    }
    constexpr ModInt pow(u64 p) const {
        ModInt ret(1);
        ModInt mul(x);
        while (p > 0) {
            if (p & 1ul) ret *= mul;
            mul *= mul;
            p >>= 1ul;
        }
        return ret;
    }
    constexpr ModInt operator~() const noexcept {
        u64 exp = Modulas - 2;
        return pow(exp);
    }
};
const ll INF = 1e9;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
int h,w,k;
ModInt<MOD> dp[105][9] = {0};
int main(){
    scanf("%d %d %d",&h,&w,&k);
    if (w == 1){
        PRINT(1);
        return 0;
    }
    bool out;
    dp[0][0] = 1;
    rep(i,h){
        rep(b,(1<<(w-1))){
            out = 0;
            rep(m,w-2){
                if ((1<<m)&b && (1<<(m+1))&b) out = 1;
            }
            if (out) continue;
            rep(m,w-1){
                if ((1<<m)&b){
                    dp[i+1][m] += dp[i][m+1];
                    dp[i+1][m+1] += dp[i][m];
                }
                if (m == 0 && !((1<<m)&b)){
                    dp[i+1][0] += dp[i][0];
                }
                if (m == w-2 && !((1<<m)&b)){
                    dp[i+1][w-1] += dp[i][w-1];
                }
                if (m != w-2 && !((1<<m)&b) && !((1<<(m+1))&b)){
                    dp[i+1][m+1] += dp[i][m+1];
                }
            }
        }
    }
    PRINT(dp[h][k-1]);
}

Measured memory_bytes: 256