Problem: Heidi enjoyed performing the simulation because she knew exactly when a new universe would be formed and where, and when a non-existent link would be broken and where.

However, the multiverse itself works in mysterious ways. Well, it works using probabilities, which to some people is mysterious.

At each unit time, when a decision is made, one of the two events will happen randomly. Let's denote l as the current length of the multiverse. With a probability of p_{create} = 1 - l/m, a universe will be created. With a probability of p_{break}=l/m, a non-existent link will be broken at some position.

More specifically, 

  * When a universe is created, it will manifest itself between any two adjacent universes or at one of the ends. Each position occurs with a probability of (1)/(l + 1). 
  * When a link is broken, it could be cut between any two adjacent universes, each with a probability of (1)/(l-1). After separating the multiverse into two segments, the segment NOT containing the Doctor will cease to exist. 



As earlier, the Doctor remains in the same universe. However, if at some point the multiverse breaks in such a way that the Doctor finds himself at the leftmost or rightmost end of it, the TARDIS stops functioning.

In such a case, the Doctor must actually walk across the multiverse to find the tools to fix it.

We are interested in the expected value of the length of the multiverse when such an event occurs.

Input

The first and only line contains three integers n, k and m (1 ≤ k ≤ n ≤ m ≤ 250), the initial length of the multiverse, the initial position of the Doctor, and the maximum possible length of the multiverse.

Output

Output a single integer on a single line, indicating the expected length of the multiverse.

If the answer is p/q, please print r where p ≡ r ⋅ q (mod  10^9 + 7).

Examples

Input


2 1 2


Output


2


Input


2 2 10


Output


2


Input


3 2 3


Output


2


Input


3 2 5


Output


941659828


Input


10 4 20


Output


196683114

Note

For the first and the second test case, without any change to the multiverse, the Doctor is already at one of the ends.

For the third test case, the multiverse can only break at a position, which renders the Doctor at one of its ends.

For the fourth case, things seem to be a little more complicated, because the multiverse can grow and then be broken again.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
  if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
  if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
  return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
  os << "{";
  for (auto e : v) os << e << ",";
  return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
const uint mod = 1000000007;
struct mint {
  uint v;
  mint(ll vv = 0) { s(vv % mod + mod); }
  mint& s(uint vv) {
    v = vv < mod ? vv : vv - mod;
    return *this;
  }
  mint operator-() const { return mint() - *this; }
  mint& operator+=(const mint& rhs) { return s(v + rhs.v); }
  mint& operator-=(const mint& rhs) { return s(v + mod - rhs.v); }
  mint& operator*=(const mint& rhs) {
    v = ull(v) * rhs.v % mod;
    return *this;
  }
  mint& operator/=(const mint& rhs) { return *this *= rhs.inv(); }
  mint operator+(const mint& rhs) const { return mint(*this) += rhs; }
  mint operator-(const mint& rhs) const { return mint(*this) -= rhs; }
  mint operator*(const mint& rhs) const { return mint(*this) *= rhs; }
  mint operator/(const mint& rhs) const { return mint(*this) /= rhs; }
  mint pow(ll n) const {
    mint res(1), x(*this);
    while (n) {
      if (n & 1) res *= x;
      x *= x;
      n >>= 1;
    }
    return res;
  }
  mint inv() const { return pow(mod - 2); }
  friend ostream& operator<<(ostream& os, const mint& m) { return os << m.v; }
  bool operator<(const mint& r) const { return v < r.v; }
  bool operator==(const mint& r) const { return v == r.v; }
};
const ll vmax = (1 << 21) + 10;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
  fact[0] = 1;
  for (ll i = ll(1); i < ll(vmax); i++) {
    fact[i] = fact[i - 1] * i;
  }
  finv[vmax - 1] = fact[vmax - 1].inv();
  for (ll i = vmax - 2; i >= 0; i--) {
    finv[i] = finv[i + 1] * (i + 1);
  }
  for (ll i = vmax - 1; i >= 1; i--) {
    invs[i] = finv[i] * fact[i - 1];
  }
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
  return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
  return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
template <class num>
struct Vector {
  vector<num> v;
  Vector(ll s = 0) { v.resize(s, num(0)); }
  ll size() const { return v.size(); }
  num& operator[](ll i) { return v[i]; }
  num const& operator[](ll i) const { return v[i]; }
  Vector& operator+=(const Vector& rhs) {
    assert(size() == rhs.size());
    for (ll i = ll(0); i < ll(size()); i++) v[i] += rhs[i];
    return *this;
  }
  Vector& operator-=(const Vector& rhs) {
    assert(size() == rhs.size());
    for (ll i = ll(0); i < ll(size()); i++) v[i] -= rhs[i];
    return *this;
  }
  Vector& operator*=(const num& x) {
    for (ll i = ll(0); i < ll(size()); i++) v[i] *= x;
    return *this;
  }
  Vector& operator/=(const num& x) {
    num y = num(1) / x;
    for (ll i = ll(0); i < ll(size()); i++) v[i] *= y;
    return *this;
  }
  Vector operator+(const Vector& rhs) const { return Vector(*this) += rhs; }
  Vector operator-(const Vector& rhs) const { return Vector(*this) -= rhs; }
  Vector operator*(const num& x) const { return Vector(*this) *= x; }
  Vector operator/(const num& x) const { return Vector(*this) /= x; }
};
template <class num>
num dot(const Vector<num>& first, const Vector<num>& second) {
  assert(first.size() == second.size());
  const ll s = first.size();
  num ans = 0;
  for (ll i = ll(0); i < ll(s); i++) ans += first[i] * second[i];
  return ans;
}
template <class num>
struct Matrix {
  using V = Vector<num>;
  vector<V> m;
  Matrix(ll s = 0, num z = num(0)) {
    m.resize(s, V(s));
    for (ll i = ll(0); i < ll(size()); i++) m[i][i] = z;
  }
  ll size() const { return m.size(); }
  Matrix operator*(const Matrix& rhs) const {
    assert(size() == rhs.size());
    Matrix res(size());
    for (ll i = ll(0); i < ll(size()); i++)
      for (ll j = ll(0); j < ll(size()); j++)
        for (ll k = ll(0); k < ll(size()); k++)
          res[i][j] += m[i][k] * rhs[k][j];
    return res;
  }
  V operator*(const V& rhs) const {
    assert(size() == rhs.size());
    V res(size());
    for (ll i = ll(0); i < ll(size()); i++) res[i] = Dot(m[i], rhs);
    return res;
  }
  V& operator[](ll i) { return m[i]; }
  V const& operator[](ll i) const { return m[i]; }
};
template <class num>
ostream& operator<<(ostream& os, const Matrix<num>& x) {
  const ll s = x.size();
  os << "----------" << endl;
  for (ll i = ll(0); i < ll(s); i++) {
    for (ll j = ll(0); j < ll(s); j++) {
      os << x[i][j];
      if (j == s - 1) {
        os << endl;
      } else {
        os << " ";
      }
    }
  }
  return os << "----------";
}
template <class num>
num det(Matrix<num> first) {
  const ll s = first.size();
  num ans(1);
  for (ll i = ll(0); i < ll(s); i++) {
    for (ll j = ll(i + 1); j < ll(s); j++)
      if (first[j][i]) {
        ans = -ans;
        swap(first[j], first[i]);
        break;
      }
    if (!first[i][i]) return 0;
    ans *= first[i][i];
    for (ll j = ll(i + 1); j < ll(s); j++) {
      mint w = -first[j][i] / first[i][i];
      for (ll k = ll(i); k < ll(s); k++) first[j][k] += first[i][k] * w;
    }
  }
  return ans;
}
using V = Vector<mint>;
using M = Matrix<mint>;
vi sweep(vvc<mint>& first, ll c = -1) {
  if (first.empty()) return {};
  if (c == -1) c = first.size();
  ll h = first.size(), w = first[0].size(), r = 0;
  vi res;
  for (ll i = ll(0); i < ll(c); i++) {
    for (ll j = ll(r); j < ll(h); j++)
      if (first[j][i].v) {
        swap(first[r], first[j]);
        break;
      }
    if (first[r][i].v == 0) continue;
    for (ll j = ll(0); j < ll(h); j++)
      if (j != r) {
        mint z = -first[j][i] / first[r][i];
        for (ll k = ll(i); k < ll(w); k++) first[j][k] += first[r][k] * z;
      }
    res.push_back(i);
    r++;
  }
  return res;
}
vc<mint> lineareq(vvc<mint> first, ll w, vc<mint> second) {
  ll h = first.size();
  for (ll i = ll(0); i < ll(h); i++) first[i].push_back(second[i]);
  vi idx = sweep(first, w);
  for (ll i = ll(idx.size()); i < ll(h); i++)
    if (first[i][w].v) return {};
  vc<mint> res(w);
  for (ll i = ll(0); i < ll(idx.size()); i++)
    res[idx[i]] = first[i][w] / first[i][idx[i]];
  return res;
}
const ll Nmax = 255;
V first[Nmax][Nmax], second[Nmax][Nmax], c[Nmax][Nmax];
void waf(ll i, ll j, const V& v) {
  first[i][j] = v;
  if (i > 0)
    second[i][j] = v + second[i - 1][j];
  else
    second[i][j] = v;
  if (j > 0)
    c[i][j] = v + c[i][j - 1];
  else
    c[i][j] = v;
}
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(20);
  initfact();
  ll n, k, m;
  cin >> n >> k >> m;
  if (k == 1 || k == n) {
    cout << n << endl;
    return 0;
  }
  waf(0, 0, V(m - 1));
  for (ll i = ll(1); i < ll(m - 1); i++) {
    V v(m - 1);
    v[m - 2] = i + 1;
    waf(i, 0, v);
    waf(0, i, v);
  }
  for (ll i = ll(1); i < ll(m - 1); i++) {
    V v(m - 1);
    v[i - 1] = 1;
    waf(1, i, v);
  }
  for (ll i = ll(1); i < ll(m - 1); i++)
    for (ll j = ll(1); j < ll(m - 1 - i); j++) {
      ll s = i + j + 1;
      waf(i + 1, j,
          (first[i][j] * m * (s + 1) -
           (second[i - 1][j] + c[i][j - 1]) * s * (s + 1) * invs[s - 1] -
           first[i][j + 1] * (m - s) * (j + 1)) *
              invs[m - s] * invs[i + 1]);
    }
  vvc<mint> p(m - 2, vc<mint>(m - 2));
  vc<mint> q(m - 2);
  for (ll i = ll(0); i < ll(m - 2); i++) {
    V w = first[i + 1][m - 2 - i] -
          (second[i][m - 2 - i] + c[i + 1][m - 2 - i - 1]) * invs[m - 1];
    for (ll j = ll(0); j < ll(m - 2); j++) p[i][j] = w[j];
    q[i] = -w[m - 2];
  }
  auto x = lineareq(p, m - 2, q);
  V y(m - 1);
  for (ll i = ll(0); i < ll(m - 2); i++) y[i] = x[i];
  y[m - 2] = 1;
  mint ans = dot(y, first[k - 1][n - k]);
  cout << ans << endl;
}