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;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSIZE = 250;
const int MAXID = (MAXSIZE + 1) * MAXSIZE;
const int MOD = 1000000007;
void inc(int &a, int b) {
  if ((a += b) >= MOD) a -= MOD;
}
void dec(int &a, int b) { inc(a, MOD - b); }
int pw(int x, int n) {
  int ret = 1;
  while (true) {
    if (n & 1) ret = (long long)ret * x % MOD;
    if ((n >>= 1) == 0) return ret;
    x = (long long)x * x % MOD;
  }
}
int calcinv(int x) {
  assert(x != 0);
  return pw(x, MOD - 2);
}
int ssize, spos, mxsz;
int inv[MAXSIZE + 1];
struct Eq {
  vector<int> coef;
  Eq() {}
  Eq(int nvar) { coef = vector<int>(nvar + 1); }
};
Eq operator+(const Eq &a, const Eq &b) {
  assert(((int)(a.coef).size()) == ((int)(b.coef).size()));
  Eq ret = a;
  for (int i = (0); i < (((int)(b.coef).size())); ++i)
    inc(ret.coef[i], b.coef[i]);
  return ret;
}
Eq operator-(const Eq &a, const Eq &b) {
  assert(((int)(a.coef).size()) == ((int)(b.coef).size()));
  Eq ret = a;
  for (int i = (0); i < (((int)(b.coef).size())); ++i)
    dec(ret.coef[i], b.coef[i]);
  return ret;
}
Eq operator*(const Eq &a, const int &b) {
  Eq ret = a;
  for (int i = (0); i < (((int)(ret.coef).size())); ++i)
    ret.coef[i] = (long long)ret.coef[i] * b % MOD;
  return ret;
}
Eq eq[MAXSIZE + 1][MAXSIZE + 1];
Eq sumup[MAXSIZE + 1][MAXSIZE + 1];
Eq sumlt[MAXSIZE + 1][MAXSIZE + 1];
vector<Eq> eqs;
void gauss() {
  int R = ((int)(eqs).size()), C = ((int)(eqs[0].coef).size()), r = 0, c = 0;
  while (r < R) {
    {
      int rr = r;
      while (rr < R && eqs[rr].coef[c] == 0) ++rr;
      if (rr >= R) {
        ++c;
        continue;
      }
      swap(eqs[r], eqs[rr]);
      assert(eqs[r].coef[c] != 0);
    }
    eqs[r] = eqs[r] * calcinv(eqs[r].coef[c]);
    for (int rr = (0); rr < (R); ++rr)
      if (rr != r) eqs[rr] = eqs[rr] - eqs[r] * eqs[rr].coef[c];
    ++r, ++c;
  }
}
int solve() {
  if (spos == 0 || spos == ssize - 1) return ssize;
  inv[1] = 1;
  for (int i = (2); i <= (mxsz); ++i)
    inv[i] = (long long)(MOD - MOD / i) * inv[MOD % i] % MOD;
  int nvar = mxsz - 2;
  for (int j = (0); j <= (mxsz - 1); ++j) {
    eq[0][j] = Eq(nvar);
    inc(eq[0][j].coef[nvar], j + 1);
  }
  for (int i = (1); i <= (mxsz - 1); ++i) {
    eq[i][0] = Eq(nvar);
    inc(eq[i][0].coef[nvar], i + 1);
  }
  for (int j = (1); j <= (mxsz - 2); ++j) {
    eq[1][j] = Eq(nvar);
    inc(eq[1][j].coef[j - 1], 1);
  }
  eqs.clear();
  for (int i = (0); i <= (mxsz - 1); ++i)
    for (int j = (0); j <= (mxsz - 1 - i); ++j) {
      sumup[i][j] = i == 0 ? Eq(nvar) : sumup[i - 1][j] + eq[i - 1][j];
      sumlt[i][j] = j == 0 ? Eq(nvar) : sumlt[i][j - 1] + eq[i][j - 1];
      if (i == 0 || j == 0) continue;
      int pbreak = (long long)(i + j + 1) * inv[mxsz] % MOD,
          pinsert = (1 + MOD - pbreak) % MOD;
      Eq cur = eq[i][j];
      cur = cur - (sumup[i][j] + sumlt[i][j]) *
                      ((long long)pbreak * inv[i + j] % MOD);
      if (i + j + 1 <= mxsz - 1) {
        cur = cur - eq[i][j + 1] * ((long long)pinsert * (j + 1) % MOD *
                                    inv[i + j + 2] % MOD);
        cur = cur * calcinv((long long)pinsert * (i + 1) % MOD *
                            inv[i + j + 2] % MOD);
        eq[i + 1][j] = cur;
      } else {
        eqs.push_back(cur);
      }
    }
  assert(((int)(eqs).size()) == nvar);
  gauss();
  for (int i = (0); i < (nvar); ++i) assert(eqs[i].coef[i] == 1);
  vector<int> vals(nvar);
  for (int i = (0); i < (nvar); ++i) vals[i] = (MOD - eqs[i].coef[nvar]) % MOD;
  vals.push_back(1);
  int ret = 0;
  for (int k = (0); k <= (nvar); ++k)
    inc(ret, (long long)vals[k] * eq[spos][ssize - spos - 1].coef[k] % MOD);
  return ret;
}
void run() {
  scanf("%d%d%d", &ssize, &spos, &mxsz);
  --spos;
  printf("%d\n", solve());
}
int main() {
  run();
  return 0;
}