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).
import sun.misc.Compare;

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.*;

import java.math.BigInteger;

import static java.lang.Math.*;
import static java.math.BigInteger.*;
import static java.util.Arrays.*;


public class Main{

    void run(){
        Locale.setDefault(Locale.US);
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
//        boolean oj = true;
        try{
            if( oj ){
                sc  = new FastScanner( new InputStreamReader(System.in  ) );
                out = new PrintWriter(   new OutputStreamWriter(System.out) );
            } else{
                sc  = new FastScanner(new FileReader("in.txt") );
//                sc  = new FastScanner(new FileReader("D:\\JavaOlymp\\FatalError\\output.txt") );
                out = new PrintWriter(   new FileWriter("out.txt") );
            }
        } catch (Exception e) {
            System.exit(-1);
        }
        long tB = System.currentTimeMillis();
        solve();
        if( !oj ) System.err.println( "Time: " + (System.currentTimeMillis()-tB)/1e3 );
        out.flush();
    }


    class FastScanner{
        BufferedReader br;
        StringTokenizer st = new StringTokenizer("");
        FastScanner( InputStreamReader a ){
            br = new BufferedReader(a);
        }
        FastScanner( FileReader a ){
            br = new BufferedReader(a);
        }
        String next(){
            while( !st.hasMoreTokens() )
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    return null;
                }
            return st.nextToken();
        }
        String readLine(){
            try {
                return br.readLine();
            } catch (Exception e) {
                return null;
            }
        }
        int nextInt(){ return Integer.parseInt(next()); }
        long nextLong(){ return Long.parseLong(next()); }
    }

    FastScanner sc;
    PrintWriter out;



    public static void main(String[] args){
        new Main().run();
//        new Thread( null, new Runnable() {
//            @Override
//            public void run() {
//                new Main().run();
//            }
//            }, "LOL", 256L * 1024 * 1024 / 2 ).run();
//        }, "LOL", 2000 * 1024 * 1024 ).run();
    }



    void TLE(){ for(;;); }

    void MLE(){
        int[][] adj = new int[1024*1024][];
        for( int i = 0; i < adj.length; ++i )
            adj[i] = new int[1024*1024];
    }

    void exit( int val ){
        out.flush();
        System.exit(val);
    }
    //////////////////////////////////////////////////////////////////////////////////////////


    long[][][] dp;
    final long inf = Long.MAX_VALUE / 1000,
            mod = 1000000007 ;
    long[][] comb;
    {
        comb = new long[51][51];
        for( int n = 0; n <= 50; ++n )
        for( int k = 0; k <=  n; ++k )
            comb[k][n] = COMB(k, n);
    }

    BigInteger fact( int n ){
        return n<=1? ONE : valueOf(n).multiply(fact(n-1));
    }

    long COMB( int m, int n ){
        if(!( m <= n )) MLE();
        return fact(n).divide( fact(m).multiply(fact(n-m)) ).mod(valueOf(mod)).longValue();
    } 
    long C( int m, int n ){
        if(!( m <= n )) MLE();
        return comb[m][n];
    }

    long powMod( long a, long p ){
        if( p == 0 ) return 1;
        long ans = powMod(a,p/2);
        ans = (ans*ans) % mod;
        if( p%2==1 ) ans = (a*ans) % mod;
        return ans;
    }

    long getDP( int n, int k, int isNeed ){
        if (n <= 0 || k < 0) return 0;

        if( dp[n][k][isNeed] == inf ){
            long ans = 0;

            if( n == 1 ){
                if( k==0 && isNeed == 0 )
                    ans = 1;
                else
                    ans = 0;
            }
            else{
                for( int nl = 1; nl <= n-2; ++nl ){
                    for( int kl = 0; kl <= min( nl/2, (isNeed==1?k-1:k)); ++kl ){
                        long cur = (C(nl,n-1) * n) % mod;
                        if( isNeed==1 ){
                            cur *=(
                                    getDP(nl, kl, 0)*getDP(n-1-nl, k-1-kl, 1) +
                                            getDP(nl, kl, 1)*getDP(n-1-nl, k-1-kl, 0) +
                                            getDP(nl, kl, 0)*getDP(n-1-nl, k-1-kl, 0)
                            ) % mod;
                        }
                        else{
                            cur *=
                                    getDP(nl,kl,1)*getDP(n-1-nl,k-kl,1) % mod;
                        }
                        ans = (ans + cur) % mod;
                        if( n==3 ){
                            n = 3;
//                        out.printf( ":: %d/%d   %d/%d  %d\n", nl,n,   kl,k, isNeed );
                        }
                    }
                }
                ans = ans * powMod(2,mod-2) % mod;
                if( isNeed == 1 )
                    ans = ( ans + n*getDP(n-1,k-1,0) ) %mod;
                else
                    ans = ( ans + n*getDP(n-1,k  ,1) ) %mod;
            }
            dp[n][k][isNeed] = ans;
        }
        return dp[n][k][isNeed];
    }

    void solve(){
        int n, k;

        n = sc.nextInt();
        k = sc.nextInt();
        dp = new long[n+1][k+1][2];
        for( long[][] a : dp )
            for( long[] b : a )
                fill( b, inf );


        long ans = getDP(n, k, 0) + getDP(n, k, 1);
        ans %= mod;
        ans = ans * powMod( n, mod - 2 ) % mod;
        out.println( ans );
    }













}