ruby_abc 0.0.3 → 0.1.0

data/ext/abc/src/base/cba/cbaBlast.c

@@ -1,1069 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [cbaBlast.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Hierarchical word-level netlist.]
-
-  Synopsis    [Collapsing word-level design.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - July 21, 2015.]
-
-  Revision    [$Id: cbaBlast.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "cba.h"
-#include "base/abc/abc.h"
-#include "map/mio/mio.h"
-#include "bool/dec/dec.h"
-#include "base/main/mainInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Helper functions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Cba_NtkPrepareBits( Cba_Ntk_t * p )
-{
-    int i, nBits = 0;
-    Cba_NtkCleanFonCopies( p );
-    Cba_NtkForEachFon( p, i )
-    {
-        Cba_FonSetCopy( p, i, nBits );
-        nBits += Cba_FonRangeSize( p, i );
-    }
-    return nBits;
-}
-int * Cba_VecCopy( Vec_Int_t * vOut, int * pArray, int nSize )
-{
-    int i; Vec_IntClear( vOut );
-    for( i = 0; i < nSize; i++) 
-        Vec_IntPush( vOut, pArray[i] );
-    return Vec_IntArray( vOut );
-}
-int Cba_ReadHexDigit( char HexChar )
-{
-    if ( HexChar >= '0' && HexChar <= '9' )
-        return HexChar - '0';
-    if ( HexChar >= 'A' && HexChar <= 'F' )
-        return HexChar - 'A' + 10;
-    if ( HexChar >= 'a' && HexChar <= 'f' )
-        return HexChar - 'a' + 10;
-    assert( 0 ); // not a hexadecimal symbol
-    return -1; // return value which makes no sense
-}
-void Cba_BlastConst( Cba_Ntk_t * p, Vec_Int_t * vOut, int iFon, int nTotal, int fSigned )
-{
-    char * pConst = Cba_NtkConst(p, Cba_FonConst(iFon));
-    char * pLimit = pConst + strlen(pConst);
-    int i, Number, nBits = atoi( pConst );
-    assert( nBits <= nTotal );
-    while ( *pConst >= '0' && *pConst <= '9' )
-        pConst++;
-    assert( *pConst == '\'' );
-    pConst++;
-    if ( *pConst == 's' ) // assume signedness is already used in setting fSigned
-        pConst++;
-    Vec_IntClear( vOut );
-    if ( *pConst == 'b' )
-    {
-        while ( --pLimit > pConst )
-            Vec_IntPush( vOut, *pLimit == '0' ? 0 : 1 );
-    }
-    else if ( *pConst == 'h' )
-    {
-        while ( --pLimit > pConst )
-        {
-            Number = Cba_ReadHexDigit( *pLimit );
-            for ( i = 0; i < 4; i++ )
-                Vec_IntPush( vOut, (Number >> i) & 1 );
-        }
-        if ( Vec_IntSize(vOut) > nTotal )
-            Vec_IntShrink( vOut, nTotal );
-    }
-    else if ( *pConst == 'd' )
-    {
-        Number = atoi( pConst+1 );
-        assert( Number <= 0x7FFFFFFF );
-        for ( i = 0; i < 32; i++ )
-            Vec_IntPush( vOut, (Number >> i) & 1 );
-        if ( Vec_IntSize(vOut) > nTotal )
-            Vec_IntShrink( vOut, nTotal );
-    }
-    else assert( 0 );
-    if ( fSigned && Vec_IntSize(vOut) < nTotal )
-        Vec_IntFillExtra( vOut, nTotal - Vec_IntSize(vOut), Vec_IntEntryLast(vOut) );
-}
-int * Cba_VecLoadFanins( Cba_Ntk_t * p, Vec_Int_t * vOut, int iFon, int * pFanins, int nFanins, int nTotal, int fSigned )
-{
-    assert( nFanins <= nTotal );
-    if ( Cba_FonIsReal(iFon) )
-    {
-        int i, Fill = fSigned ? pFanins[nFanins-1] : 0;
-        Vec_IntClear( vOut );
-        for( i = 0; i < nTotal; i++) 
-            Vec_IntPush( vOut, i < nFanins ? pFanins[i] : Fill );
-    }
-    else if ( Cba_FonIsConst(iFon) )
-        Cba_BlastConst( p, vOut, iFon, nTotal, fSigned );
-    else if ( iFon == 0 ) // undriven input
-        Vec_IntFill( vOut, nTotal, 0 );
-    else assert( 0 );
-    assert( Vec_IntSize(vOut) == nTotal );
-    return Vec_IntArray( vOut );
-}
-int Cba_NtkMuxTree_rec( Gia_Man_t * pNew, int * pCtrl, int nCtrl, Vec_Int_t * vData, int Shift )
-{
-    int iLit0, iLit1;
-    if ( nCtrl == 0 )
-        return Vec_IntEntry( vData, Shift );
-    iLit0 = Cba_NtkMuxTree_rec( pNew, pCtrl, nCtrl-1, vData, Shift );
-    iLit1 = Cba_NtkMuxTree_rec( pNew, pCtrl, nCtrl-1, vData, Shift + (1<<(nCtrl-1)) );
-    return Gia_ManHashMux( pNew, pCtrl[nCtrl-1], iLit1, iLit0 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Bit blasting for specific operations.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Cba_BlastShiftRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes )
-{
-    int * pRes = Cba_VecCopy( vRes, pNum, nNum );
-    int Fill = fSticky ? pNum[nNum-1] : 0;
-    int i, j, fShort = 0;
-    if ( nShift > 32 )
-        nShift = 32;
-    assert( nShift <= 32 );
-    for( i = 0; i < nShift; i++ ) 
-        for( j = 0; j < nNum - fSticky; j++ ) 
-        {
-            if( fShort || j + (1<<i) >= nNum ) 
-            {
-                pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] );
-                if ( (1<<i) > nNum ) 
-                    fShort = 1;
-            } 
-            else 
-                pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j+(1<<i)], pRes[j] );
-        }
-}
-void Cba_BlastShiftLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes )
-{
-    int * pRes = Cba_VecCopy( vRes, pNum, nNum );
-    int Fill = fSticky ? pNum[0] : 0;
-    int i, j, fShort = 0;
-    if ( nShift > 32 )
-        nShift = 32;
-    assert( nShift <= 32 );
-    for( i = 0; i < nShift; i++ ) 
-        for( j = nNum-1; j >= fSticky; j-- ) 
-        {
-            if( fShort || (1<<i) > j ) 
-            {
-                pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] );
-                if ( (1<<i) > nNum ) 
-                    fShort = 1;
-            } 
-            else 
-                pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j-(1<<i)], pRes[j] );
-        }
-}
-void Cba_BlastRotateRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, Vec_Int_t * vRes )
-{
-    int * pRes = Cba_VecCopy( vRes, pNum, nNum );
-    int i, j, * pTemp = ABC_ALLOC( int, nNum );
-    assert( nShift <= 32 );
-    for( i = 0; i < nShift; i++, pRes = Cba_VecCopy(vRes, pTemp, nNum) ) 
-        for( j = 0; j < nNum; j++ ) 
-            pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[(j+(1<<i))%nNum], pRes[j] );
-    ABC_FREE( pTemp );
-}
-void Cba_BlastRotateLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, Vec_Int_t * vRes )
-{
-    int * pRes = Cba_VecCopy( vRes, pNum, nNum );
-    int i, j, * pTemp = ABC_ALLOC( int, nNum );
-    assert( nShift <= 32 );
-    for( i = 0; i < nShift; i++, pRes = Cba_VecCopy(vRes, pTemp, nNum) ) 
-        for( j = 0; j < nNum; j++ ) 
-        {
-            int move = (j >= (1<<i)) ? (j-(1<<i))%nNum : (nNum - (((1<<i)-j)%nNum)) % nNum;
-            pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[move], pRes[j] );
-//            pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[((unsigned)(nNum-(1<<i)+j))%nNum], pRes[j] );
-        }
-    ABC_FREE( pTemp );
-}
-int Cba_BlastReduction( Gia_Man_t * pNew, int * pFans, int nFans, int Type )
-{
-    if ( Type == CBA_BOX_RAND )
-    {
-        int k, iLit = 1;
-        for ( k = 0; k < nFans; k++ )
-            iLit = Gia_ManHashAnd( pNew, iLit, pFans[k] );
-        return iLit;
-    }
-    if ( Type == CBA_BOX_ROR )
-    {
-        int k, iLit = 0;
-        for ( k = 0; k < nFans; k++ )
-            iLit = Gia_ManHashOr( pNew, iLit, pFans[k] );
-        return iLit;
-    }
-    if ( Type == CBA_BOX_RXOR )
-    {
-        int k, iLit = 0;
-        for ( k = 0; k < nFans; k++ )
-            iLit = Gia_ManHashXor( pNew, iLit, pFans[k] );
-        return iLit;
-    }
-    assert( 0 );
-    return -1;
-}
-int Cba_BlastLess2( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
-{
-    int k, iKnown = 0, iRes = 0;
-    for ( k = nBits - 1; k >= 0; k-- )
-    {
-        iRes   = Gia_ManHashMux( pNew, iKnown, iRes, Gia_ManHashAnd(pNew, Abc_LitNot(pArg0[k]), pArg1[k]) );
-        iKnown = Gia_ManHashOr( pNew, iKnown, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
-        if ( iKnown == 1 )
-            break;
-    }
-    return iRes;
-}
-void Cba_BlastLess_rec( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits, int * pYes, int * pNo )
-{
-    if ( nBits > 1 )
-    {
-        int Yes = Gia_ManHashAnd( pNew, Abc_LitNot(pArg0[nBits-1]), pArg1[nBits-1] ), YesR;
-        int No  = Gia_ManHashAnd( pNew, Abc_LitNot(pArg1[nBits-1]), pArg0[nBits-1] ), NoR;
-        if ( Yes == 1 || No == 1 )
-        {
-            *pYes = Yes;
-            *pNo  = No;
-            return;
-        }
-        Cba_BlastLess_rec( pNew, pArg0, pArg1, nBits-1, &YesR, &NoR );
-        *pYes = Gia_ManHashOr( pNew, Yes, Gia_ManHashAnd(pNew, Abc_LitNot(No),  YesR) );
-        *pNo  = Gia_ManHashOr( pNew, No,  Gia_ManHashAnd(pNew, Abc_LitNot(Yes), NoR ) );
-        return;
-    }
-    assert( nBits == 1 );
-    *pYes = Gia_ManHashAnd( pNew, Abc_LitNot(pArg0[0]), pArg1[0] );
-    *pNo  = Gia_ManHashAnd( pNew, Abc_LitNot(pArg1[0]), pArg0[0] );
-}
-int Cba_BlastLess( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
-{
-    int Yes, No;
-    if ( nBits == 0 )
-        return 0;
-    Cba_BlastLess_rec( pNew, pArg0, pArg1, nBits, &Yes, &No );
-    return Yes;
-}
-int Cba_BlastLessSigned( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
-{
-    int iDiffSign = Gia_ManHashXor( pNew, pArg0[nBits-1], pArg1[nBits-1] );
-    return Gia_ManHashMux( pNew, iDiffSign, pArg0[nBits-1], Cba_BlastLess(pNew, pArg0, pArg1, nBits-1) );
-}
-void Cba_BlastFullAdder( Gia_Man_t * pNew, int a, int b, int c, int * pc, int * ps )
-{
-    int fUseXor = 0;
-    if ( fUseXor )
-    {
-        int Xor  = Gia_ManHashXor(pNew, a, b);
-        int And1 = Gia_ManHashAnd(pNew, a, b);
-        int And2 = Gia_ManHashAnd(pNew, c, Xor);
-        *ps      = Gia_ManHashXor(pNew, c, Xor);
-        *pc      = Gia_ManHashOr (pNew, And1, And2);
-    }
-    else
-    {
-        int And1 = Gia_ManHashAnd(pNew, a, b);
-        int And1_= Gia_ManHashAnd(pNew, Abc_LitNot(a), Abc_LitNot(b));
-        int Xor  = Abc_LitNot(Gia_ManHashOr(pNew, And1, And1_));
-        int And2 = Gia_ManHashAnd(pNew, c, Xor);
-        int And2_= Gia_ManHashAnd(pNew, Abc_LitNot(c), Abc_LitNot(Xor));
-        *ps      = Abc_LitNot(Gia_ManHashOr(pNew, And2, And2_));
-        *pc      = Gia_ManHashOr (pNew, And1, And2);
-    }
-}
-int Cba_BlastAdder( Gia_Man_t * pNew, int Carry, int * pAdd0, int * pAdd1, int nBits ) // result is in pAdd0
-{
-    int b;
-    for ( b = 0; b < nBits; b++ )
-        Cba_BlastFullAdder( pNew, pAdd0[b], pAdd1[b], Carry, &Carry, &pAdd0[b] );
-    return Carry;
-}
-void Cba_BlastSubtract( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits ) // result is in pAdd0
-{
-    int b, Carry = 1;
-    for ( b = 0; b < nBits; b++ )
-        Cba_BlastFullAdder( pNew, pAdd0[b], Abc_LitNot(pAdd1[b]), Carry, &Carry, &pAdd0[b] );
-}
-void Cba_BlastMinus( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vRes )
-{
-    int * pRes  = Cba_VecCopy( vRes, pNum, nNum );
-    int i, invert = 0;
-    for ( i = 0; i < nNum; i++ )
-    {
-        pRes[i] = Gia_ManHashMux( pNew, invert, Abc_LitNot(pRes[i]), pRes[i] );
-        invert = Gia_ManHashOr( pNew, invert, pNum[i] );    
-    }
-}
-void Cba_BlastMultiplier2( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits, Vec_Int_t * vTemp, Vec_Int_t * vRes )
-{
-    int i, j;
-    Vec_IntFill( vRes, nBits, 0 );
-    for ( i = 0; i < nBits; i++ )
-    {
-        Vec_IntFill( vTemp, i, 0 );
-        for ( j = 0; Vec_IntSize(vTemp) < nBits; j++ )
-            Vec_IntPush( vTemp, Gia_ManHashAnd(pNew, pArg0[j], pArg1[i]) );
-        assert( Vec_IntSize(vTemp) == nBits );
-        Cba_BlastAdder( pNew, 0, Vec_IntArray(vRes), Vec_IntArray(vTemp), nBits );
-    }
-}
-void Cba_BlastFullAdderCtrl( Gia_Man_t * pNew, int a, int ac, int b, int c, int * pc, int * ps, int fNeg )
-{
-    int And  = Abc_LitNotCond( Gia_ManHashAnd(pNew, a, ac), fNeg );
-    Cba_BlastFullAdder( pNew, And, b, c, pc, ps );
-}
-void Cba_BlastFullAdderSubtr( Gia_Man_t * pNew, int a, int b, int c, int * pc, int * ps, int fSub )
-{
-    Cba_BlastFullAdder( pNew, Gia_ManHashXor(pNew, a, fSub), b, c, pc, ps );
-}
-void Cba_BlastMultiplier( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vTemp, Vec_Int_t * vRes, int fSigned )
-{
-    int * pRes, * pArgC, * pArgS, a, b, Carry = fSigned;
-    assert( nArgA > 0 && nArgB > 0 );
-    assert( fSigned == 0 || fSigned == 1 );
-    // prepare result
-    Vec_IntFill( vRes, nArgA + nArgB, 0 );
-    pRes = Vec_IntArray( vRes );
-    // prepare intermediate storage
-    Vec_IntFill( vTemp, 2 * nArgA, 0 );
-    pArgC = Vec_IntArray( vTemp );
-    pArgS = pArgC + nArgA;
-    // create matrix
-    for ( b = 0; b < nArgB; b++ )
-        for ( a = 0; a < nArgA; a++ )
-            Cba_BlastFullAdderCtrl( pNew, pArgA[a], pArgB[b], pArgS[a], pArgC[a], 
-                &pArgC[a], a ? &pArgS[a-1] : &pRes[b], fSigned && ((a+1 == nArgA) ^ (b+1 == nArgB)) );
-    // final addition
-    pArgS[nArgA-1] = fSigned;
-    for ( a = 0; a < nArgA; a++ )
-        Cba_BlastFullAdderCtrl( pNew, 1, pArgC[a], pArgS[a], Carry, &Carry, &pRes[nArgB+a], 0 );
-}
-void Cba_BlastDivider( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
-{
-    int * pRes  = Cba_VecCopy( vRes, pNum, nNum );
-    int * pQuo  = ABC_ALLOC( int, nNum );
-    int * pTemp = ABC_ALLOC( int, nNum );
-    int i, j, known, borrow, y_bit, top_bit;
-    assert( nNum == nDiv );
-    for ( j = nNum - 1; j >= 0; j-- ) 
-    {
-        known = 0;
-        for ( i = nNum - 1; i > nNum - 1 - j; i-- ) 
-        {
-            known = Gia_ManHashOr( pNew, known, pDiv[i] );
-            if( known == 1 ) 
-                break;
-        }
-        pQuo[j] = known;
-        for ( i = nNum - 1; i >= 0; i-- ) 
-        {
-            if ( known == 1 ) 
-                break;
-            y_bit = (i >= j) ? pDiv[i-j] : 0;
-            pQuo[j] = Gia_ManHashMux( pNew, known, pQuo[j], Gia_ManHashAnd( pNew, y_bit, Abc_LitNot(pRes[i]) ) );
-            known = Gia_ManHashOr( pNew, known, Gia_ManHashXor(pNew, y_bit, pRes[i]));
-        }
-        pQuo[j] = Abc_LitNot(pQuo[j]);
-        if ( pQuo[j] == 0 )
-            continue;
-        borrow = 0;
-        for ( i = 0; i < nNum; i++ ) 
-        {
-            top_bit  = Gia_ManHashMux( pNew, borrow, Abc_LitNot(pRes[i]), pRes[i] );
-            y_bit    = (i >= j) ? pDiv[i-j] : 0;
-            borrow   = Gia_ManHashMux( pNew, pRes[i], Gia_ManHashAnd(pNew, borrow, y_bit), Gia_ManHashOr(pNew, borrow, y_bit) );
-            pTemp[i] = Gia_ManHashXor( pNew, top_bit, y_bit );
-        }
-        if ( pQuo[j] == 1 ) 
-            Cba_VecCopy( vRes, pTemp, nNum );
-        else 
-            for( i = 0; i < nNum; i++ ) 
-                pRes[i] = Gia_ManHashMux( pNew, pQuo[j], pTemp[i], pRes[i] );
-    }
-    ABC_FREE( pTemp );
-    if ( fQuo )
-        Cba_VecCopy( vRes, pQuo, nNum );
-    ABC_FREE( pQuo );
-}
-// non-restoring divider
-void Cba_BlastDivider2( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
-{
-    int i, * pRes  = Vec_IntArray(vRes);
-    int k, * pQuo  = ABC_ALLOC( int, nNum );
-    assert( nNum > 0 && nDiv > 0 );
-    assert( Vec_IntSize(vRes) < nNum + nDiv );
-    for ( i = 0; i < nNum + nDiv; i++ )
-        pRes[i] = i < nNum ? pNum[i] : 0;
-    for ( i = nNum-1; i >= 0; i-- )
-    {
-        int Cntrl = i == nNum-1 ? 1 : pQuo[i+1];
-        int Carry = Cntrl;
-        for ( k = 0; k <= nDiv; k++ )
-            Cba_BlastFullAdderSubtr( pNew, k < nDiv ? pDiv[k] : 0, pRes[i+k], Carry, &Carry, &pRes[i+k], Cntrl );
-        pQuo[i] = Abc_LitNot(pRes[i+nDiv]);
-    }
-    if ( fQuo )
-        Cba_VecCopy( vRes, pQuo, nNum );
-    else
-    {
-        int Carry = 0, Temp;
-        for ( k = 0; k < nDiv; k++ )
-        {
-            Cba_BlastFullAdder( pNew, pDiv[k], pRes[k], Carry, &Carry, &Temp );
-            pRes[k] = Gia_ManHashMux( pNew, pQuo[0], pRes[k], Temp );
-        }
-        Vec_IntShrink( vRes, nDiv );
-    }
-    ABC_FREE( pQuo );
-}
-void Cba_BlastDividerSigned( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
-{
-    Vec_Int_t * vNum   = Vec_IntAlloc( nNum );
-    Vec_Int_t * vDiv   = Vec_IntAlloc( nDiv );
-    Vec_Int_t * vRes00 = Vec_IntAlloc( nNum + nDiv );
-    Vec_Int_t * vRes01 = Vec_IntAlloc( nNum + nDiv );
-    Vec_Int_t * vRes10 = Vec_IntAlloc( nNum + nDiv );
-    Vec_Int_t * vRes11 = Vec_IntAlloc( nNum + nDiv );
-    Vec_Int_t * vRes2  = Vec_IntAlloc( nNum );
-    int k, iDiffSign   = Gia_ManHashXor( pNew, pNum[nNum-1], pDiv[nDiv-1] );
-    Cba_BlastMinus( pNew, pNum, nNum, vNum );
-    Cba_BlastMinus( pNew, pDiv, nDiv, vDiv );
-    Cba_BlastDivider( pNew,               pNum, nNum,               pDiv, nDiv, fQuo, vRes00 );
-    Cba_BlastDivider( pNew,               pNum, nNum, Vec_IntArray(vDiv), nDiv, fQuo, vRes01 );
-    Cba_BlastDivider( pNew, Vec_IntArray(vNum), nNum,               pDiv, nDiv, fQuo, vRes10 );
-    Cba_BlastDivider( pNew, Vec_IntArray(vNum), nNum, Vec_IntArray(vDiv), nDiv, fQuo, vRes11 );
-    Vec_IntClear( vRes );
-    for ( k = 0; k < nNum; k++ )
-    {
-        int Data0 =  Gia_ManHashMux( pNew, pDiv[nDiv-1], Vec_IntEntry(vRes01,k), Vec_IntEntry(vRes00,k) );
-        int Data1 =  Gia_ManHashMux( pNew, pDiv[nDiv-1], Vec_IntEntry(vRes11,k), Vec_IntEntry(vRes10,k) );
-        Vec_IntPush( vRes, Gia_ManHashMux(pNew, pNum[nNum-1], Data1, Data0) );
-    }
-    Cba_BlastMinus( pNew, Vec_IntArray(vRes), nNum, vRes2 );
-    for ( k = 0; k < nNum; k++ )
-        Vec_IntWriteEntry( vRes, k, Gia_ManHashMux(pNew, fQuo ? iDiffSign : pNum[nNum-1], Vec_IntEntry(vRes2,k), Vec_IntEntry(vRes,k)) );
-    Vec_IntFree( vNum );
-    Vec_IntFree( vDiv );
-    Vec_IntFree( vRes00 );
-    Vec_IntFree( vRes01 );
-    Vec_IntFree( vRes10 );
-    Vec_IntFree( vRes11 );
-    Vec_IntFree( vRes2 );
-    assert( Vec_IntSize(vRes) == nNum );
-}
-void Cba_BlastZeroCondition( Gia_Man_t * pNew, int * pDiv, int nDiv, Vec_Int_t * vRes )
-{
-    int i, Entry, iLit = Cba_BlastReduction( pNew, pDiv, nDiv, CBA_BOX_ROR );
-    Vec_IntForEachEntry( vRes, Entry, i )
-        Vec_IntWriteEntry( vRes, i, Gia_ManHashAnd(pNew, iLit, Entry) );
-}
-void Cba_BlastTable( Gia_Man_t * pNew, word * pTable, int * pFans, int nFans, int nOuts, Vec_Int_t * vRes )
-{
-    extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash );
-    Vec_Int_t * vMemory = Vec_IntAlloc( 0 );
-    Vec_Int_t vLeaves = { nFans, nFans, pFans };
-    word * pTruth = ABC_ALLOC( word, Abc_TtWordNum(nFans) );
-    int o, i, m, iLit, nMints = (1 << nFans);
-    Vec_IntClear( vRes );
-    for ( o = 0; o < nOuts; o++ )
-    {
-        // derive truth table
-        memset( pTruth, 0, sizeof(word) * Abc_TtWordNum(nFans) );
-        for ( m = 0; m < nMints; m++ )
-            for ( i = 0; i < nFans; i++ )
-                if ( Abc_TtGetBit( pTable, m * nFans + i ) )
-                    Abc_TtSetBit( pTruth, m );
-        // implement truth table
-        if ( nFans < 6 )
-            pTruth[0] = Abc_Tt6Stretch( pTruth[0], nFans );
-        iLit = Kit_TruthToGia( pNew, (unsigned *)pTruth, nFans, vMemory, &vLeaves, 1 );
-        Vec_IntPush( vRes, iLit );
-    }
-    Vec_IntFree( vMemory );
-    ABC_FREE( pTruth );
-}
-void Cba_BlastPower( Gia_Man_t * pNew, int * pNum, int nNum, int * pExp, int nExp, Vec_Int_t * vTemp, Vec_Int_t * vRes )
-{
-    Vec_Int_t * vDegrees = Vec_IntAlloc( 2*nNum );
-    Vec_Int_t * vResTemp = Vec_IntAlloc( 2*nNum );
-    int i, * pDegrees = NULL, * pRes = Vec_IntArray(vRes);
-    int k, * pResTemp = Vec_IntArray(vResTemp);
-    Vec_IntFill( vRes, nNum, 0 );
-    Vec_IntWriteEntry( vRes, 0, 1 );
-    for ( i = 0; i < nExp; i++ )
-    {
-        if ( i == 0 )
-            pDegrees = Cba_VecCopy( vDegrees, pNum, nNum );
-        else
-        {
-            Cba_BlastMultiplier2( pNew, pDegrees, pDegrees, nNum, vTemp, vResTemp );
-            pDegrees = Cba_VecCopy( vDegrees, pResTemp, nNum );
-        }
-        Cba_BlastMultiplier2( pNew, pRes, pDegrees, nNum, vTemp, vResTemp );
-        for ( k = 0; k < nNum; k++ )
-            pRes[k] = Gia_ManHashMux( pNew, pExp[i], pResTemp[k], pRes[k] );
-    }
-    Vec_IntFree( vResTemp );
-    Vec_IntFree( vDegrees );
-}
-void Cba_BlastSqrt( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vTmp, Vec_Int_t * vRes )
-{
-    int * pRes, * pSum, * pSumP;
-    int i, k, Carry = -1;
-    assert( nNum % 2 == 0 );
-    Vec_IntFill( vRes, nNum/2, 0 );
-    Vec_IntFill( vTmp, 2*nNum, 0 );
-    pRes = Vec_IntArray( vRes );
-    pSum = Vec_IntArray( vTmp );
-    pSumP = pSum + nNum;
-    for ( i = 0; i < nNum/2; i++ )
-    {
-        pSumP[0] = pNum[nNum-2*i-2];
-        pSumP[1] = pNum[nNum-2*i-1];
-        for ( k = 0; k < i+1; k++ )
-            pSumP[k+2] = pSum[k];
-        for ( k = 0; k < i + 3; k++ )
-        {
-            if ( k >= 2 && k < i + 2 ) // middle ones
-                Cba_BlastFullAdder( pNew, pSumP[k], Abc_LitNot(pRes[i-k+1]), Carry, &Carry, &pSum[k] );
-            else
-                Cba_BlastFullAdder( pNew, pSumP[k], Abc_LitNot(k ? Carry:1), 1,     &Carry, &pSum[k] );
-            if ( k == 0 || k > i )
-                Carry = Abc_LitNot(Carry);
-        }
-        pRes[i] = Abc_LitNot(Carry);
-        for ( k = 0; k < i + 3; k++ )
-            pSum[k] = Gia_ManHashMux( pNew, pRes[i], pSum[k], pSumP[k] );
-    }
-    Vec_IntReverseOrder( vRes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Cba_NtkBlast( Cba_Ntk_t * p, int fSeq )
-{
-    int fUseOldMultiplierBlasting = 0;
-    Gia_Man_t * pTemp, * pNew;
-    Vec_Int_t * vTemp0, * vTemp1, * vTemp2, * vRes;
-    Vec_Str_t * vInit = fSeq ? Vec_StrAlloc(100) : NULL;
-    Vec_Int_t * vBits = &p->vFonBits;
-    int nBits = Cba_NtkPrepareBits( p );
-    int * pFans0, * pFans1, * pFans2;
-    int nRange, nRange0, nRange1, nRange2;
-    int Type, iFon, iFon0, iFon1, iFon2, fSigned01;
-    int i, k, b, iFin, iObj, iLit, nAndPrev;
-    Vec_IntClear( vBits );
-    Vec_IntGrow( vBits, nBits );
-    vTemp0 = Vec_IntAlloc( 1000 );
-    vTemp1 = Vec_IntAlloc( 1000 );
-    vTemp2 = Vec_IntAlloc( 1000 );
-    vRes   = Vec_IntAlloc( 1000 );
-    // clean AND-gate counters
-    memset( p->pDesign->nAnds, 0, sizeof(int) * CBA_BOX_LAST );
-    // create AIG manager
-    pNew = Gia_ManStart( 5 * Cba_NtkObjNum(p) + 1000 );
-    pNew->pName = Abc_UtilStrsav( Cba_ManName(p->pDesign) );
-    Gia_ManHashAlloc( pNew );
-    // blast in the topological order
-    Cba_NtkForEachObj( p, i )
-    {
-        Type = Cba_ObjType(p, i);
-        if ( Type == CBA_OBJ_PO )
-            continue;
-        assert( Vec_IntSize(vBits) == Cba_FonCopy(p, Cba_ObjFon0(p, i)) );
-        nRange = Cba_ObjRangeSize(p, i); assert( nRange > 0 );
-        if ( Cba_ObjIsPi(p, i) || Cba_ObjIsSeq(p, i) )
-        {
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vBits, Gia_ManAppendCi(pNew) );
-            assert( Type == CBA_BOX_DFFCPL || Cba_ObjFonNum(p, i) == 1 );
-            continue;
-        }
-        assert( Cba_ObjFinNum(p, i) > 0 );
-        iFon0     = Cba_ObjFinNum(p, i) > 0 ? Cba_ObjFinFon(p, i, 0) : -1;
-        iFon1     = Cba_ObjFinNum(p, i) > 1 ? Cba_ObjFinFon(p, i, 1) : -1;
-        iFon2     = Cba_ObjFinNum(p, i) > 2 ? Cba_ObjFinFon(p, i, 2) : -1;
-        nRange0   = Cba_ObjFinNum(p, i) > 0 ? Cba_FonRangeSize(p, iFon0) : -1; 
-        nRange1   = Cba_ObjFinNum(p, i) > 1 ? Cba_FonRangeSize(p, iFon1) : -1; 
-        nRange2   = Cba_ObjFinNum(p, i) > 2 ? Cba_FonRangeSize(p, iFon2) : -1; 
-        pFans0    = (Cba_ObjFinNum(p, i) > 0 && Cba_FonIsReal(iFon0)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon0) ) : NULL;
-        pFans1    = (Cba_ObjFinNum(p, i) > 1 && Cba_FonIsReal(iFon1)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon1) ) : NULL;
-        pFans2    = (Cba_ObjFinNum(p, i) > 2 && Cba_FonIsReal(iFon2)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon2) ) : NULL;
-        fSigned01 = (Cba_ObjFinNum(p, i) > 1 && Cba_FonSigned(p, iFon0) && Cba_FonSigned(p, iFon1));
-        nAndPrev  = Gia_ManAndNum(pNew);
-        Vec_IntClear( vRes );
-        if ( Type == CBA_BOX_SLICE )
-        {
-            int Left   = Cba_ObjLeft( p, i );
-            int Right  = Cba_ObjRight( p, i );
-            int Left0  = Cba_FonLeft( p, iFon0 );
-            int Right0 = Cba_FonRight( p, iFon0 );
-            if ( Left > Right )
-            {
-                assert( Left0 > Right0 );
-                for ( k = Right; k <= Left; k++ )
-                    Vec_IntPush( vRes, pFans0[k - Right0] );
-            }
-            else
-            {
-                assert( Left < Right && Left0 < Right0 );
-                for ( k = Right; k >= Left; k-- )
-                    Vec_IntPush( vRes, pFans0[k - Right0] );
-            }
-        }
-        else if ( Type == CBA_BOX_CONCAT )
-        {
-            int iFinT, iFonT, nTotal = 0;
-            Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
-                nTotal += Cba_FonRangeSize( p, iFonT );
-            assert( nRange == nTotal );
-            Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
-            {
-                nRange0 = Cba_FonRangeSize( p, iFonT );
-                pFans0  = Cba_FonIsReal(iFonT) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFonT) ) : NULL;
-                pFans0  = Cba_VecLoadFanins( p, vTemp0, iFonT, pFans0, nRange0, nRange0, Cba_FonSigned(p, iFonT) );
-                for ( b = 0; b < nRange0; b++ )
-                    Vec_IntPush( vRes, pFans0[b] );
-            }
-        }
-        else if ( Type == CBA_BOX_BUF )
-        {
-            int nRangeMax = Abc_MaxInt( nRange0, nRange );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vRes, pArg0[k] );
-        }
-        else if ( Type >= CBA_BOX_CF && Type <= CBA_BOX_CZ )
-        {
-            assert( 0 );
-            //word * pTruth = (word *)Cba_ObjFanins(p, i);
-            //for ( k = 0; k < nRange; k++ )
-            //    Vec_IntPush( vRes, Abc_TtGetBit(pTruth, k) );
-        }
-        else if ( Type == CBA_BOX_MUX || Type == CBA_BOX_NMUX )
-        {
-            // It is strange and disturbing that Verilog standard treats these statements differently:
-            // Statement 1:   
-            //     assign o = i ? b : a;
-            // Statement 2:
-            //     always @( i or a or b )
-            //       begin
-            //         case ( i )
-            //           0 : o = a ;
-            //           1 : o = b ;
-            //         endcase
-            //       end
-            // If a is signed and b is unsigned,  Statement 1 does not sign-extend a, while Statement 2 does.
-            // The signedness of o does not matter.
-            //
-            // Below we (somewhat arbitrarily) distinguish these two by assuming that 
-            // Statement 1 has three fanins, while Statement 2 has more than three fanins.
-            //
-            int iFinT, iFonT, fSigned = 1;
-            assert( nRange0 >= 1 && Cba_ObjFinNum(p, i) >= 3 );
-            assert( 1 + (1 << nRange0) == Cba_ObjFinNum(p, i) );
-            Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
-                if ( k > 0 )
-                    fSigned &= Cba_FonSigned(p, iFonT);
-            for ( b = 0; b < nRange; b++ )
-            {
-                Vec_IntClear( vTemp0 );
-                Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
-                    if ( k > 0 )
-                    {
-                        nRange1 = Cba_FonRangeSize( p, iFonT );
-                        pFans1  = Cba_FonIsReal(iFonT) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFonT) ) : NULL;
-                        if ( Cba_ObjFinNum(p, i) == 3 ) // Statement 1
-                            Vec_IntPush( vTemp0, k < nRange1 ? pFans1[k] : (fSigned? pFans1[nRange1-1] : 0) );
-                        else // Statement 2
-                            Vec_IntPush( vTemp0, k < nRange1 ? pFans1[k] : (Cba_FonSigned(p, iFonT)? pFans1[nRange1-1] : 0) );
-                    }
-                Vec_IntPush( vRes, Cba_NtkMuxTree_rec(pNew, pFans0, nRange0, vTemp0, 0) );
-            }
-        }
-        else if ( Type == CBA_BOX_SHIR || Type == CBA_BOX_SHIRA ||
-                  Type == CBA_BOX_SHIL || Type == CBA_BOX_SHILA )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, nRange0 );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
-            if ( Type == CBA_BOX_SHIR || Type == CBA_BOX_SHIRA )
-                Cba_BlastShiftRight( pNew, pArg0, nRangeMax, pFans1, nRange1, Cba_FonSigned(p, iFon0) && Type == CBA_BOX_SHIRA, vRes );
-            else
-                Cba_BlastShiftLeft( pNew, pArg0, nRangeMax, pFans1, nRange1, 0, vRes );
-            Vec_IntShrink( vRes, nRange );
-        }
-        else if ( Type == CBA_BOX_ROTR )
-        {
-            assert( nRange0 == nRange );
-            Cba_BlastRotateRight( pNew, pFans0, nRange0, pFans1, nRange1, vRes );
-        }
-        else if ( Type == CBA_BOX_ROTL )
-        {
-            assert( nRange0 == nRange );
-            Cba_BlastRotateLeft( pNew, pFans0, nRange0, pFans1, nRange1, vRes );
-        }
-        else if ( Type == CBA_BOX_INV )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, nRange0 );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vRes, Abc_LitNot(pArg0[k]) );
-        }
-        else if ( Type == CBA_BOX_AND )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vRes, Gia_ManHashAnd(pNew, pArg0[k], pArg1[k]) );
-        }
-        else if ( Type == CBA_BOX_OR )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vRes, Gia_ManHashOr(pNew, pArg0[k], pArg1[k]) );
-        }
-        else if ( Type == CBA_BOX_XOR )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            for ( k = 0; k < nRange; k++ )
-                Vec_IntPush( vRes, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
-        }
-        else if ( Type == CBA_BOX_LNOT )
-        {
-            iLit = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
-            Vec_IntFill( vRes, 1, Abc_LitNot(iLit) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_LAND )
-        {
-            int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
-            int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
-            Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_LOR )
-        {
-            int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
-            int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
-            Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_LXOR )
-        {
-            int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
-            int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
-            Vec_IntFill( vRes, 1, Gia_ManHashXor(pNew, iLit0, iLit1) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_EQU || Type == CBA_BOX_NEQU )
-        {
-            int iLit = 0, nRangeMax = Abc_MaxInt( nRange0, nRange1 );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            for ( k = 0; k < nRangeMax; k++ )
-                iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) ); 
-            Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, Type == CBA_BOX_EQU) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_LTHAN || Type == CBA_BOX_METHAN ||
-                  Type == CBA_BOX_MTHAN || Type == CBA_BOX_LETHAN )
-        {
-            int nRangeMax = Abc_MaxInt( nRange0, nRange1 );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            int fSwap  = (Type == CBA_BOX_MTHAN  || Type == CBA_BOX_LETHAN);
-            int fCompl = (Type == CBA_BOX_METHAN || Type == CBA_BOX_LETHAN);
-            if ( fSwap ) ABC_SWAP( int *, pArg0, pArg1 );
-            if ( fSigned01 )
-                iLit = Cba_BlastLessSigned( pNew, pArg0, pArg1, nRangeMax );
-            else
-                iLit = Cba_BlastLess( pNew, pArg0, pArg1, nRangeMax );
-            iLit = Abc_LitNotCond( iLit, fCompl );
-            Vec_IntFill( vRes, 1, iLit );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_RAND || Type == CBA_BOX_ROR || Type == CBA_BOX_RXOR )
-        {
-            Vec_IntPush( vRes, Cba_BlastReduction( pNew, pFans0, nRange0, Type ) );
-            for ( k = 1; k < nRange; k++ )
-                Vec_IntPush( vRes, 0 );
-        }
-        else if ( Type == CBA_BOX_ADD ) 
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange1, nRange2) );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, 1, 1, 0 );
-            int * pArg1 = Cba_VecLoadFanins( p, vRes,   iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            int * pArg2 = Cba_VecLoadFanins( p, vTemp1, iFon2, pFans2, nRange2, nRangeMax, fSigned01 );
-            int Carry   = Cba_BlastAdder( pNew, pArg0[0], pArg1, pArg2, nRange ); // result is in pArg1 (vRes)
-            assert( nRange0 == 1 );
-            Vec_IntShrink( vRes, nRange );
-            Vec_IntPush( vRes, Carry );
-        }
-        else if ( Type == CBA_BOX_SUB ) 
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-            int * pArg0 = Cba_VecLoadFanins( p, vRes,   iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            Cba_BlastSubtract( pNew, pArg0, pArg1, nRange ); // result is in pFan0 (vRes)
-            Vec_IntShrink( vRes, nRange );
-        }
-        else if ( Type == CBA_BOX_MUL )
-        {
-            if ( fUseOldMultiplierBlasting )
-            {
-                int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-                int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-                int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-                Cba_BlastMultiplier2( pNew, pArg0, pArg1, nRange, vTemp2, vRes );
-                Vec_IntShrink( vRes, nRange );
-            }
-            else
-            {
-                int nRangeMax = Abc_MaxInt(nRange0, nRange1);
-                int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-                int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-                Cba_BlastMultiplier( pNew, pArg0, pArg1, nRangeMax, nRangeMax, vTemp2, vRes, fSigned01 );
-                if ( nRange > nRangeMax + nRangeMax )
-                    Vec_IntFillExtra( vRes, nRange, fSigned01 ? Vec_IntEntryLast(vRes) : 0 );
-                else
-                    Vec_IntShrink( vRes, nRange );
-                assert( Vec_IntSize(vRes) == nRange );
-            }
-        }
-        else if ( Type == CBA_BOX_DIV || Type == CBA_BOX_MOD )
-        {
-            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
-            if ( fSigned01 )
-                Cba_BlastDividerSigned( pNew, pArg0, nRangeMax, pArg1, nRangeMax, Type == CBA_BOX_DIV, vRes );
-            else
-                Cba_BlastDivider( pNew, pArg0, nRangeMax, pArg1, nRangeMax, Type == CBA_BOX_DIV, vRes );
-            Vec_IntShrink( vRes, nRange );
-            if ( Type == CBA_BOX_DIV )
-                Cba_BlastZeroCondition( pNew, pFans1, nRange1, vRes );
-        }
-        else if ( Type == CBA_BOX_MIN )
-        {
-            int nRangeMax = Abc_MaxInt( nRange0, nRange );
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
-            Cba_BlastMinus( pNew, pArg0, nRangeMax, vRes );
-            Vec_IntShrink( vRes, nRange );
-        }
-        else if ( Type == CBA_BOX_POW )
-        {
-            int nRangeMax = Abc_MaxInt(nRange0, nRange);
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
-            int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRange1,   Cba_FonSigned(p, iFon1) );
-            Cba_BlastPower( pNew, pArg0, nRangeMax, pArg1, nRange1, vTemp2, vRes );
-            Vec_IntShrink( vRes, nRange );
-        }
-        else if ( Type == CBA_BOX_SQRT )
-        {
-            int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRange0 + (nRange0 & 1), 0 );
-            nRange0 += (nRange0 & 1);
-            Cba_BlastSqrt( pNew, pArg0, nRange0, vTemp2, vRes );
-            if ( nRange > Vec_IntSize(vRes) )
-                Vec_IntFillExtra( vRes, nRange, 0 );
-            else
-                Vec_IntShrink( vRes, nRange );
-        }
-        else if ( Type == CBA_BOX_TABLE )
-        {
-            assert( 0 );
-            //Cba_BlastTable( pNew, Cba_ObjTable(p, p, i), pFans0, nRange0, nRange, vRes );
-        }
-        else assert( 0 );
-        Vec_IntAppend( vBits, vRes );
-        p->pDesign->nAnds[Type] += Gia_ManAndNum(pNew) - nAndPrev;
-    }
-    assert( nBits == Vec_IntSize(vBits) );
-    p->pDesign->nAnds[0] = Gia_ManAndNum(pNew);
-    // create COs
-    Cba_NtkForEachPo( p, iObj, i )
-    {
-        Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
-        {
-            nRange = Cba_FonRangeSize( p, iFon );
-            pFans0  = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
-            pFans0  = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange, nRange, Cba_FonSigned(p, iFon) );
-            for ( b = 0; b < nRange; b++ )
-                Gia_ManAppendCo( pNew, pFans0[b] );
-        }
-    }
-    Cba_NtkForEachBoxSeq( p, iObj, i )
-    {
-        if ( fSeq )
-        {
-            assert( Cba_ObjType(p, iObj) == CBA_BOX_DFFCPL );
-            iFon0 = Cba_ObjFinFon( p, iObj, 0 );
-            iFon1 = Cba_ObjFinFon( p, iObj, 1 );
-            nRange0 = Cba_FonRangeSize( p, iFon0 );
-            nRange1 = Cba_FonRangeSize( p, iFon1 );
-            assert( nRange0 == nRange1 );
-            Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
-            {
-                nRange = Cba_FonRangeSize( p, iFon );
-                pFans0 = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
-                pFans0 = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange0, nRange0, Cba_FonSigned(p, iFon) );
-                if ( k == 0 )
-                {
-                    for ( b = 0; b < nRange; b++ )
-                        Gia_ManAppendCo( pNew, pFans0[b] );
-                }
-                else if ( k == 1 )
-                {
-                    for ( b = 0; b < nRange; b++ )
-                        if ( pFans0[b] == 0 )
-                            Vec_StrPush( vInit, '0' );
-                        else if ( pFans0[b] == 1 )
-                            Vec_StrPush( vInit, '1' );
-                        else
-                            Vec_StrPush( vInit, 'x' );
-                }
-                else break;
-            }
-        }
-        else // combinational
-        {
-            Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
-            {
-                nRange = Cba_FonRangeSize( p, iFon );
-                pFans0  = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
-                pFans0  = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange, nRange, Cba_FonSigned(p, iFon) );
-                for ( b = 0; b < nRange; b++ )
-                    Gia_ManAppendCo( pNew, pFans0[b] );
-            }
-        }
-    }
-    Vec_IntFree( vTemp0 );
-    Vec_IntFree( vTemp1 );
-    Vec_IntFree( vTemp2 );
-    Vec_IntFree( vRes );
-    // finalize AIG
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManDupRemapLiterals( vBits, pTemp );
-    Gia_ManStop( pTemp );
-    // transform AIG with init state
-    if ( fSeq )
-    {
-        Gia_ManSetRegNum( pNew, Vec_StrSize(vInit) );
-        Vec_StrPush( vInit, '\0' );
-        pNew = Gia_ManDupZeroUndc( pTemp = pNew, Vec_StrArray(vInit), 0, 1 );
-        Gia_ManDupRemapLiterals( vBits, pTemp );
-        Gia_ManStop( pTemp );
-        Vec_StrFreeP( &vInit );
-    }
-    //Vec_IntErase( vBits );
-    //Vec_IntErase( &p->vCopies );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Cba_ManBlast( Cba_Man_t * p, int fBarBufs, int fSeq, int fVerbose )
-{
-    return Cba_NtkBlast( Cba_ManRoot(p), fSeq );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
-{
-    return NULL;
-}
-Cba_Man_t * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc )
-{
-    Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc;
-    return (Cba_Man_t *)pNtk;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-