#include <bits/stdc++.h>
using namespace std;

#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x,y) CPP_CAT_I(x,y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x,y) x ## y

using i8  = int8_t;
using u8  = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;

using f32 = float;
using f64 = double;

#define FOR(i, start, end) for(i64 i = (start), CPP_CAT(i,xxxx_end)=(end); i < CPP_CAT(i,xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) for(i64 i = 1; i <= n; ++i)
#define RREP(i, n) for(i64 i = n - 1; i >= 0 ; --i)
#define RREPS(i, n) for(i64 i = n; i >= 1; --i)

#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))

#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

#define pb push_back
#define mp make_pair
#define F first
#define S second

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<typename C>
i64 SIZE(const C& c) { return static_cast<i64>(c.size()); }

template<typename T, size_t N>
i64 SIZE(const T (&)[N]) { return static_cast<i64>(N); }


struct ProconInit {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;

    ProconInit() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(IOS_PREC);
        if(AUTOFLUSH)
            cout << unitbuf;
    }
} PROCON_INIT;


#define MAX_H 100
#define MAX_W 8

template<int MOD>
struct Fp {
    i64 val;
    constexpr Fp(i64 v = 0) noexcept : val(v % MOD) {
        if (val < 0) val += MOD;
    }
    constexpr int getmod() { return MOD; }
    constexpr Fp operator - () const noexcept {
        return val ? MOD - val : 0;
    }
    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
    constexpr Fp& operator += (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Fp& operator -= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Fp& operator *= (const Fp& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp& operator /= (const Fp& r) noexcept {
        i64 a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            i64 t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator != (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    constexpr bool operator > (const Fp& r) const noexcept {
        return this->val > r.val;
    }
    constexpr bool operator >= (const Fp& r) const noexcept {
        return this->val >= r.val;
    }
    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, i64 n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1) t = t * a;
        return t;
    }
};

#define MOD 1'000'000'007
using mint = Fp<MOD>;

i64 H, W, K;
mint dp[MAX_H + 1][MAX_W];
mint fact[2 * MAX_W];

mint modfact(i64 n) {
    if (fact[n] > (mint)0) return fact[n];

    mint p = 1;
    REPS(i, n) {
        p *= (mint)i;
        fact[i] = p;
    }

    return fact[n] = p;
}

mint modcomb(i64 n, i64 k) {
    if (n < k) return (mint)0;
    return modfact(n) / (modfact(k) * modfact(n - k));
}

int main() {
    cin >> H >> W >> K;
    K--;

    i64 N_GAP = W - 1;

    vector<mint> C(N_GAP, 0);
    REP(i, N_GAP) {
        REP(k, N_GAP) {
            i64 n = i - k + 1;
            if (n < k) break;
            C[i] += modcomb(n, k);
        }
        if (N_GAP <= 0) C[i] = 1;
    }

    REP(i, H + 1) REP(j, W) dp[i][j] = 0;
    dp[0][0] = 1;

    REP(i, H) {
        REP(j, W) {
            auto comb = [&](i64 n) {
                if (n <= 0) return (mint)1;
                return C[n];
            };
            i64 left_gap = j;
            i64 right_gap = W - 1 - j;
            if (j > 0) dp[i + 1][j - 1] += dp[i][j] * comb(left_gap - 2) * comb(right_gap - 1);
            if (j < W - 1) dp[i + 1][j + 1] += dp[i][j] * comb(left_gap - 1) * comb(right_gap - 2);

            dp[i + 1][j] += dp[i][j] * comb(left_gap - 1) * comb(right_gap - 1);
        }
    }

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

    return 0;
}

Measured memory_bytes: 256