// _Adrian Dacko_, Jan 30 2019

import java.math.*;

public class A306228_program
{
	 // create the object of the class triangleOfAuxiliaryTermsVmSGDand (with parameter M) in order to generate the 
	 // triangle of terms N_{n, k} for 0<=n<=M and 1<=k<=n+1 and use the method centralLimitTheoremToString() 
	 // to display (a(0), a(1), ..., a(M)) or toString() in order to display the whole triangle 
    public static void main(String[] args) 
    {
        int M = 15;
        
        triangleOfAuxiliaryTermsVmSGD table = new triangleOfAuxiliaryTermsVmSGD(M);
		
		// displays (a(0), a(1), ..., a(M))
        System.out.println(table.centralLimitTheoremToString());
		
		// displays the whole triangle 
		System.out.println(table.toString());
    }
}

class triangleOfAuxiliaryTermsVmSGD 
{
    // if we use Integer, the program returns wrong values of $N_{n,k}$ for $n>9$
    private BigInteger[][] choose;
    private BigInteger[][] vMonotone;
    private int M;
    
    public triangleOfAuxiliaryTermsVmSGD(int M)
    {
        if(M<1) { throw new IllegalArgumentException(); }
        this.M = M;
        
        int n,k;
        
        // the binomial coefficients --- by $choose[n][k]$ we mean $'n choose k'$
        // for $k > n$ we put $'n choose k' = 0$
        choose = new BigInteger[M+1][M+2];
        
        // by $vMonotone[n][k]$ we mean the term $N_{n,k}$,
        // defined just before the formulation of Lemma 5.4. in the paper 'V-monotone independence'
        // $N_{n,k}$ is defined only for a non-negative integer n and $k=1,...,n+1$
        // we put $vMonotone[n][k] = 0$ for $k=0,n+2,...,N+1$, for any non-negative
        // integer $n$
        vMonotone = new BigInteger[M+1][M+2];
        
        for(n=0; n<M+1; n++)
        {
            for(k=0; k<M+2; k++)
            {
                choose[n][k] = BigInteger.ZERO;
                vMonotone[n][k] = BigInteger.ZERO;
            }
        }
        
        //======================================================================
        
        choose[0][0] = BigInteger.ONE;
        for(n=0; n<=M-1; n++)
        {
            choose[n+1][0] = BigInteger.ONE;
            for(k=0; k<=n; k++) 
            {
                choose[n+1][k+1] = choose[n][k].add( choose[n][k+1] );
            }
        }
        
        //======================================================================
        
        BigInteger S1, S2, S3;
        int L1, L2;
        
        vMonotone[0][1] = BigInteger.ONE;
        for(n=0; n<=M-1; n++)
        {
            for(k=1; k<=n+2; k++)
            {
                // we are about to determine $N_{n+1,k}$
                S1 = BigInteger.ZERO;
                for(int m=0; m<=n; m++)
                {
                    L1 = max( 0, (m+k)-(n+1) );
                    L2 = min( k-1, m+1 );
            
                    S2 = BigInteger.ZERO;
                    for(int l=L1; l<=L2; l++)
                    {
                        S3 = BigInteger.ZERO;
                        for(int r=1; r<=l; r++) { S3 = S3.add( vMonotone[m][r] ); }
                        if(l == 0) { S3 = vMonotone[m][1]; }
                
                        S2 = S2.add( choose[k-1][l].multiply( choose[n+2-k][m+1-l].multiply( S3.multiply( vMonotone[n-m][k-l] ) ) ) );
                    }
            
                    S1 = S1.add(S2);
                }
        
                vMonotone[n+1][k] = S1;
            }
        }
    }
    
    private static int max(int a, int b) { if(a > b) { return a; } return b; }
    private static int min(int a, int b) { if(a < b) { return a; } return b; }
    
    public String chooseToString()
    {
        String wholeTriangle = "";
        String oneRow = "(";
        int K;
        int n,k;
        
        for(n=0; n<=M; n++)
        {
            K = n;
            for(k=0; k<=K; k++)
            {
                oneRow = oneRow + choose[n][k].toString();
                if (k<K) { oneRow = oneRow + ", "; }
                else { oneRow = oneRow + ")\n"; }
            }
            wholeTriangle = wholeTriangle + oneRow;
            oneRow = "(";
        }
        
        return wholeTriangle;
    }
    
    public String centralLimitTheoremToString()
    {
        String line = "(";
        for(int n=0; n<=M; n++)
        {
            line = line + vMonotone[n][n+1].toString();
            if (n<M) { line = line + ", "; }
            else { line = line + ")"; }
        }
        
        return line;
    }
    
    public String toString()
    {
        String wholeTriangle = "";
        String oneRow = "(";
        int K;
        int n,k;
        
        for(n=0; n<=M; n++)
        {
            K = n+1;
            for(k=1; k<=K; k++)
            {
                oneRow = oneRow + vMonotone[n][k].toString();
                if (k<K) { oneRow = oneRow + ", "; }
                else { oneRow = oneRow + ")\n"; }
            }
            wholeTriangle = wholeTriangle + oneRow;
            oneRow = "(";
        }
        
        return wholeTriangle;
    }
}