#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<functional>
#include<map>
#include<cstdlib>
#include<complex>
#include<numeric>
#include<set>
#include<deque>
#include<queue>

using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000000 + 7;

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

using mint = Mint<>;

template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
	for (const auto& e : vec) os << e << (&e == &vec.back() ? "\n" : " ");
	return os;
}

#ifdef _DEBUG
template <class T>
void dump(const char* str, T&& h) { cerr << str << " = " << h << "\n"; };
template <class Head, class... Tail>
void dump(const char* str, Head&& h, Tail&&... t) {
	while (*str != ',') cerr << *str++; cerr << " = " << h << "\n";
	dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else 
#define DMP(...) ((void)0)
#endif

int main() {

	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	Int H, W, K;
	cin >> H >> W >> K;

	vector<vector<mint>> dp(H + 1, vector<mint>(W, mint(0LL)));
	dp[0][0] = 1;

	for (Int i = 0; i < H; i++) {

		//bit全探索で横棒の位置を決定
		for (Int bit = 0; bit < (1LL<<(W-1)); bit++) {
			
			//横棒が二本連続していないか
			Int flag = 0;
			for (Int j = 0; j < W-2; j++) {
				if ((bit & (1LL << j)) && (bit & (1LL << (j + 1)))) {
					flag = 1;
					break;
				}
			}
			if (flag)continue;

			//dpの遷移
			for (Int j = 0; j < W-1; j++) {
				//横棒がある場合（スワップされる）
				if (bit & (1LL << j)) {
					dp[i + 1][j] += dp[i][j + 1];
					dp[i + 1][j + 1] += dp[i][j];

					if (j == W - 3) {//右端が飛ばされないように
						dp[i + 1][j + 2] += dp[i][j + 2];
					}
					j++;//余分にインクリメント
				}
				//横棒がない場合（そのまま降りる）
				else {
					dp[i + 1][j] += dp[i][j];

					if (j == W - 2) {//右端の処理
						dp[i + 1][j + 1] += dp[i][j + 1];
					}
				}
			}
		}
	}

	DMP(dp);

	if (W == 1) {
		cout << 1 << "\n";
	}
	else {
		cout << dp[H][K - 1] << "\n";
	}
}


Measured memory_bytes: 256