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-mod : x; }
	static auto make_(uint x) { Mod!mod m; m.n = x; 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_( ((ulong(n)*b.n) % mod).to!uint ); }
	auto opBinary(string op:"^^")(Mod b) const { return make_( ( n ^^ ( b.n % (mod-1) ) % mod ).to!uint ); }
	static Mod inv(Mod x) { return x^^(mod-2); }
	auto opBinary(string op:"/")(Mod b)  const { return this*inv(b); }
	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"); }
	
	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");
	}
	
	auto opAssign(ulong b) { n = cast(uint)(b%mod); return this; }
	auto opAssign(long b)  { n = (b < 0) ? cast(uint)(b%mod + mod) : cast(uint)(b%mod); return this; }
	auto opAssign(int b)   { return opAssign(long(b)); }
	
	
	string toString() const { return n.to!string; }
}

void main() {
	static immutable uint 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);
	alias Int = Mod!mod;
	Int[10][101] A; A[0][0] = 1;
	//patterns.writeln;
	foreach (h; 0 .. H) foreach (w; 0 .. W) {
		
		Int X, Y, Z;
		if (w == 0) {
			Z = patterns.count!(a => a[w]), Y = Int(patterns.length) - Z;
			A[h+1][w]   += Y * A[h][w];
			A[h+1][w+1] += Z * A[h][w];
			//writeln(Y * A[h][w], ", ", Z * A[h][w]);
		}
		else if (w == W-1) {
			X = patterns.count!(a => a[w-1]), Y = Int(patterns.length) - X;
			A[h+1][w-1] += X * A[h][w];
			A[h+1][w]   += Y * A[h][w];
			//writeln(X * A[h][w], ", ", Y * A[h][w]);
		}
		else {
			X = patterns.count!(a => a[w-1]), Z = patterns.count!(a => a[w]), Y = Int(patterns.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(X * A[h][w], ", ", Y * A[h][w], ", ", Z * A[h][w]);
		}
      
	}
	A[H][K-1].writeln;
}


Measured memory_bytes: 256