#pragma comment(linker,"/STACK:300000000")
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <iomanip>
#include <memory.h>
#include <cstdio>
#include <sstream>
#include <deque>
#include <bitset>
#include <numeric>
#include <ctime>
#include <queue>

using namespace std;

#define show(x) cout << #x << " = " << (x) << endl;
#define fori(i,n) for(int i = 0; i < (n); i++)
#define forn(i,n) for(int i = 1; i <= (n); i++)
#define forab(i,a,b) for(int i = (a); i <= (b); i++)
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(),(v).end()
const double pi = 3.1415926535897932384626433832795;
template<class T> T abs(T &a) { return a >= 0 ? a : -a; };
template<class T> T sqr(T &x) { return x * x; }
typedef pair<int,int> ii;
typedef long long ll;
///////////////////////////////////////

const ll mod = 1000000007;

class BricksN
{
public:

    ll dp[60][60];
    ll prec[60];    //prec[i] - сколькими способами можно набрать сумму i

    int countStructures(int w, int h, int k)
    {
        memset(dp,-1,sizeof(dp));
        memset(prec,0,sizeof(prec));

        prec[0] = 1;
        for(int i = 0; i < 50; i++)
            for(int d = 1; d <= k; d++)
            {
                int to = i+d;
                if(to <= 50)
                    prec[to] = (prec[to]+prec[i])%mod;
            }
        ll ans = 0;
        for(int i = 0; i <= h; i++)
            ans = (ans + f(w,i))%mod;
        return int(ans);
    }

    ll f(ll w, ll h) //сколькими способами можно набрать высоту РОВНО h при ширине бейсмента w
    {
        if(dp[w][h] == -1)
        {
            if(h == 0 || w == 1)
            {
                dp[w][h] = 1;
            }
            else if(w == 0)
            {
                dp[w][h] = 0;
            }
            else
            {
                dp[w][h] = prec[w]*f(w,h-1)%mod;     //если полностью заполнен нижний уровень
                dp[w][h] = (dp[w][h]+f(w-1,h))%mod;  //если левая клетка нижнего уровня пуста

                for(int lp = 1; lp < w; lp++)        //перебираем остальные положения самой левой пустой
                                                     // клетки нижнего уровня
                {
                    ll lb = prec[lp];                //сколькими способами можно заполнить нижний
                                                     //уровень левее пустой клетки

                    for(int lh = 1; lh < h; lh++)    //слева высота меньше h, справа ровно h
                    {
                        ll testLeft = lb*f(lp,lh-1);
                        ll testRight = f(w-lp-1,h);
                        dp[w][h] = (dp[w][h] + testLeft*testRight)%mod;
                    }
                    for(int rh = 0; rh <= h; rh++)   //справа высота меньше либо равна h, слева ровно h
                    {
                        ll testLeft = lb*f(lp,h-1);
                        ll testRight = f(w-lp-1,rh);
                        dp[w][h] = (dp[w][h] + testLeft*testRight)%mod;
                    }
                }
            }
        }
        return dp[w][h];
    }
};