use std::vec::Vec;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 3);
  (v[0], v[1], v[2])
}

const MOD: usize = 1_000_000_000 + 7;
fn main() {
    let (H, W, K) = read_touple::<usize>();
    let bits = BitSet::empty(W-1);
    let mut dp = vec![vec![0; W+1]; H+1];


    // init 
    dp[0][0] = 1;

    for i in 0..H {
      for j in 0..W {
        for b in bits {
          if !check(b) {
             continue
          }
          //println!("{:?}", b);

          if 0 < j && j < W-1 {
             if b.include(j-1) {
                dp[i+1][j] += dp[i][j-1];
                dp[i+1][j] %= MOD;
             }
             if !b.include(j-1) && !b.include(j) {
                dp[i+1][j] += dp[i][j];
                dp[i+1][j] %= MOD;
             }
             if b.include(j) {
                dp[i+1][j] += dp[i][j+1];
                dp[i+1][j] %= MOD;
             }
          } else if j == 0 {
             if b.include(j) {
                dp[i+1][j] += dp[i][j+1];
                dp[i+1][j] %= MOD;
             } else {
               dp[i+1][j] += dp[i][j];
               dp[i+1][j] %= MOD;
             }
          } else if j == W-1 {
            if b.include(j-1) {
               dp[i+1][j] += dp[i][j-1];
               dp[i+1][j] %= MOD;
            }
            if !b.include(j-1) {
               dp[i+1][j] += dp[i][j];
               dp[i+1][j] %= MOD;
            }
          }
        }
        // for i in 0..H+1 {
        //   println!("{:?}", dp[i]);
        // }
        // println!("");
      }
    }
    // for i in 0..H+1 {
    //   println!("{:?}", dp[i]);
    // }

    println!("{}", dp[H][K-1] % MOD);
}

fn check(bits: BitSet) -> bool {
  let biv = bits.to_vec();
  let n = biv.len();
  if n == 0 {
     return true;
  }
  for i in 0..n-1  {
    if biv[i] == 1 && biv[i+1] == 1 {
       return false;
    }
  }
  true
}

#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
struct BitSet {
    bits: usize,
    size: usize,
}

impl std::fmt::Debug for BitSet {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "BitSet {{ bits: {:b}, size: {} }}", self.bits, self.size)
    }
}

impl BitSet {
    //
    fn empty(size: usize) -> BitSet {
        if size > 64 {
            panic!("large set size")
        }
        BitSet {
            bits: 0,
            size: size,
        }
    }
    // コンンストラクター
    fn new(n: usize, size: usize) -> BitSet {
        BitSet {
            bits: n,
            size: size,
        }
    }

    // 和集合を求める
    fn union(&self, other: BitSet) -> BitSet {
        BitSet {
            bits: self.bits | other.bits,
            size: self.size, // debug
        }
    }

    // 共通部分を求める
    fn intersect(&self, other: BitSet) -> BitSet {
        BitSet {
            bits: self.bits & other.bits,
            size: self.size, // debug
        }
    }

    // n を含むかどうか
    fn include(&self, n: usize) -> bool {
        if self.size < n {
            return false;
        }
        self.bits & (1 << n) != 0
    }

    fn to_vec(&self) -> std::vec::Vec<usize> {
        let mut res = std::vec::Vec::new();
        let mut bits = self.bits;

        for _ in 0..self.size {
            res.push(bits % 2);
            bits /= 2;
        }
        res
    }

    // 集合を表すusizeの値を返す
    fn unwrap(&self) -> usize {
        self.bits
    }
}

impl Iterator for BitSet {
    type Item = BitSet;

    fn next(&mut self) -> Option<Self::Item> {
        if (1 << self.size) <= self.bits {
            return None;
        }
        self.bits += 1;
        Some(BitSet {
            bits: self.bits-1,
            size: self.size,
        })
    }
}

Measured memory_bytes: 4352