#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chmin(T1& a, T2 b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1& a, T2 b) {
  if (a < b) a = b;
}
using Int = long long;
const char newl = '\n';
template <typename T, T MOD = 1000000007>
struct Mint {
  static constexpr T mod = MOD;
  T v;
  Mint() : v(0) {}
  Mint(signed v) : v(v) {}
  Mint(long long t) {
    v = t % MOD;
    if (v < 0) v += MOD;
  }
  Mint pow(long long k) {
    Mint res(1), tmp(v);
    while (k) {
      if (k & 1) res *= tmp;
      tmp *= tmp;
      k >>= 1;
    }
    return res;
  }
  static Mint add_identity() { return Mint(0); }
  static Mint mul_identity() { return Mint(1); }
  Mint inv() { return pow(MOD - 2); }
  Mint& operator+=(Mint a) {
    v += a.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  Mint& operator-=(Mint a) {
    v += MOD - a.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  Mint& operator*=(Mint a) {
    v = 1LL * v * a.v % MOD;
    return *this;
  }
  Mint& operator/=(Mint a) { return (*this) *= a.inv(); }
  Mint operator+(Mint a) const { return Mint(v) += a; }
  Mint operator-(Mint a) const { return Mint(v) -= a; }
  Mint operator*(Mint a) const { return Mint(v) *= a; }
  Mint operator/(Mint a) const { return Mint(v) /= a; }
  Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
  bool operator==(const Mint a) const { return v == a.v; }
  bool operator!=(const Mint a) const { return v != a.v; }
  bool operator<(const Mint a) const { return v < a.v; }
  static Mint comb(long long n, int k) {
    Mint num(1), dom(1);
    for (int i = 0; i < k; i++) {
      num *= Mint(n - i);
      dom *= Mint(i + 1);
    }
    return num / dom;
  }
};
template <typename T, T MOD>
constexpr T Mint<T, MOD>::mod;
template <typename T, T MOD>
ostream& operator<<(ostream& os, Mint<T, MOD> m) {
  os << m.v;
  return os;
}
template <typename M_>
class Enumeration {
  using M = M_;

 protected:
  static vector<M> fact, finv, invs;

 public:
  static void init(int n) {
    n = min<decltype(M::mod)>(n, M::mod - 1);
    int m = fact.size();
    if (n < m) return;
    fact.resize(n + 1, 1);
    finv.resize(n + 1, 1);
    invs.resize(n + 1, 1);
    if (m == 0) m = 1;
    for (int i = m; i <= n; i++) fact[i] = fact[i - 1] * M(i);
    finv[n] = M(1) / fact[n];
    for (int i = n; i >= m; i--) finv[i - 1] = finv[i] * M(i);
    for (int i = m; i <= n; i++) invs[i] = finv[i] * fact[i - 1];
  }
  static M Fact(int n) {
    init(n);
    return fact[n];
  }
  static M Finv(int n) {
    init(n);
    return finv[n];
  }
  static M Invs(int n) {
    init(n);
    return invs[n];
  }
  static M C(int n, int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k] * finv[k];
  }
  static M P(int n, int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k];
  }
  static M H(int n, int k) {
    if (n < 0 || k < 0) return M(0);
    if (!n && !k) return M(1);
    init(n + k);
    return C(n + k - 1, n);
  }
};
template <typename M>
vector<M> Enumeration<M>::fact = vector<M>();
template <typename M>
vector<M> Enumeration<M>::finv = vector<M>();
template <typename M>
vector<M> Enumeration<M>::invs = vector<M>();
using M = Mint<int>;
using E = Enumeration<M>;
const int MAX = 55;
M dp[MAX][MAX] = {};
M od[MAX][MAX] = {};
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  E::init(1000);
  auto comb = [&](M a, int b) {
    M dom{1};
    for (int i = 0; i < b; i++) dom *= a - M(i);
    return dom * E::Finv(b);
  };
  dp[0][1] = M(1);
  for (int i = 1; i < MAX; i++) {
    for (int j = 1; j <= i + 1; j++) {
      for (int a = 0; a < i; a++) {
        int c = i - (a + 1);
        for (int b = j; b <= a + 1; b++) {
          for (int d = j; d <= c + 1; d++) {
            if (min(b, d) != j) continue;
            od[i][j] += dp[a][b] * dp[c][d];
          }
        }
      }
      for (int x = MAX; x >= 0; x--)
        for (int y = x + 1; y >= 1; y--)
          for (int t = 1; x + t * i < MAX and y + t * j < MAX; t++)
            dp[x + t * i][y + t * j] += dp[x][y] * comb(od[i][j] + M(t - 1), t);
    }
  }
  int n, m;
  cin >> n >> m;
  cout << dp[n][m] << newl;
  return 0;
}
