#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <numeric>
#include <queue>
#include <map> 
#include <set>
#include <string>
#include <functional>
#include <list>
#include <random>
#include <time.h>
#include <iomanip>
#include <assert.h>
#include <numeric>
//#define int long long
//#define double long double
#define oku7 1000000007
#define MAXN (int)1e+5 * 2+1
#define LL_MAX 9223372036854775807	//ない環境用
#define LL_HALFMAX 9223372036854775807 / 2	//ない環境用

using namespace std;
std::mt19937 mt((int)time(0));

int dx[4] = { 0, 1, 0, -1 }; // x軸方向への変位
int dy[4] = { 1, 0, -1, 0 }; // y軸方向への変位

template <signed M, unsigned T>
struct mod_int {
	constexpr static signed MODULO = M;
	constexpr static unsigned TABLE_SIZE = T;

	signed x;

	mod_int() : x(0) {}

	mod_int(long long y) : x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}

	mod_int(int y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}

	mod_int &operator+=(const mod_int &rhs) {
		if ((x += rhs.x) >= MODULO) x -= MODULO;
		return *this;
	}

	mod_int &operator-=(const mod_int &rhs) {
		if ((x += MODULO - rhs.x) >= MODULO) x -= MODULO;
		return *this;
	}

	mod_int &operator*=(const mod_int &rhs) {
		x = static_cast<signed>(1LL * x * rhs.x % MODULO);
		return *this;
	}

	mod_int &operator/=(const mod_int &rhs) {
		x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
		return *this;
	}

	mod_int operator-() const { return mod_int(-x); }

	mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }

	mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }

	mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }

	mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }

	bool operator<(const mod_int &rhs) const { return x < rhs.x; }

	mod_int inv() const {
		assert(x != 0);
		if (x <= static_cast<signed>(TABLE_SIZE)) {
			if (_inv[1].x == 0) prepare();
			return _inv[x];
		}
		else {
			signed a = x, b = MODULO, u = 1, v = 0, t;
			while (b) {
				t = a / b;
				a -= t * b;
				std::swap(a, b);
				u -= t * v;
				std::swap(u, v);
			}
			return mod_int(u);
		}
	}

	mod_int pow(long long t) const {
		assert(!(x == 0 && t == 0));
		mod_int e = *this, res = mod_int(1);
		for (; t; e *= e, t >>= 1)
			if (t & 1) res *= e;
		return res;
	}

	mod_int fact() {
		if (_fact[0].x == 0) prepare();
		return _fact[x];
	}

	mod_int inv_fact() {
		if (_fact[0].x == 0) prepare();
		return _inv_fact[x];
	}

	mod_int choose(mod_int y) {
		assert(y.x <= x);
		return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
	}

	static mod_int _inv[TABLE_SIZE + 1];

	static mod_int _fact[TABLE_SIZE + 1];

	static mod_int _inv_fact[TABLE_SIZE + 1];

	static void prepare() {
		_inv[1] = 1;
		for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
			_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
		}
		_fact[0] = 1;
		for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
			_fact[i] = _fact[i - 1] * int(i);
		}
		_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
		for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
			_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
		}
	}
};

template <int M, unsigned F>
std::ostream &operator<<(std::ostream &os, const mod_int<M, F> &rhs) {
	return os << rhs.x;
}

template <int M, unsigned F>
std::istream &operator>>(std::istream &is, mod_int<M, F> &rhs) {
	long long s;
	is >> s;
	rhs = mod_int<M, F>(s);
	return is;
}

template <int M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];

template <int M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];

template <int M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];

template <int M, unsigned F>
bool operator==(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
	return lhs.x == rhs.x;
}

template <int M, unsigned F>
bool operator!=(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
	return !(lhs == rhs);
}

const int MF = 1000010;
const int MOD = 1000000007;

using mint = mod_int<MOD, MF>;

mint binom(int n, int r) { return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r); }

mint fact(int n) { return mint(n).fact(); }

mint inv_fact(int n) { return mint(n).inv_fact(); }

int f(int b, int n) {
	//if (n < b) return n;
	//else return f(b, floor((double)n / (double)b)) + n%b;
	int ret=0;
	while (n >= b) {
		ret += n % b;
		n = floor((double)n / (double)b);
	}
	ret += n;
	return ret;
}
mint arr[101][9];
signed main() {
	int H, W, K;
	cin >> H >> W >> K;

	if (W == 1) {
		if (K == 1) cout << "1\n";
		else cout << "0\n";
		return 0;
	}

	for (int i = 0; i < 9; i++) {
		for (int j = 0; j < 101; j++) {
			arr[i][j] = 0;
		}
	}

	//h = 0, w = 1は1
	arr[0][0] = 1;
	int bit = 1;
	for (int i = 0; i < W - 1; i++)bit *= 2;
	for (int i = 1; i <= H; i++) {
		//ヨコ1行を全探索
		for (int j = 0; j < bit; j++) {
			vector<bool> line;
			for (int k = 0; k < W-1; k++) {
				line.push_back(j >> k & 1);
			}
			bool bad = false;
			for (int l = 0; l < line.size() -1; l++) {
				if (line[l] && line[l + 1]) bad = true;
			}
			if (bad) continue;
			for (int m = 0; m < line.size(); m++) {
				if (line[m]) {
					//line[m] : mとm+1が繋がっている
					arr[i][m] += arr[i - 1][m + 1];
					arr[i][m + 1] += arr[i - 1][m];
					//if (arr[i][m] >= MOD) arr[i][m] %= MOD;
					//if (arr[i][m+1] >= MOD) arr[i][m+1] %= MOD;
				}
			}

			for (int l = 0; l < line.size() - 1; l++) {
				if (!line[l] && !line[l + 1]) arr[i][l + 1] += arr[i-1][l + 1];
			}
			if(line[0] == false) arr[i][0] += arr[i - 1][0];
			if (line[line.size() - 1] == false) arr[i][line.size()] += arr[i - 1][line.size()];


			//for (int po = 0; po < line.size(); po++) cout << line[po] << " ";
			//cout << "\n";
		}
		int q = 0;

	}
	cout << arr[H][K-1]<<"\n";



	return 0;
}

Measured memory_bytes: 12032