Various transformations of Cba_Ntk_t.

8 files changed, 692 insertions, 371 deletions

diff --git a/src/base/cba/cba.h b/src/base/cba/cba.h
index b38fee90..88b601cf 100644
--- a/src/base/cba/cba.h
+++ b/src/base/cba/cba.h
@@ -100,16 +100,17 @@ struct Cba_Ntk_t_
     char *       pName;    // name
     Cba_Man_t *  pDesign;  // design
     // interface
-    Vec_Int_t    vInouts;  // inouts          (used by parser to store signals) 
-    Vec_Int_t    vInputs;  // inputs          (used by parser to store signals)
-    Vec_Int_t    vOutputs; // outputs         (used by parser to store signals) 
-    Vec_Int_t    vWires;   // wires           (used by parser to store signals)
+    Vec_Int_t    vInouts;  // inouts          (used by parser to store signals as NameId) 
+    Vec_Int_t    vInputs;  // inputs          (used by parser to store signals as NameId)
+    Vec_Int_t    vOutputs; // outputs         (used by parser to store signals as NameId) 
+    Vec_Int_t    vWires;   // wires           (used by parser to store signals as NameId)
     // objects
     Vec_Int_t    vTypes;   // types           (used by parser to store Cba_PrsType_t)
     Vec_Int_t    vFuncs;   // functions       (used by parser to store function)
     Vec_Int_t    vInstIds; // instance names  (used by parser to store instance name as NameId)
     Vec_Int_t    vFanins;  // fanins          (used by parser to store fanin/fanout/range as NameId)      
     // attributes
+    Vec_Int_t    vBoxes;   // box objects
     Vec_Int_t    vNameIds; // original names as NameId  
     Vec_Int_t    vRanges;  // ranges as NameId
     Vec_Int_t    vCopies;  // copy pointers
@@ -118,15 +119,22 @@ struct Cba_Ntk_t_
 
 static inline char *        Cba_ManName( Cba_Man_t * p )                    { return p->pName;                                                                            }
 static inline int           Cba_ManNtkNum( Cba_Man_t * p )                  { return Vec_PtrSize(&p->vNtks) - 1;                                                          }
+static inline int           Cba_ManNtkId( Cba_Man_t * p, char * pName )     { return Abc_NamStrFind(p->pModels, pName);                                                   }
 static inline Cba_Ntk_t *   Cba_ManNtk( Cba_Man_t * p, int i )              { assert( i > 0 ); return (Cba_Ntk_t *)Vec_PtrEntry(&p->vNtks, i);                            }
 static inline Cba_Ntk_t *   Cba_ManRoot( Cba_Man_t * p )                    { return Cba_ManNtk(p, p->iRoot);                                                             }
 static inline Vec_Set_t *   Cba_ManMem( Cba_Man_t * p )                     { return &p->Mem;                                                                             }
 static inline int           Cba_ManMemSave( Cba_Man_t * p, int * d, int s ) { return Vec_SetAppend(Cba_ManMem(p), d, s);                                                  }
-static inline int *         Cba_ManMemRead( Cba_Man_t * p, int h )          { return (int *)Vec_SetEntry(Cba_ManMem(p), h);                                               }
+static inline int *         Cba_ManMemRead( Cba_Man_t * p, int h )          { return h ? (int *)Vec_SetEntry(Cba_ManMem(p), h) : NULL;                                    }
 
 static inline char *        Cba_NtkName( Cba_Ntk_t * p )                    { return p->pName;                                                                            }
 static inline Cba_Man_t *   Cba_NtkMan( Cba_Ntk_t * p )                     { return p->pDesign;                                                                          }
 static inline int           Cba_NtkObjNum( Cba_Ntk_t * p )                  { return Vec_IntSize(&p->vFanins);                                                            }
+static inline int           Cba_NtkPiNum( Cba_Ntk_t * p )                   { return Vec_IntSize(&p->vInputs);                                                            }
+static inline int           Cba_NtkPoNum( Cba_Ntk_t * p )                   { return Vec_IntSize(&p->vOutputs);                                                           }
+static inline int           Cba_NtkBoxNum( Cba_Ntk_t * p )                  { return Vec_IntSize(&p->vBoxes);                                                             }
+static inline int           Cba_NtkNodeNum( Cba_Ntk_t * p )                 { return Cba_NtkObjNum(p) - Cba_NtkPiNum(p) - Cba_NtkPoNum(p) - Cba_NtkBoxNum(p);             }
+static inline int           Cba_NtkPi( Cba_Ntk_t * p, int i )               { return Vec_IntEntry(&p->vInputs, i);                                                        }
+static inline int           Cba_NtkPo( Cba_Ntk_t * p, int i )               { return Vec_IntEntry(&p->vOutputs, i);                                                       }
 static inline char *        Cba_NtkStr( Cba_Ntk_t * p, int i )              { return Abc_NamStr(p->pDesign->pNames, i);                                                   }
 static inline char *        Cba_NtkModelStr( Cba_Ntk_t * p, int i )         { return Abc_NamStr(p->pDesign->pModels, i);                                                  }
 static inline char *        Cba_NtkFuncStr( Cba_Ntk_t * p, int i )          { return Abc_NamStr(p->pDesign->pFuncs, i);                                                   }
@@ -135,13 +143,19 @@ static inline int           Cba_NtkMemSave( Cba_Ntk_t * p, int * d, int s ) { re
 static inline int *         Cba_NtkMemRead( Cba_Ntk_t * p, int h )          { return Cba_ManMemRead(p->pDesign, h);                                                       }
 
 static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i )             { return Vec_IntEntry(&p->vTypes, i);                                                         }
+static inline int           Cba_ObjIsPi( Cba_Ntk_t * p, int i )             { return Cba_ObjType(p, i) == CBA_OBJ_PI;                                                     }
+static inline int           Cba_ObjIsPo( Cba_Ntk_t * p, int i )             { return Cba_ObjType(p, i) == CBA_OBJ_PO;                                                     }
+static inline int           Cba_ObjIsNode( Cba_Ntk_t * p, int i )           { return Cba_ObjType(p, i) == CBA_OBJ_NODE;                                                   }
+static inline int           Cba_ObjIsBox( Cba_Ntk_t * p, int i )            { return Cba_ObjType(p, i) == CBA_OBJ_BOX;                                                    }
+static inline int           Cba_ObjIsPin( Cba_Ntk_t * p, int i )            { return Cba_ObjType(p, i) == CBA_OBJ_PIN;                                                    }
 static inline int           Cba_ObjFuncId( Cba_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vFuncs, i);                                                         }
 static inline int           Cba_ObjInstId( Cba_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vInstIds, i);                                                       }
 static inline int *         Cba_ObjFaninArray( Cba_Ntk_t * p, int i )       { return Cba_NtkMemRead(p, Vec_IntEntry(&p->vFanins, i));                                     }
 static inline int           Cba_ObjFaninNum( Cba_Ntk_t * p, int i )         { return *Cba_ObjFaninArray(p, i);                                                            }
 static inline int *         Cba_ObjFanins( Cba_Ntk_t * p, int i )           { return Cba_ObjFaninArray(p, i) + 1;                                                         }
-static inline Vec_Int_t *   Cba_ObjFaninVec( Cba_Ntk_t * p, int i )         { static Vec_Int_t V; V.pArray = Cba_ObjFaninArray(p, i); V.nSize = V.nCap = *V.pArray++; return &V; }
-static inline Vec_Int_t *   Cba_ObjFaninVec2( Cba_Ntk_t * p, int i )        { static Vec_Int_t W; W.pArray = Cba_ObjFaninArray(p, i); W.nSize = W.nCap = *W.pArray++; return &W; }
+static inline Vec_Int_t *   Cba_ObjFaninVec( Cba_Ntk_t * p, int i )         { static Vec_Int_t V; V.pArray = Cba_ObjFaninArray(p, i); V.nSize = V.nCap = V.pArray ? *V.pArray++ : 0; return &V; }
+static inline Vec_Int_t *   Cba_ObjFaninVec2( Cba_Ntk_t * p, int i )        { static Vec_Int_t W; W.pArray = Cba_ObjFaninArray(p, i); W.nSize = W.nCap = W.pArray ? *W.pArray++ : 0; return &W; }
+static inline Cba_Ntk_t *   Cba_ObjModel( Cba_Ntk_t * p, int i )            { assert(Cba_ObjIsBox(p, i)); return Cba_ManNtk(p->pDesign, Cba_ObjFuncId(p, i));             }
 
 static inline int           Cba_ObjNameId( Cba_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vNameIds, i);                                                       }
 static inline int           Cba_ObjRangeId( Cba_Ntk_t * p, int i )          { return Vec_IntEntry(&p->vRanges, i);                                                        }
@@ -162,10 +176,15 @@ static inline char *        Cba_ObjRangeStr( Cba_Ntk_t * p, int i )         { re
 ////////////////////////////////////////////////////////////////////////
 
 
-#define Cba_ManForEachNtk( p, pNtk, i )                     \
+#define Cba_ManForEachNtk( p, pNtk, i )                                   \
     for ( i = 1; (i <= Cba_ManNtkNum(p)) && (((pNtk) = Cba_ManNtk(p, i)), 1); i++ ) 
 
-#define Cba_NtkForEachObjType( p, Type, i )      \
+#define Cba_NtkForEachPi( p, iObj, i )                                          \
+    for ( i = 0; (i < Cba_NtkPiNum(p))  && (((iObj) = Vec_IntEntry(&p->vInputs, i)), 1); i++ ) 
+#define Cba_NtkForEachPo( p, iObj, i )                                          \
+    for ( i = 0; (i < Cba_NtkPoNum(p))  && (((iObj) = Vec_IntEntry(&p->vOutputs, i)), 1); i++ ) 
+
+#define Cba_NtkForEachObjType( p, Type, i )                               \
     for ( i = 0; (i < Cba_NtkObjNum(p))  && (((Type) = Cba_ObjType(p, i)), 1); i++ ) 
 #define Cba_NtkForEachObjTypeFuncFanins( p, Type, Func, vFanins, i )      \
     for ( i = 0; (i < Cba_NtkObjNum(p))  && (((Type) = Cba_ObjType(p, i)), 1)  && (((Func) = Cba_ObjFuncId(p, i)), 1)  && (((vFanins) = Cba_ObjFaninVec(p, i)), 1); i++ ) 
@@ -175,27 +194,60 @@ static inline char *        Cba_ObjRangeStr( Cba_Ntk_t * p, int i )         { re
 ///                    FUNCTION DECLARATIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
+// copy contents to the vector
+static inline int Cba_ManHandleArray( Cba_Man_t * p, Vec_Int_t * vFrom )
+{
+    int h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * (Vec_IntSize(vFrom) + 1) );
+    int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h );
+    pArray[0] = Vec_IntSize(vFrom);
+    memcpy( pArray+1, Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) );
+    Vec_IntClear( vFrom );
+    return h;
+}
+static inline int Cba_ManHandleBuffer( Cba_Man_t * p, int iFanin )
+{
+    int h = Vec_SetFetchH( Cba_ManMem(p), sizeof(int) * 2 );
+    int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p), h );
+    pArray[0] = 1;
+    pArray[1] = iFanin;
+    return h;
+}
+static inline void Cba_ManSetupArray( Cba_Man_t * p, Vec_Int_t * vTo, Vec_Int_t * vFrom )
+{
+    if ( Vec_IntSize(vFrom) == 0 )
+        return;
+    vTo->nSize = vTo->nCap = Vec_IntSize(vFrom);
+    vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p), sizeof(int) * Vec_IntSize(vFrom) );
+    memcpy( Vec_IntArray(vTo), Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) );
+    Vec_IntClear( vFrom );
+}
+static inline void Cba_ManFetchArray( Cba_Man_t * p, Vec_Int_t * vTo, int nSize )
+{
+    if ( nSize == 0 )
+        return;
+    vTo->nSize = vTo->nCap = nSize;
+    vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p), sizeof(int) * nSize );
+    memset( Vec_IntArray(vTo), 0xff, sizeof(int) * nSize );
+}
+
+// constructors desctructors
 static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName )
 {
     Cba_Ntk_t * pNtk = Vec_SetFetch( Cba_ManMem(p), sizeof(Cba_Ntk_t) );
     memset( pNtk, 0, sizeof(Cba_Ntk_t) );
     pNtk->pDesign = p;
-    pNtk->pName = Vec_SetStrsav( Cba_ManMem(p), pName );
+    pNtk->pName   = Vec_SetStrsav( Cba_ManMem(p), pName );
     Vec_PtrPush( &p->vNtks, pNtk );
     return pNtk;
 }
-
 static inline Cba_Man_t * Cba_ManAlloc( char * pFileName )
 {
-    Cba_Man_t * p;
-    p = ABC_CALLOC( Cba_Man_t, 1 );
-    // design names
-    p->pName      = Extra_FileDesignName( pFileName );
-    p->pSpec      = Abc_UtilStrsav( pFileName );
-    p->pNames     = Abc_NamStart( 1000, 20 );
-    p->pModels    = Abc_NamStart( 1000, 20 );
-    p->pFuncs     = Abc_NamStart( 1000, 20 );
-    // internal data
+    Cba_Man_t * p = ABC_CALLOC( Cba_Man_t, 1 );
+    p->pName    = Extra_FileDesignName( pFileName );
+    p->pSpec    = Abc_UtilStrsav( pFileName );
+    p->pNames   = Abc_NamStart( 1000, 20 );
+    p->pModels  = Abc_NamStart( 1000, 20 );
+    p->pFuncs   = Abc_NamStart( 1000, 20 );
     Vec_SetAlloc_( &p->Mem, 20 );
     Vec_PtrPush( &p->vNtks, NULL );
     return p;
@@ -204,7 +256,6 @@ static inline void Cba_ManFree( Cba_Man_t * p )
 {
     ABC_FREE( p->vNtks.pArray );
     Vec_SetFree_( &p->Mem );
-    // design names
     Abc_NamStop( p->pNames );
     Abc_NamStop( p->pModels );
     Abc_NamStop( p->pFuncs );
@@ -232,6 +283,10 @@ extern void        Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * pDes );
 extern Cba_Man_t * Cba_PrsReadVerilog( char * pFileName );
 /*=== cbaWriteVer.c =========================================================*/
 extern void        Cba_PrsWriteVerilog( char * pFileName, Cba_Man_t * pDes );
+/*=== cbaNtk.c =========================================================*/
+extern void        Cba_ManAssignInternNames( Cba_Man_t * p );
+/*=== cbaBuild.c =========================================================*/
+extern Cba_Man_t * Cba_ManBuild( Cba_Man_t * p );
 
 
 
diff --git a/src/base/cba/cbaBuild.c b/src/base/cba/cbaBuild.c
index ca805d50..db29cc49 100644
--- a/src/base/cba/cbaBuild.c
+++ b/src/base/cba/cbaBuild.c
@@ -26,44 +26,14 @@ ABC_NAMESPACE_IMPL_START
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
 
-typedef struct Int_Des_t_ Int_Des_t;
-struct Int_Des_t_
-{
-    char *           pName;   // design name
-    Abc_Nam_t *      pNames;  // name manager
-    Vec_Ptr_t        vModels; // models
-};
-typedef struct Int_Obj_t_ Int_Obj_t;
-struct Int_Obj_t_
-{
-    int              iModel;
-    int              iFunc;
-    Vec_Wrd_t        vFanins;
-};
-typedef struct Int_Ntk_t_ Int_Ntk_t;
-struct Int_Ntk_t_
-{
-    int              iName;
-    int              nObjs;
-    Int_Des_t *      pMan;
-    Vec_Ptr_t        vInstances;
-    Vec_Wrd_t        vOutputs;
-    Vec_Int_t        vInputNames;
-    Vec_Int_t        vOutputNames;
-    Vec_Int_t *      vCopies;
-    Vec_Int_t *      vCopies2;
-};
-
-static inline char *      Int_DesName( Int_Des_t * p )       { return p->pName;                                     }
-static inline int         Int_DesNtkNum( Int_Des_t * p )     { return Vec_PtrSize( &p->vModels ) - 1;               }
-static inline Int_Ntk_t * Int_DesNtk( Int_Des_t * p, int i ) { return (Int_Ntk_t *)Vec_PtrEntry( &p->vModels, i );  }
-
-static inline char *      Int_NtkName( Int_Ntk_t * p )       { return Abc_NamStr( p->pMan->pNames, p->iName );      }
-static inline int         Int_NtkPiNum( Int_Ntk_t * p )      { return Vec_IntSize( &p->vInputNames );               }
-static inline int         Int_NtkPoNum( Int_Ntk_t * p )      { return Vec_IntSize( &p->vOutputNames );              }
-
-static inline int         Int_ObjInputNum( Int_Ntk_t * p, Int_Obj_t * pObj )  { return pObj->iModel ? Int_NtkPiNum(Int_DesNtk(p->pMan, pObj->iModel)) : Vec_WrdSize(&pObj->vFanins); }
-static inline int         Int_ObjOutputNum( Int_Ntk_t * p, Int_Obj_t * pObj ) { return pObj->iModel ? Int_NtkPoNum(Int_DesNtk(p->pMan, pObj->iModel)) : 1;                           }
+/*
+    Elaboration input data:
+    Vec_Int_t    vInputs;  // inputs          (used by parser to store signals as NameId)
+    Vec_Int_t    vOutputs; // outputs         (used by parser to store signals as NameId) 
+    Vec_Int_t    vTypes;   // types           (used by parser to store Cba_PrsType_t)
+    Vec_Int_t    vFuncs;   // functions       (used by parser to store function)
+    Vec_Int_t    vFanins;  // fanins          (used by parser to store fanin/fanout signals as NameId)      
+*/
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
@@ -71,73 +41,7 @@ static inline int         Int_ObjOutputNum( Int_Ntk_t * p, Int_Obj_t * pObj ) {
 
 /**Function*************************************************************
 
-  Synopsis    [Transform Ptr into Int.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ptr_ManCheckArray( Vec_Ptr_t * vArray )
-{
-    if ( Vec_PtrSize(vArray) == 0 )
-        return 1;
-    if ( Abc_MaxInt(8, Vec_PtrSize(vArray)) == Vec_PtrCap(vArray) )
-        return 1;
-    assert( 0 );
-    return 0;
-}
-Vec_Int_t * Ptr_ManDumpArrayToInt( Abc_Nam_t * pNames, Vec_Ptr_t * vVec, int fNode )
-{
-    char * pName; int i;
-    Vec_Int_t * vNew = Vec_IntAlloc( Vec_PtrSize(vVec) );
-    Vec_PtrForEachEntry( char *, vVec, pName, i )
-        Vec_IntPush( vNew, (fNode && i == 1) ? Abc_Ptr2Int(pName) : Abc_NamStrFind(pNames, pName) );
-    return vNew;
-}
-Vec_Ptr_t * Ptr_ManDumpArrarArrayToInt( Abc_Nam_t * pNames, Vec_Ptr_t * vNodes, int fNode )
-{
-    Vec_Ptr_t * vNode; int i;
-    Vec_Ptr_t * vNew = Vec_PtrAlloc( Vec_PtrSize(vNodes) );
-    Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
-        Vec_PtrPush( vNew, Ptr_ManDumpArrayToInt(pNames, vNode, fNode) );
-    assert( Ptr_ManCheckArray(vNew) );
-    return vNew;
-}
-Vec_Ptr_t * Ptr_ManDumpNtkToInt( Abc_Nam_t * pNames, Vec_Ptr_t * vNtk, int i )
-{
-    Vec_Ptr_t * vNew   = Vec_PtrAlloc( 5 );
-    assert( Abc_NamStrFind(pNames, (char *)Vec_PtrEntry(vNtk, 0)) == i );
-    Vec_PtrPush( vNew, Abc_Int2Ptr(i) );
-    Vec_PtrPush( vNew, Ptr_ManDumpArrayToInt(pNames, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), 0) );
-    Vec_PtrPush( vNew, Ptr_ManDumpArrayToInt(pNames, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), 0) );
-    Vec_PtrPush( vNew, Ptr_ManDumpArrarArrayToInt(pNames, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3), 1) );
-    Vec_PtrPush( vNew, Ptr_ManDumpArrarArrayToInt(pNames, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4), 0) );
-    assert( Ptr_ManCheckArray(vNew) );
-    return vNew;
-}
-Vec_Ptr_t * Ptr_ManDumpToInt( Vec_Ptr_t * vDes )
-{
-    Vec_Ptr_t * vNew = Vec_PtrAlloc( Vec_PtrSize(vDes) );
-    Vec_Ptr_t * vNtk; int i;
-    // create module names
-    Abc_Nam_t * pNames = Abc_NamStart( 1000, 20 );
-    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
-        Abc_NamStrFind( pNames, (char *)Vec_PtrEntry(vNtk, 0) );
-    assert( i == Abc_NamObjNumMax(pNames) );
-    // create resulting array
-    Vec_PtrPush( vNew, pNames );
-    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
-        Vec_PtrPush( vNew, Ptr_ManDumpNtkToInt(pNames, vNtk, i) );
-    assert( Ptr_ManCheckArray(vNew) );
-    return vNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Transform Ptr into Int.]
+  Synopsis    []
 
   Description []
                
@@ -146,202 +50,249 @@ Vec_Ptr_t * Ptr_ManDumpToInt( Vec_Ptr_t * vDes )
   SeeAlso     []
 
 ***********************************************************************/
-Int_Obj_t * Int_ObjAlloc( int nFanins )
-{
-    Int_Obj_t * p = (Int_Obj_t *)ABC_CALLOC( char, sizeof(Int_Obj_t) + sizeof(word) * nFanins );
-    p->vFanins.pArray = (word *)((char *)p + sizeof(Int_Obj_t));
-    p->vFanins.nCap = nFanins;
-    return p;
-}
-void Int_ObjFree( Int_Obj_t * p )
-{
-    ABC_FREE( p );
-}
-Int_Ntk_t * Int_NtkAlloc( Int_Des_t * pMan, int Id, int nPis, int nPos, int nInsts )
-{
-    Int_Ntk_t * p = ABC_CALLOC( Int_Ntk_t, 1 );
-    p->iName = Id;
-    p->nObjs = nPis + nInsts;
-    p->pMan  = pMan;
-    Vec_PtrGrow( &p->vInstances,   nInsts );
-    Vec_WrdGrow( &p->vOutputs,     nPos );
-    Vec_IntGrow( &p->vInputNames,  nPis );
-    Vec_IntGrow( &p->vOutputNames, nPos );
-    return p;
-}
-void Int_NtkFree( Int_Ntk_t * p )
-{
-    Int_Obj_t * pObj; int i;
-    Vec_PtrForEachEntry( Int_Obj_t *, &p->vInstances, pObj, i )
-        Int_ObjFree( pObj );
-    ABC_FREE( p->vInstances.pArray );
-    ABC_FREE( p->vOutputs.pArray );
-    ABC_FREE( p->vInputNames.pArray );
-    ABC_FREE( p->vOutputNames.pArray );
-    Vec_IntFreeP( &p->vCopies );
-    Vec_IntFreeP( &p->vCopies2 );
-    ABC_FREE( p );
-}
-Int_Des_t * Int_DesAlloc( char * pName, Abc_Nam_t * pNames, int nModels )
+// replaces NameIds of formal names by their index in the box model
+void Cba_RemapBox( Cba_Ntk_t * pNtk, int iBox, Vec_Int_t * vMap )
 {
-    Int_Des_t * p = ABC_CALLOC( Int_Des_t, 1 );
-    p->pName  = pName;
-    p->pNames = pNames;
-    Vec_PtrGrow( &p->vModels, nModels );
-    return p;
-}
-void Int_DesFree( Int_Des_t * p )
-{
-    Int_Ntk_t * pTemp; int i;
-    Vec_PtrForEachEntry( Int_Ntk_t *, &p->vModels, pTemp, i )
-        Int_NtkFree( pTemp );
-    ABC_FREE( p );
-}
-
-// replaces formal inputs by their indixes
-void Ptr_ManFindInputOutputNumbers( Int_Ntk_t * pModel, Vec_Int_t * vBox, Vec_Int_t * vMap ) 
-{
-    int i, iFormal, iName, nPis = Int_NtkPiNum(pModel);
-    Vec_IntForEachEntry( &pModel->vInputNames, iFormal, i )
-        Vec_IntWriteEntry( vMap, iFormal, i );
-    Vec_IntForEachEntry( &pModel->vOutputNames, iFormal, i )
-        Vec_IntWriteEntry( vMap, iFormal, nPis+i );
-    Vec_IntForEachEntryDouble( vBox, iFormal, iName, i )
+    Cba_Ntk_t * pBoxModel = Cba_ObjModel( pNtk, iBox );
+    Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iBox );
+    int i, NameId;
+    // map formal names into I/O indexes
+    Cba_NtkForEachPi( pBoxModel, NameId, i )
     {
-        if ( i == 0 ) continue;
-        assert( Vec_IntEntry(vMap, iFormal) >= 0 );
-        Vec_IntWriteEntry( vBox, i, Vec_IntEntry(vMap, iFormal) );
+        assert( Vec_IntEntry(vMap, NameId) == -1 );
+        Vec_IntWriteEntry( vMap, NameId, i );
     }
-    Vec_IntForEachEntry( &pModel->vInputNames, iFormal, i )
-        Vec_IntWriteEntry( vMap, iFormal, -1 );
-    Vec_IntForEachEntry( &pModel->vOutputNames, iFormal, i )
-        Vec_IntWriteEntry( vMap, iFormal, -1 );
-}
-void Ptr_ManConvertNtk( Int_Ntk_t * pNtk, Vec_Ptr_t * vNtk, Vec_Wrd_t * vMap, Vec_Int_t * vMap2 )
-{
-    Vec_Int_t * vInputs  = (Vec_Int_t *)Vec_PtrEntry(vNtk, 1);
-    Vec_Int_t * vOutputs = (Vec_Int_t *)Vec_PtrEntry(vNtk, 2);
-    Vec_Ptr_t * vNodes   = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3);
-    Vec_Ptr_t * vBoxes   = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
-    Vec_Int_t * vNode, * vBox;
-    Int_Ntk_t * pModel;
-    Int_Obj_t * pObj;
-    int i, k, iFormal, iName, nPis, nOffset, nNonDriven = 0;
-
-    // map primary inputs
-    Vec_IntForEachEntry( vInputs, iName, i )
+    Cba_NtkForEachPo( pBoxModel, NameId, i )
     {
-        assert( ~Vec_WrdEntry(vMap, iName) == 0 ); // driven twice
-        Vec_WrdWriteEntry( vMap, iName, i );
+        assert( Vec_IntEntry(vMap, NameId) == -1 );
+        Vec_IntWriteEntry( vMap, NameId, Cba_NtkPiNum(pBoxModel) + i );
     }
-    // map internal nodes
-    nOffset = Vec_IntSize(vInputs);
-    Vec_PtrForEachEntry( Vec_Int_t *, vNodes, vNode, i )
+    // remap box
+    assert( Vec_IntSize(vFanins) % 2 == 0 );
+    Vec_IntForEachEntry( vFanins, NameId, i )
     {
-        iName = Vec_IntEntry(vNode, 0);
-        assert( ~Vec_WrdEntry(vMap, iName) == 0 ); // driven twice
-        Vec_WrdWriteEntry( vMap, iName, nOffset + i );
+        assert( Vec_IntEntry(vMap, NameId) != -1 );
+        Vec_IntWriteEntry( vFanins, i++, Vec_IntEntry(vMap, NameId) );
     }
-    // map internal boxes
-    nOffset += Vec_PtrSize(vNodes);
-    Vec_PtrForEachEntry( Vec_Int_t *, vBoxes, vBox, i )
+    // unmap formal inputs
+    Cba_NtkForEachPi( pBoxModel, NameId, i )
+        Vec_IntWriteEntry( vMap, NameId, -1 );
+    Cba_NtkForEachPo( pBoxModel, NameId, i )
+        Vec_IntWriteEntry( vMap, NameId, -1 );
+}
+void Cba_RemapBoxes( Cba_Ntk_t * pNtk, Vec_Int_t * vMap )
+{
+    int Type, iBox;
+    Cba_NtkForEachObjType( pNtk, Type, iBox )
+        if ( Type == CBA_OBJ_BOX )
+            Cba_RemapBox( pNtk, iBox, vMap );
+}
+Cba_Ntk_t * Cba_NtkBuild( Cba_Man_t * pNew, Cba_Ntk_t * pNtk, Vec_Int_t * vMap, Vec_Int_t * vBoxes, Vec_Int_t * vTemp )
+{
+    Vec_Int_t * vFanins;
+    Cba_Ntk_t * pNtkNew, * pNtkBox;
+    int i, iObj, ObjId, FaninId, Type, Index, NameId;
+    int nBoxes = 0, nObjCount = 0, NonDriven = 0;
+
+    // map old name IDs into new object IDs
+    Vec_IntClear( vBoxes );
+    Cba_NtkForEachPi( pNtk, NameId, i )
     {
-        // get model name
-        iName = Vec_IntEntry( vBox, 0 );
-        assert( iName >= 1 && iName <= Int_DesNtkNum(pNtk->pMan) ); // bad model name
-        pModel = Int_DesNtk( pNtk->pMan, iName );
-        nPis = Int_NtkPiNum( pModel );
-        // replace inputs/outputs by their IDs
-        Ptr_ManFindInputOutputNumbers( pModel, vBox, vMap2 );
-        // go through outputs of this box
-        Vec_IntForEachEntryDouble( vBox, iFormal, iName, k )
-            if ( k > 0 && i >= nPis )  // output
+        if ( Vec_IntEntry(vMap, NameId) != -1 )
+            printf( "Primary inputs %d and %d have the same name.\n", Vec_IntEntry(vMap, NameId), i );
+        Vec_IntWriteEntry( vMap, NameId, nObjCount++ );
+    }
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
+    {
+        vFanins = Cba_ObjFaninVec( pNtk, iObj );
+        if ( Type == CBA_OBJ_NODE )
+        {
+            // consider node output name
+            NameId = Vec_IntEntry( vFanins, 0 ); 
+            if ( Vec_IntEntry(vMap, NameId) != -1 )
+                printf( "Node output name %d is already driven.\n", NameId );
+            Vec_IntWriteEntry( vMap, NameId, nObjCount++ );
+        }
+        else if ( Type == CBA_OBJ_BOX )
+        {
+            Vec_IntPush( vBoxes, nObjCount++ );
+            pNtkBox = Cba_ObjModel( pNtk, iObj );
+            Vec_IntForEachEntry( vFanins, Index, i )
             {
-                assert( ~Vec_WrdEntry(vMap, iName) == 0 ); // driven twice
-                Vec_WrdWriteEntry( vMap, iName, (nOffset + i) | ((word)iFormal << 32) );
+                i++;
+                if ( Index < Cba_NtkPiNum(pNtkBox) )
+                    continue;
+                // consider box output name
+                NameId = Vec_IntEntry( vFanins, i );
+                if ( Vec_IntEntry(vMap, NameId) != -1 )
+                    printf( "Box output name %d is already driven.\n", NameId );
+                Vec_IntWriteEntry( vMap, NameId, nObjCount + Index - Cba_NtkPiNum(pNtkBox) );
             }
+            nObjCount += Cba_NtkPoNum(pNtkBox);
+        }
     }
 
-    // save input names
-    Vec_IntForEachEntry( vInputs, iName, i )
-        Vec_IntPush( &pNtk->vInputNames, iName );
-    // create nodes with the given connectivity
-    Vec_PtrForEachEntry( Vec_Int_t *, vNodes, vNode, i )
+    // check non-driven nets
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
     {
-        pObj = Int_ObjAlloc( Vec_IntSize(vNode) - 2 );
-        pObj->iFunc = Vec_IntEntry(vNode, 1);
-        Vec_IntForEachEntryStart( vNode, iName, k, 2 )
+        vFanins = Cba_ObjFaninVec( pNtk, iObj );
+        if ( Type == CBA_OBJ_NODE )
         {
-            Vec_WrdPush( &pObj->vFanins, Vec_WrdEntry(vMap, iName) );
-            nNonDriven += (~Vec_WrdEntry(vMap, iName) == 0);
+            // consider node input names
+            Vec_IntForEachEntryStart( vFanins, NameId, i, 1 )
+            {
+                if ( Vec_IntEntry(vMap, NameId) != -1 )
+                    continue;
+                if ( NonDriven++ == 0 ) nObjCount++;
+                Vec_IntWriteEntry( vMap, NameId, nObjCount-1 );
+            }
+        }
+        else if ( Type == CBA_OBJ_BOX )
+        {
+            pNtkBox = Cba_ObjModel( pNtk, iObj );
+            Vec_IntForEachEntry( vFanins, Index, i )
+            {
+                i++;
+                if ( Index >= Cba_NtkPiNum(pNtkBox) )
+                    continue;
+                // consider box input name
+                NameId = Vec_IntEntry( vFanins, i );
+                if ( Vec_IntEntry(vMap, NameId) != -1 )
+                    continue;
+                if ( NonDriven++ == 0 ) nObjCount++;
+                Vec_IntWriteEntry( vMap, NameId, nObjCount-1 );
+            }
         }
-        Vec_PtrPush( &pNtk->vInstances, pObj );
     }
-    // create boxes with the given connectivity
-    Vec_PtrForEachEntry( Vec_Int_t *, vBoxes, vBox, i )
+    Cba_NtkForEachPo( pNtk, NameId, i )
     {
-        pModel = Int_DesNtk( pNtk->pMan, Vec_IntEntry(vBox, 0) );
-        nPis = Int_NtkPiNum( pModel );
-        pObj = Int_ObjAlloc( nPis );
-        Vec_IntForEachEntryDouble( vBox, iFormal, iName, k )
-            if ( k > 0 && iFormal < nPis ) // input
+        if ( Vec_IntEntry(vMap, NameId) != -1 )
+            continue;
+        if ( NonDriven++ == 0 ) nObjCount++;
+        Vec_IntWriteEntry( vMap, NameId, nObjCount-1 );
+    }
+    if ( NonDriven > 0 )
+        printf( "Detected %d non-driven nets.\n", NonDriven );
+    assert( NonDriven == 0 );
+
+    // start network
+    pNtkNew = Cba_NtkAlloc( pNew, Cba_NtkName(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vInputs,  Cba_NtkPiNum(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vOutputs, Cba_NtkPoNum(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vTypes,   nObjCount + Cba_NtkPoNum(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vFuncs,   nObjCount + Cba_NtkPoNum(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vFanins,  nObjCount + Cba_NtkPoNum(pNtk) );
+    Cba_ManFetchArray( pNew, &pNtkNew->vNameIds, nObjCount + Cba_NtkPoNum(pNtk) );
+    Cba_ManSetupArray( pNew, &pNtkNew->vBoxes,   vBoxes );
+
+    // fill object information
+    Cba_NtkForEachPi( pNtk, NameId, i )
+    {
+        ObjId = Vec_IntEntry( vMap, NameId );
+        Vec_IntWriteEntry( &pNtkNew->vInputs, i, ObjId );
+        Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
+    }
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
+    {
+        vFanins = Cba_ObjFaninVec( pNtk, iObj );
+        if ( Type == CBA_OBJ_NODE )
+        {
+            ObjId = Vec_IntEntry( vMap, Vec_IntEntry(vFanins, 0) );
+            Vec_IntClear( vTemp );
+            Vec_IntForEachEntryStart( vFanins, NameId, i, 1 )
+            {
+                assert( Vec_IntEntry(vMap, NameId) != -1 );
+                Vec_IntPush( vTemp, Vec_IntEntry(vMap, NameId) );
+            }
+            Vec_IntWriteEntry( &pNtkNew->vTypes,   ObjId, CBA_OBJ_NODE );
+            Vec_IntWriteEntry( &pNtkNew->vFuncs,   ObjId, Cba_ObjFuncId(pNtk, iObj) );
+            Vec_IntWriteEntry( &pNtkNew->vFanins,  ObjId, Cba_ManHandleArray(pNew, vTemp) );
+            Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, Vec_IntEntry(vFanins, 0) );
+        }
+        else if ( Type == CBA_OBJ_BOX )
+        {
+            ObjId = Vec_IntEntry( vBoxes, nBoxes++ );
+            pNtkBox = Cba_ObjModel( pNtk, iObj );
+            Vec_IntFill( vTemp, Cba_NtkPiNum(pNtkBox), -1 );
+            Vec_IntForEachEntry( vFanins, Index, i )
             {
-                Vec_WrdPush( &pObj->vFanins, Vec_WrdEntry(vMap, iName) );
-                nNonDriven += (~Vec_WrdEntry(vMap, iName) == 0);
+                i++; NameId = Vec_IntEntry( vFanins, i );
+                assert( Vec_IntEntry(vMap, NameId) != -1 );
+                if ( Index < Cba_NtkPiNum(pNtkBox) )
+                    Vec_IntWriteEntry( vTemp, Index, Vec_IntEntry(vMap, NameId) );
+                else
+                    Vec_IntWriteEntry( &pNtkNew->vNameIds, Vec_IntEntry(vMap, NameId), NameId );
             }
-        Vec_PtrPush( &pNtk->vInstances, pObj );
+            Vec_IntForEachEntry( vTemp, Index, i )
+                assert( Index >= 0 );
+            // craete box
+            Vec_IntWriteEntry( &pNtkNew->vTypes,  ObjId, CBA_OBJ_BOX );
+            Vec_IntWriteEntry( &pNtkNew->vFuncs,  ObjId, Cba_ManNtkId(pNew, Cba_NtkName(pNtkBox)) );
+            Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId, Cba_ManHandleArray(pNew, vTemp) );
+            // create box outputs
+            for ( i = 1; i <= Cba_NtkPoNum(pNtkBox); i++ )
+            {
+                Vec_IntWriteEntry( &pNtkNew->vTypes,  ObjId + i, CBA_OBJ_PIN );
+                Vec_IntWriteEntry( &pNtkNew->vFuncs,  ObjId + i, -1 );
+                Vec_IntWriteEntry( &pNtkNew->vFanins, ObjId + i, Cba_ManHandleBuffer(pNew, ObjId) );
+            }
+        }
     }
-    // save output names
-    Vec_IntForEachEntry( vOutputs, iName, i )
+    assert( nBoxes == Vec_IntSize(vBoxes) );
+    Cba_NtkForEachPo( pNtk, NameId, i )
     {
-        Vec_IntPush( &pNtk->vOutputNames, iName );
-        Vec_WrdPush( &pNtk->vOutputs, Vec_WrdEntry(vMap, iName) );
-        nNonDriven += (~Vec_WrdEntry(vMap, iName) == 0);
+        ObjId = nObjCount + i;
+        FaninId = Vec_IntEntry( vMap, NameId );
+        assert( FaninId != -1 );
+        Vec_IntWriteEntry( &pNtkNew->vOutputs, i, ObjId );
+        Vec_IntWriteEntry( &pNtkNew->vTypes,   ObjId, CBA_OBJ_PO );
+        Vec_IntWriteEntry( &pNtkNew->vFuncs,   ObjId, -1 );
+        Vec_IntWriteEntry( &pNtkNew->vFanins,  ObjId, Cba_ManHandleBuffer(pNew, FaninId) );
+        // remove NameId from the driver and assign it to the output
+        Vec_IntWriteEntry( &pNtkNew->vNameIds, FaninId, -1 );
+        Vec_IntWriteEntry( &pNtkNew->vNameIds, ObjId, NameId );
     }
-    if ( nNonDriven )
-        printf( "Model %s has %d non-driven nets.\n", Int_NtkName(pNtk), nNonDriven );
-}
-Int_Ntk_t * Ptr_ManConvertNtkInter( Int_Des_t * pDes, Vec_Ptr_t * vNtk, int Id )
-{
-    Vec_Int_t * vInputs  = (Vec_Int_t *)Vec_PtrEntry(vNtk, 1);
-    Vec_Int_t * vOutputs = (Vec_Int_t *)Vec_PtrEntry(vNtk, 2);
-    Vec_Ptr_t * vNodes   = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3);
-    Vec_Ptr_t * vBoxes   = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
-    return Int_NtkAlloc( pDes, Id, Vec_IntSize(vInputs), Vec_IntSize(vOutputs), Vec_PtrSize(vNodes) + Vec_PtrSize(vBoxes) );
+
+    // clean map
+    Cba_NtkForEachPi( pNtk, NameId, i )
+        Vec_IntWriteEntry( vMap, NameId, -1 );
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
+    {
+        vFanins = Cba_ObjFaninVec( pNtk, iObj );
+        if ( Type == CBA_OBJ_NODE )
+        {
+            Vec_IntForEachEntry( vFanins, NameId, i )
+                Vec_IntWriteEntry( vMap, NameId, -1 );
+        }
+        else if ( Type == CBA_OBJ_BOX )
+        {
+            Vec_IntForEachEntry( vFanins, Index, i )
+                Vec_IntWriteEntry( vMap, Vec_IntEntry(vFanins, ++i), -1 );
+        }
+    }
+    Cba_NtkForEachPo( pNtk, NameId, i )
+        Vec_IntWriteEntry( vMap, NameId, -1 );
+    return pNtkNew;
 }
-Int_Des_t * Ptr_ManConvert( Vec_Ptr_t * vDesPtr )
+Cba_Man_t * Cba_ManBuild( Cba_Man_t * p )
 {
-    Vec_Ptr_t * vNtk; int i;
-    char * pName = (char *)Vec_PtrEntry(vDesPtr, 0);
-    Vec_Ptr_t * vDes = Ptr_ManDumpToInt( vDesPtr );
-    Abc_Nam_t * pNames = (Abc_Nam_t *)Vec_PtrEntry(vDes, 0);
-    Vec_Wrd_t * vMap = Vec_WrdStartFull( Abc_NamObjNumMax(pNames) + 1 );
-    Vec_Int_t * vMap2 = Vec_IntStartFull( Abc_NamObjNumMax(pNames) + 1 );
-    Int_Des_t * pDes = Int_DesAlloc( pName, pNames, Vec_PtrSize(vDes)-1 );
-    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
-        Vec_PtrPush( &pDes->vModels, Ptr_ManConvertNtkInter(pDes, vNtk, i) );
-    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
-        Ptr_ManConvertNtk( Int_DesNtk(pDes, i), vNtk, vMap, vMap2 );
-//    Ptr_ManFreeDes( vDes );
-    Vec_IntFree( vMap2 );
-    Vec_WrdFree( vMap );
-    return pDes;
+    Cba_Man_t * pNew   = Cba_ManAlloc( Cba_ManName(p) );
+    Vec_Int_t * vMap   = Vec_IntStartFull( Abc_NamObjNumMax(p->pNames) + 1 );
+    Vec_Int_t * vBoxes = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vTemp  = Vec_IntAlloc( 1000 );
+    Cba_Ntk_t * pNtk; int i;
+    Cba_ManForEachNtk( p, pNtk, i )
+        Abc_NamStrFindOrAdd( p->pModels, Cba_NtkName(pNtk), NULL );
+    assert( Abc_NamObjNumMax(p->pModels) == Cba_ManNtkNum(p) + 1 );
+    Cba_RemapBoxes( pNtk, vMap );
+    Cba_ManForEachNtk( p, pNtk, i )
+        Cba_NtkBuild( p, pNtk, vMap, vBoxes, vTemp );
+    Vec_IntFree( vTemp );
+    Vec_IntFree( vBoxes );
+    Vec_IntFree( vMap );
+    return pNew;
 }
 
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-
-
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/base/cba/cbaNtk.c b/src/base/cba/cbaNtk.c
index 253c0cda..c0c63bec 100644
--- a/src/base/cba/cbaNtk.c
+++ b/src/base/cba/cbaNtk.c
@@ -41,7 +41,27 @@ ABC_NAMESPACE_IMPL_START
   SeeAlso     []
 
 ***********************************************************************/
-
+void Cba_ManAssignInternNamesNtk( Cba_Ntk_t * p )
+{
+    int i, Type, NameId;
+    int nDigits = Abc_Base10Log( Cba_NtkObjNum(p) );
+    Cba_NtkForEachObjType( p, Type, i )
+    {
+        if ( Type == CBA_OBJ_NODE || Type == CBA_OBJ_PIN )
+        {
+            char Buffer[100];
+            sprintf( Buffer, "%s%0*d", "_n_", nDigits, i );
+            NameId = Abc_NamStrFindOrAdd( p->pDesign->pNames, Buffer, NULL );
+            Vec_IntWriteEntry( &p->vNameIds, i, NameId );
+        }
+    }
+}
+void Cba_ManAssignInternNames( Cba_Man_t * p )
+{
+    Cba_Ntk_t * pNtk; int i;
+    Cba_ManForEachNtk( p, pNtk, i )
+        Cba_ManAssignInternNamesNtk( pNtk );
+}
 
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
diff --git a/src/base/cba/cbaPrs.h b/src/base/cba/cbaPrs.h
index 17346dcf..76745d8c 100644
--- a/src/base/cba/cbaPrs.h
+++ b/src/base/cba/cbaPrs.h
@@ -111,38 +111,19 @@ static inline int Cba_PrsErrorPrint( Cba_Prs_t * p )
     return 0;
 }
 
-
-// copy contents to the vector
-static inline int Cba_PrsSetupDataInt( Cba_Prs_t * p, Vec_Int_t * vFrom )
-{
-    int h = Vec_SetFetchH( Cba_ManMem(p->pDesign), sizeof(int) * (Vec_IntSize(vFrom) + 1) );
-    int * pArray = (int *)Vec_SetEntry( Cba_ManMem(p->pDesign), h );
-    pArray[0] = Vec_IntSize(vFrom);
-    memcpy( pArray+1, Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) );
-    Vec_IntClear( vFrom );
-    return h;
-}
-static inline void Cba_PrsSetupVecInt( Cba_Prs_t * p, Vec_Int_t * vTo, Vec_Int_t * vFrom )
-{
-    if ( Vec_IntSize(vFrom) == 0 )
-        return;
-    vTo->nSize = vTo->nCap = Vec_IntSize(vFrom);
-    vTo->pArray = (int *)Vec_SetFetch( Cba_ManMem(p->pDesign), sizeof(int) * Vec_IntSize(vFrom) );
-    memcpy( Vec_IntArray(vTo), Vec_IntArray(vFrom), sizeof(int) * Vec_IntSize(vFrom) );
-    Vec_IntClear( vFrom );
-}
+// create network
 static inline Cba_Ntk_t * Cba_PrsAddCurrentModel( Cba_Prs_t * p, int iNameId )
 {
     Cba_Ntk_t * pNtk = Cba_NtkAlloc( p->pDesign, Abc_NamStr(p->pDesign->pNames, iNameId) );
     assert( Vec_IntSize(&p->vInputsCur) != 0 || Vec_IntSize(&p->vOutputsCur) != 0 );
-    Cba_PrsSetupVecInt( p, &pNtk->vInouts,  &p->vInoutsCur  );
-    Cba_PrsSetupVecInt( p, &pNtk->vInputs,  &p->vInputsCur  );
-    Cba_PrsSetupVecInt( p, &pNtk->vOutputs, &p->vOutputsCur );
-    Cba_PrsSetupVecInt( p, &pNtk->vWires,   &p->vWiresCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vTypes,   &p->vTypesCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vFuncs,   &p->vFuncsCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vInstIds, &p->vInstIdsCur );
-    Cba_PrsSetupVecInt( p, &pNtk->vFanins,  &p->vFaninsCur  );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vInouts,  &p->vInoutsCur  );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vInputs,  &p->vInputsCur  );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vOutputs, &p->vOutputsCur );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vWires,   &p->vWiresCur   );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vTypes,   &p->vTypesCur   );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vFuncs,   &p->vFuncsCur   );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vInstIds, &p->vInstIdsCur );
+    Cba_ManSetupArray( p->pDesign, &pNtk->vFanins,  &p->vFaninsCur  );
     return pNtk;
 }
 
diff --git a/src/base/cba/cbaReadBlif.c b/src/base/cba/cbaReadBlif.c
index fc32a614..88440aca 100644
--- a/src/base/cba/cbaReadBlif.c
+++ b/src/base/cba/cbaReadBlif.c
@@ -267,7 +267,7 @@ static inline int Cba_PrsReadNode( Cba_Prs_t * p )
     // save results
     Vec_IntPush( &p->vTypesCur, CBA_PRS_NODE );
     Vec_IntPush( &p->vFuncsCur, 1 ); // default const 0 function
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 0;
 }
 static inline int Cba_PrsReadBox( Cba_Prs_t * p, int fGate )
@@ -278,7 +278,7 @@ static inline int Cba_PrsReadBox( Cba_Prs_t * p, int fGate )
     // save results
     Vec_IntPush( &p->vTypesCur, CBA_PRS_BOX );
     Vec_IntPush( &p->vFuncsCur, iToken );
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 0;
 }
 static inline int Cba_PrsReadLatch( Cba_Prs_t * p )
@@ -301,7 +301,7 @@ static inline int Cba_PrsReadLatch( Cba_Prs_t * p )
     // save results
     Vec_IntPush( &p->vTypesCur, CBA_PRS_LATCH );
     Vec_IntPush( &p->vFuncsCur, iToken );
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 0;
 }
 static inline int Cba_PrsReadShort( Cba_Prs_t * p )
@@ -318,7 +318,7 @@ static inline int Cba_PrsReadShort( Cba_Prs_t * p )
     // save results
     Vec_IntPush( &p->vTypesCur, CBA_PRS_NODE );
     Vec_IntPush( &p->vFuncsCur, 2 );   // default buffer function
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 0;
 }
 static inline int Cba_PrsReadModel( Cba_Prs_t * p )
diff --git a/src/base/cba/cbaReadVer.c b/src/base/cba/cbaReadVer.c
index 473de32e..b5ff9ea4 100644
--- a/src/base/cba/cbaReadVer.c
+++ b/src/base/cba/cbaReadVer.c
@@ -370,7 +370,7 @@ static inline int Cba_PrsReadConcat( Cba_Prs_t * p, Vec_Int_t * vTemp2 )
     Vec_IntPush( &p->vTypesCur, CBA_PRS_CONCAT );
     Vec_IntPush( &p->vFuncsCur, 0 );
     Vec_IntPush( &p->vInstIdsCur, 0 );
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, vTemp2) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, vTemp2) ); 
     return Vec_IntSize(&p->vFaninsCur);
 }
 static inline int Cba_PrsReadSignalOrConcat( Cba_Prs_t * p, int * pName, int * pRange )
@@ -500,7 +500,7 @@ static inline int Cba_PrsReadAssign( Cba_Prs_t * p )
         Vec_IntPush( &p->vTypesCur, CBA_PRS_NODE );
         Vec_IntPush( &p->vFuncsCur, fCompl ? CBA_NODE_INV : CBA_NODE_BUF );
         Vec_IntPush( &p->vInstIdsCur, 0 );
-        Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+        Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
         return 1;
     }
     if ( Cba_PrsIsChar(p, '&') ) 
@@ -535,7 +535,7 @@ static inline int Cba_PrsReadAssign( Cba_Prs_t * p )
     Vec_IntPush( &p->vTypesCur, CBA_PRS_NODE );
     Vec_IntPush( &p->vFuncsCur, Oper );
     Vec_IntPush( &p->vInstIdsCur, 0 );
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 1;
 }
 static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
@@ -565,7 +565,7 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
     Vec_IntPush( &p->vTypesCur, Type );
     Vec_IntPush( &p->vFuncsCur, Func );
     Vec_IntPush( &p->vInstIdsCur, InstId );
-    Vec_IntPush( &p->vFaninsCur, Cba_PrsSetupDataInt(p, &p->vTemp) ); 
+    Vec_IntPush( &p->vFaninsCur, Cba_ManHandleArray(p->pDesign, &p->vTemp) ); 
     return 1;
 }
 
diff --git a/src/base/cba/cbaSimple.c b/src/base/cba/cbaSimple.c
index 628c205d..a58b8d9b 100644
--- a/src/base/cba/cbaSimple.c
+++ b/src/base/cba/cbaSimple.c
@@ -19,6 +19,7 @@
 ***********************************************************************/
 
 #include "cba.h"
+#include "cbaPrs.h"
 #include "base/abc/abc.h"
 
 ABC_NAMESPACE_IMPL_START
@@ -144,18 +145,18 @@ Ptr_ObjType_t Ptr_HopToType( Abc_Obj_t * pObj )
   SeeAlso     []
 
 ***********************************************************************/
-static inline char * Ptr_ObjName( Abc_Obj_t * pObj )
+char * Ptr_AbcObjName( Abc_Obj_t * pObj )
 {
     if ( Abc_ObjIsNet(pObj) || Abc_ObjIsBox(pObj) )
         return Abc_ObjName(pObj);
     if ( Abc_ObjIsCi(pObj) || Abc_ObjIsNode(pObj) )
-        return Ptr_ObjName(Abc_ObjFanout0(pObj));
+        return Ptr_AbcObjName(Abc_ObjFanout0(pObj));
     if ( Abc_ObjIsCo(pObj) )
-        return Ptr_ObjName(Abc_ObjFanin0(pObj));
+        return Ptr_AbcObjName(Abc_ObjFanin0(pObj));
     assert( 0 );
     return NULL;
 }
-static int Ptr_ManCheckArray( Vec_Ptr_t * vArray )
+static int Ptr_CheckArray( Vec_Ptr_t * vArray )
 {
     if ( Vec_PtrSize(vArray) == 0 )
         return 1;
@@ -164,97 +165,97 @@ static int Ptr_ManCheckArray( Vec_Ptr_t * vArray )
     assert( 0 );
     return 0;
 }
-Vec_Ptr_t * Ptr_ManDeriveNode( Abc_Obj_t * pObj )
+Vec_Ptr_t * Ptr_AbcDeriveNode( Abc_Obj_t * pObj )
 {
     Abc_Obj_t * pFanin; int i;
     Vec_Ptr_t * vNode = Vec_PtrAlloc( 2 + Abc_ObjFaninNum(pObj) );
     assert( Abc_ObjIsNode(pObj) );
-    Vec_PtrPush( vNode, Ptr_ObjName(pObj) );
+    Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
     Vec_PtrPush( vNode, Abc_Int2Ptr(Ptr_HopToType(pObj)) );
     Abc_ObjForEachFanin( pObj, pFanin, i )
-        Vec_PtrPush( vNode, Ptr_ObjName(pFanin) );
-    assert( Ptr_ManCheckArray(vNode) );
+        Vec_PtrPush( vNode, Ptr_AbcObjName(pFanin) );
+    assert( Ptr_CheckArray(vNode) );
     return vNode;
 }
-Vec_Ptr_t * Ptr_ManDeriveNodes( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveNodes( Abc_Ntk_t * pNtk )
 {
     Abc_Obj_t * pObj; int i;
     Vec_Ptr_t * vNodes = Vec_PtrAlloc( Abc_NtkNodeNum(pNtk) );
     Abc_NtkForEachNode( pNtk, pObj, i )
-        Vec_PtrPush( vNodes, Ptr_ManDeriveNode(pObj) );
-    assert( Ptr_ManCheckArray(vNodes) );
+        Vec_PtrPush( vNodes, Ptr_AbcDeriveNode(pObj) );
+    assert( Ptr_CheckArray(vNodes) );
     return vNodes;
 }
 
-Vec_Ptr_t * Ptr_ManDeriveBox( Abc_Obj_t * pObj )
+Vec_Ptr_t * Ptr_AbcDeriveBox( Abc_Obj_t * pObj )
 {
     Abc_Obj_t * pNext; int i;
     Abc_Ntk_t * pModel = Abc_ObjModel(pObj);
     Vec_Ptr_t * vBox = Vec_PtrAlloc( 2 + 2 * Abc_ObjFaninNum(pObj) + 2 * Abc_ObjFanoutNum(pObj) );
     assert( Abc_ObjIsBox(pObj) );
     Vec_PtrPush( vBox, Abc_NtkName(pModel) );
-    Vec_PtrPush( vBox, Ptr_ObjName(pObj) );
+    Vec_PtrPush( vBox, Ptr_AbcObjName(pObj) );
     Abc_ObjForEachFanin( pObj, pNext, i )
     {
-        Vec_PtrPush( vBox, Ptr_ObjName(Abc_NtkPi(pModel, i)) );
-        Vec_PtrPush( vBox, Ptr_ObjName(pNext) );
+        Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPi(pModel, i)) );
+        Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
     }
     Abc_ObjForEachFanout( pObj, pNext, i )
     {
-        Vec_PtrPush( vBox, Ptr_ObjName(Abc_NtkPo(pModel, i)) );
-        Vec_PtrPush( vBox, Ptr_ObjName(pNext) );
+        Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPo(pModel, i)) );
+        Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
     }
-    assert( Ptr_ManCheckArray(vBox) );
+    assert( Ptr_CheckArray(vBox) );
     return vBox;
 }
-Vec_Ptr_t * Ptr_ManDeriveBoxes( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveBoxes( Abc_Ntk_t * pNtk )
 {
     Abc_Obj_t * pObj; int i;
     Vec_Ptr_t * vBoxes = Vec_PtrAlloc( Abc_NtkBoxNum(pNtk) );
     Abc_NtkForEachBox( pNtk, pObj, i )
-        Vec_PtrPush( vBoxes, Ptr_ManDeriveBox(pObj) );
-    assert( Ptr_ManCheckArray(vBoxes) );
+        Vec_PtrPush( vBoxes, Ptr_AbcDeriveBox(pObj) );
+    assert( Ptr_CheckArray(vBoxes) );
     return vBoxes;
 }
 
-Vec_Ptr_t * Ptr_ManDeriveInputs( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveInputs( Abc_Ntk_t * pNtk )
 {
     Abc_Obj_t * pObj; int i;
     Vec_Ptr_t * vSigs = Vec_PtrAlloc( Abc_NtkPiNum(pNtk) );
     Abc_NtkForEachPi( pNtk, pObj, i )
-        Vec_PtrPush( vSigs, Ptr_ObjName(pObj) );
-    assert( Ptr_ManCheckArray(vSigs) );
+        Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
+    assert( Ptr_CheckArray(vSigs) );
     return vSigs;
 }
-Vec_Ptr_t * Ptr_ManDeriveOutputs( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveOutputs( Abc_Ntk_t * pNtk )
 {
     Abc_Obj_t * pObj; int i;
     Vec_Ptr_t * vSigs = Vec_PtrAlloc( Abc_NtkPoNum(pNtk) );
     Abc_NtkForEachPo( pNtk, pObj, i )
-        Vec_PtrPush( vSigs, Ptr_ObjName(pObj) );
-    assert( Ptr_ManCheckArray(vSigs) );
+        Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
+    assert( Ptr_CheckArray(vSigs) );
     return vSigs;
 }
-Vec_Ptr_t * Ptr_ManDeriveNtk( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveNtk( Abc_Ntk_t * pNtk )
 {
     Vec_Ptr_t * vNtk = Vec_PtrAlloc( 5 );
     Vec_PtrPush( vNtk, Abc_NtkName(pNtk) );
-    Vec_PtrPush( vNtk, Ptr_ManDeriveInputs(pNtk) );
-    Vec_PtrPush( vNtk, Ptr_ManDeriveOutputs(pNtk) );
-    Vec_PtrPush( vNtk, Ptr_ManDeriveNodes(pNtk) );
-    Vec_PtrPush( vNtk, Ptr_ManDeriveBoxes(pNtk) );
-    assert( Ptr_ManCheckArray(vNtk) );
+    Vec_PtrPush( vNtk, Ptr_AbcDeriveInputs(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_AbcDeriveOutputs(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_AbcDeriveNodes(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_AbcDeriveBoxes(pNtk) );
+    assert( Ptr_CheckArray(vNtk) );
     return vNtk;
 }
-Vec_Ptr_t * Ptr_ManDeriveDes( Abc_Ntk_t * pNtk )
+Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk )
 {
     Vec_Ptr_t * vDes;
     Abc_Ntk_t * pTemp; int i;
     vDes = Vec_PtrAlloc( 1 + Vec_PtrSize(pNtk->pDesign->vModules) );
     Vec_PtrPush( vDes, pNtk->pDesign->pName );
     Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
-        Vec_PtrPush( vDes, Ptr_ManDeriveNtk(pTemp) );
-    assert( Ptr_ManCheckArray(vDes) );
+        Vec_PtrPush( vDes, Ptr_AbcDeriveNtk(pTemp) );
+    assert( Ptr_CheckArray(vDes) );
     return vDes;
 }
 
@@ -500,7 +501,7 @@ void Ptr_ManExperiment( Abc_Ntk_t * pNtk )
 {
     abctime clk = Abc_Clock();
     char * pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out.blif");
-    Vec_Ptr_t * vDes = Ptr_ManDeriveDes( pNtk );
+    Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
     printf( "Converting to Ptr:  Memory = %6.3f MB  ", 1.0*Ptr_ManMemDes(vDes)/(1<<20) );
     Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
     Ptr_ManDumpBlif( pFileName, vDes );
@@ -511,6 +512,238 @@ void Ptr_ManExperiment( Abc_Ntk_t * pNtk )
 
 
 
+/**Function*************************************************************
+
+  Synopsis    [Dumping hierarchical Cba_Ntk_t in Ptr form.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Ptr_t * Ptr_CbaDeriveNode( Cba_Ntk_t * pNtk, int iObj )
+{
+    Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
+    Vec_Ptr_t * vNode = Vec_PtrAlloc( 2 + Vec_IntSize(vFanins) );
+    int i, iFanin;
+    assert( Cba_ObjIsNode(pNtk, iObj) );
+    Vec_PtrPush( vNode, Cba_ObjNameStr(pNtk, iObj) );
+    if ( Abc_NamObjNumMax(pNtk->pDesign->pFuncs) > 1 )
+        Vec_PtrPush( vNode, Cba_NtkFuncStr( pNtk, Cba_ObjFuncId(pNtk, iObj) ) );
+    else
+        Vec_PtrPush( vNode, Abc_Int2Ptr(Cba_ObjFuncId(pNtk, iObj)) );
+    Vec_IntForEachEntry( vFanins, iFanin, i )
+        Vec_PtrPush( vNode, Cba_ObjNameStr(pNtk, iFanin) );
+    assert( Ptr_CheckArray(vNode) );
+    return vNode;
+}
+Vec_Ptr_t * Ptr_CbaDeriveNodes( Cba_Ntk_t * pNtk )
+{
+    int Type, iObj;
+    Vec_Ptr_t * vNodes = Vec_PtrAlloc( Cba_NtkNodeNum(pNtk) );
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
+        if ( Type == CBA_PRS_NODE )
+            Vec_PtrPush( vNodes, Ptr_CbaDeriveNode(pNtk, iObj) );
+    assert( Ptr_CheckArray(vNodes) );
+    return vNodes;
+}
+
+Vec_Ptr_t * Ptr_CbaDeriveBox( Cba_Ntk_t * pNtk, int iObj )
+{
+    int i, iTerm;
+    Vec_Int_t * vFanins = Cba_ObjFaninVec( pNtk, iObj );
+    Cba_Ntk_t * pModel = Cba_ObjModel( pNtk, iObj );
+    Vec_Ptr_t * vBox = Vec_PtrAlloc( 2 + Cba_NtkPiNum(pModel) + Cba_NtkPoNum(pModel) );
+    assert( Cba_ObjIsBox(pNtk, iObj) );
+    assert( Cba_NtkPiNum(pModel) == Vec_IntSize(vFanins) );
+    Vec_PtrPush( vBox, Cba_NtkName(pModel) );
+    Vec_PtrPush( vBox, Vec_IntSize(&pNtk->vInstIds) ? Cba_ObjInstStr(pNtk, iObj) : NULL );
+    Cba_NtkForEachPi( pModel, iTerm, i )
+    {
+        Vec_PtrPush( vBox, Cba_ObjNameStr(pModel, iTerm) );
+        Vec_PtrPush( vBox, Cba_ObjNameStr(pNtk, Vec_IntEntry(vFanins, i)) );
+    }
+    Cba_NtkForEachPo( pModel, iTerm, i )
+    {
+        Vec_PtrPush( vBox, Cba_ObjNameStr(pModel, iTerm) );
+        Vec_PtrPush( vBox, Cba_ObjNameStr(pNtk, iObj+1+i) );
+    }
+    assert( Ptr_CheckArray(vBox) );
+    return vBox;
+}
+Vec_Ptr_t * Ptr_CbaDeriveBoxes( Cba_Ntk_t * pNtk )
+{
+    int Type, iObj;
+    Vec_Ptr_t * vBoxes = Vec_PtrAlloc( Cba_NtkBoxNum(pNtk) );
+    Cba_NtkForEachObjType( pNtk, Type, iObj )
+        if ( Type == CBA_PRS_BOX )
+            Vec_PtrPush( vBoxes, Ptr_CbaDeriveBox(pNtk, iObj) );
+    assert( Ptr_CheckArray(vBoxes) );
+    return vBoxes;
+}
+
+Vec_Ptr_t * Ptr_CbaDeriveInputs( Cba_Ntk_t * pNtk )
+{
+    int i, iObj;
+    Vec_Ptr_t * vSigs = Vec_PtrAlloc( Cba_NtkPiNum(pNtk) );
+    Cba_NtkForEachPi( pNtk, iObj, i )
+        Vec_PtrPush( vSigs, Cba_ObjNameStr(pNtk, iObj) );
+    assert( Ptr_CheckArray(vSigs) );
+    return vSigs;
+}
+Vec_Ptr_t * Ptr_CbaDeriveOutputs( Cba_Ntk_t * pNtk )
+{
+    int i, iObj;
+    Vec_Ptr_t * vSigs = Vec_PtrAlloc( Cba_NtkPoNum(pNtk) );
+    Cba_NtkForEachPo( pNtk, iObj, i )
+        Vec_PtrPush( vSigs, Cba_ObjNameStr(pNtk, iObj) );
+    assert( Ptr_CheckArray(vSigs) );
+    return vSigs;
+}
+Vec_Ptr_t * Ptr_CbaDeriveNtk( Cba_Ntk_t * pNtk )
+{
+    Vec_Ptr_t * vNtk = Vec_PtrAlloc( 5 );
+    Vec_PtrPush( vNtk, Cba_NtkName(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_CbaDeriveInputs(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_CbaDeriveOutputs(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_CbaDeriveNodes(pNtk) );
+    Vec_PtrPush( vNtk, Ptr_CbaDeriveBoxes(pNtk) );
+    assert( Ptr_CheckArray(vNtk) );
+    return vNtk;
+}
+Vec_Ptr_t * Ptr_CbaDeriveDes( Cba_Man_t * p )
+{
+    Vec_Ptr_t * vDes;
+    Cba_Ntk_t * pTemp; int i;
+    vDes = Vec_PtrAlloc( 1 + Cba_ManNtkNum(p) );
+    Vec_PtrPush( vDes, p->pName );
+    Cba_ManForEachNtk( p, pTemp, i )
+        Vec_PtrPush( vDes, Ptr_CbaDeriveNtk(pTemp) );
+    assert( Ptr_CheckArray(vDes) );
+    return vDes;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+Vec_Int_t * Cba_PrsReadList( Cba_Man_t * p, Vec_Ptr_t * vNames, Vec_Int_t * vList, int nSkip, int nSkip2 )
+{
+    char * pName; int i;
+    Vec_IntClear( vList );
+    Vec_PtrForEachEntry( char *, vNames, pName, i )
+        if ( i != nSkip && i != nSkip2 )
+            Vec_IntPush( vList, Abc_NamStrFindOrAdd(p->pNames, pName, NULL) );
+    return vList;
+}
+void Cba_PrsReadNodes( Cba_Man_t * p, Vec_Ptr_t * vNodes, Vec_Int_t * vTypesCur, Vec_Int_t * vFuncsCur, Vec_Int_t * vInstIdsCur, Vec_Int_t * vFaninsCur, Vec_Int_t * vList )
+{
+    Vec_Ptr_t * vNode; int i;
+    Vec_PtrForEachEntry( Vec_Ptr_t *, vNodes, vNode, i )
+    {
+        Vec_IntPush( vTypesCur,   CBA_PRS_NODE );
+        Vec_IntPush( vFuncsCur,   (Ptr_ObjType_t)Abc_Ptr2Int(Vec_PtrEntry(vNode, 1)) );
+        Vec_IntPush( vInstIdsCur, 0 );
+        Vec_IntPush( vFaninsCur,  Cba_ManHandleArray(p, Cba_PrsReadList(p, vNode, vList, 1, -1)) ); 
+    }
+}
+void Cba_PrsReadBoxes( Cba_Man_t * p, Vec_Ptr_t * vBoxes, Vec_Int_t * vTypesCur, Vec_Int_t * vFuncsCur, Vec_Int_t * vInstIdsCur, Vec_Int_t * vFaninsCur, Vec_Int_t * vList )
+{
+    Vec_Ptr_t * vBox; int i;
+    Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
+    {
+        Vec_IntPush( vTypesCur,   CBA_PRS_BOX );
+        Vec_IntPush( vFuncsCur,   Abc_NamStrFindOrAdd(p->pNames, Vec_PtrEntry(vBox, 0), NULL) );
+        Vec_IntPush( vInstIdsCur, Abc_NamStrFindOrAdd(p->pNames, Vec_PtrEntry(vBox, 1), NULL) );
+        Vec_IntPush( vFaninsCur,  Cba_ManHandleArray(p, Cba_PrsReadList(p, vBox, vList, 0, 1)) ); 
+    }
+}
+void Cba_PrsReadModule( Cba_Man_t * p, Vec_Ptr_t * vNtk )   
+{
+    Vec_Int_t * vInputsCur  = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vOutputsCur = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vTypesCur   = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vFuncsCur   = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vInstIdsCur = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vFaninsCur  = Vec_IntAlloc( 1000 );
+    Vec_Int_t * vList       = Vec_IntAlloc( 1000 );
+
+    Cba_Ntk_t * pNtk = Cba_NtkAlloc( p, (char *)Vec_PtrEntry(vNtk, 0) );
+    Cba_PrsReadList( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1), vInputsCur,  -1, -1 );
+    Cba_PrsReadList( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2), vOutputsCur, -1, -1 );
+    Cba_PrsReadNodes( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3), vTypesCur, vFuncsCur, vInstIdsCur, vFaninsCur, vList );
+    Cba_PrsReadBoxes( p, (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4), vTypesCur, vFuncsCur, vInstIdsCur, vFaninsCur, vList );
+
+    Cba_ManSetupArray( p, &pNtk->vInputs,  vInputsCur  );
+    Cba_ManSetupArray( p, &pNtk->vOutputs, vOutputsCur );
+    Cba_ManSetupArray( p, &pNtk->vTypes,   vTypesCur   );
+    Cba_ManSetupArray( p, &pNtk->vFuncs,   vFuncsCur   );
+    Cba_ManSetupArray( p, &pNtk->vInstIds, vInstIdsCur );
+    Cba_ManSetupArray( p, &pNtk->vFanins,  vFaninsCur  );
+
+    Vec_IntFree( vInputsCur );
+    Vec_IntFree( vOutputsCur );
+    Vec_IntFree( vTypesCur );
+    Vec_IntFree( vFuncsCur );
+    Vec_IntFree( vInstIdsCur );
+    Vec_IntFree( vFaninsCur );
+    Vec_IntFree( vList );
+}
+Cba_Man_t * Cba_PrsReadDes( Vec_Ptr_t * vDes )
+{
+    Vec_Ptr_t * vNtk; int i;
+    Cba_Man_t * p = Cba_ManAlloc( (char *)Vec_PtrEntry(vDes, 0) );
+    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vDes, vNtk, i, 1 )
+        Cba_PrsReadModule( p, vNtk );
+    return p;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Cba_ManReadDesExperiment( Abc_Ntk_t * pNtk )
+{
+    abctime clk = Abc_Clock();
+    char * pFileName1 = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out1.blif");
+    char * pFileName2 = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out2.blif");
+    Cba_Man_t * p;
+
+    Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
+    printf( "Converting to Ptr:  Memory = %6.3f MB  ", 1.0*Ptr_ManMemDes(vDes)/(1<<20) );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+
+    Ptr_ManDumpBlif( pFileName1, vDes );
+    printf( "Finished writing output file \"%s\".  ", pFileName1 );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+    
+    p = Cba_PrsReadDes( vDes );
+    Ptr_ManFreeDes( vDes );
+
+    //    Abc_NamPrint( p->pDesign->pNames );
+    Cba_PrsWriteBlif( pFileName2, p );
+    Cba_ManFree( p );
+    printf( "Finished writing output file \"%s\".  ", pFileName2 );
+    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
+}
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/base/cba/cbaWriteBlif.c b/src/base/cba/cbaWriteBlif.c
index 5ef31ac3..ef6b31fc 100644
--- a/src/base/cba/cbaWriteBlif.c
+++ b/src/base/cba/cbaWriteBlif.c
@@ -121,7 +121,7 @@ void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * pDes )
 
 /**Function*************************************************************
 
-  Synopsis    []
+  Synopsis    [Write elaborated design.]
 
   Description []
                
@@ -130,6 +130,87 @@ void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * pDes )
   SeeAlso     []
 
 ***********************************************************************/
+void Cba_ManWriteBlifArray( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins, int iObj )
+{
+    int iFanin, i;
+    Vec_IntForEachEntry( vFanins, iFanin, i )
+        fprintf( pFile, " %s", Cba_ObjNameStr(p, iFanin) );
+    if ( iObj >= 0 )
+        fprintf( pFile, " %s", Cba_ObjNameStr(p, iObj) );
+    fprintf( pFile, "\n" );
+}
+void Cba_ManWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, int iObj )
+{
+    int iTerm, i;
+    Vec_Int_t * vFanins = Cba_ObjFaninVec( p, iObj );
+    Cba_Ntk_t * pModel = Cba_ObjModel( p, iObj );
+    Cba_NtkForEachPi( pModel, iTerm, i )
+        fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, Vec_IntEntry(vFanins, i)) );
+    Cba_NtkForEachPo( pModel, iTerm, i )
+        fprintf( pFile, " %s=%s", Cba_ObjNameStr(pModel, iTerm), Cba_ObjNameStr(p, iObj + 1 + i) );
+    fprintf( pFile, "\n" );
+}
+void Cba_ManWriteBlifLines( FILE * pFile, Cba_Ntk_t * p )
+{
+    int Type, i;
+    Cba_NtkForEachObjType( p, Type, i )
+    {
+        if ( Type == CBA_OBJ_NODE ) // .names/assign/box2 (no formal/actual binding)
+        {
+            fprintf( pFile, ".names" );
+            Cba_ManWriteBlifArray( pFile, p, Cba_ObjFaninVec(p, i), i );
+            fprintf( pFile, "%s", Cba_ObjFuncStr(p, i) );
+        }
+        else if ( Type == CBA_OBJ_BOX ) // .names/assign/box2 (no formal/actual binding)
+        {
+            fprintf( pFile, ".subckt" );
+            fprintf( pFile, " %s", Cba_ObjFuncStr(p, i) );
+            Cba_ManWriteBlifArray2( pFile, p, i );
+        }
+        else if ( Type == CBA_OBJ_LATCH ) // .names/assign/box2 (no formal/actual binding)
+        {
+            Vec_Int_t * vFanins = Cba_ObjFaninVec(p, i);
+            fprintf( pFile, ".latch" );
+            fprintf( pFile, " %s", Cba_ObjNameStr(p, Vec_IntEntry(vFanins, 1)) );
+            fprintf( pFile, " %s", Cba_ObjNameStr(p, Vec_IntEntry(vFanins, 0)) );
+            fprintf( pFile, " %c\n", '0' + Cba_ObjFuncId(p, i) );
+        }
+    }
+}
+void Cba_ManWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p )
+{
+    assert( Vec_IntSize(&p->vTypes) == Cba_NtkObjNum(p) );
+    assert( Vec_IntSize(&p->vFuncs) == Cba_NtkObjNum(p) );
+    // write header
+    fprintf( pFile, ".model %s\n", Cba_NtkName(p) );
+    if ( Vec_IntSize(&p->vInouts) )
+    fprintf( pFile, ".inouts" );
+    if ( Vec_IntSize(&p->vInouts) )
+    Cba_ManWriteBlifArray( pFile, p, &p->vInouts, -1 );
+    fprintf( pFile, ".inputs" );
+    Cba_ManWriteBlifArray( pFile, p, &p->vInputs, -1 );
+    fprintf( pFile, ".outputs" );
+    Cba_ManWriteBlifArray( pFile, p, &p->vOutputs, -1 );
+    // write objects
+    Cba_ManWriteBlifLines( pFile, p );
+    fprintf( pFile, ".end\n\n" );
+}
+void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p )
+{
+    FILE * pFile;
+    Cba_Ntk_t * pNtk; 
+    int i;
+    pFile = fopen( pFileName, "wb" );
+    if ( pFile == NULL )
+    {
+        printf( "Cannot open output file \"%s\".\n", pFileName );
+        return;
+    }
+    fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Cba_ManName(p), Extra_TimeStamp() );
+    Cba_ManForEachNtk( p, pNtk, i )
+        Cba_ManWriteBlifNtk( pFile, pNtk );
+    fclose( pFile );
+}
 
 
 ////////////////////////////////////////////////////////////////////////