// set_families.h
// Copyright (C) 2023 Mark Bowron

// Create and manipulate the set families KZ, K, KFZ, KF, KFGZ, and KFG.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Sets are represented by unsigned 32-bit integers with leading zeros.

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
} KZ;

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
    uint32_t    *_a;
    uint32_t    *_ab;
    uint32_t    *_ai;
    uint32_t    *_abi;
    uint32_t    *_aib;
    uint32_t    *_abib;
    uint32_t    *_aibi;
} K;

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
    uint32_t    *_f;
    uint32_t    *_ff;
    uint32_t    *_if;
    uint32_t    *_bif;
    uint32_t    *_fb;
    uint32_t    *_fib;
    uint32_t    *_fi;
    uint32_t    *_fbi;
    uint32_t    *_fif;
    uint32_t    *_zero;
} KFZ;

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
    uint32_t    *_f;
    uint32_t    *_ff;
    uint32_t    *_if;
    uint32_t    *_bif;
    uint32_t    *_fb;
    uint32_t    *_fib;
    uint32_t    *_fi;
    uint32_t    *_fbi;
    uint32_t    *_fif;
    uint32_t    *_zero;
    uint32_t    *_a;
    uint32_t    *_ab;
    uint32_t    *_ai;
    uint32_t    *_abi;
    uint32_t    *_aib;
    uint32_t    *_abib;
    uint32_t    *_aibi;
    uint32_t    *_af;
    uint32_t    *_aff;
    uint32_t    *_aif;
    uint32_t    *_abif;
    uint32_t    *_afb;
    uint32_t    *_afib;
    uint32_t    *_afi;
    uint32_t    *_afbi;
    uint32_t    *_afif;
    uint32_t    *_one;
} KF;

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
    uint32_t    *_f;
    uint32_t    *_ff;
    uint32_t    *_if;
    uint32_t    *_bif;
    uint32_t    *_fb;
    uint32_t    *_fib;
    uint32_t    *_fi;
    uint32_t    *_fbi;
    uint32_t    *_fif;
    uint32_t    *_g;
    uint32_t    *_bg;
    uint32_t    *_fbg;
    uint32_t    *_zero;
} KFGZ;

typedef struct
{
    uint32_t    *_id;
    uint32_t    *_b;
    uint32_t    *_i;
    uint32_t    *_bi;
    uint32_t    *_ib;
    uint32_t    *_bib;
    uint32_t    *_ibi;
    uint32_t    *_f;
    uint32_t    *_ff;
    uint32_t    *_if;
    uint32_t    *_bif;
    uint32_t    *_fb;
    uint32_t    *_fib;
    uint32_t    *_fi;
    uint32_t    *_fbi;
    uint32_t    *_fif;
    uint32_t    *_g;
    uint32_t    *_bg;
    uint32_t    *_fbg;
    uint32_t    *_zero;
    uint32_t    *_a;
    uint32_t    *_ab;
    uint32_t    *_ai;
    uint32_t    *_abi;
    uint32_t    *_aib;
    uint32_t    *_abib;
    uint32_t    *_aibi;
    uint32_t    *_af;
    uint32_t    *_aff;
    uint32_t    *_aif;
    uint32_t    *_abif;
    uint32_t    *_afb;
    uint32_t    *_afib;
    uint32_t    *_afi;
    uint32_t    *_afbi;
    uint32_t    *_afif;
    uint32_t    *_ag;
    uint32_t    *_abg;
    uint32_t    *_afbg;
    uint32_t    *_one;
} KFG;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
} KZenum;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
    int _a;
    int _ab;
    int _ai;
    int _abi;
    int _aib;
    int _abib;
    int _aibi;
} Kenum;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
    int _f;
    int _ff;
    int _if;
    int _bif;
    int _fb;
    int _fib;
    int _fi;
    int _fbi;
    int _fif;
    int _zero;
} KFZenum;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
    int _f;
    int _ff;
    int _if;
    int _bif;
    int _fb;
    int _fib;
    int _fi;
    int _fbi;
    int _fif;
    int _zero;
    int _a;
    int _ab;
    int _ai;
    int _abi;
    int _aib;
    int _abib;
    int _aibi;
    int _af;
    int _aff;
    int _aif;
    int _abif;
    int _afb;
    int _afib;
    int _afi;
    int _afbi;
    int _afif;
    int _one;
} KFenum;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
    int _f;
    int _ff;
    int _if;
    int _bif;
    int _fb;
    int _fib;
    int _fi;
    int _fbi;
    int _fif;
    int _g;
    int _bg;
    int _fbg;
    int _zero;
} KFGZenum;

typedef struct
{
    int _id;
    int _b;
    int _i;
    int _bi;
    int _ib;
    int _bib;
    int _ibi;
    int _f;
    int _ff;
    int _if;
    int _bif;
    int _fb;
    int _fib;
    int _fi;
    int _fbi;
    int _fif;
    int _g;
    int _bg;
    int _fbg;
    int _zero;
    int _a;
    int _ab;
    int _ai;
    int _abi;
    int _aib;
    int _abib;
    int _aibi;
    int _af;
    int _aff;
    int _aif;
    int _abif;
    int _afb;
    int _afib;
    int _afi;
    int _afbi;
    int _afif;
    int _ag;
    int _abg;
    int _afbg;
    int _one;
} KFGenum;


KZ     *CreateKZ(int spacesize);
K      *CreateK(int spacesize);
KFZ    *CreateKFZ(int spacesize);
KF     *CreateKF(int spacesize);
KFGZ   *CreateKFGZ(int spacesize);
KFG    *CreateKFG(int spacesize);

void    KZlabels(char **label);
void    Klabels(char **label);
void    KFZlabels(char **label);
void    KFlabels(char **label);
void    KFGZlabels(char **label);
void    KFGlabels(char **label);

void    EraseKZ(KZ *fam, int spacesize);
void    EraseK(K *fam, int spacesize);
void    EraseKFZ(KFZ *fam, int spacesize);
void    EraseKF(KF *fam, int spacesize);
void    EraseKFGZ(KFGZ *fam, int spacesize);
void    EraseKFG(KFG *fam, int spacesize);

void    FreeKZ(KZ *fam);
void    FreeK(K *fam);
void    FreeKFZ(KFZ *fam);
void    FreeKF(KF *fam);
void    FreeKFGZ(KFGZ *fam);
void    FreeKFG(KFG *fam);

void    ComputeKZ(KZ *fam, int spacesize, uint32_t *point_closures);
void    ComputeK(K *fam, int spacesize, uint32_t *point_closures);
void    ComputeKFZ(KFZ *fam, int spacesize, uint32_t *point_closures);
void    ComputeKF(KF *fam, int spacesize, uint32_t *point_closures);
void    ComputeKFGZ(KFGZ *fam, int spacesize, uint32_t *point_closures);
void    ComputeKFG(KFG *fam, int spacesize, uint32_t *point_closures);

void    ComputeKZarray(uint32_t **fam, KZ *kz, int spacesize, uint32_t *point_closures);
void    ComputeKarray(uint32_t **fam, K *k, int spacesize, uint32_t *point_closures);
void    ComputeKFZarray(uint32_t **fam, KFZ *kfz, int spacesize, uint32_t *point_closures);
void    ComputeKFarray(uint32_t **fam, KF *kf, int spacesize, uint32_t *point_closures);
void    ComputeKFGZarray(uint32_t **fam, KFGZ *kfgz, int spacesize, uint32_t *point_closures);
void    ComputeKFGarray(uint32_t **fam, KFG *kfg, int spacesize, uint32_t *point_closures);

void    CopyKZarray(uint32_t **fam, KZ *kz, int spacesize);
void    CopyKarray(uint32_t **fam, K *k, int spacesize);
void    CopyKFZarray(uint32_t **fam, KFZ *kfz, int spacesize);
void    CopyKFarray(uint32_t **fam, KF *kf, int spacesize);
void    CopyKFGZarray(uint32_t **fam, KFGZ *kfgz, int spacesize);
void    CopyKFGarray(uint32_t **fam, KFG *kfg, int spacesize);

void    CopyKZfromK(KZ  *kz, K *fam, int spacesize);
void    CopyKZfromKFZ(KZ *kz, KFZ *fam, int spacesize);
void    CopyKZfromKF(KZ *kz, KF *fam, int spacesize);
void    CopyKZfromKFGZ(KZ *kz, KFGZ *fam, int spacesize);
void    CopyKZfromKFG(KZ *kz, KFG *fam, int spacesize);
void    CopyKFZfromKF(KFZ *kfz, KF *fam, int spacesize);
void    CopyKFZfromKFGZ(KFZ *kfz, KFGZ *fam, int spacesize);
void    CopyKFZfromKFG(KFZ *kfz, KFG *fam, int spacesize);

void    ExtractKFfromKFG(int **kf, int **kfg);


KZ *CreateKZ(int spacesize)
{
    KZ  *fam;

    fam = (KZ *)malloc(sizeof(KZ));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }
    
    EraseKZ(fam, spacesize);

    return fam;
}


K *CreateK(int spacesize)
{
    K   *fam;

    fam = (K *)malloc(sizeof(K));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }

    fam->_a = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_a==0)
    {
        printf("\nCould not allocate space for fam->_a.\n");
        exit(0);
    }

    fam->_ab = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ab==0)
    {
        printf("\nCould not allocate space for fam->_ab.\n");
        exit(0);
    }

    fam->_ai = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ai==0)
    {
        printf("\nCould not allocate space for fam->_ai.\n");
        exit(0);
    }

    fam->_abi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abi==0)
    {
        printf("\nCould not allocate space for fam->_abi.\n");
        exit(0);
    }

    fam->_aib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aib==0)
    {
        printf("\nCould not allocate space for fam->_aib.\n");
        exit(0);
    }

    fam->_abib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abib==0)
    {
        printf("\nCould not allocate space for fam->_abib.\n");
        exit(0);
    }

    fam->_aibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aibi==0)
    {
        printf("\nCould not allocate space for fam->_aibi.\n");
        exit(0);
    }
    
    EraseK(fam, spacesize);

    return fam;
}


KFZ *CreateKFZ(int spacesize)
{
    KFZ *fam;

    fam = (KFZ *)malloc(sizeof(KFZ));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }

    fam->_f = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_f==0)
    {
        printf("\nCould not allocate space for fam->_f.\n");
        exit(0);
    }

    fam->_ff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ff==0)
    {
        printf("\nCould not allocate space for fam->_ff.\n");
        exit(0);
    }

    fam->_if = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_if==0)
    {
        printf("\nCould not allocate space for fam->_if.\n");
        exit(0);
    }

    fam->_bif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bif==0)
    {
        printf("\nCould not allocate space for fam->_bif.\n");
        exit(0);
    }

    fam->_fb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fb==0)
    {
        printf("\nCould not allocate space for fam->_fb.\n");
        exit(0);
    }

    fam->_fib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fib==0)
    {
        printf("\nCould not allocate space for fam->_fib.\n");
        exit(0);
    }

    fam->_fi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fi==0)
    {
        printf("\nCould not allocate space for fam->_fi.\n");
        exit(0);
    }

    fam->_fbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbi==0)
    {
        printf("\nCould not allocate space for fam->_fbi.\n");
        exit(0);
    }

    fam->_fif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fif==0)
    {
        printf("\nCould not allocate space for fam->_fif.\n");
        exit(0);
    }

    fam->_zero = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_zero==0)
    {
        printf("\nCould not allocate space for fam->_zero.\n");
        exit(0);
    }

    EraseKFZ(fam, spacesize);

    return fam;
}


KF *CreateKF(int spacesize)
{
    KF  *fam;

    fam = (KF *)malloc(sizeof(KF));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }

    fam->_f = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_f==0)
    {
        printf("\nCould not allocate space for fam->_f.\n");
        exit(0);
    }

    fam->_ff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ff==0)
    {
        printf("\nCould not allocate space for fam->_ff.\n");
        exit(0);
    }

    fam->_if = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_if==0)
    {
        printf("\nCould not allocate space for fam->_if.\n");
        exit(0);
    }

    fam->_bif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bif==0)
    {
        printf("\nCould not allocate space for fam->_bif.\n");
        exit(0);
    }

    fam->_fb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fb==0)
    {
        printf("\nCould not allocate space for fam->_fb.\n");
        exit(0);
    }

    fam->_fib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fib==0)
    {
        printf("\nCould not allocate space for fam->_fib.\n");
        exit(0);
    }

    fam->_fi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fi==0)
    {
        printf("\nCould not allocate space for fam->_fi.\n");
        exit(0);
    }

    fam->_fbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbi==0)
    {
        printf("\nCould not allocate space for fam->_fbi.\n");
        exit(0);
    }

    fam->_fif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fif==0)
    {
        printf("\nCould not allocate space for fam->_fif.\n");
        exit(0);
    }

    fam->_zero = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_zero==0)
    {
        printf("\nCould not allocate space for fam->_zero.\n");
        exit(0);
    }

    fam->_a = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_a==0)
    {
        printf("\nCould not allocate space for fam->_a.\n");
        exit(0);
    }

    fam->_ab = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ab==0)
    {
        printf("\nCould not allocate space for fam->_ab.\n");
        exit(0);
    }

    fam->_ai = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ai==0)
    {
        printf("\nCould not allocate space for fam->_ai.\n");
        exit(0);
    }

    fam->_abi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abi==0)
    {
        printf("\nCould not allocate space for fam->_abi.\n");
        exit(0);
    }

    fam->_aib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aib==0)
    {
        printf("\nCould not allocate space for fam->_aib.\n");
        exit(0);
    }

    fam->_abib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abib==0)
    {
        printf("\nCould not allocate space for fam->_abib.\n");
        exit(0);
    }

    fam->_aibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aibi==0)
    {
        printf("\nCould not allocate space for fam->_aibi.\n");
        exit(0);
    }

    fam->_af = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_af==0)
    {
        printf("\nCould not allocate space for fam->_af.\n");
        exit(0);
    }

    fam->_aff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aff==0)
    {
        printf("\nCould not allocate space for fam->_aff.\n");
        exit(0);
    }

    fam->_aif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aif==0)
    {
        printf("\nCould not allocate space for fam->_aif.\n");
        exit(0);
    }

    fam->_abif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abif==0)
    {
        printf("\nCould not allocate space for fam->_abif.\n");
        exit(0);
    }

    fam->_afb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afb==0)
    {
        printf("\nCould not allocate space for fam->_afb.\n");
        exit(0);
    }

    fam->_afib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afib==0)
    {
        printf("\nCould not allocate space for fam->_afib.\n");
        exit(0);
    }

    fam->_afi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afi==0)
    {
        printf("\nCould not allocate space for fam->_afi.\n");
        exit(0);
    }

    fam->_afbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afbi==0)
    {
        printf("\nCould not allocate space for fam->_afbi.\n");
        exit(0);
    }

    fam->_afif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afif==0)
    {
        printf("\nCould not allocate space for fam->_afif.\n");
        exit(0);
    }

    fam->_one = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_one==0)
    {
        printf("\nCould not allocate space for fam->_one.\n");
        exit(0);
    }
    
    EraseKF(fam, spacesize);

    return fam;
}


KFGZ *CreateKFGZ(int spacesize)
{
    KFGZ    *fam;

    fam = (KFGZ *)malloc(sizeof(KFGZ));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }

    fam->_f = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_f==0)
    {
        printf("\nCould not allocate space for fam->_f.\n");
        exit(0);
    }

    fam->_ff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ff==0)
    {
        printf("\nCould not allocate space for fam->_ff.\n");
        exit(0);
    }

    fam->_if = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_if==0)
    {
        printf("\nCould not allocate space for fam->_if.\n");
        exit(0);
    }

    fam->_bif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bif==0)
    {
        printf("\nCould not allocate space for fam->_bif.\n");
        exit(0);
    }

    fam->_fb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fb==0)
    {
        printf("\nCould not allocate space for fam->_fb.\n");
        exit(0);
    }

    fam->_fib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fib==0)
    {
        printf("\nCould not allocate space for fam->_fib.\n");
        exit(0);
    }

    fam->_fi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fi==0)
    {
        printf("\nCould not allocate space for fam->_fi.\n");
        exit(0);
    }

    fam->_fbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbi==0)
    {
        printf("\nCould not allocate space for fam->_fbi.\n");
        exit(0);
    }

    fam->_fif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fif==0)
    {
        printf("\nCould not allocate space for fam->_fif.\n");
        exit(0);
    }

    fam->_g = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_g==0)
    {
        printf("\nCould not allocate space for fam->_g.\n");
        exit(0);
    }

    fam->_bg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bg==0)
    {
        printf("\nCould not allocate space for fam->_bg.\n");
        exit(0);
    }

    fam->_fbg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbg==0)
    {
        printf("\nCould not allocate space for fam->_fbg.\n");
        exit(0);
    }

    fam->_zero = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_zero==0)
    {
        printf("\nCould not allocate space for fam->_zero.\n");
        exit(0);
    }
    
    EraseKFGZ(fam, spacesize);

    return fam;
}


KFG *CreateKFG(int spacesize)
{
    KFG *fam;

    fam = (KFG *)malloc(sizeof(KFG));
    if (fam==0)
    {
        printf("\nCould not allocate space for fam.\n");
        exit(0);
    }

    fam->_id = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_id==0)
    {
        printf("\nCould not allocate space for fam->_id.\n");
        exit(0);
    }

    fam->_b = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_b==0)
    {
        printf("\nCould not allocate space for fam->_b.\n");
        exit(0);
    }

    fam->_i = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_i==0)
    {
        printf("\nCould not allocate space for fam->_i.\n");
        exit(0);
    }

    fam->_bi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bi==0)
    {
        printf("\nCould not allocate space for fam->_bi.\n");
        exit(0);
    }

    fam->_ib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ib==0)
    {
        printf("\nCould not allocate space for fam->_ib.\n");
        exit(0);
    }

    fam->_bib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bib==0)
    {
        printf("\nCould not allocate space for fam->_bib.\n");
        exit(0);
    }

    fam->_ibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ibi==0)
    {
        printf("\nCould not allocate space for fam->_ibi.\n");
        exit(0);
    }

    fam->_f = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_f==0)
    {
        printf("\nCould not allocate space for fam->_f.\n");
        exit(0);
    }

    fam->_ff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ff==0)
    {
        printf("\nCould not allocate space for fam->_ff.\n");
        exit(0);
    }

    fam->_if = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_if==0)
    {
        printf("\nCould not allocate space for fam->_if.\n");
        exit(0);
    }

    fam->_bif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bif==0)
    {
        printf("\nCould not allocate space for fam->_bif.\n");
        exit(0);
    }

    fam->_fb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fb==0)
    {
        printf("\nCould not allocate space for fam->_fb.\n");
        exit(0);
    }

    fam->_fib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fib==0)
    {
        printf("\nCould not allocate space for fam->_fib.\n");
        exit(0);
    }

    fam->_fi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fi==0)
    {
        printf("\nCould not allocate space for fam->_fi.\n");
        exit(0);
    }

    fam->_fbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbi==0)
    {
        printf("\nCould not allocate space for fam->_fbi.\n");
        exit(0);
    }

    fam->_fif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fif==0)
    {
        printf("\nCould not allocate space for fam->_fif.\n");
        exit(0);
    }

    fam->_g = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_g==0)
    {
        printf("\nCould not allocate space for fam->_g.\n");
        exit(0);
    }

    fam->_bg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_bg==0)
    {
        printf("\nCould not allocate space for fam->_bg.\n");
        exit(0);
    }

    fam->_fbg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_fbg==0)
    {
        printf("\nCould not allocate space for fam->_fbg.\n");
        exit(0);
    }

    fam->_zero = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_zero==0)
    {
        printf("\nCould not allocate space for fam->_zero.\n");
        exit(0);
    }

    fam->_a = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_a==0)
    {
        printf("\nCould not allocate space for fam->_a.\n");
        exit(0);
    }

    fam->_ab = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ab==0)
    {
        printf("\nCould not allocate space for fam->_ab.\n");
        exit(0);
    }

    fam->_ai = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ai==0)
    {
        printf("\nCould not allocate space for fam->_ai.\n");
        exit(0);
    }

    fam->_abi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abi==0)
    {
        printf("\nCould not allocate space for fam->_abi.\n");
        exit(0);
    }

    fam->_aib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aib==0)
    {
        printf("\nCould not allocate space for fam->_aib.\n");
        exit(0);
    }

    fam->_abib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abib==0)
    {
        printf("\nCould not allocate space for fam->_abib.\n");
        exit(0);
    }

    fam->_aibi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aibi==0)
    {
        printf("\nCould not allocate space for fam->_aibi.\n");
        exit(0);
    }

    fam->_af = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_af==0)
    {
        printf("\nCould not allocate space for fam->_af.\n");
        exit(0);
    }

    fam->_aff = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aff==0)
    {
        printf("\nCould not allocate space for fam->_aff.\n");
        exit(0);
    }

    fam->_aif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_aif==0)
    {
        printf("\nCould not allocate space for fam->_aif.\n");
        exit(0);
    }

    fam->_abif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abif==0)
    {
        printf("\nCould not allocate space for fam->_abif.\n");
        exit(0);
    }

    fam->_afb = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afb==0)
    {
        printf("\nCould not allocate space for fam->_afb.\n");
        exit(0);
    }

    fam->_afib = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afib==0)
    {
        printf("\nCould not allocate space for fam->_afib.\n");
        exit(0);
    }

    fam->_afi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afi==0)
    {
        printf("\nCould not allocate space for fam->_afi.\n");
        exit(0);
    }

    fam->_afbi = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afbi==0)
    {
        printf("\nCould not allocate space for fam->_afbi.\n");
        exit(0);
    }

    fam->_afif = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afif==0)
    {
        printf("\nCould not allocate space for fam->_afif.\n");
        exit(0);
    }

    fam->_ag = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_ag==0)
    {
        printf("\nCould not allocate space for fam->_ag.\n");
        exit(0);
    }

    fam->_abg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_abg==0)
    {
        printf("\nCould not allocate space for fam->_abg.\n");
        exit(0);
    }

    fam->_afbg = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_afbg==0)
    {
        printf("\nCould not allocate space for fam->_afbg.\n");
        exit(0);
    }

    fam->_one = (uint32_t *)malloc((one<<spacesize) * sizeof(uint32_t));
    if (fam->_one==0)
    {
        printf("\nCould not allocate space for fam->_one.\n");
        exit(0);
    }
    
    EraseKFG(fam, spacesize);

    return fam;
}


void KZlabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
}


void Klabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
    strcpy(label[7],"a");
    strcpy(label[8],"ab");
    strcpy(label[9],"ai");
    strcpy(label[10],"abi");
    strcpy(label[11],"aib");
    strcpy(label[12],"abib");
    strcpy(label[13],"aibi");
}


void KFZlabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
    strcpy(label[7],"f");
    strcpy(label[8],"ff");
    strcpy(label[9],"if");
    strcpy(label[10],"bif");
    strcpy(label[11],"fb");
    strcpy(label[12],"fib");
    strcpy(label[13],"fi");
    strcpy(label[14],"fbi");
    strcpy(label[15],"fif");
    strcpy(label[16],"0");
}


void KFlabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
    strcpy(label[7],"f");
    strcpy(label[8],"ff");
    strcpy(label[9],"if");
    strcpy(label[10],"bif");
    strcpy(label[11],"fb");
    strcpy(label[12],"fib");
    strcpy(label[13],"fi");
    strcpy(label[14],"fbi");
    strcpy(label[15],"fif");
    strcpy(label[16],"0");
    strcpy(label[17],"a");
    strcpy(label[18],"ab");
    strcpy(label[19],"ai");
    strcpy(label[20],"abi");
    strcpy(label[21],"aib");
    strcpy(label[22],"abib");
    strcpy(label[23],"aibi");
    strcpy(label[24],"af");
    strcpy(label[25],"aff");
    strcpy(label[26],"aif");
    strcpy(label[27],"abif");
    strcpy(label[28],"afb");
    strcpy(label[29],"afib");
    strcpy(label[30],"afi");
    strcpy(label[31],"afbi");
    strcpy(label[32],"afif");
    strcpy(label[33],"1");
}


void KFGZlabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
    strcpy(label[7],"f");
    strcpy(label[8],"ff");
    strcpy(label[9],"if");
    strcpy(label[10],"bif");
    strcpy(label[11],"fb");
    strcpy(label[12],"fib");
    strcpy(label[13],"fi");
    strcpy(label[14],"fbi");
    strcpy(label[15],"fif");
    strcpy(label[16],"g");
    strcpy(label[17],"bg");
    strcpy(label[18],"fbg");
    strcpy(label[19],"0");
}


void KFGlabels(char **label)
{
    strcpy(label[0],"id");
    strcpy(label[1],"b");
    strcpy(label[2],"i");
    strcpy(label[3],"bi");
    strcpy(label[4],"ib");
    strcpy(label[5],"bib");
    strcpy(label[6],"ibi");
    strcpy(label[7],"f");
    strcpy(label[8],"ff");
    strcpy(label[9],"if");
    strcpy(label[10],"bif");
    strcpy(label[11],"fb");
    strcpy(label[12],"fib");
    strcpy(label[13],"fi");
    strcpy(label[14],"fbi");
    strcpy(label[15],"fif");
    strcpy(label[16],"g");
    strcpy(label[17],"bg");
    strcpy(label[18],"fbg");
    strcpy(label[19],"0");
    strcpy(label[20],"a");
    strcpy(label[21],"ab");
    strcpy(label[22],"ai");
    strcpy(label[23],"abi");
    strcpy(label[24],"aib");
    strcpy(label[25],"abib");
    strcpy(label[26],"aibi");
    strcpy(label[27],"af");
    strcpy(label[28],"aff");
    strcpy(label[29],"aif");
    strcpy(label[30],"abif");
    strcpy(label[31],"afb");
    strcpy(label[32],"afib");
    strcpy(label[33],"afi");
    strcpy(label[34],"afbi");
    strcpy(label[35],"afif");
    strcpy(label[36],"ag");
    strcpy(label[37],"abg");
    strcpy(label[38],"afbg");
    strcpy(label[39],"1");
}


void EraseKZ(KZ *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
    }
}


void EraseK(K *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
        fam->_a[j] = 0;
        fam->_ab[j] = 0;
        fam->_ai[j] = 0;
        fam->_abi[j] = 0;
        fam->_aib[j] = 0;
        fam->_abib[j] = 0;
        fam->_aibi[j] = 0;
    }
}


void EraseKFZ(KFZ *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
        fam->_f[j] = 0;
        fam->_ff[j] = 0;
        fam->_if[j] = 0;
        fam->_bif[j] = 0;
        fam->_fb[j] = 0;
        fam->_fib[j] = 0;
        fam->_fi[j] = 0;
        fam->_fbi[j] = 0;
        fam->_fif[j] = 0;
        fam->_zero[j] = 0;
    }
}


void EraseKF(KF *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
        fam->_f[j] = 0;
        fam->_ff[j] = 0;
        fam->_if[j] = 0;
        fam->_bif[j] = 0;
        fam->_fb[j] = 0;
        fam->_fib[j] = 0;
        fam->_fi[j] = 0;
        fam->_fbi[j] = 0;
        fam->_fif[j] = 0;
        fam->_zero[j] = 0;
        fam->_a[j] = 0;
        fam->_ab[j] = 0;
        fam->_ai[j] = 0;
        fam->_abi[j] = 0;
        fam->_aib[j] = 0;
        fam->_abib[j] = 0;
        fam->_aibi[j] = 0;
        fam->_af[j] = 0;
        fam->_aff[j] = 0;
        fam->_aif[j] = 0;
        fam->_abif[j] = 0;
        fam->_afb[j] = 0;
        fam->_afib[j] = 0;
        fam->_afi[j] = 0;
        fam->_afbi[j] = 0;
        fam->_afif[j] = 0;
        fam->_one[j] = 0;
    }
}


void EraseKFGZ(KFGZ *fam, int spacesize)
{
    int j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
        fam->_f[j] = 0;
        fam->_ff[j] = 0;
        fam->_if[j] = 0;
        fam->_bif[j] = 0;
        fam->_fb[j] = 0;
        fam->_fib[j] = 0;
        fam->_fi[j] = 0;
        fam->_fbi[j] = 0;
        fam->_fif[j] = 0;
        fam->_g[j] = 0;
        fam->_bg[j] = 0;
        fam->_fbg[j] = 0;
        fam->_zero[j] = 0;
    }
}


void EraseKFG(KFG *fam, int spacesize)
{
    int j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = 0;
        fam->_b[j] = 0;
        fam->_i[j] = 0;
        fam->_bi[j] = 0;
        fam->_ib[j] = 0;
        fam->_bib[j] = 0;
        fam->_ibi[j] = 0;
        fam->_f[j] = 0;
        fam->_ff[j] = 0;
        fam->_if[j] = 0;
        fam->_bif[j] = 0;
        fam->_fb[j] = 0;
        fam->_fib[j] = 0;
        fam->_fi[j] = 0;
        fam->_fbi[j] = 0;
        fam->_fif[j] = 0;
        fam->_g[j] = 0;
        fam->_bg[j] = 0;
        fam->_fbg[j] = 0;
        fam->_zero[j] = 0;
        fam->_a[j] = 0;
        fam->_ab[j] = 0;
        fam->_ai[j] = 0;
        fam->_abi[j] = 0;
        fam->_aib[j] = 0;
        fam->_abib[j] = 0;
        fam->_aibi[j] = 0;
        fam->_af[j] = 0;
        fam->_aff[j] = 0;
        fam->_aif[j] = 0;
        fam->_abif[j] = 0;
        fam->_afb[j] = 0;
        fam->_afib[j] = 0;
        fam->_afi[j] = 0;
        fam->_afbi[j] = 0;
        fam->_afif[j] = 0;
        fam->_ag[j] = 0;
        fam->_abg[j] = 0;
        fam->_afbg[j] = 0;
        fam->_one[j] = 0;
    }
}


void FreeKZ(KZ *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam);
}


void FreeK(K *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam->_a);
    free(fam->_ab);
    free(fam->_ai);
    free(fam->_abi);
    free(fam->_aib);
    free(fam->_abib);
    free(fam->_aibi);
    free(fam);
}


void FreeKFZ(KFZ *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam->_f);
    free(fam->_ff);
    free(fam->_if);
    free(fam->_bif);
    free(fam->_fb);
    free(fam->_fib);
    free(fam->_fi);
    free(fam->_fbi);
    free(fam->_fif);
    free(fam->_zero);
    free(fam);
}


void FreeKF(KF *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam->_f);
    free(fam->_ff);
    free(fam->_if);
    free(fam->_bif);
    free(fam->_fb);
    free(fam->_fib);
    free(fam->_fi);
    free(fam->_fbi);
    free(fam->_fif);
    free(fam->_zero);
    free(fam->_a);
    free(fam->_ab);
    free(fam->_ai);
    free(fam->_abi);
    free(fam->_aib);
    free(fam->_abib);
    free(fam->_aibi);
    free(fam->_af);
    free(fam->_aff);
    free(fam->_aif);
    free(fam->_abif);
    free(fam->_afb);
    free(fam->_afib);
    free(fam->_afi);
    free(fam->_afbi);
    free(fam->_afif);
    free(fam->_one);
    free(fam);
}


void FreeKFGZ(KFGZ *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam->_f);
    free(fam->_ff);
    free(fam->_if);
    free(fam->_bif);
    free(fam->_fb);
    free(fam->_fib);
    free(fam->_fi);
    free(fam->_fbi);
    free(fam->_fif);
    free(fam->_g);
    free(fam->_bg);
    free(fam->_fbg);
    free(fam->_zero);
    free(fam);
}


void FreeKFG(KFG *fam)
{
    free(fam->_id);
    free(fam->_b);
    free(fam->_i);
    free(fam->_bi);
    free(fam->_ib);
    free(fam->_bib);
    free(fam->_ibi);
    free(fam->_f);
    free(fam->_ff);
    free(fam->_if);
    free(fam->_bif);
    free(fam->_fb);
    free(fam->_fib);
    free(fam->_fi);
    free(fam->_fbi);
    free(fam->_fif);
    free(fam->_g);
    free(fam->_bg);
    free(fam->_fbg);
    free(fam->_zero);
    free(fam->_a);
    free(fam->_ab);
    free(fam->_ai);
    free(fam->_abi);
    free(fam->_aib);
    free(fam->_abib);
    free(fam->_aibi);
    free(fam->_af);
    free(fam->_aff);
    free(fam->_aif);
    free(fam->_abif);
    free(fam->_afb);
    free(fam->_afib);
    free(fam->_afi);
    free(fam->_afbi);
    free(fam->_afif);
    free(fam->_ag);
    free(fam->_abg);
    free(fam->_afbg);
    free(fam->_one);
    free(fam);
}


void ComputeKZ(KZ *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
    }
}


void ComputeK(K *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
        fam->_a[j] = Comp(j, spacesize);
        fam->_ab[j] = Comp(fam->_b[j], spacesize);
        fam->_ai[j] = Comp(fam->_i[j], spacesize);
        fam->_abi[j] = Comp(fam->_bi[j], spacesize);
        fam->_aib[j] = Comp(fam->_ib[j], spacesize);
        fam->_abib[j] = Comp(fam->_bib[j], spacesize);
        fam->_aibi[j] = Comp(fam->_ibi[j], spacesize);
    }
}


void ComputeKFZ(KFZ *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
        fam->_f[j] = Bdry(j, spacesize, point_closures);
        fam->_ff[j] = Bdry(fam->_f[j], spacesize, point_closures);
        fam->_if[j] = Int(fam->_f[j], spacesize, point_closures);
        fam->_bif[j] = Clos(fam->_if[j], spacesize, point_closures);
        fam->_fb[j] = Bdry(fam->_b[j], spacesize, point_closures);
        fam->_fib[j] = Bdry(fam->_ib[j], spacesize, point_closures);
        fam->_fi[j] = Bdry(fam->_i[j], spacesize, point_closures);
        fam->_fbi[j] = Bdry(fam->_bi[j], spacesize, point_closures);
        fam->_fif[j] = Bdry(fam->_if[j], spacesize, point_closures);
        fam->_zero[j] = 0;
    }
}


void ComputeKF(KF *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
        fam->_f[j] = Bdry(j, spacesize, point_closures);
        fam->_ff[j] = Bdry(fam->_f[j], spacesize, point_closures);
        fam->_if[j] = Int(fam->_f[j], spacesize, point_closures);
        fam->_bif[j] = Clos(fam->_if[j], spacesize, point_closures);
        fam->_fb[j] = Bdry(fam->_b[j], spacesize, point_closures);
        fam->_fib[j] = Bdry(fam->_ib[j], spacesize, point_closures);
        fam->_fi[j] = Bdry(fam->_i[j], spacesize, point_closures);
        fam->_fbi[j] = Bdry(fam->_bi[j], spacesize, point_closures);
        fam->_fif[j] = Bdry(fam->_if[j], spacesize, point_closures);
        fam->_zero[j] = 0;
        fam->_a[j] = Comp(j, spacesize);
        fam->_ab[j] = Comp(fam->_b[j], spacesize);
        fam->_ai[j] = Comp(fam->_i[j], spacesize);
        fam->_abi[j] = Comp(fam->_bi[j], spacesize);
        fam->_aib[j] = Comp(fam->_ib[j], spacesize);
        fam->_abib[j] = Comp(fam->_bib[j], spacesize);
        fam->_aibi[j] = Comp(fam->_ibi[j], spacesize);
        fam->_af[j] = Comp(fam->_f[j], spacesize);
        fam->_aff[j] = Comp(fam->_ff[j], spacesize);
        fam->_aif[j] = Comp(fam->_if[j], spacesize);
        fam->_abif[j] = Comp(fam->_bif[j], spacesize);
        fam->_afb[j] = Comp(fam->_fb[j], spacesize);
        fam->_afib[j] = Comp(fam->_fib[j], spacesize);
        fam->_afi[j] = Comp(fam->_fi[j], spacesize);
        fam->_afbi[j] = Comp(fam->_fbi[j], spacesize);
        fam->_afif[j] = Comp(fam->_fif[j], spacesize);
        fam->_one[j] = (one<<spacesize) - 1;
    }
}


void ComputeKFGZ(KFGZ *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
        fam->_f[j] = Bdry(j, spacesize, point_closures);
        fam->_ff[j] = Bdry(fam->_f[j], spacesize, point_closures);
        fam->_if[j] = Int(fam->_f[j], spacesize, point_closures);
        fam->_bif[j] = Clos(fam->_if[j], spacesize, point_closures);
        fam->_fb[j] = Bdry(fam->_b[j], spacesize, point_closures);
        fam->_fib[j] = Bdry(fam->_ib[j], spacesize, point_closures);
        fam->_fi[j] = Bdry(fam->_i[j], spacesize, point_closures);
        fam->_fbi[j] = Bdry(fam->_bi[j], spacesize, point_closures);
        fam->_fif[j] = Bdry(fam->_if[j], spacesize, point_closures);
        fam->_g[j] = Bord(j, spacesize, point_closures);
        fam->_bg[j] = Clos(fam->_g[j], spacesize, point_closures);
        fam->_fbg[j] = Bdry(fam->_bg[j], spacesize, point_closures);
        fam->_zero[j] = 0;
    }
}


void ComputeKFG(KFG *fam, int spacesize, uint32_t *point_closures)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam->_id[j] = j;
        fam->_b[j] = Clos(j, spacesize, point_closures);
        fam->_i[j] = Int(j, spacesize, point_closures);
        fam->_bi[j] = Clos(fam->_i[j], spacesize, point_closures);
        fam->_ib[j] = Int(fam->_b[j], spacesize, point_closures);
        fam->_bib[j] = Clos(fam->_ib[j], spacesize, point_closures);
        fam->_ibi[j] = Int(fam->_bi[j], spacesize, point_closures);
        fam->_f[j] = Bdry(j, spacesize, point_closures);
        fam->_ff[j] = Bdry(fam->_f[j], spacesize, point_closures);
        fam->_if[j] = Int(fam->_f[j], spacesize, point_closures);
        fam->_bif[j] = Clos(fam->_if[j], spacesize, point_closures);
        fam->_fb[j] = Bdry(fam->_b[j], spacesize, point_closures);
        fam->_fib[j] = Bdry(fam->_ib[j], spacesize, point_closures);
        fam->_fi[j] = Bdry(fam->_i[j], spacesize, point_closures);
        fam->_fbi[j] = Bdry(fam->_bi[j], spacesize, point_closures);
        fam->_fif[j] = Bdry(fam->_if[j], spacesize, point_closures);
        fam->_g[j] = Bord(j, spacesize, point_closures);
        fam->_bg[j] = Clos(fam->_g[j], spacesize, point_closures);
        fam->_fbg[j] = Bdry(fam->_bg[j], spacesize, point_closures);
        fam->_zero[j] = 0;
        fam->_a[j] = Comp(j, spacesize);
        fam->_ab[j] = Comp(fam->_b[j], spacesize);
        fam->_ai[j] = Comp(fam->_i[j], spacesize);
        fam->_abi[j] = Comp(fam->_bi[j], spacesize);
        fam->_aib[j] = Comp(fam->_ib[j], spacesize);
        fam->_abib[j] = Comp(fam->_bib[j], spacesize);
        fam->_aibi[j] = Comp(fam->_ibi[j], spacesize);
        fam->_af[j] = Comp(fam->_f[j], spacesize);
        fam->_aff[j] = Comp(fam->_ff[j], spacesize);
        fam->_aif[j] = Comp(fam->_if[j], spacesize);
        fam->_abif[j] = Comp(fam->_bif[j], spacesize);
        fam->_afb[j] = Comp(fam->_fb[j], spacesize);
        fam->_afib[j] = Comp(fam->_fib[j], spacesize);
        fam->_afi[j] = Comp(fam->_fi[j], spacesize);
        fam->_afbi[j] = Comp(fam->_fbi[j], spacesize);
        fam->_afif[j] = Comp(fam->_fif[j], spacesize);
        fam->_ag[j] = Comp(fam->_g[j], spacesize);
        fam->_abg[j] = Comp(fam->_bg[j], spacesize);
        fam->_afbg[j] = Comp(fam->_fbg[j], spacesize);
        fam->_one[j] = (one<<spacesize) - 1;
    }
}


void ComputeKZarray(uint32_t **fam, KZ *kz, int spacesize, uint32_t *point_closures)
{
    ComputeKZ(kz,spacesize,point_closures);
    CopyKZarray(fam,kz,spacesize);
}


void ComputeKarray(uint32_t **fam, K *k, int spacesize, uint32_t *point_closures)
{
    ComputeK(k,spacesize,point_closures);
    CopyKarray(fam,k,spacesize);
}


void ComputeKFZarray(uint32_t **fam, KFZ *kfz, int spacesize, uint32_t *point_closures)
{
    ComputeKFZ(kfz,spacesize,point_closures);
    CopyKFZarray(fam,kfz,spacesize);
}


void ComputeKFarray(uint32_t **fam, KF *kf, int spacesize, uint32_t *point_closures)
{
    ComputeKF(kf,spacesize,point_closures);
    CopyKFarray(fam,kf,spacesize);
}


void ComputeKFGZarray(uint32_t **fam, KFGZ *kfgz, int spacesize, uint32_t *point_closures)
{
    ComputeKFGZ(kfgz,spacesize,point_closures);
    CopyKFGZarray(fam,kfgz,spacesize);
}


void ComputeKFGarray(uint32_t **fam, KFG *kfg, int spacesize, uint32_t *point_closures)
{
    ComputeKFG(kfg,spacesize,point_closures);
    CopyKFGarray(fam,kfg,spacesize);
}


void CopyKZarray(uint32_t **fam, KZ *kz, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = kz->_b[j];
        fam[2][j] = kz->_i[j];
        fam[3][j] = kz->_bi[j];
        fam[4][j] = kz->_ib[j];
        fam[5][j] = kz->_bib[j];
        fam[6][j] = kz->_ibi[j];
    }
}


void CopyKarray(uint32_t **fam, K *k, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = k->_b[j];
        fam[2][j] = k->_i[j];
        fam[3][j] = k->_bi[j];
        fam[4][j] = k->_ib[j];
        fam[5][j] = k->_bib[j];
        fam[6][j] = k->_ibi[j];
        fam[7][j] = k->_a[j];
        fam[8][j] = k->_ab[j];
        fam[9][j] = k->_ai[j];
        fam[10][j] = k->_abi[j];
        fam[11][j] = k->_aib[j];
        fam[12][j] = k->_abib[j];
        fam[13][j] = k->_aibi[j];
    }
}


void CopyKFZarray(uint32_t **fam, KFZ *kfz, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = kfz->_b[j];
        fam[2][j] = kfz->_i[j];
        fam[3][j] = kfz->_bi[j];
        fam[4][j] = kfz->_ib[j];
        fam[5][j] = kfz->_bib[j];
        fam[6][j] = kfz->_ibi[j];
        fam[7][j] = kfz->_f[j];
        fam[8][j] = kfz->_ff[j];
        fam[9][j] = kfz->_if[j];
        fam[10][j] = kfz->_bif[j];
        fam[11][j] = kfz->_fb[j];
        fam[12][j] = kfz->_fib[j];
        fam[13][j] = kfz->_fi[j];
        fam[14][j] = kfz->_fbi[j];
        fam[15][j] = kfz->_fif[j];
        fam[16][j] = 0;
    }
}


void CopyKFarray(uint32_t **fam, KF *kf, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = kf->_b[j];
        fam[2][j] = kf->_i[j];
        fam[3][j] = kf->_bi[j];
        fam[4][j] = kf->_ib[j];
        fam[5][j] = kf->_bib[j];
        fam[6][j] = kf->_ibi[j];
        fam[7][j] = kf->_f[j];
        fam[8][j] = kf->_ff[j];
        fam[9][j] = kf->_if[j];
        fam[10][j] = kf->_bif[j];
        fam[11][j] = kf->_fb[j];
        fam[12][j] = kf->_fib[j];
        fam[13][j] = kf->_fi[j];
        fam[14][j] = kf->_fbi[j];
        fam[15][j] = kf->_fif[j];
        fam[16][j] = 0;
        fam[17][j] = kf->_a[j];
        fam[18][j] = kf->_ab[j];
        fam[19][j] = kf->_ai[j];
        fam[20][j] = kf->_abi[j];
        fam[21][j] = kf->_aib[j];
        fam[22][j] = kf->_abib[j];
        fam[23][j] = kf->_aibi[j];
        fam[24][j] = kf->_af[j];
        fam[25][j] = kf->_aff[j];
        fam[26][j] = kf->_aif[j];
        fam[27][j] = kf->_abif[j];
        fam[28][j] = kf->_afb[j];
        fam[29][j] = kf->_afib[j];
        fam[30][j] = kf->_afi[j];
        fam[31][j] = kf->_afbi[j];
        fam[32][j] = kf->_afif[j];
        fam[33][j] = (one<<spacesize) - 1;
    }
}


void CopyKFGZarray(uint32_t **fam, KFGZ *kfgz, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = kfgz->_b[j];
        fam[2][j] = kfgz->_i[j];
        fam[3][j] = kfgz->_bi[j];
        fam[4][j] = kfgz->_ib[j];
        fam[5][j] = kfgz->_bib[j];
        fam[6][j] = kfgz->_ibi[j];
        fam[7][j] = kfgz->_f[j];
        fam[8][j] = kfgz->_ff[j];
        fam[9][j] = kfgz->_if[j];
        fam[10][j] = kfgz->_bif[j];
        fam[11][j] = kfgz->_fb[j];
        fam[12][j] = kfgz->_fib[j];
        fam[13][j] = kfgz->_fi[j];
        fam[14][j] = kfgz->_fbi[j];
        fam[15][j] = kfgz->_fif[j];
        fam[16][j] = kfgz->_g[j];
        fam[17][j] = kfgz->_bg[j];
        fam[18][j] = kfgz->_fbg[j];
        fam[19][j] = 0;
    }
}


void CopyKFGarray(uint32_t **fam, KFG *kfg, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        fam[0][j] = j;
        fam[1][j] = kfg->_b[j];
        fam[2][j] = kfg->_i[j];
        fam[3][j] = kfg->_bi[j];
        fam[4][j] = kfg->_ib[j];
        fam[5][j] = kfg->_bib[j];
        fam[6][j] = kfg->_ibi[j];
        fam[7][j] = kfg->_f[j];
        fam[8][j] = kfg->_ff[j];
        fam[9][j] = kfg->_if[j];
        fam[10][j] = kfg->_bif[j];
        fam[11][j] = kfg->_fb[j];
        fam[12][j] = kfg->_fib[j];
        fam[13][j] = kfg->_fi[j];
        fam[14][j] = kfg->_fbi[j];
        fam[15][j] = kfg->_fif[j];
        fam[16][j] = kfg->_g[j];
        fam[17][j] = kfg->_bg[j];
        fam[18][j] = kfg->_fbg[j];
        fam[19][j] = 0;
        fam[20][j] = kfg->_a[j];
        fam[21][j] = kfg->_ab[j];
        fam[22][j] = kfg->_ai[j];
        fam[23][j] = kfg->_abi[j];
        fam[24][j] = kfg->_aib[j];
        fam[25][j] = kfg->_abib[j];
        fam[26][j] = kfg->_aibi[j];
        fam[27][j] = kfg->_af[j];
        fam[28][j] = kfg->_aff[j];
        fam[29][j] = kfg->_aif[j];
        fam[30][j] = kfg->_abif[j];
        fam[31][j] = kfg->_afb[j];
        fam[32][j] = kfg->_afib[j];
        fam[33][j] = kfg->_afi[j];
        fam[34][j] = kfg->_afbi[j];
        fam[35][j] = kfg->_afif[j];
        fam[36][j] = kfg->_ag[j];
        fam[37][j] = kfg->_abg[j];
        fam[38][j] = kfg->_afbg[j];
        fam[39][j] = (one<<spacesize) - 1;
    }
}


void CopyKZfromK(KZ *kz, K *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kz->_id[j] = fam->_id[j];
        kz->_b[j] = fam->_b[j];
        kz->_i[j] = fam->_i[j];
        kz->_bi[j] = fam->_bi[j];
        kz->_ib[j] = fam->_ib[j];
        kz->_bib[j] = fam->_bib[j];
        kz->_ibi[j] = fam->_ibi[j];
    }
}


void CopyKZfromKFZ(KZ *kz, KFZ *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kz->_id[j] = fam->_id[j];
        kz->_b[j] = fam->_b[j];
        kz->_i[j] = fam->_i[j];
        kz->_bi[j] = fam->_bi[j];
        kz->_ib[j] = fam->_ib[j];
        kz->_bib[j] = fam->_bib[j];
        kz->_ibi[j] = fam->_ibi[j];
    }
}


void CopyKZfromKF(KZ *kz, KF *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kz->_id[j] = fam->_id[j];
        kz->_b[j] = fam->_b[j];
        kz->_i[j] = fam->_i[j];
        kz->_bi[j] = fam->_bi[j];
        kz->_ib[j] = fam->_ib[j];
        kz->_bib[j] = fam->_bib[j];
        kz->_ibi[j] = fam->_ibi[j];
    }
}


void CopyKZfromKFGZ(KZ *kz, KFGZ *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kz->_id[j] = fam->_id[j];
        kz->_b[j] = fam->_b[j];
        kz->_i[j] = fam->_i[j];
        kz->_bi[j] = fam->_bi[j];
        kz->_ib[j] = fam->_ib[j];
        kz->_bib[j] = fam->_bib[j];
        kz->_ibi[j] = fam->_ibi[j];
    }
}


void CopyKZfromKFG(KZ *kz, KFG *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kz->_id[j] = fam->_id[j];
        kz->_b[j] = fam->_b[j];
        kz->_i[j] = fam->_i[j];
        kz->_bi[j] = fam->_bi[j];
        kz->_ib[j] = fam->_ib[j];
        kz->_bib[j] = fam->_bib[j];
        kz->_ibi[j] = fam->_ibi[j];
    }
}


void CopyKFZfromKF(KFZ *kfz, KF *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kfz->_id[j] = fam->_id[j];
        kfz->_b[j] = fam->_b[j];
        kfz->_i[j] = fam->_i[j];
        kfz->_bi[j] = fam->_bi[j];
        kfz->_ib[j] = fam->_ib[j];
        kfz->_bib[j] = fam->_bib[j];
        kfz->_ibi[j] = fam->_ibi[j];
        kfz->_f[j] = fam->_f[j];
        kfz->_ff[j] = fam->_ff[j];
        kfz->_if[j] = fam->_if[j];
        kfz->_bif[j] = fam->_bif[j];
        kfz->_fb[j] = fam->_fb[j];
        kfz->_fib[j] = fam->_fib[j];
        kfz->_fi[j] = fam->_fi[j];
        kfz->_fbi[j] = fam->_fbi[j];
        kfz->_fif[j] = fam->_fif[j];
        kfz->_zero[j] = fam->_zero[j];
    }
}


void CopyKFZfromKFGZ(KFZ *kfz, KFGZ *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kfz->_id[j] = fam->_id[j];
        kfz->_b[j] = fam->_b[j];
        kfz->_i[j] = fam->_i[j];
        kfz->_bi[j] = fam->_bi[j];
        kfz->_ib[j] = fam->_ib[j];
        kfz->_bib[j] = fam->_bib[j];
        kfz->_ibi[j] = fam->_ibi[j];
        kfz->_f[j] = fam->_f[j];
        kfz->_ff[j] = fam->_ff[j];
        kfz->_if[j] = fam->_if[j];
        kfz->_bif[j] = fam->_bif[j];
        kfz->_fb[j] = fam->_fb[j];
        kfz->_fib[j] = fam->_fib[j];
        kfz->_fi[j] = fam->_fi[j];
        kfz->_fbi[j] = fam->_fbi[j];
        kfz->_fif[j] = fam->_fif[j];
        kfz->_zero[j] = fam->_zero[j];
    }
}


void CopyKFZfromKFG(KFZ *kfz, KFG *fam, int spacesize)
{
    uint32_t    j;

    for (j=0; j<(one<<spacesize); j++)
    {
        kfz->_id[j] = fam->_id[j];
        kfz->_b[j] = fam->_b[j];
        kfz->_i[j] = fam->_i[j];
        kfz->_bi[j] = fam->_bi[j];
        kfz->_ib[j] = fam->_ib[j];
        kfz->_bib[j] = fam->_bib[j];
        kfz->_ibi[j] = fam->_ibi[j];
        kfz->_f[j] = fam->_f[j];
        kfz->_ff[j] = fam->_ff[j];
        kfz->_if[j] = fam->_if[j];
        kfz->_bif[j] = fam->_bif[j];
        kfz->_fb[j] = fam->_fb[j];
        kfz->_fib[j] = fam->_fib[j];
        kfz->_fi[j] = fam->_fi[j];
        kfz->_fbi[j] = fam->_fbi[j];
        kfz->_fif[j] = fam->_fif[j];
        kfz->_zero[j] = fam->_zero[j];
    }
}


void ExtractKFfromKFG(int **kf, int **kfg)
{
    int j, k;

    for (j=0; j<16; j++)
    {
        for (k=0; k<16; k++) kf[j][k] = kfg[j][k];
        for (k=16; k<33; k++) kf[j][k] = kfg[j][k+3];
        kf[j][33] = kfg[j][39];
    }
    for (j=16; j<33; j++)
    {
        for (k=0; k<16; k++) kf[j][k] = kfg[j+3][k];
        for (k=16; k<33; k++) kf[j][k] = kfg[j+3][k+3];
        kf[j][33] = kfg[j+3][39];
    }
    for (k=0; k<16; k++) kf[33][k] = kfg[39][k];
    for (k=16; k<33; k++) kf[33][k] = kfg[39][k+3];
    kf[33][33] = kfg[39][39];
}