#include <bits/stdc++.h>
using namespace std;

template<class Numeric> class matrix {
  protected:
    vector< vector<Numeric> > _mat;
    const int _col, _row;
    const bool usingModulo = true;
    const Numeric modulo = 1000000007; // using modulo
  public:
    matrix(int col, int row) : _col(col), _row(row) {
      _mat.assign(col, vector<Numeric>(row, 0));
    }
    matrix(int col, int row, int num) : _col(col), _row(row) {
      _mat.assign(col, vector<Numeric>(row, num));
    }
    int col() const { return _col; }
    int row() const { return _row; }
    vector<Numeric> &operator[](int i) { return _mat[i]; }
    Numeric &operator() (int i, int j) { return _mat[i][j]; }
    matrix<Numeric> operator+(matrix<Numeric> &x) {
      if (this->col() != x.col() || this->row() != x.row()) {
        cout << "matrices are different sizes .. ";
        this->size(false); cout << "+"; x.size(true);
        exit(0);
      }
      matrix<Numeric> ret(this->col(), this->row());
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          ret[i][j] = _mat[i][j] + x[i][j];
          if (usingModulo) ret[i][j] %= modulo;
        }
      }
      return ret;
    }
    matrix<Numeric> &operator+=(matrix<Numeric> &x) {
      if (this->col() != x.col() || this->row() != x.row()) {
        cout << "matrices are different sizes .. ";
        this->size(false); cout << "+"; x.size(true);
        exit(0);
      }
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          _mat[i][j] += x[i][j];
          if (usingModulo) _mat[i][j] %= modulo;
        }
      }
    }
    matrix<Numeric> operator-(matrix<Numeric> &x) {
      if (this->col() != x.col() || this->row() != x.row()) {
        cout << "matrices are different sizes .. ";
        this->size(false); cout << "-"; x.size(true);
        exit(0);
      }
      matrix<Numeric> ret(this->col(), this->row());
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          ret[i][j] = _mat[i][j] - x[i][j];
          if (usingModulo) ret[i][j] %= modulo;
        }
      }
      return ret;
    }
    matrix<Numeric> &operator-=(matrix<Numeric> &x) {
      if (this->col() != x.col() || this->row() != x.row()) {
        cout << "matrices are different sizes .. ";
        this->size(false); cout << "-"; x.size(true);
        exit(0);
      }
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          _mat[i][j] -= x[i][j];
          if (usingModulo) _mat[i][j] %= modulo;
        }
      }
    }
    matrix<Numeric> operator*(matrix<Numeric> &x) {
      if (this->row() != x.col()) {
        cout << "cannot multiply matrices .. ";
        this->size(false); cout << "*"; x.size(true);
        exit(0);
      }
      matrix<Numeric> ret(this->col(), x.row());
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < x.row(); ++j) {
          for (int k = 0; k < this->row(); ++k) {
            ret[i][j] += _mat[i][k] * x[k][j];
            if (usingModulo) ret[i][j] %= modulo;
          }
        }
      }
      return ret;
    }
    matrix<Numeric> &operator*(Numeric k) {
      matrix<Numeric> ret(this->col(), this->row());
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          ret(i, j) = _mat[i][j] * k;
          if (usingModulo) ret(i, j) %= modulo;
        }
      }
      return ret;
    }
    matrix<Numeric> &operator*=(Numeric k) {
      matrix<Numeric> ret(this->col(), this->row());
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          _mat[i][j] *= k;
          if (usingModulo) _mat %= modulo;
        }
      }
      return *this;
    }
    void print() {
      cout << "-- print "; this->size(false); cout << " --" << endl;
      for (int i = 0; i < _col; ++i) {
        for (int j = 0; j < _row; ++j) {
          if (j != 0) cout << "\t";
          cout << _mat[i][j];
        }
        cout << endl;
      }
      cout << "------------------" << endl;
    }
    void print(string str) {
      cout << "-- print \"" << str << "\" "; this->size(false); cout << " --" << endl;
      for (int i = 0; i < _col; ++i) {
        for (int j = 0; j < _row; ++j) {
          if (j != 0) cout << "\t";
          cout << _mat[i][j];
        }
        cout << endl;
      }
      cout << "------------------" << endl;
    }
    void size (bool endline = true) const {
      cout << "(" << this->col() << ", " << this->row() << ")";
      if (endline) cout << endl;
    }
};

template<class Numeric> class squareMatrix : public matrix<Numeric> {
  private:
  public:
    squareMatrix(int col): matrix<Numeric>(col, col){
    }
    squareMatrix(int col, int num): matrix<Numeric>(col, col, num) {
    }
    squareMatrix(int col, bool identity): matrix<Numeric>(col, col) {
      if (identity) {
        for (int i = 0; i < col; ++i) {
          this->_mat[i][i] = 1;
        }
      }
    }
    squareMatrix<Numeric> operator= (matrix<Numeric> x) {
      if (this->col() != x.col() || this->row() != x.row()) {
        cout << "matrices are different sizes .. ";
        this->size(false); cout << "-"; x.size(true);
        exit(0);
      }
      for (int i = 0; i < this->col(); ++i) {
        for (int j = 0; j < this->row(); ++j) {
          this->_mat[i][j] = x[i][j];
        }
      }
      return *this;
    }
};


// abc113-d
int main(){
  int h, w, k; cin >> h >> w >> k;
  squareMatrix<long long> ans(w, true), pow2(w, 0);
  vector<long long> d(w, 1);
  for (int i = 2; i < w; ++i) {
    d[i] = d[i-1] + d[i-2];
  }
  for (int i = 0; i < w; ++i) {
    // (i, i)
    pow2[i][i] = d[i] * d[w-i-1];
    // (i, i+1), (i+1, i)
    if (i+1 < w) {
      pow2[i][i+1] = d[i] * d[w-i-2];
      pow2[i+1][i] = pow2[i][i+1];
    }
  }
  while (h) {
    if (h % 2) {
      ans = ans * pow2;
    }
    h /= 2; pow2 = pow2 * pow2;
  }
  cout << ans[0][k-1] << endl;
  return 0;
}


Measured memory_bytes: 256