/*****************************************************************
 *  FUNCTION:  dvector -- dynamically allocates space in memory  *
 *                        for a vector                           *
 *  INPUT: n = number of elements in vector                      *
 *  OUTPUT: v = vector of size n                                 *
 *****************************************************************/
double *dvector (n)
int n;
{
double *v;

v = (double *) calloc(n, sizeof(double));
return(v);
}  /* end of function dvector */


/*****************************************************************
 *  FUNCTION:  cvector -- dynamically allocates space in memory  *
 *                        for a vector of chars                  *
 *  INPUT: n = number of elements in vector                      *
 *  OUTPUT: v = vector of size n                                 *
 *****************************************************************/
char *cvector (n)
int n;
{
char *v;

v = (char *) calloc(n, sizeof(char));
return(v);
}  /* end of function cvector */


/*****************************************************************
 *  FUNCTION:  ivector -- dynamically allocates space in memory  *
 *                        for a vector of ints                   *
 *  INPUT: n = number of elements in vector                      *
 *  OUTPUT: v = vector of size n                                 *
 *****************************************************************/
int *ivector (n)
int n;
{
int *v;

v = (int *) calloc(n, sizeof(int));
return(v);
}  /* end of function ivector */


/***********************************************************
 *  FUNCTION:  free_matrix -- de-allocate space in memory  *
 *                        for a 2-dimensional matrix       *
 *  INPUT: rows = number of rows                           *
 *          cols = number of columns                       *
 *  OUTPUT: A = rows x columns matrix                      *
 ***********************************************************/
void free_matrix(A, rows)
double **A;
int rows;
{
int i;

for (i = 0; i < rows; i++)
    free(A[i]);
free(A);

}  /* end of fucntion free_matrix */


/****************************************************************
 *  FUNCTION:  dmatrix -- dynamically allocate space in memory  *
 *                        for a 2-dimensional matrix            *
 *  INPUT: rows = number of rows                                *
 *          cols = number of columns                            *
 *  OUTPUT: A = rows x columns matrix                           *
 *****************************************************************/
double **dmatrix(int rows, int cols)
{
int i;
double **A;

A = (double **) calloc(rows, sizeof(double *));
for(i = 0; i < rows; i++)
    A[i] = (double *) calloc(cols, sizeof(double));
return(A);
}  /* end of function dmatrix */


/************************************************************
 *  FUNCTION:  free_cmatrix -- de-allocate space in memory  *
 *                 for a 2-dimensional matrix of char       *
 *  INPUT: rows = number of rows                            *
 *          cols = number of columns                        *
 *  OUTPUT: A = rows x columns matrix                       *
 ************************************************************/
void free_cmatrix(A, rows)
char **A;
int rows;
{
int i;

for (i = 0; i < rows; i++)
    free(A[i]);
free(A);

}  /* end of fucntion free_cmatrix */


/****************************************************************
 *  FUNCTION:  cmatrix -- dynamically allocate space in memory  *
 *                        for a 2-dimensional matrix of char    *
 *  INPUT: rows = number of rows                                *
 *          cols = number of columns                            *
 *  OUTPUT: A = rows x columns matrix                           *
 *****************************************************************/
char **cmatrix(int rows, int cols)
{
int i;
char **A;

A = (char **) calloc(rows, sizeof(char *));
for(i = 0; i < rows; i++)
    A[i] = (char *) calloc(cols, sizeof(char));
return(A);
}  /* end of function dmatrix */


/***************************************************************
 *  FUNCTION:  free_triblock22 -- de-allocate space in memory  *
 *                        for a triblock22                     *
 ***************************************************************/
void free_triblock22 (T)
struct triblock22 *T;
{
free(T->a);
free(T->b);
free(T->c);
}  /* end of function free_triblock22 */


/********************************************************************
 *  FUNCTION:  dtriblock22 -- dynamically allocate space in memory  *
 *                        for a triblock22                          *
 ********************************************************************/
void dtriblock22 (T, xm)
struct triblock22 *T;
int xm;
{
T->c = calloc(xm-1, sizeof(struct v2));
T->a = calloc(xm,   sizeof(struct m22));
T->b = calloc(xm-1, sizeof(struct v2));
}  /* end of fucntion dtriblock22 */


/***************************************************************
 *  FUNCTION:  free_triblock24 -- de-allocate space in memory  *
 *                        for a triblock24                     *
 ***************************************************************/
void free_triblock24 (T)
struct triblock24 *T;
{
free(T->a);
free(T->b);
free(T->c);
}  /* end of fucntion free_triblock24 */
     

/********************************************************************
 *  FUNCTION:  dtriblock24 -- dynamically allocate space in memory  *
 *                        for a triblock24                          *
 ********************************************************************/
void dtriblock24 (T, xm)
struct triblock24 *T;
int xm;
{
T->c = calloc(xm-1, sizeof(struct m22));
T->a = calloc(xm,   sizeof(struct m24));
T->b = calloc(xm-1, sizeof(struct m22));
}  /* end of fucntion dtriblock24 */


/***************************************************************
 *  FUNCTION:  free_triblock44 -- de-allocate space in memory  *
 *                        for a triblock24                     *
 ***************************************************************/
void free_triblock44 (T)
struct triblock44 *T;
{
free(T->a);
free(T->b);
free(T->c);
}  /* end of fucntion free_triblock44 */


/********************************************************************
 *  FUNCTION:  dtriblock44 -- dynamically allocate space in memory  *
 *                        for a triblock44                          *
 ********************************************************************/
void dtriblock44 (T, xm)
struct triblock44 *T;
int xm;
{
T->c = calloc(xm-1, sizeof(struct m42));
T->a = calloc(xm,   sizeof(struct m44));
T->b = calloc(xm-1, sizeof(struct m42));
}  /* end of fucntion dtriblock44 */


/**********************************************************************
 *  FUNCTION:  free_kvec2 -- de-allocate space in memory for a kvec2  *
 **********************************************************************/
void free_kvec2 (K)
struct kvec2 *K;
{
free(K->el);
}  /* end of fucntion free_kvec2 */


/***************************************************************
 *  FUNCTION:  dkvec2 -- dynamically allocate space in memory  *
 *                        for a kvec2                          *
 ***************************************************************/
void dkvec2 (K, xm)
struct kvec2 *K;
int xm;
{
K->el = calloc(xm, sizeof(struct v2));
}  /* end of function dkvev2 */


/**********************************************************************
 *  FUNCTION:  free_kvec4 -- de-allocate space in memory for a kvec4  *
 **********************************************************************/
void free_kvec4 (K)
struct kvec4 *K;
{
free(K->el);
}  /* end of fucntion free_kvec4 */


/***************************************************************
 *  FUNCTION:  dkvec4 -- dynamically allocate space in memory  *
 *                        for a kvec4                          *
 ***************************************************************/
void dkvec4 (K, xm)
struct kvec4 *K;
int xm;
{
K->el = calloc(xm, sizeof(struct v4));
}  /* end of function dkvev4 */


/**********************************************************
 *  FUNCTION:  free_gvec2 -- de-allocate space in memory  *
 *                        for a gvec2                     *
 **********************************************************/
void free_gvec2 (G)
struct gvec2 *G;
{
free(G->el);
}  /* end of fucntion free_gvec2 */


/***************************************************************
 *  FUNCTION:  dgvec2 -- dynamically allocate space in memory  *
 *                        for a gvec2                          *
 ***************************************************************/
void dgvec2 (G, xm)
struct gvec2 *G;
int xm;
{
G->el = calloc(xm-1, sizeof(struct v2));
}  /* end of function dgvev2 */


/**********************************************************
 *  FUNCTION:  free_gvec4 -- de-allocate space in memory  *
 *                        for a gvec4                     *
 **********************************************************/
void free_gvec4 (G)
struct gvec4 *G;
{
free(G->el);
}  /* end of fucntion free_gvec4 */


/***************************************************************
 *  FUNCTION:  dgvec4 -- dynamically allocate space in memory  *
 *                        for a gvec4                          *
 ***************************************************************/
void dgvec4 (G, xm)
struct gvec4 *G;
int xm;
{
G->el = calloc(xm-1, sizeof(struct m42));
}  /* end of function dgvev2 */


/************************************************************
 *  FUNCTION:  free_collvec -- de-allocate space in memory  *
 *                                for a collvec             *
 ************************************************************/
void free_collvec (K, ym)
struct collvec *K;
int ym;
{
int i;

free(K->F->el);
free(K->F);

free(K->L->el);
free(K->L);

for (i = 0; i <= ym-2; i++)
    free(K->M[i].el);
free(K->M);
}  /* end of fucntion free_collvec */


/*****************************************************************
 *  FUNCTION:  dcollvec -- dynamically allocate space in memory  *
 *                      for a collvec                            *
 *****************************************************************/
void dcollvec (K, xm, ym)
struct collvec *K;
int xm, ym;
{
struct kvec2 T2;
struct kvec4 T4;

int i;

dkvec2(&T2, xm);
dkvec4(&T4, xm);

K->F     = calloc(1,  sizeof(T2));
K->F->el = calloc(xm, sizeof(struct v2));

K->L     = calloc(1,  sizeof(T2));
K->L->el = calloc(xm, sizeof(struct v2));

K->M     = calloc(ym-1,  sizeof(T4));
for (i = 0; i <= ym-2; i++)
    K->M[i].el = calloc(xm, sizeof(struct v4));

free_kvec2(&T2);
free_kvec4(&T4);
}  /* end of function dcollvec */


/****************************************************************
 *  FUNCTION:  free_mat_collvec -- de-allocate space in memory  *
 *                      for a matrix whose columns are collvecs *
 ****************************************************************/
void free_mat_collvec (K, j, ym)
struct mat_collvec *K;
int j, ym;
{
int i, n;

for (n = 0; n < j; n++)
    {
    free(K->el[n].F->el);
    free(K->el[n].F);

    free(K->el[n].L->el);
    free(K->el[n].L);

    for (i = 0; i <= ym-2; i++)
          free(K->el[n].M[i].el);
    free(K->el[n].M);
    }

free(K->el);

}  /* end of function free_mat_collvec */


/*********************************************************************
 *  FUNCTION:  dmat_collvec -- dynamically allocate space in memory  *
 *                      for a matrix whose columns are collvecs      *
 *********************************************************************/
void dmat_collvec (K, j, xm, ym)
struct mat_collvec *K;
int j, xm, ym;
{
struct kvec2 T2;
struct kvec4 T4;
struct collvec T;

int i, n;

dkvec2(&T2, xm);
dkvec4(&T4, xm);
dcollvec(&T, xm, ym);

K->el = calloc(j, sizeof(T));

for (n = 0; n < j; n++)
    {
    K->el[n].F     = calloc(1,  sizeof(T2));
    K->el[n].F->el = calloc(xm, sizeof(struct v2));

    K->el[n].L     = calloc(1,  sizeof(T2));
    K->el[n].L->el = calloc(xm, sizeof(struct v2));

    K->el[n].M     = calloc(ym-1,  sizeof(T4));
    for (i = 0; i <= ym-2; i++)
          K->el[n].M[i].el = calloc(xm, sizeof(struct v4));
    
    }

free_kvec2(&T2);
free_kvec4(&T4);
free_collvec(&T, ym);
}  /* end of function dmat_collvec */


/**************************************************************
 *  FUNCTION:  free_mat_kvec4 -- de-allocate space in memory  *
 *             for a matrix whose columns are kvec4's         *
 **************************************************************/
void free_mat_kvec4 (K, blocks)
struct mat_kvec4 *K;
int blocks;
{
int n;

for (n = 0; n < blocks; n++)
    free(K->el[n].el);
free(K->el);
}  
/* end of function free_mat_kvev4 */


/*******************************************************
 *  FUNCTION:  dmat_kvec4 -- allocate space in memory  *
 *             for a matrix whose columns are kvec4's  *
 *******************************************************/
void dmat_kvec4 (K, blocks, xm)
struct mat_kvec4 *K;
int blocks, xm;
{
int n;
struct kvec4 T4;

dkvec4(&T4, xm);

K->el = calloc(blocks, sizeof(T4));
for (n = 0; n < blocks; n++)
    K->el[n].el = calloc(xm, sizeof(struct v4));

free_kvec4(&T4);
}
/* end of function dmat_kvev4 */


/************************************************************
 *  FUNCTION:  free_collmat -- de-allocate space in memory  *
 *                      for a collmat                       *
 ************************************************************/
void free_collmat (M, ym)
struct collmat *M;
int ym;
{
int i, ymm1=ym-1, ymm2=ym-2;

free(M->AF->a);
free(M->AF->b);
free(M->AF->c);
free(M->AF);

free(M->AL->a);
free(M->AL->b);
free(M->AL->c);
free(M->AL);

for (i = 0; i < ymm1; i++)
    {
    free(M->A[i].a);
    free(M->A[i].b);
    free(M->A[i].c);
    }
free(M->A);


free(M->BF->a);
free(M->BF->b);
free(M->BF->c);
free(M->BF);

free(M->BL->a);
free(M->BL->b);
free(M->BL->c);
free(M->BL);

for (i = 0; i < ymm2; i++)
    {
    free(M->B[i].a);
    free(M->B[i].b);
    free(M->B[i].c);
    }
free(M->B);


free(M->CF->a);
free(M->CF->b);
free(M->CF->c);
free(M->CF);

free(M->CL->a);
free(M->CL->b);
free(M->CL->c);
free(M->CL);

for (i = 0; i < ymm2; i++)
    {
    free(M->C[i].a);
    free(M->C[i].b);
    free(M->C[i].c);
    }
free(M->C);
}  /* end of function free_collmat */


/*****************************************************************
 *  FUNCTION:  dcollmat -- dynamically allocate space in memory  *
 *                      for a collmat                            *
 *****************************************************************/
void dcollmat (M, xm, ym)
struct collmat *M;
int xm, ym;
{
struct triblock22 T22;
struct triblock24 T24;
struct triblock44 T44;

int i, xmm1=xm-1, ymm1=ym-1, ymm2=ym-2;

dtriblock22(&T22, xm);
dtriblock24(&T24, xm);
dtriblock44(&T44, xm);


M->AF    = calloc(1,    sizeof(T22));
M->AF->a = calloc(xm,   sizeof(struct m22));
M->AF->b = calloc(xmm1, sizeof(struct v2));
M->AF->c = calloc(xmm1, sizeof(struct v2));

M->A = calloc(ymm1, sizeof(T44));
for (i = 0; i < ymm1; i++)
    {
    M->A[i].a = calloc(xm,   sizeof(struct m44));
    M->A[i].b = calloc(xmm1, sizeof(struct m42));
    M->A[i].c = calloc(xmm1, sizeof(struct m42));
    }

M->AL    = calloc(1,    sizeof(T22));
M->AL->a = calloc(xm,   sizeof(struct m22));
M->AL->b = calloc(xmm1, sizeof(struct v2));
M->AL->c = calloc(xmm1, sizeof(struct v2));

M->BL    = calloc(1,    sizeof(T22));
M->BL->a = calloc(xm,   sizeof(struct m22));
M->BL->b = calloc(xmm1, sizeof(struct v2));
M->BL->c = calloc(xmm1, sizeof(struct v2));

M->B = calloc(ymm2, sizeof(T24));
for (i = 0; i < ymm2; i++)
    {
    M->B[i].a = calloc(xm,   sizeof(struct m24));
    M->B[i].b = calloc(xmm1, sizeof(struct m22));
    M->B[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->BF    = calloc(1,    sizeof(T24));
M->BF->a = calloc(xm,   sizeof(struct m24));
M->BF->b = calloc(xmm1, sizeof(struct m22));
M->BF->c = calloc(xmm1, sizeof(struct m22));

M->CF    = calloc(1,    sizeof(T22));
M->CF->a = calloc(xm,   sizeof(struct m22));
M->CF->b = calloc(xmm1, sizeof(struct v2));
M->CF->c = calloc(xmm1, sizeof(struct v2));

M->C = calloc(ymm2, sizeof(T24));
for (i = 0; i < ymm2; i++)
    {
    M->C[i].a = calloc(xm,   sizeof(struct m24));
    M->C[i].b = calloc(xmm1, sizeof(struct m22));
    M->C[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->CL    = calloc(1,    sizeof(T24));
M->CL->a = calloc(xm,   sizeof(struct m24));
M->CL->b = calloc(xmm1, sizeof(struct m22));
M->CL->c = calloc(xmm1, sizeof(struct m22));

free_triblock22(&T22);
free_triblock24(&T24);
free_triblock44(&T44);
}  /* end of function dcollmat */


/************************************************************
 *  FUNCTION:  free_first_proc_collmat -- de-allocate space *
 *              in memory for the portion of a collmat that *
 *              resides at the first processor              *
 ************************************************************/
void free_first_proc_collmat (M, ym)
struct first_proc_collmat *M;
int ym;
{
int i, ymm1=ym-1, ymm2=ym-2;

free(M->AF->a);
free(M->AF->b);
free(M->AF->c);
free(M->AF);

free(M->AL->a);
free(M->AL->b);
free(M->AL->c);
free(M->AL);

for (i = 0; i < ym; i++)
    {
    free(M->A[i].a);
    free(M->A[i].b);
    free(M->A[i].c);
    }
free(M->A);


free(M->BF->a);
free(M->BF->b);
free(M->BF->c);
free(M->BF);

for (i = 0; i < ym; i++)
    {
    free(M->B[i].a);
    free(M->B[i].b);
    free(M->B[i].c);
    }
free(M->B);


free(M->CF->a);
free(M->CF->b);
free(M->CF->c);
free(M->CF);

for (i = 0; i < ym; i++)
    {
    free(M->C[i].a);
    free(M->C[i].b);
    free(M->C[i].c);
    }
free(M->C);
}  /* end of function free_first_proc_collmat */


/****************************************************************
 *  FUNCTION:  d_first_proc_collmat -- dynamically allocate     *
 *                space in memory for the portion of a collmat  *
 *                that resides at the first processor           * 
 ****************************************************************/
void d_first_proc_collmat (M, xm, ym)
struct first_proc_collmat *M;
int xm, ym;
{
struct triblock22 T22;
struct triblock24 T24;
struct triblock44 T44;

int i, xmm1=xm-1, ymm1=ym-1, ymm2=ym-2;

dtriblock22(&T22, xm);
dtriblock24(&T24, xm);
dtriblock44(&T44, xm);


M->AF    = calloc(1,    sizeof(T22));
M->AF->a = calloc(xm,   sizeof(struct m22));
M->AF->b = calloc(xmm1, sizeof(struct v2));
M->AF->c = calloc(xmm1, sizeof(struct v2));

M->A = calloc(ym, sizeof(T44));
for (i = 0; i < ym; i++)
    {
    M->A[i].a = calloc(xm,   sizeof(struct m44));
    M->A[i].b = calloc(xmm1, sizeof(struct m42));
    M->A[i].c = calloc(xmm1, sizeof(struct m42));
    }

M->AL    = calloc(1,    sizeof(T22));
M->AL->a = calloc(xm,   sizeof(struct m22));
M->AL->b = calloc(xmm1, sizeof(struct v2));
M->AL->c = calloc(xmm1, sizeof(struct v2));

M->B = calloc(ym, sizeof(T24));
for (i = 0; i < ym; i++)
    {
    M->B[i].a = calloc(xm,   sizeof(struct m24));
    M->B[i].b = calloc(xmm1, sizeof(struct m22));
    M->B[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->BF    = calloc(1,    sizeof(T24));
M->BF->a = calloc(xm,   sizeof(struct m24));
M->BF->b = calloc(xmm1, sizeof(struct m22));
M->BF->c = calloc(xmm1, sizeof(struct m22));

M->CF    = calloc(1,    sizeof(T22));
M->CF->a = calloc(xm,   sizeof(struct m22));
M->CF->b = calloc(xmm1, sizeof(struct v2));
M->CF->c = calloc(xmm1, sizeof(struct v2));

M->C = calloc(ym, sizeof(T24));
for (i = 0; i < ym; i++)
    {
    M->C[i].a = calloc(xm,   sizeof(struct m24));
    M->C[i].b = calloc(xmm1, sizeof(struct m22));
    M->C[i].c = calloc(xmm1, sizeof(struct m22));
    }

free_triblock22(&T22);
free_triblock24(&T24);
free_triblock44(&T44);
}  /* end of function d_first_proc_collmat */


/*****************************************************************
 *  FUNCTION:  free_proc_collmat -- de-allocate space in memory  *
 *                      for a proc_collmat                       *
 *****************************************************************/
void free_proc_collmat (M, ym)
struct proc_collmat *M;
int ym;
{
int i;

for (i = 0; i < ym; i++)
    {
    free(M->A[i].a);
    free(M->A[i].b);
    free(M->A[i].c);
    }
free(M->A);

for (i = 0; i < ym; i++)
    {
    free(M->B[i].a);
    free(M->B[i].b);
    free(M->B[i].c);
    }
free(M->B);

for (i = 0; i < ym; i++)
    {
    free(M->C[i].a);
    free(M->C[i].b);
    free(M->C[i].c);
    }
free(M->C);
}  /* end of function free_proc_collmat */


/************************************************************************
 *  FUNCTION:  d_proc_collmat -- dynamically allocate space in memory   * 
 *    for the portion of a collmat that resides on a typical processor  *
 ************************************************************************/
void d_proc_collmat (M, xm, bpp)
struct proc_collmat *M;
int xm, bpp;
{
struct triblock22 T22;
struct triblock24 T24;
struct triblock44 T44;

int i, xmm1=xm-1;

dtriblock22(&T22, xm);
dtriblock24(&T24, xm);
dtriblock44(&T44, xm);

M->A = calloc(bpp, sizeof(T44));
for (i = 0; i < bpp; i++)
    {
    M->A[i].a = calloc(xm,   sizeof(struct m44));
    M->A[i].b = calloc(xmm1, sizeof(struct m42));
    M->A[i].c = calloc(xmm1, sizeof(struct m42));
    }

M->B = calloc(bpp, sizeof(T24));
for (i = 0; i < bpp; i++)
    {
    M->B[i].a = calloc(xm,   sizeof(struct m24));
    M->B[i].b = calloc(xmm1, sizeof(struct m22));
    M->B[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->C = calloc(bpp, sizeof(T24));
for (i = 0; i < bpp; i++)
    {
    M->C[i].a = calloc(xm,   sizeof(struct m24));
    M->C[i].b = calloc(xmm1, sizeof(struct m22));
    M->C[i].c = calloc(xmm1, sizeof(struct m22));
    }

free_triblock22(&T22);
free_triblock24(&T24);
free_triblock44(&T44);
}  /* end of function d_proc_collmat */


/**********************************************************************
 *  FUNCTION:  free_last_proc_collmat -- de-allocate space in memory  *
 *    for the portion of a collmat that resides on the last processor *
 **********************************************************************/
void free_last_proc_collmat (M, ym)
struct last_proc_collmat *M;
int ym;
{
int i, ymm1=ym-1;

for (i = 0; i < ym; i++)
    {
    free(M->A[i].a);
    free(M->A[i].b);
    free(M->A[i].c);
    }
free(M->A);

free(M->BL->a);
free(M->BL->b);
free(M->BL->c);
free(M->BL);

for (i = 0; i < ymm1; i++)
    {
    free(M->B[i].a);
    free(M->B[i].b);
    free(M->B[i].c);
    }
free(M->B);

free(M->CL->a);
free(M->CL->b);
free(M->CL->c);
free(M->CL);

for (i = 0; i < ymm1; i++)
    {
    free(M->C[i].a);
    free(M->C[i].b);
    free(M->C[i].c);
    }
free(M->C);
}  /* end of function free_last_proc_collmat */


/****************************************************************************
 *  FUNCTION:  d_last_proc_collmat -- dynamically allocate space in memory  *
 *     for the portion of a collmat that resides on the last processor      *
 ****************************************************************************/
void d_last_proc_collmat (M, xm, ym)
struct last_proc_collmat *M;
int xm, ym;
{
struct triblock22 T22;
struct triblock24 T24;
struct triblock44 T44;

int i, xmm1=xm-1, ymm1=ym-1;

dtriblock22(&T22, xm);
dtriblock24(&T24, xm);
dtriblock44(&T44, xm);

M->A = calloc(ym, sizeof(T44));
for (i = 0; i < ym; i++)
    {
    M->A[i].a = calloc(xm,   sizeof(struct m44));
    M->A[i].b = calloc(xmm1, sizeof(struct m42));
    M->A[i].c = calloc(xmm1, sizeof(struct m42));
    }

M->BL    = calloc(1,    sizeof(T22));
M->BL->a = calloc(xm,   sizeof(struct m22));
M->BL->b = calloc(xmm1, sizeof(struct v2));
M->BL->c = calloc(xmm1, sizeof(struct v2));

M->B = calloc(ymm1, sizeof(T24));
for (i = 0; i < ymm1; i++)
    {
    M->B[i].a = calloc(xm,   sizeof(struct m24));
    M->B[i].b = calloc(xmm1, sizeof(struct m22));
    M->B[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->C = calloc(ymm1, sizeof(T24));
for (i = 0; i < ymm1; i++)
    {
    M->C[i].a = calloc(xm,   sizeof(struct m24));
    M->C[i].b = calloc(xmm1, sizeof(struct m22));
    M->C[i].c = calloc(xmm1, sizeof(struct m22));
    }

M->CL    = calloc(1,    sizeof(T24));
M->CL->a = calloc(xm,   sizeof(struct m24));
M->CL->b = calloc(xmm1, sizeof(struct m22));
M->CL->c = calloc(xmm1, sizeof(struct m22));

free_triblock22(&T22);
free_triblock24(&T24);
free_triblock44(&T44);
}  /* end of function d_last_proc_collmat */