import std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;

/+
// mod must be a prime number
struct Mod(uint mod) if (mod < int.max) {
	import std.conv : to;
	
	uint n;
	this(int m)  { this(long(m)); }
	this(long m) { this.n = m >= 0L ? cast(uint)(m % mod) : cast(uint)(m % mod + mod); }
	this(ulong m) { this.n = cast(uint)(m % mod); }
	
	static auto normalize_(uint x) { return (x<=mod)? x : x-mod; }
	static auto make_(uint n_) { Mod!mod m; m.n = n_; return m; }
	
	auto opBinary(string op:"+")(Mod b)  const { return make_(normalize_(n+b.n)); }
	auto opBinary(string op:"-")(Mod b)  const { return make_(normalize_(n+mod-b.n)); }
	auto opBinary(string op:"*")(Mod b)  const { return make_( ((n*b.n) % mod).to!uint ); }
	auto opBinary(string op:"/")(Mod b)  const { return this*inv(b); }
	auto opBinary(string op:"^^")(Mod b) const { return make_( ( n ^^ ( b.n % (mod-1) ) % mod ).to!uint ); }
	auto opUnary(string op: "-")() const { return make_(normalize_( mod-this.n )); }
	auto opOpAssign(string op)(Mod b) if (op == "+" || op == "-" || op == "*" || op == "/" || op == "^^") { return mixin("this=this"~op~"b"); }
	static Mod inv(Mod x) { return x^^(mod-2); }
	auto opAssign(ulong b) { n = cast(uint)(b%mod); return this; }
	auto opAssign(long b) { return opAssign( b < 0 ? cast(ulong)(b%mod + mod) : cast(ulong)(b) ); }
	
	auto opBinary(string op)(long b) const if (op == "+" || op == "-" || op == "*" || op == "/" || op == "^^") {
		auto m = Mod!mod(b); return mixin("this"~op~"m");
	}
	auto opUnary(string op)(long b) const if (op == "-") {
		auto m = Mod!mod(b); return mixin(op~"m");
	}
	auto opOpAssign(string op)(long b) if (op == "+" || op == "-" || op == "*" || op == "/" || op == "^^") {
		auto m = Mod!mod(b); return mixin("this"~op~"=m");
	}
	
	string toString() const { return n.to!string; }
}

void main() {
	//static immutable uint mod = 1_000_000_007;
	alias Int = Mod!1_000_000_007;
	
	auto data = readln.split; 
	auto H = data[0].to!int, W = data[1].to!int, K = data[2].to!int;
	if (W == 1) { writeln("1"); return; }
	
	bool[][] all_pattern(uint n) {
		if (n == 1) return [[false], [true]];
		auto next = all_pattern(n-1);
		auto result = next.map!"a~false".array;
		foreach (pat; next) { if (!pat[$-1]) result ~= pat ~ true; }
		return result;
	}
	
	auto pattern = all_pattern(W-1);
	Int[10][100] A; A[0][0] = Int(1);
	//pattern.writeln;
	foreach (h; 0 .. H) foreach (w; 0 .. W) {
		Int X, Y, Z;
		if (w == 0) {
			Y = pattern.count!((a,b) => a[0]==b)(false), Z = Int(pattern.length) - Y;
			//writeln("--here"); Y.writeln; Z.writeln; writeln("here--");
			A[h+1][w] += Y * A[h][w]; A[h+1][w+1] += Z * A[h][w];
		}
		else if (w == W-1) {
			Y = pattern.count!((a,b) => a[W-2]==b)(false), X = Int(pattern.length) - Y;
			A[h+1][w-1] += X * A[h][w]; A[h+1][w] += Y * A[h][w];
			//writeln("--here"); X.writeln; Y.writeln; writeln("here--");
		}
		else {
			X = pattern.count!((a,b) => a[w-1]==b)(true), Z = pattern.count!((a,b) => a[w]==b)(true), Y = Int(pattern.length)-X-Z;
			A[h+1][w-1] += X * A[h][w]; A[h+1][w] += Y * A[h][w]; A[h+1][w+1] += Z * A[h][w];
			//writeln("--here"); X.writeln; Y.writeln; Z.writeln; writeln("here--");
		}
		//writeln(A[h+1][w]);
	}
	A[H][K-1].writeln;
}
+/

void main() {
	static immutable uint mod = 1_000_000_007;
	//alias Int = Mod!1_000_000_007;
	
	auto data = readln.split; 
	auto H = data[0].to!int, W = data[1].to!int, K = data[2].to!int;
	if (W == 1) { writeln("1"); return; }
	
	bool[][] all_pattern(uint n) {
		if (n == 1) return [[false], [true]];
		auto next = all_pattern(n-1);
		auto result = next.map!"a~false".array;
		foreach (pat; next) { if (!pat[$-1]) result ~= pat ~ true; }
		return result;
	}
	
	auto patterns = all_pattern(W-1);
	ulong[10][101] A; A[0][0] = 1;
	//patterns.writeln;
	foreach (h; 0 .. H) foreach (w; 0 .. W) {
		foreach (row; patterns) {
			if      (w == 0) {
				if (row[0]) { A[h+1][w+1] += A[h][w]; A[h+1][w+1] %= mod; }
				else { A[h+1][w] += A[h][w]; A[h+1][w] %= mod;  }
			}
			else if (w == W-1) {
				if (row[w-1]) { A[h+1][w-1] += A[h][w]; A[h+1][w-1] %= mod; }
				else { A[h+1][w] += A[h][w]; A[h+1][w] %= mod; }
			}
			else {
				if (row[w-1]) { A[h+1][w-1] += A[h][w]; A[h+1][w-1] %= mod; }
				else if (row[w]) { A[h+1][w+1] += A[h][w]; A[h+1][w+1] %= mod; }
				else { A[h+1][w] += A[h][w]; A[h+1][w] %= mod; }
			}
		}
	}
	A[H][K-1].writeln;
}
