#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <array>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <stack>
#include <queue>
#include <bitset>
#include <tuple>
#include <cmath>
#include <complex>
#include <algorithm>
#include <utility>
#include <regex>
#include <cstdint>
#include <numeric>
#include <functional>
#include <cassert>

using namespace std;
using ll = int64_t;
using ull = uint64_t;

constexpr ll INF = 1000000000;/* 1e+9a */

vector<pair<ll, ll>> split_swap(const vector<int> &perm){
    vector<pair<ll, ll>> sw;
    int p = 0;
    for (int i = 0; i < perm.size(); ++i) {
        int x = i - perm[i];
        if(abs(x) >= 2) return {};
        if(x == p and p != 0){
            return {};
        }
        if(x == 1){
            sw.emplace_back(i-1, i);
        }
        else if(p == -1){
            return {};
        }
        p = x;
    } // end i
    return sw;
}

// Residue Class Ring
namespace Xelmh_RCR {
    class RCR {
        // Residue Class Ring
    public:
        static const int64_t MOD = 1000000007;
//        static const int64_t MOD = 998244353;
        int64_t val;
        RCR(int64_t l) : val{l % MOD} {}
        RCR() : val{0} {}

        RCR pow(RCR m) const {
            RCR rv{1};
            auto nmul = val;
            while (m.val > 0) {
                if ((m.val & 1) == 1) {
                    rv.val *= nmul;
                    rv.val %= MOD;
                }
                nmul *= nmul;
                nmul %= MOD;
                m.val /= 2;
            }
            return rv;
        }
        RCR inv() const { /* return Inverse */ return this->pow(MOD - 2); }
        void operator+=(const RCR &a) {
            val += a.val;
            val %= MOD;
        }
        void operator-=(const RCR &a) {
            val -= a.val;
            val %= MOD;
        }
        void operator*=(const RCR &a) {
            val *= a.val;
            val %= MOD;
        }
        void operator/=(const RCR &a) {
            val *= a.inv().val;
            val %= MOD;
        }
    };

    // supported operator :: + - * / ^
    RCR operator+(const RCR &a, const RCR &b) { return (a.val + b.val) % RCR::MOD; }
    RCR operator-(const RCR &a, const RCR &b) { return (a.val - b.val + RCR::MOD) % RCR::MOD; }
    RCR operator*(const RCR &a, const RCR &b) { return (a.val * b.val) % RCR::MOD; }
    RCR operator/(const RCR &a, const RCR &b) { return (a.val * b.inv().val) % RCR::MOD; }
    RCR operator^(const RCR &a, const RCR &b) { return a.pow(b); }

    RCR operator==(const RCR &a, const RCR &b) { return a.val == b.val; }
    RCR operator!=(const RCR &a, const RCR &b) { return a.val != b.val; }
    // IO
    std::ostream &operator<<(std::ostream &os, const RCR &m) { return os << m.val; }
    std::istream &operator>>(std::istream &is, RCR &m) { return is >> m.val; }

    RCR fact(ll N) {
        /* N -> N! */
        static vector<RCR> cal(1, RCR{1});

        if (cal.size() > N) return cal[N];
        else {
            RCR nm = fact(N - 1);
            assert(cal.size() == N);
            cal.push_back(nm * N);
            return cal[N];
        }
    }

    RCR choice(ll N, ll k) {
        /* N, k -> N C k */

        // N! / k!(N-k!)
        RCR ans = fact(N) / (fact(k) * fact(N - k));
        return ans;
    }
}
using namespace Xelmh_RCR;


void solve(istream &cin) {
    ll H, W, K;
    cin >> H >> W >> K;
    if(!cin) return;
    K--;

    vector<vector<ll>> s_to_s(W,vector<ll>(W));
    for (int i = 0; i < W; ++i) {
        s_to_s[i][i] = 1;
    } // end i
    vector<int> perm(W); iota(perm.begin(), perm.end(), 0);
    do{
        auto sw = split_swap(perm);
        if(!sw.empty()){
            for (auto &&p : sw) {
                s_to_s[p.first][p.second]++;
                s_to_s[p.second][p.first]++;
            } // end p
            for (int i = 0; i < perm.size(); ++i) {
                if(i == perm[i]){
                    s_to_s[i][i]++;
                }
            } // end i
        }
    }while(next_permutation(perm.begin(), perm.end()));

    vector<RCR> dp(W);
    dp[0] = 1;
    for (int i = 0; i < H; ++i) {
        vector<RCR> dp2(W);
        for (int i = 0; i < W; ++i) {
            for (int j = 0; j < W; ++j) {
                dp2[i] += dp[j] * s_to_s[j][i];
            } // end j
        } // end i
        dp = dp2;
    } // end i
    cout << dp[K] << endl;

}

int main(int argc, char *argv[]) {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << setprecision(16) << scientific;
#ifdef DEBUG
    cerr << "DEBUG MODE" << endl;
    string test_cases = "test.txt";
    auto fs = fstream(test_cases, fstream::in);
    while(fs) {
        solve(fs);
    }
#else
    solve(cin);
#endif
    return 0;
}


Measured memory_bytes: 256