#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-18;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
  return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
  return a = max(a, b);
}
struct Mod {
  unsigned n;
  Mod() {}
  Mod(long long int x) {
    if (x < 0)
      n = x % MOD + MOD;
    else
      n = x % MOD;
  }
};
Mod operator+(Mod a, Mod b) { return Mod(a.n + b.n); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-(Mod a, Mod b) { return Mod(a.n + MOD - b.n); }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*(Mod a, Mod b) { return Mod((long long int)a.n * b.n); }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod modpow(Mod x, long long int k) {
  Mod res = 1;
  while (k) {
    if (k & 1) res *= x;
    k /= 2;
    x *= x;
  }
  return res;
}
Mod inv(Mod a) { return modpow(a, MOD - 2); }
Mod operator/(Mod a, Mod b) { return Mod((long long int)a.n * inv(b).n); }
Mod operator/=(Mod &a, Mod b) { return a = a / b; }
class Comb : public vector<vector<Mod> > {
 public:
  Comb(int max_n) {
    resize(max_n, vector<Mod>(max_n, 0));
    for (long long int i = (0); i < (long long int)(max_n); i++) {
      at(i).at(0) = at(i).at(i) = 1;
      for (long long int j = (1); j < (long long int)(i); j++)
        at(i).at(j) = at(i - 1).at(j - 1) + at(i - 1).at(j);
    }
  }
};
const long long int MAX_N = 72;
Comb C(MAX_N);
Mod dp[MAX_N][MAX_N][2];
long long int n, k;
int main() {
  scanf("%lld %lld", &n, &k);
  dp[0][0][1] = 1;
  dp[1][0][0] = 1;
  for (long long int i = (2); i < (long long int)(n + 1); i++) {
    for (long long int l = (0); l < (long long int)((i + 1) / 2); l++) {
      long long int r = i - 1 - l;
      for (long long int j = (0); j < (long long int)(l / 2 + 1); j++)
        if (dp[l][j][0].n != 0 || dp[l][j][1].n != 0) {
          for (long long int m = (0); m < (long long int)(r / 2 + 1); m++)
            if (dp[r][m][0].n != 0 || dp[r][m][1].n != 0) {
              if (i % 2 == 1 && l == (i - 1) / 2) {
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][0] / 2;
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][0] / 2;
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][1] / 2;
                dp[i][j + m][0] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][1] / 2;
              } else {
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][0];
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][0];
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][1];
                dp[i][j + m][0] += i * dp[l][j][1] * C[i - 1][l] * dp[r][m][1];
              }
            }
        }
    }
  }
  Mod ans = dp[n][k][0] / n + dp[n][k][1] / n;
  printf("%lld\n", (long long int)ans.n);
  return 0;
}

### Prompt

In Cpp, your task is to solve 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;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-18;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
  return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
  return a = max(a, b);
}
struct Mod {
  unsigned n;
  Mod() {}
  Mod(long long int x) {
    if (x < 0)
      n = x % MOD + MOD;
    else
      n = x % MOD;
  }
};
Mod operator+(Mod a, Mod b) { return Mod(a.n + b.n); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-(Mod a, Mod b) { return Mod(a.n + MOD - b.n); }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*(Mod a, Mod b) { return Mod((long long int)a.n * b.n); }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod modpow(Mod x, long long int k) {
  Mod res = 1;
  while (k) {
    if (k & 1) res *= x;
    k /= 2;
    x *= x;
  }
  return res;
}
Mod inv(Mod a) { return modpow(a, MOD - 2); }
Mod operator/(Mod a, Mod b) { return Mod((long long int)a.n * inv(b).n); }
Mod operator/=(Mod &a, Mod b) { return a = a / b; }
class Comb : public vector<vector<Mod> > {
 public:
  Comb(int max_n) {
    resize(max_n, vector<Mod>(max_n, 0));
    for (long long int i = (0); i < (long long int)(max_n); i++) {
      at(i).at(0) = at(i).at(i) = 1;
      for (long long int j = (1); j < (long long int)(i); j++)
        at(i).at(j) = at(i - 1).at(j - 1) + at(i - 1).at(j);
    }
  }
};
const long long int MAX_N = 72;
Comb C(MAX_N);
Mod dp[MAX_N][MAX_N][2];
long long int n, k;
int main() {
  scanf("%lld %lld", &n, &k);
  dp[0][0][1] = 1;
  dp[1][0][0] = 1;
  for (long long int i = (2); i < (long long int)(n + 1); i++) {
    for (long long int l = (0); l < (long long int)((i + 1) / 2); l++) {
      long long int r = i - 1 - l;
      for (long long int j = (0); j < (long long int)(l / 2 + 1); j++)
        if (dp[l][j][0].n != 0 || dp[l][j][1].n != 0) {
          for (long long int m = (0); m < (long long int)(r / 2 + 1); m++)
            if (dp[r][m][0].n != 0 || dp[r][m][1].n != 0) {
              if (i % 2 == 1 && l == (i - 1) / 2) {
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][0] / 2;
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][0] / 2;
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][1] / 2;
                dp[i][j + m][0] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][1] / 2;
              } else {
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][0];
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][1] * C[i - 1][l] * dp[r][m][0];
                dp[i][j + m + 1][1] +=
                    i * dp[l][j][0] * C[i - 1][l] * dp[r][m][1];
                dp[i][j + m][0] += i * dp[l][j][1] * C[i - 1][l] * dp[r][m][1];
              }
            }
        }
    }
  }
  Mod ans = dp[n][k][0] / n + dp[n][k][1] / n;
  printf("%lld\n", (long long int)ans.n);
  return 0;
}

```