#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int _LEN = 1 << 17;
char Rbuf[1 << 17], Pbuf[1 << 17], *Reb = Rbuf, *Prb = Pbuf, *RD = Rbuf;
const char* P_end = Pbuf + _LEN;
int TP, stkbuf[20];
inline int gec() {
  return Reb == RD &&
                 (RD = (Reb = Rbuf) + fread(Rbuf, 1, _LEN, stdin), Reb == RD)
             ? EOF
             : *Reb++;
}
inline void puc(int c) {
  if (Prb == P_end) {
    fwrite(Pbuf, 1, _LEN, stdout);
    Prb = Pbuf;
  }
  *Prb++ = c;
}
template <typename T>
inline int read(T& a) {
  static char ch;
  static bool sign;
  for (sign = 0, ch = gec(); !isdigit(ch) && ch != EOF; ch = gec())
    if (ch == '-') sign = 1;
  if (ch == EOF) return EOF;
  for (a = 0; isdigit(ch); ch = gec()) a = ((a + (a << 2)) << 1) + (ch ^ '0');
  if (sign) a = -a;
  return 0;
}
template <typename Tp>
inline void print(Tp a, const char* CH = " ") {
  if (!a) puc('0');
  if (a < 0) puc('-'), a = -a;
  for (Tp bf; a; a = bf)
    bf = a / 10, stkbuf[++TP] = a - (((bf << 2) + bf) << 1);
  while (TP) puc(stkbuf[TP--] + '0');
  int lth = strlen(CH);
  for (int i = 0; i < lth; i++) puc(CH[i]);
}
void flush() { fwrite(Pbuf, 1, Prb - Pbuf, stdout); }
}  // namespace IO
using namespace IO;
const int N = 55;
const int Mods = 1e9 + 7;
int f[N][N], g[N][N], C[N][N];
int n, _k_;
void Prep(int n) {
  C[0][0] = 1;
  for (int i = 1; i <= n; i++) {
    C[i][0] = C[i][i] = 1;
    for (int j = 1; j < i; j++)
      C[i][j] = C[i - 1][j] + C[i - 1][j - 1],
      ((C[i][j] >= Mods) ? (C[i][j] -= Mods) : 0);
  }
}
int main() {
  read(n);
  read(_k_);
  f[0][0] = 1;
  g[1][0] = 1;
  Prep(n);
  for (int i = 2, Lim_R = n; i <= Lim_R; i++) {
    for (int k = 0, Lim_R = i >> 1; k <= Lim_R; k++) {
      for (int p = 0, O = i - 1; p <= O; p++, O--) {
        long long ways, a = 0, b = 0;
        if (p != O)
          ways = C[i - 1][p];
        else
          ways = C[i - 2][p - 1];
        ways = ways * (p ? p : 1) * O % Mods;
        for (int K = 0, Lim_R = min(p >> 1, k - 1); K <= Lim_R; K++)
          a +=
              (1LL * (f[p][K] + g[p][K]) * (f[O][k - K - 1] + g[O][k - K - 1]) -
               1LL * f[p][K] * f[O][k - K - 1]) %
              Mods;
        for (int K = 0, Lim_R = min(p >> 1, k); K <= Lim_R; K++)
          b += 1LL * f[p][K] * f[O][k - K] % Mods;
        (f[i][k] += (a % Mods * ways) % Mods) %= Mods;
        ((f[i][k] < 0) ? (f[i][k] += Mods)
                       : (((f[i][k] >= Mods) ? (f[i][k] -= Mods) : 0)));
        (g[i][k] += (b % Mods * ways) % Mods) %= Mods;
        ((g[i][k] >= Mods) ? (g[i][k] -= Mods) : 0);
      }
    }
  }
  printf("%d", (f[n][_k_] + g[n][_k_]) % Mods);
  flush();
  return 0;
}

### Prompt

Your task is to create a cpp solution to the following problem:

Ksenia has her winter exams. Today she is learning combinatorics. Here's one of the problems she needs to learn to solve.

How many distinct trees are there consisting of n vertices, each with the following properties:

  * the tree is marked, that is, the vertices of the tree are numbered from 1 to n; 
  * each vertex of the tree is connected with at most three other vertices, and at the same moment the vertex with number 1 is connected with at most two other vertices; 
  * the size of the tree's maximum matching equals k. 



Two trees are considered distinct if there are such two vertices u and v, that in one tree they are connected by an edge and in the other tree they are not.

Help Ksenia solve the problem for the given n and k. As the answer to the problem can be very huge you should output it modulo 1000000007 (109 + 7).

Input

The first line contains two integers n, k (1 ≤ n, k ≤ 50).

Output

Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).

Examples

Input

1 1


Output

0


Input

2 1


Output

1


Input

3 1


Output

3


Input

4 2


Output

12

Note

If you aren't familiar with matchings, please, read the following link: http://en.wikipedia.org/wiki/Matching_(graph_theory).

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int _LEN = 1 << 17;
char Rbuf[1 << 17], Pbuf[1 << 17], *Reb = Rbuf, *Prb = Pbuf, *RD = Rbuf;
const char* P_end = Pbuf + _LEN;
int TP, stkbuf[20];
inline int gec() {
  return Reb == RD &&
                 (RD = (Reb = Rbuf) + fread(Rbuf, 1, _LEN, stdin), Reb == RD)
             ? EOF
             : *Reb++;
}
inline void puc(int c) {
  if (Prb == P_end) {
    fwrite(Pbuf, 1, _LEN, stdout);
    Prb = Pbuf;
  }
  *Prb++ = c;
}
template <typename T>
inline int read(T& a) {
  static char ch;
  static bool sign;
  for (sign = 0, ch = gec(); !isdigit(ch) && ch != EOF; ch = gec())
    if (ch == '-') sign = 1;
  if (ch == EOF) return EOF;
  for (a = 0; isdigit(ch); ch = gec()) a = ((a + (a << 2)) << 1) + (ch ^ '0');
  if (sign) a = -a;
  return 0;
}
template <typename Tp>
inline void print(Tp a, const char* CH = " ") {
  if (!a) puc('0');
  if (a < 0) puc('-'), a = -a;
  for (Tp bf; a; a = bf)
    bf = a / 10, stkbuf[++TP] = a - (((bf << 2) + bf) << 1);
  while (TP) puc(stkbuf[TP--] + '0');
  int lth = strlen(CH);
  for (int i = 0; i < lth; i++) puc(CH[i]);
}
void flush() { fwrite(Pbuf, 1, Prb - Pbuf, stdout); }
}  // namespace IO
using namespace IO;
const int N = 55;
const int Mods = 1e9 + 7;
int f[N][N], g[N][N], C[N][N];
int n, _k_;
void Prep(int n) {
  C[0][0] = 1;
  for (int i = 1; i <= n; i++) {
    C[i][0] = C[i][i] = 1;
    for (int j = 1; j < i; j++)
      C[i][j] = C[i - 1][j] + C[i - 1][j - 1],
      ((C[i][j] >= Mods) ? (C[i][j] -= Mods) : 0);
  }
}
int main() {
  read(n);
  read(_k_);
  f[0][0] = 1;
  g[1][0] = 1;
  Prep(n);
  for (int i = 2, Lim_R = n; i <= Lim_R; i++) {
    for (int k = 0, Lim_R = i >> 1; k <= Lim_R; k++) {
      for (int p = 0, O = i - 1; p <= O; p++, O--) {
        long long ways, a = 0, b = 0;
        if (p != O)
          ways = C[i - 1][p];
        else
          ways = C[i - 2][p - 1];
        ways = ways * (p ? p : 1) * O % Mods;
        for (int K = 0, Lim_R = min(p >> 1, k - 1); K <= Lim_R; K++)
          a +=
              (1LL * (f[p][K] + g[p][K]) * (f[O][k - K - 1] + g[O][k - K - 1]) -
               1LL * f[p][K] * f[O][k - K - 1]) %
              Mods;
        for (int K = 0, Lim_R = min(p >> 1, k); K <= Lim_R; K++)
          b += 1LL * f[p][K] * f[O][k - K] % Mods;
        (f[i][k] += (a % Mods * ways) % Mods) %= Mods;
        ((f[i][k] < 0) ? (f[i][k] += Mods)
                       : (((f[i][k] >= Mods) ? (f[i][k] -= Mods) : 0)));
        (g[i][k] += (b % Mods * ways) % Mods) %= Mods;
        ((g[i][k] >= Mods) ? (g[i][k] -= Mods) : 0);
      }
    }
  }
  printf("%d", (f[n][_k_] + g[n][_k_]) % Mods);
  flush();
  return 0;
}

```