extraBddCas.c File Reference

#include "extraBdd.h"

Include dependency graph for extraBddCas.c:

Go to the source code of this file.

Classes
struct	_HashEntry_cof
struct	_HashEntry_mint
struct	traventry

Macros
#define	_TABLESIZE_COF   51113
#define	_TABLESIZE_MINT   15113

Functions
unsigned	Extra_CountCofactorMinterms (DdManager *dd, DdNode *bFunc, DdNode *bVarsCof, DdNode *bVarsAll)
DdNode *	Extra_bddEncodingBinary (DdManager *dd, DdNode **pbFuncs, int nFuncs, DdNode **pbVars, int nVars)
DdNode *	Extra_bddEncodingNonStrict (DdManager *dd, DdNode **pbColumns, int nColumns, DdNode *bVarsCol, DdNode **pCVars, int nMulti, int *pSimple)
st__table *	Extra_bddNodePathsUnderCut (DdManager *dd, DdNode *bFunc, int CutLevel)
int	Extra_bddNodePathsUnderCutArray (DdManager *dd, DdNode **paNodes, DdNode **pbCubes, int nNodes, DdNode **paNodesRes, DdNode **pbCubesRes, int CutLevel)
void	extraCollectNodes (DdNode *Func, st__table *tNodes)
st__table *	Extra_CollectNodes (DdNode *Func)
void	extraProfileUpdateTopLevel (st__table *tNodeTopRef, int TopLevelNew, DdNode *node)
int	Extra_ProfileWidth (DdManager *dd, DdNode *Func, int *pProfile, int CutLevel)

Variables
_HashEntry_cof	HHTable1 [_TABLESIZE_COF]
_HashEntry_mint	HHTable2 [_TABLESIZE_MINT]

Macro Definition Documentation

_TABLESIZE_COF

#define _TABLESIZE_COF   51113

CFile****************************************************************

FileName [extraBddCas.c]

PackageName [extra]

Synopsis [Procedures related to LUT cascade synthesis.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 2.0. Started - September 1, 2003.]

Revision [

Id

extraBddCas.c,v 1.0 2003/05/21 18:03:50 alanmi Exp

]

Definition at line 37 of file extraBddCas.c.

_TABLESIZE_MINT

#define _TABLESIZE_MINT   15113

Definition at line 46 of file extraBddCas.c.

Function Documentation

Extra_bddEncodingBinary()

DdNode * Extra_bddEncodingBinary	(	DdManager *	dd,
		DdNode **	pbFuncs,
		int	nFuncs,
		DdNode **	pbVars,
		int	nVars )

AutomaticEnd Function********************************************************************

Synopsis [Performs the binary encoding of the set of function using the given vars.]

Description [Performs a straight binary encoding of the set of functions using the variable cubes formed from the given set of variables. ]

SideEffects []

SeeAlso []

Definition at line 138 of file extraBddCas.c.

{
    int i;
    DdNode * bResult;
    DdNode * bCube, * bTemp, * bProd;
 
    assert( nVars >= Abc_Base2Log(nFuncs) );
 
    bResult = b0;   Cudd_Ref( bResult );
    for ( i = 0; i < nFuncs; i++ )
    {
        bCube   = Extra_bddBitsToCube( dd, i, nVars, pbVars, 1 );   Cudd_Ref( bCube );
        bProd   = Cudd_bddAnd( dd, bCube, pbFuncs[i] );         Cudd_Ref( bProd );
        Cudd_RecursiveDeref( dd, bCube );
 
        bResult = Cudd_bddOr( dd, bProd, bTemp = bResult );     Cudd_Ref( bResult );
        Cudd_RecursiveDeref( dd, bTemp );
        Cudd_RecursiveDeref( dd, bProd );
    }
 
    Cudd_Deref( bResult );
    return bResult;
} /* end of Extra_bddEncodingBinary */

Here is the call graph for this function:

Here is the caller graph for this function:

Extra_bddEncodingNonStrict()

DdNode * Extra_bddEncodingNonStrict	(	DdManager *	dd,
		DdNode **	pbColumns,
		int	nColumns,
		DdNode *	bVarsCol,
		DdNode **	pCVars,
		int	nMulti,
		int *	pSimple )

Function********************************************************************

Synopsis [Solves the column encoding problem using a sophisticated method.]

Description [The encoding is based on the idea of deriving functions which depend on only one variable, which corresponds to the case of non-disjoint decompostion. It is assumed that the variables pCVars are ordered below the variables representing the solumns, and the first variable pCVars[0] is the topmost one.]

SideEffects []

SeeAlso [Extra_bddEncodingBinary]

Definition at line 184 of file extraBddCas.c.

{
    DdNode * bEncoded, * bResult;
    int nVarsCol = Cudd_SupportSize(dd,bVarsCol);
    abctime clk;
 
    // cannot work with more that 32-bit codes
    assert( nMulti < 32 );
 
    // perform the preliminary encoding using the straight binary code
    bEncoded = Extra_bddEncodingBinary( dd, pbColumns, nColumns, pCVars, nMulti );   Cudd_Ref( bEncoded );
    //printf( "Node count = %d", Cudd_DagSize(bEncoded) );
 
    // set the backgroup value for counting minterms
    s_Terminal = b0;
    // set the level of the encoding variables
    s_EncodingVarsLevel = dd->invperm[pCVars[0]->index];
 
    // the current number of backtracks
    s_BackTracks = 0;
    // the variables that are cofactored on the topmost level where everything starts (no vars)
    s_Field[0][0] = b1;   
    // the size of the best set of "simple" encoding variables found so far
    s_nVarsBest   = 0;
 
    // set the relation to be accessible to traversal procedures
    s_Encoded = bEncoded;
    // the set of all vars to be accessible to traversal procedures
    s_VarAll  = bVarsCol;
    // the column multiplicity
    s_MultiStart  = nMulti;
 
 
    clk = Abc_Clock();
    // find the simplest encoding
    if ( nColumns > 2 )
    EvaluateEncodings_rec( dd, bVarsCol, nVarsCol, nMulti, 1 );
//  printf( "The number of backtracks = %d\n", s_BackTracks );
//  s_EncSearchTime += Abc_Clock() - clk;
 
    // allocate the temporary storage for the columns
    s_pbTemp = (DdNode **)ABC_ALLOC( char, nColumns * sizeof(DdNode *) );
 
//  clk = Abc_Clock();
    bResult = CreateTheCodes_rec( dd, bEncoded, 0, pCVars );   Cudd_Ref( bResult );
//  s_EncComputeTime += Abc_Clock() - clk;
    
    // delocate the preliminarily encoded set
    Cudd_RecursiveDeref( dd, bEncoded );
//  Cudd_RecursiveDeref( dd, aEncoded );
 
    ABC_FREE( s_pbTemp );
 
    *pSimple = s_nVarsBest;
    Cudd_Deref( bResult );
    return bResult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Extra_bddNodePathsUnderCut()

st__table * Extra_bddNodePathsUnderCut	(	DdManager *	dd,
		DdNode *	bFunc,
		int	CutLevel )

Function********************************************************************

Synopsis [Collects the nodes under the cut and, for each node, computes the sum of paths leading to it from the root.]

Description [The table returned contains the set of BDD nodes pointed to under the cut and, for each node, the BDD of the sum of paths leading to this node from the root The sums of paths in the table are referenced. CutLevel is the first DD level considered to be under the cut.]

SideEffects []

SeeAlso [Extra_bddNodePaths]

Definition at line 263 of file extraBddCas.c.

{
    st__table * Visited;  // temporary table to remember the visited nodes
    st__table * CutNodes; // the result goes here
    st__table * Result; // the result goes here
    DdNode * aFunc;
 
    s_CutLevel = CutLevel;
 
    Result  = st__init_table( st__ptrcmp, st__ptrhash);;
    // the terminal cases
    if ( Cudd_IsConstant( bFunc ) )
    {
        if ( bFunc == b1 )
        {
            st__insert( Result, (char*)b1, (char*)b1 );
            Cudd_Ref( b1 );
            Cudd_Ref( b1 );
        }
        else
        {
            st__insert( Result, (char*)b0, (char*)b0 );
            Cudd_Ref( b0 );
            Cudd_Ref( b0 );
        }
        return Result;
    }
 
    // create the ADD to simplify processing (no complemented edges)
    aFunc = Cudd_BddToAdd( dd, bFunc );   Cudd_Ref( aFunc );
 
    // Step 1: Start the tables and collect information about the nodes above the cut 
    // this information tells how many edges point to each node
    Visited  = st__init_table( st__ptrcmp, st__ptrhash);;
    CutNodes = st__init_table( st__ptrcmp, st__ptrhash);;
 
    CountNodeVisits_rec( dd, aFunc, Visited );
 
    // Step 2: Traverse the BDD using the visited table and compute the sum of paths
    CollectNodesAndComputePaths_rec( dd, aFunc, b1, Visited, CutNodes );
 
    // at this point the table of cut nodes is ready and the table of visited is useless
    {
        st__generator * gen;
        DdNode * aNode;
        traventry * p;
        st__foreach_item( Visited, gen, (const char**)&aNode, (char**)&p )
        {
            Cudd_RecursiveDeref( dd, p->bSum );
            ABC_FREE( p );
        }
        st__free_table( Visited );
    }
 
    // go through the table CutNodes and create the BDD and the path to be returned
    {
        st__generator * gen;
        DdNode * aNode, * bNode, * bSum;
        st__foreach_item( CutNodes, gen, (const char**)&aNode, (char**)&bSum)
        {
            // aNode is not referenced, because aFunc is holding it
            bNode = Cudd_addBddPattern( dd, aNode );  Cudd_Ref( bNode ); 
            st__insert( Result, (char*)bNode, (char*)bSum );
            // the new table takes both refs
        }
        st__free_table( CutNodes );
    }
 
    // dereference the ADD
    Cudd_RecursiveDeref( dd, aFunc );
 
    // return the table
    return Result;
 
} /* end of Extra_bddNodePathsUnderCut */

Here is the call graph for this function:

Extra_bddNodePathsUnderCutArray()

int Extra_bddNodePathsUnderCutArray	(	DdManager *	dd,
		DdNode **	paNodes,
		DdNode **	pbCubes,
		int	nNodes,
		DdNode **	paNodesRes,
		DdNode **	pbCubesRes,
		int	CutLevel )

Function********************************************************************

Synopsis [Collects the nodes under the cut in the ADD starting from the given set of ADD nodes.]

Description [Takes the array, paNodes, of ADD nodes to start the traversal, the array, pbCubes, of BDD cubes to start the traversal with in each node, and the number, nNodes, of ADD nodes and BDD cubes in paNodes and pbCubes. Returns the number of columns found. Fills in paNodesRes (pbCubesRes) with the set of ADD columns (BDD paths). These arrays should be allocated by the user.]

SideEffects []

SeeAlso [Extra_bddNodePaths]

Definition at line 355 of file extraBddCas.c.

{
    st__table * Visited;  // temporary table to remember the visited nodes
    st__table * CutNodes; // the nodes under the cut go here
    int i, Counter;
 
    s_CutLevel = CutLevel;
 
    // there should be some nodes
    assert( nNodes > 0 );
    if ( nNodes == 1 && Cudd_IsConstant( paNodes[0] ) )
    {
        if ( paNodes[0] == a1 )
        {
            paNodesRes[0] = a1;          Cudd_Ref( a1 );
            pbCubesRes[0] = pbCubes[0];  Cudd_Ref( pbCubes[0] );
        }
        else
        {
            paNodesRes[0] = a0;          Cudd_Ref( a0 );
            pbCubesRes[0] = pbCubes[0];  Cudd_Ref( pbCubes[0] );
        }
        return 1;
    }
 
    // Step 1: Start the table and collect information about the nodes above the cut 
    // this information tells how many edges point to each node
    CutNodes = st__init_table( st__ptrcmp, st__ptrhash);;
    Visited  = st__init_table( st__ptrcmp, st__ptrhash);;
 
    for ( i = 0; i < nNodes; i++ )
        CountNodeVisits_rec( dd, paNodes[i], Visited );
 
    // Step 2: Traverse the BDD using the visited table and compute the sum of paths
    for ( i = 0; i < nNodes; i++ )
        CollectNodesAndComputePaths_rec( dd, paNodes[i], pbCubes[i], Visited, CutNodes );
 
    // at this point, the table of cut nodes is ready and the table of visited is useless
    {
        st__generator * gen;
        DdNode * aNode;
        traventry * p;
        st__foreach_item( Visited, gen, (const char**)&aNode, (char**)&p )
        {
            Cudd_RecursiveDeref( dd, p->bSum );
            ABC_FREE( p );
        }
        st__free_table( Visited );
    }
 
    // go through the table CutNodes and create the BDD and the path to be returned
    {
        st__generator * gen;
        DdNode * aNode, * bSum;
        Counter = 0;
        st__foreach_item( CutNodes, gen, (const char**)&aNode, (char**)&bSum)
        {
            paNodesRes[Counter] = aNode;   Cudd_Ref( aNode ); 
            pbCubesRes[Counter] = bSum;
            Counter++;
        }
        st__free_table( CutNodes );
    }
 
    // return the number of cofactors found
    return Counter;
 
} /* end of Extra_bddNodePathsUnderCutArray */

Here is the call graph for this function:

Here is the caller graph for this function:

Extra_CollectNodes()

st__table * Extra_CollectNodes

(

DdNode *

Func

)

Function*************************************************************

Synopsis [Collects all the nodes of one DD into the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 458 of file extraBddCas.c.

{
    st__table * tNodes;
    tNodes = st__init_table( st__ptrcmp, st__ptrhash );
    extraCollectNodes( Func, tNodes );
    return tNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Extra_CountCofactorMinterms()

unsigned Extra_CountCofactorMinterms	(	DdManager *	dd,
		DdNode *	bFunc,
		DdNode *	bVarsCof,
		DdNode *	bVarsAll )

Function********************************************************************

Synopsis [Counts the number of encoding minterms pointed to by the cofactor of the function.]

Description []

SideEffects [None]

Definition at line 910 of file extraBddCas.c.

{
    unsigned HKey;
    DdNode * bFuncR;
 
    // if the function is zero, there are no minterms
//  if ( bFunc == b0 )
//      return 0;
 
//  if ( st__lookup(Visited, (char*)bFunc, NULL) )
//      return 0;
 
//  HKey = hashKey2c( s_Signature, bFuncR );
//  if ( HHTable1[HKey].Sign == s_Signature && HHTable1[HKey].Arg1 == bFuncR ) // this node is visited
//      return 0;
 
 
    // check the hash-table 
    bFuncR = Cudd_Regular(bFunc);
//  HKey = hashKey2( s_Signature, bFuncR, _TABLESIZE_COF );
    HKey = hashKey2( s_Signature, bFunc, _TABLESIZE_COF );
    for ( ;  HHTable1[HKey].Sign == s_Signature; HKey = (HKey+1) % _TABLESIZE_COF )
//      if ( HHTable1[HKey].Arg1 == bFuncR ) // this node is visited
        if ( HHTable1[HKey].Arg1 == bFunc ) // this node is visited
            return 0;
 
 
    // if the function is already the code
    if ( dd->perm[bFuncR->index] >= s_EncodingVarsLevel )
    {
//      st__insert(Visited, (char*)bFunc, NULL);
 
//      HHTable1[HKey].Sign = s_Signature;
//      HHTable1[HKey].Arg1 = bFuncR;
 
        assert( HHTable1[HKey].Sign != s_Signature );
        HHTable1[HKey].Sign = s_Signature;
//      HHTable1[HKey].Arg1 = bFuncR;
        HHTable1[HKey].Arg1 = bFunc;
 
        return Extra_CountMintermsSimple( bFunc, (1<<s_MultiStart) );
    }
    else
    {
        DdNode * bFunc0,    * bFunc1;
        DdNode * bVarsCof0, * bVarsCof1;
        DdNode * bVarsCofR = Cudd_Regular(bVarsCof);
        unsigned Res;
 
        // get the levels
        int LevelF = dd->perm[bFuncR->index];
        int LevelC = cuddI(dd,bVarsCofR->index);
        int LevelA = dd->perm[bVarsAll->index];
 
        int LevelTop = LevelF;
 
        if ( LevelTop > LevelC )
             LevelTop = LevelC;
 
        if ( LevelTop > LevelA )
             LevelTop = LevelA;
 
        // the top var in the function or in cofactoring vars always belongs to the set of all vars
        assert( !( LevelTop == LevelF || LevelTop == LevelC ) || LevelTop == LevelA );
 
        // cofactor the function
        if ( LevelTop == LevelF )
        {
            if ( bFuncR != bFunc ) // bFunc is complemented 
            {
                bFunc0 = Cudd_Not( cuddE(bFuncR) );
                bFunc1 = Cudd_Not( cuddT(bFuncR) );
            }
            else
            {
                bFunc0 = cuddE(bFuncR);
                bFunc1 = cuddT(bFuncR);
            }
        }
        else // bVars is higher in the variable order 
            bFunc0 = bFunc1 = bFunc;
 
        // cofactor the cube
        if ( LevelTop == LevelC )
        {
            if ( bVarsCofR != bVarsCof ) // bFunc is complemented 
            {
                bVarsCof0 = Cudd_Not( cuddE(bVarsCofR) );
                bVarsCof1 = Cudd_Not( cuddT(bVarsCofR) );
            }
            else
            {
                bVarsCof0 = cuddE(bVarsCofR);
                bVarsCof1 = cuddT(bVarsCofR);
            }
        }
        else // bVars is higher in the variable order 
            bVarsCof0 = bVarsCof1 = bVarsCof;
 
        // there are two cases: 
        // (1) the top variable belongs to the cofactoring variables
        // (2) the top variable does not belong to the cofactoring variables
 
        // (1) the top variable belongs to the cofactoring variables
        Res = 0;
        if ( LevelTop == LevelC )
        {
            if ( bVarsCof1 == b0 ) // this is a negative cofactor
            {
                if ( bFunc0 != b0 )
                Res = Extra_CountCofactorMinterms( dd, bFunc0, bVarsCof0, cuddT(bVarsAll) );
            }
            else                        // this is a positive cofactor
            {
                if ( bFunc1 != b0 )
                Res = Extra_CountCofactorMinterms( dd, bFunc1, bVarsCof1, cuddT(bVarsAll) );
            }
        }
        else
        {
            if ( bFunc0 != b0 )
            Res += Extra_CountCofactorMinterms( dd, bFunc0, bVarsCof0, cuddT(bVarsAll) );
            
            if ( bFunc1 != b0 )
            Res += Extra_CountCofactorMinterms( dd, bFunc1, bVarsCof1, cuddT(bVarsAll) );
        }
 
//      st__insert(Visited, (char*)bFunc, NULL);
 
//      HHTable1[HKey].Sign = s_Signature;
//      HHTable1[HKey].Arg1 = bFuncR;
 
        // skip through the entries with the same signatures 
        // (these might have been created at the time of recursive calls)
        for ( ; HHTable1[HKey].Sign == s_Signature; HKey = (HKey+1) % _TABLESIZE_COF );
        assert( HHTable1[HKey].Sign != s_Signature );
        HHTable1[HKey].Sign = s_Signature;
//      HHTable1[HKey].Arg1 = bFuncR;
        HHTable1[HKey].Arg1 = bFunc;
 
        return Res;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Extra_ProfileWidth()

int Extra_ProfileWidth	(	DdManager *	dd,
		DdNode *	Func,
		int *	pProfile,
		int	CutLevel )

Function*************************************************************

Synopsis [Fast computation of the BDD profile.]

Description [The array to store the profile is given by the user and should contain at least as many entries as there is the maximum of the BDD/ZDD size of the manager PLUS ONE. When we say that the widths of the DD on level L is W, we mean the following. Let us create the cut between the level L-1 and the level L and count the number of different DD nodes pointed to across the cut. This number is the width W. From this it follows the on level 0, the width is equal to the number of external pointers to the considered DDs. If there is only one DD, then the profile on level 0 is always 1. If this DD is rooted in the topmost variable, then the width on level 1 is always 2, etc. The width at the level equal to dd->size is the number of terminal nodes in the DD. (Because we consider the first level #0 and the last level #dd->size, the profile array should contain dd->size+1 entries.) ]

SideEffects [This procedure will not work for BDDs w/ complement edges, only for ADDs and ZDDs]

SeeAlso []

Definition at line 519 of file extraBddCas.c.

{
    st__generator * gen;
    st__table * tNodeTopRef; // this table stores the top level from which this node is pointed to
    st__table * tNodes;
    DdNode * node;
    DdNode * nodeR;
    int LevelStart, Limit;
    int i, size;
    int WidthMax;
  
    // start the mapping table
    tNodeTopRef = st__init_table( st__ptrcmp, st__ptrhash);;
    // add the topmost node to the profile
    extraProfileUpdateTopLevel( tNodeTopRef, 0, Func );
 
    // collect all nodes
    tNodes = Extra_CollectNodes( Func );
    // go though all the nodes and set the top level the cofactors are pointed from
//  Cudd_ForeachNode( dd, Func, genDD, node )
    st__foreach_item( tNodes, gen, (const char**)&node, NULL )
    {
//      assert( Cudd_Regular(node) );  // this procedure works only with ADD/ZDD (not BDD w/ compl.edges)
        nodeR = Cudd_Regular(node);
        if ( cuddIsConstant(nodeR) )
            continue;
        // this node is not a constant - consider its cofactors
        extraProfileUpdateTopLevel( tNodeTopRef, dd->perm[node->index]+1, cuddE(nodeR) );
        extraProfileUpdateTopLevel( tNodeTopRef, dd->perm[node->index]+1, cuddT(nodeR) );
    }
    st__free_table( tNodes );
 
    // clean the profile
    size = ddMax(dd->size, dd->sizeZ) + 1;
    for ( i = 0; i < size; i++ ) 
        pProfile[i] = 0;
 
    // create the profile
    st__foreach_item( tNodeTopRef, gen, (const char**)&node, (char**)&LevelStart )
    {
        nodeR = Cudd_Regular(node);
        Limit = (cuddIsConstant(nodeR))? dd->size: dd->perm[nodeR->index];
        for ( i = LevelStart; i <= Limit; i++ )
            pProfile[i]++;
    }
 
    if ( CutLevel != -1 && CutLevel != 0  )
        size = CutLevel;
 
    // get the max width
    WidthMax = 0;
    for ( i = 0; i < size; i++ ) 
        if ( WidthMax < pProfile[i] )
            WidthMax = pProfile[i];
 
    // deref the table
    st__free_table( tNodeTopRef );
 
    return WidthMax;
} /* end of Extra_ProfileWidth */

Here is the call graph for this function:

Here is the caller graph for this function:

extraCollectNodes()

void extraCollectNodes	(	DdNode *	Func,
		st__table *	tNodes )

Function*************************************************************

Synopsis [Collects all the BDD nodes into the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 435 of file extraBddCas.c.

{
    DdNode * FuncR;
    FuncR = Cudd_Regular(Func);
    if ( st__find_or_add( tNodes, (char*)FuncR, NULL ) )
        return;
    if ( cuddIsConstant(FuncR) )
        return;
    extraCollectNodes( cuddE(FuncR), tNodes );
    extraCollectNodes( cuddT(FuncR), tNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

extraProfileUpdateTopLevel()

void extraProfileUpdateTopLevel	(	st__table *	tNodeTopRef,
		int	TopLevelNew,
		DdNode *	node )

Function*************************************************************

Synopsis [Updates the topmost level from which the given node is referenced.]

Description [Takes the table which maps each BDD nodes (including the constants) into the topmost level on which this node counts as a cofactor. Takes the topmost level, on which this node counts as a cofactor (see Extra_ProfileWidthFast(). Takes the node, for which the table entry should be updated.]

SideEffects []

SeeAlso []

Definition at line 480 of file extraBddCas.c.

{
    int * pTopLevel;
 
    if ( st__find_or_add( tNodeTopRef, (char*)node, (char***)&pTopLevel ) )
    { // the node is already referenced
        // the current top level should be updated if it is larger than the new level
        if ( *pTopLevel > TopLevelNew ) 
             *pTopLevel = TopLevelNew;
    }
    else
    { // the node is not referenced
        // its level should be set to the current new level
        *pTopLevel = TopLevelNew;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

HHTable1

_HashEntry_cof HHTable1[_TABLESIZE_COF]

Definition at line 43 of file extraBddCas.c.

HHTable2

_HashEntry_mint HHTable2[_TABLESIZE_MINT]

Definition at line 53 of file extraBddCas.c.