ruby_abc 0.0.3 → 0.1.0

data/ext/abc/src/base/cba/cba.h

@@ -1,1024 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [cba.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Hierarchical word-level netlist.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - July 21, 2015.]
-
-  Revision    [$Id: cba.h,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef ABC__base__cba__cba_h
-#define ABC__base__cba__cba_h
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include "aig/gia/gia.h"
-#include "misc/extra/extra.h"
-#include "misc/util/utilNam.h"
-#include "misc/vec/vecHash.h"
-#include "cbaTypes.h"
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_HEADER_START 
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-
-
-typedef struct Cba_Ntk_t_ Cba_Ntk_t;
-typedef struct Cba_Man_t_ Cba_Man_t;
-
-// network
-struct Cba_Ntk_t_
-{
-    Cba_Man_t *     pDesign;  // design
-    int             Id;       // network ID
-    int             NameId;   // name ID 
-    int             iCopy;    // copy module
-    unsigned        Mark : 1; // visit mark 
-    unsigned        fComb: 1; // the network is combinational
-    unsigned        fSeq : 1; // the network is sequential
-    // interface
-    Vec_Int_t       vInputs;  // inputs 
-    Vec_Int_t       vOutputs; // outputs
-    Vec_Int_t       vOrder;   // order
-    Vec_Int_t       vSeq;     // sequential objects
-    // stucture
-    Vec_Str_t       vObjType; // type     
-    Vec_Int_t       vObjFin0; // fanins
-    Vec_Int_t       vObjFon0; // outputs
-    Vec_Int_t       vFinFon;  // fons
-    Vec_Int_t       vFonObj;  // object
-    // optional
-    Vec_Int_t       vObjCopy; // copy
-    Vec_Int_t       vObjFunc; // function
-    Vec_Int_t       vObjName; // name
-    Vec_Int_t       vObjAttr; // attribute offset
-    Vec_Int_t       vAttrSto; // attribute storage
-    Vec_Int_t       vFonCopy; // copy
-    Vec_Int_t       vFonName; // name
-    Vec_Int_t       vFonRange;// range
-    Vec_Int_t       vFonPrev; // fanout: prev fon
-    Vec_Int_t       vFonNext; // fanout: next fon
-    Vec_Int_t       vFinFon0; // fanout: first fon
-    Vec_Int_t       vFinObj;  // object
-    Vec_Int_t       vNtkObjs; // instances
-    Vec_Int_t       vFonBits; // fon mapping into AIG nodes
-    // other
-    Vec_Ptr_t *     vOther;   // various data
-    Vec_Int_t       vArray0;
-    Vec_Int_t       vArray1;
-};
-
-// design
-struct Cba_Man_t_
-{
-    // design names
-    char *          pName;    // design name
-    char *          pSpec;    // spec file name
-    Abc_Nam_t *     pStrs;    // string manager
-    Abc_Nam_t *     pFuns;    // constant manager
-    Abc_Nam_t *     pMods;    // module name manager
-    Hash_IntMan_t * vHash; // variable ranges
-    Vec_Int_t       vNameMap; // mapping names
-    Vec_Int_t       vNameMap2;// mapping names
-    Vec_Int_t       vUsed;    // used map entries
-    Vec_Int_t       vUsed2;   // used map entries
-    char *          pTypeNames[CBA_BOX_LAST];
-    int             nObjs[CBA_BOX_LAST]; // counter of objects of each type
-    int             nAnds[CBA_BOX_LAST]; // counter of AND gates after blasting
-    // internal data
-    int             iRoot;    // root network
-    Vec_Ptr_t       vNtks;    // networks
-    // user data
-    int             nOpens;
-    Vec_Str_t       vOut;     
-    Vec_Str_t       vOut2;     
-    void *          pMioLib;
-};
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-static inline char *         Cba_ManName( Cba_Man_t * p )                    { return p->pName;                                                                            }
-static inline char *         Cba_ManSpec( Cba_Man_t * p )                    { return p->pSpec;                                                                            }
-static inline int            Cba_ManNtkNum( Cba_Man_t * p )                  { return Vec_PtrSize(&p->vNtks)-1;                                                            }
-static inline int            Cba_ManNtkIsOk( Cba_Man_t * p, int i )          { return i > 0 && i <= Cba_ManNtkNum(p);                                                      }
-static inline Cba_Ntk_t *    Cba_ManNtk( Cba_Man_t * p, int i )              { return Cba_ManNtkIsOk(p, i) ? (Cba_Ntk_t *)Vec_PtrEntry(&p->vNtks, i) : NULL;               }
-static inline int            Cba_ManNtkFindId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName);                                                     }
-static inline Cba_Ntk_t *    Cba_ManNtkFind( Cba_Man_t * p, char * pName )   { return Cba_ManNtk( p, Cba_ManNtkFindId(p, pName) );                                         }
-static inline Cba_Ntk_t *    Cba_ManRoot( Cba_Man_t * p )                    { return Cba_ManNtk(p, p->iRoot);                                                             }
-static inline char *         Cba_ManStr( Cba_Man_t * p, int i )              { return Abc_NamStr(p->pStrs, i);                                                             }
-static inline int            Cba_ManStrId( Cba_Man_t * p, char * pStr )      { return Abc_NamStrFind(p->pStrs, pStr);                                                      }
-static inline int            Cba_ManNameIdMax( Cba_Man_t * p )               { return Abc_NamObjNumMax(p->pStrs) + 1;                                                      }
-static inline char *         Cba_ManConst( Cba_Man_t * p, int i )            { return Abc_NamStr(p->pFuns, i);                                                             }
-static inline int            Cba_ManConstId( Cba_Man_t * p, char * pStr )    { return Abc_NamStrFind(p->pFuns, pStr);                                                      }
-static inline int            Cba_ManConstIdMax( Cba_Man_t * p )              { return Abc_NamObjNumMax(p->pFuns) + 1;                                                      }
-
-static inline Cba_Man_t *    Cba_NtkMan( Cba_Ntk_t * p )                     { return p->pDesign;                                                                          }
-static inline Cba_Ntk_t *    Cba_NtkNtk( Cba_Ntk_t * p, int i )              { return Cba_ManNtk(p->pDesign, i);                                                           }
-static inline int            Cba_NtkId( Cba_Ntk_t * p )                      { return p->Id;                                                                               }
-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 int            Cba_NtkPioOrder( Cba_Ntk_t * p, int i )         { return Vec_IntEntry(&p->vOrder, i);                                                         }
-static inline int            Cba_NtkBoxSeq( Cba_Ntk_t * p, int i )           { return Vec_IntEntry(&p->vSeq, i);                                                           }
-static inline Abc_Nam_t *    Cba_NtkNam( Cba_Ntk_t * p )                     { return p->pDesign->pStrs;                                                                   }
-static inline char *         Cba_NtkStr( Cba_Ntk_t * p, int i )              { return Cba_ManStr(p->pDesign, i);                                                           }
-static inline int            Cba_NtkStrId( Cba_Ntk_t * p, char * pName )     { return Cba_ManStrId(p->pDesign, pName);                                                     }
-static inline char *         Cba_NtkConst( Cba_Ntk_t * p, int i )            { return Cba_ManConst(p->pDesign, i);                                                         }
-static inline char *         Cba_NtkSop( Cba_Ntk_t * p, int i )              { return Cba_ManConst(p->pDesign, i);                                                         }
-static inline int            Cba_NtkNameId( Cba_Ntk_t * p )                  { return p->NameId;                                                                           }
-static inline char *         Cba_NtkName( Cba_Ntk_t * p )                    { return Cba_NtkStr(p, p->NameId);                                                            }
-static inline char *         Cba_NtkTypeName( Cba_Ntk_t * p, int Type )      { return p->pDesign->pTypeNames[Type];                                                        }
-static inline int            Cba_NtkCopy( Cba_Ntk_t * p )                    { return p->iCopy;                                                                            }
-static inline Cba_Ntk_t *    Cba_NtkCopyNtk(Cba_Man_t * pNew, Cba_Ntk_t * p) { return Cba_ManNtk(pNew, Cba_NtkCopy(p));                                                    }
-static inline void           Cba_NtkSetCopy( Cba_Ntk_t * p, int i )          { assert(p->iCopy == 0); p->iCopy = i;                                                        }
-static inline int            Cba_NtkHashRange( Cba_Ntk_t * p, int l, int r ) { return Hash_Int2ManInsert( p->pDesign->vHash, l, r, 0 );                                    }
-static inline int            Cba_NtkRangeLeft( Cba_Ntk_t * p, int h )        { return h ? Hash_IntObjData0( p->pDesign->vHash, h ) : 0;                                    }
-static inline int            Cba_NtkRangeRight( Cba_Ntk_t * p, int h )       { return h ? Hash_IntObjData1( p->pDesign->vHash, h ) : 0;                                    }
-static inline int            Cba_NtkRangeSize( Cba_Ntk_t * p, int h )        { int l = Cba_NtkRangeLeft(p, h), r = Cba_NtkRangeRight(p, h); return 1 + (l > r ? l-r : r-l);}
-
-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_NtkPioNum( Cba_Ntk_t * p )                  { return Cba_NtkPiNum(p) + Cba_NtkPoNum(p);                                                   }
-static inline int            Cba_NtkPiNumAlloc( Cba_Ntk_t * p )              { return Vec_IntCap(&p->vInputs);                                                             }
-static inline int            Cba_NtkPoNumAlloc( Cba_Ntk_t * p )              { return Vec_IntCap(&p->vOutputs);                                                            }
-static inline int            Cba_NtkPioOrderNum( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vOrder);                                                             }
-static inline int            Cba_NtkObjNum( Cba_Ntk_t * p )                  { return Vec_StrSize(&p->vObjType)-1;                                                         }
-static inline int            Cba_NtkObjNumAlloc( Cba_Ntk_t * p )             { return Vec_StrCap(&p->vObjType)-1;                                                          }
-static inline int            Cba_NtkFinNum( Cba_Ntk_t * p )                  { return Vec_IntSize(&p->vFinFon)-1;                                                          }
-static inline int            Cba_NtkFinNumAlloc( Cba_Ntk_t * p )             { return Vec_IntCap(&p->vFinFon)-1;                                                           }
-static inline int            Cba_NtkFonNum( Cba_Ntk_t * p )                  { return Vec_IntSize(&p->vFonObj)-1;                                                          }
-static inline int            Cba_NtkFonNumAlloc( Cba_Ntk_t * p )             { return Vec_IntCap(&p->vFonObj)-1;                                                           }
-static inline int            Cba_NtkTypeNum( Cba_Ntk_t * p, int Type )       { return Vec_StrCountEntry(&p->vObjType, (char)Type);                                         }
-static inline int            Cba_NtkBoxNum( Cba_Ntk_t * p )                  { return Cba_NtkObjNum(p) - Cba_NtkPioNum(p);                                                 }
-static inline int            Cba_NtkBoxUserNum( Cba_Ntk_t * p )              { return Cba_NtkTypeNum(p, CBA_OBJ_BOX);                                                      }
-static inline int            Cba_NtkBoxPrimNum( Cba_Ntk_t * p )              { return Vec_StrCountLarger(&p->vObjType, (char)CBA_OBJ_BOX);                                 }
-static inline int            Cba_NtkBoxSeqNum( Cba_Ntk_t * p )               { return Vec_IntSize(&p->vSeq);                                                               }
-
-static inline void           Cba_NtkCleanObjCopies( Cba_Ntk_t * p )          { Vec_IntFill(&p->vObjCopy,  Vec_StrCap(&p->vObjType), -1);        }
-static inline void           Cba_NtkCleanObjFuncs( Cba_Ntk_t * p )           { Vec_IntFill(&p->vObjFunc,  Vec_StrCap(&p->vObjType),  0);        }
-static inline void           Cba_NtkCleanObjNames( Cba_Ntk_t * p )           { Vec_IntFill(&p->vObjName,  Vec_StrCap(&p->vObjType),  0);        }
-static inline void           Cba_NtkCleanObjAttrs( Cba_Ntk_t * p )           { Vec_IntFill(&p->vObjAttr,  Vec_StrCap(&p->vObjType),  0); Vec_IntFill(&p->vAttrSto, 1, -1); }
-static inline void           Cba_NtkCleanFonCopies( Cba_Ntk_t * p )          { Vec_IntFill(&p->vFonCopy,  Vec_IntCap(&p->vFonObj),   0);        }
-static inline void           Cba_NtkCleanFonNames( Cba_Ntk_t * p )           { Vec_IntFill(&p->vFonName,  Vec_IntCap(&p->vFonObj),   0);        }
-static inline void           Cba_NtkCleanFonRanges( Cba_Ntk_t * p )          { Vec_IntFill(&p->vFonRange, Vec_IntCap(&p->vFonObj),   0);        }
-static inline void           Cba_NtkCleanFonPrevs( Cba_Ntk_t * p )           { Vec_IntFill(&p->vFonPrev,  Vec_IntCap(&p->vFonObj),   0);        }
-static inline void           Cba_NtkCleanFonNexts( Cba_Ntk_t * p )           { Vec_IntFill(&p->vFonNext,  Vec_IntCap(&p->vFonObj),   0);        }
-static inline void           Cba_NtkCleanFinFon0( Cba_Ntk_t * p )            { Vec_IntFill(&p->vFinFon0,  Vec_IntCap(&p->vFinFon),   0);        }
-static inline void           Cba_NtkCleanFinObjs( Cba_Ntk_t * p )            { Vec_IntFill(&p->vFinObj,   Vec_IntCap(&p->vFinFon),   0);        }
-
-static inline int            Cba_NtkHasObjCopies( Cba_Ntk_t * p )            { return Vec_IntSize(&p->vObjCopy)  > 0; }
-static inline int            Cba_NtkHasObjFuncs( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vObjFunc)  > 0; }
-static inline int            Cba_NtkHasObjNames( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vObjName)  > 0; }
-static inline int            Cba_NtkHasObjAttrs( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vObjAttr)  > 0; }
-static inline int            Cba_NtkHasFonCopies( Cba_Ntk_t * p )            { return Vec_IntSize(&p->vFonCopy)  > 0; }
-static inline int            Cba_NtkHasFonNames( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vFonName)  > 0; }
-static inline int            Cba_NtkHasFonRanges( Cba_Ntk_t * p )            { return Vec_IntSize(&p->vFonRange) > 0; }
-static inline int            Cba_NtkHasFonPrevs( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vFonPrev)  > 0; }
-static inline int            Cba_NtkHasFonNexts( Cba_Ntk_t * p )             { return Vec_IntSize(&p->vFonNext)  > 0; }
-static inline int            Cba_NtkHasFinFon0( Cba_Ntk_t * p )              { return Vec_IntSize(&p->vFinFon0)  > 0; }
-static inline int            Cba_NtkHasFinObjs( Cba_Ntk_t * p )              { return Vec_IntSize(&p->vFinObj)   > 0; }
-
-static inline void           Cba_NtkFreeObjCopies( Cba_Ntk_t * p )           { Vec_IntErase(&p->vObjCopy);   }
-static inline void           Cba_NtkFreeObjFuncs( Cba_Ntk_t * p )            { Vec_IntErase(&p->vObjFunc);   }
-static inline void           Cba_NtkFreeObjNames( Cba_Ntk_t * p )            { Vec_IntErase(&p->vObjName);   }
-static inline void           Cba_NtkFreeObjAttrs( Cba_Ntk_t * p )            { Vec_IntErase(&p->vObjAttr);   }
-static inline void           Cba_NtkFreeFonCopies( Cba_Ntk_t * p )           { Vec_IntErase(&p->vFonCopy);   }
-static inline void           Cba_NtkFreeFonNames( Cba_Ntk_t * p )            { Vec_IntErase(&p->vFonName);   }
-static inline void           Cba_NtkFreeFonRanges( Cba_Ntk_t * p )           { Vec_IntErase(&p->vFonRange);  }
-static inline void           Cba_NtkFreeFonPrevs( Cba_Ntk_t * p )            { Vec_IntErase(&p->vFonPrev);   }
-static inline void           Cba_NtkFreeFonNexts( Cba_Ntk_t * p )            { Vec_IntErase(&p->vFonNext);   }
-static inline void           Cba_NtkFreeFinFon0( Cba_Ntk_t * p )             { Vec_IntErase(&p->vFinFon0);   }
-static inline void           Cba_NtkFreeFinObjs( Cba_Ntk_t * p )             { Vec_IntErase(&p->vFinObj);    }
-
-static inline Cba_ObjType_t  Cba_ObjType( Cba_Ntk_t * p, int i )             { assert(i>0); return (Cba_ObjType_t)(int)(unsigned char)Vec_StrEntry(&p->vObjType, i);       }
-static inline void           Cba_ObjCleanType( Cba_Ntk_t * p, int i )        { assert(i>0); Vec_StrWriteEntry( &p->vObjType, i, (char)CBA_OBJ_NONE );                      }
-static inline int            Cba_TypeIsBox( Cba_ObjType_t Type )             { return Type >= CBA_OBJ_BOX && Type < CBA_BOX_LAST;                                          }
-static inline int            Cba_TypeIsSeq( Cba_ObjType_t Type )             { return Type >= CBA_BOX_RAM && Type <= CBA_BOX_DFFRS;                                        }
-static inline int            Cba_TypeIsUnary( Cba_ObjType_t Type )           { return Type == CBA_BOX_BUF || Type == CBA_BOX_INV || Type == CBA_BOX_LNOT || Type == CBA_BOX_MIN || Type == CBA_BOX_SQRT || Type == CBA_BOX_ABS || (Type >= CBA_BOX_RAND && Type <= CBA_BOX_RXNOR);  }
-static inline int            Cba_TypeIsMux( Cba_ObjType_t Type )             { return Type == CBA_BOX_MUX || Type == CBA_BOX_NMUX || Type == CBA_BOX_SEL || Type == CBA_BOX_PSEL;  }
-
-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_ObjIsPio( Cba_Ntk_t * p, int i )            { return Cba_ObjIsPi(p, i) || Cba_ObjIsPo(p, i);                                              }
-static inline int            Cba_ObjIsBox( Cba_Ntk_t * p, int i )            { return Cba_TypeIsBox(Cba_ObjType(p, i));                                                    }
-static inline int            Cba_ObjIsBoxUser( Cba_Ntk_t * p, int i )        { return Cba_ObjType(p, i) == CBA_OBJ_BOX;                                                    }
-static inline int            Cba_ObjIsBoxPrim( Cba_Ntk_t * p, int i )        { return Cba_ObjType(p, i) >  CBA_OBJ_BOX && Cba_ObjType(p, i) < CBA_BOX_LAST;                }
-static inline int            Cba_ObjIsGate( Cba_Ntk_t * p, int i )           { return Cba_ObjType(p, i) == CBA_BOX_GATE;                                                   }
-static inline int            Cba_ObjIsSlice( Cba_Ntk_t * p, int i )          { return Cba_ObjType(p, i) == CBA_BOX_SLICE;                                                  }
-static inline int            Cba_ObjIsConcat( Cba_Ntk_t * p, int i )         { return Cba_ObjType(p, i) == CBA_BOX_CONCAT;                                                 }
-static inline int            Cba_ObjIsUnary( Cba_Ntk_t * p, int i )          { return Cba_TypeIsUnary(Cba_ObjType(p, i));                                                  }
-
-static inline int            Cba_ObjFin0( Cba_Ntk_t * p, int i )             { assert(i>0); return Vec_IntEntry(&p->vObjFin0, i);                                          }
-static inline int            Cba_ObjFon0( Cba_Ntk_t * p, int i )             { assert(i>0); return Vec_IntEntry(&p->vObjFon0, i);                                          }
-static inline int            Cba_ObjFin( Cba_Ntk_t * p, int i, int k )       { assert(i>0); return Cba_ObjFin0(p, i) + k;                                                  }
-static inline int            Cba_ObjFon( Cba_Ntk_t * p, int i, int k )       { assert(i>0); return Cba_ObjFon0(p, i) + k;                                                  }
-static inline int            Cba_ObjFinNum( Cba_Ntk_t * p, int i )           { assert(i>0); return Cba_ObjFin0(p, i+1) - Cba_ObjFin0(p, i);                                }
-static inline int            Cba_ObjFonNum( Cba_Ntk_t * p, int i )           { assert(i>0); return Cba_ObjFon0(p, i+1) - Cba_ObjFon0(p, i);                                }
-
-static inline int            Cba_ObjCopy( Cba_Ntk_t * p, int i )             { assert(i>0); assert( Cba_NtkHasObjCopies(p) ); return Vec_IntGetEntryFull(&p->vObjCopy, i); }
-static inline int            Cba_ObjFunc( Cba_Ntk_t * p, int i )             { assert(i>0); assert( Cba_NtkHasObjFuncs(p) );  return Vec_IntGetEntry(&p->vObjFunc, i);     }
-static inline int            Cba_ObjName( Cba_Ntk_t * p, int i )             { assert(i>0); assert( Cba_NtkHasObjNames(p) );  return Vec_IntGetEntry(&p->vObjName, i);     }
-static inline char *         Cba_ObjNameStr( Cba_Ntk_t * p, int i )          { assert(i>0); return Cba_NtkStr(p, Cba_ObjName(p, i));                                       }
-static inline int            Cba_ObjAttr( Cba_Ntk_t * p, int i )             { assert(i>=0); return Cba_NtkHasObjAttrs(p) ? Vec_IntGetEntry(&p->vObjAttr, i) : 0;          }
-static inline int            Cba_ObjAttrSize( Cba_Ntk_t * p, int i )         { assert(i>=0); return Cba_ObjAttr(p, i) ? Vec_IntEntry(&p->vAttrSto, Cba_ObjAttr(p, i)) : 0; }
-static inline int *          Cba_ObjAttrArray( Cba_Ntk_t * p, int i )        { assert(i>=0); return Cba_ObjAttr(p, i) ? Vec_IntEntryP(&p->vAttrSto, Cba_ObjAttr(p, i)+1) : NULL; }
-static inline int            Cba_ObjAttrValue( Cba_Ntk_t * p, int i, int x ) { int k, s = Cba_ObjAttrSize(p, i), * a = Cba_ObjAttrArray(p, i); for ( k = 0; k < s; k += 2)  if (a[k] == x) return a[k+1]; return 0; }
-
-static inline void           Cba_ObjSetCopy( Cba_Ntk_t * p, int i, int x )   { assert(Cba_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vObjCopy, i, x );                     }
-static inline void           Cba_ObjSetFunc( Cba_Ntk_t * p, int i, int x )   { assert(Cba_ObjFunc(p, i) ==  0); Vec_IntSetEntry( &p->vObjFunc, i, x );                     }
-static inline void           Cba_ObjSetName( Cba_Ntk_t * p, int i, int x )   { assert(Cba_ObjName(p, i) ==  0); Vec_IntSetEntry( &p->vObjName, i, x );                     }
-static inline void           Cba_ObjSetAttrs( Cba_Ntk_t * p, int i, int * a, int s )  { assert(Cba_ObjAttr(p, i) == 0); if ( !a ) return; Vec_IntSetEntry(&p->vObjAttr, i, Vec_IntSize(&p->vAttrSto)); Vec_IntPush(&p->vAttrSto, s); Vec_IntPushArray(&p->vAttrSto, a, s);  }
-
-static inline int            Cba_FinFon( Cba_Ntk_t * p, int f )              { assert(f>0); return Vec_IntEntry(&p->vFinFon, f);                                           }
-static inline void           Cba_PatchFinFon( Cba_Ntk_t * p, int f, int x )  { assert(f>0); Vec_IntWriteEntry(&p->vFinFon, f, x);                                          }
-static inline int            Cba_ObjFinFon( Cba_Ntk_t * p, int i, int k )    { assert(i>0); return Cba_FinFon(p, Cba_ObjFin(p, i, k));                                     }
-static inline int *          Cba_ObjFinFons( Cba_Ntk_t * p, int i )          { assert(i>0); return Vec_IntEntryP(&p->vFinFon, Cba_ObjFin0(p, i));                          }
-
-static inline void           Cba_ObjSetFinFon( Cba_Ntk_t * p, int i, int k, int x ) { assert(i>0); assert(Cba_ObjFinFon(p, i, k)== 0); Vec_IntWriteEntry(&p->vFinFon, Cba_ObjFin(p, i, k), x); }
-static inline void           Cba_ObjCleanFinFon( Cba_Ntk_t * p, int i, int k)       { assert(i>0); assert(Cba_ObjFinFon(p, i, k)!= 0); Vec_IntWriteEntry(&p->vFinFon, Cba_ObjFin(p, i, k), 0); }
-static inline void           Cba_ObjPatchFinFon( Cba_Ntk_t * p, int i, int k, int x){ assert(i>0); Cba_ObjCleanFinFon(p, i, k); Cba_ObjSetFinFon(p, i, k, x);                                  }
-
-static inline int            Cba_ObjNtkId( Cba_Ntk_t * p, int i )            { assert(i>0); return (Cba_ObjIsBoxUser(p, i) && Cba_NtkHasObjFuncs(p)) ? Cba_ObjFunc(p, i) : 0;}
-static inline Cba_Ntk_t *    Cba_ObjNtk( Cba_Ntk_t * p, int i )              { assert(i>0); return Cba_NtkNtk(p, Cba_ObjNtkId(p, i));                                      }
-static inline void           Cba_ObjSetNtkId( Cba_Ntk_t * p, int i, int x )  { assert(i>0); assert(Cba_ObjIsBoxUser(p, i)); Cba_ObjSetFunc( p, i, x );                     }
-static inline int            Cba_ObjIsSeq( Cba_Ntk_t * p, int i )            { assert(i>0); return Cba_ObjIsBoxUser(p, i) ? Cba_ObjNtk(p, i)->fSeq : Cba_TypeIsSeq(Cba_ObjType(p, i));  }
-
-static inline int            Cba_FonIsReal( int f )                          { return f > 0;                             }
-static inline int            Cba_FonIsConst( int f )                         { return f < 0;                             }
-static inline int            Cba_FonConst( int f )                           { assert(Cba_FonIsConst(f)); return -f-1;   }
-static inline int            Cba_FonFromConst( int c )                       { assert(c >= 0); return -c-1;              }
-static inline int            Cba_FonConstRangeSize( Cba_Ntk_t * p, int f )   { assert(Cba_FonIsConst(f)); return atoi(Cba_NtkConst(p, Cba_FonConst(f)));                   }
-static inline int            Cba_FonConstSigned( Cba_Ntk_t * p, int f )      { assert(Cba_FonIsConst(f)); return strchr(Cba_NtkConst(p, Cba_FonConst(f)), 's') != NULL;    }
-
-static inline int            Cba_FonObj( Cba_Ntk_t * p, int f )              { return Cba_FonIsReal(f) ? Vec_IntEntry(&p->vFonObj, f) : 0;                                 }
-static inline int            Cba_FonRangeId( Cba_Ntk_t * p, int f )          { assert(Cba_FonIsReal(f)); return Cba_NtkHasFonRanges(p)?Vec_IntGetEntry(&p->vFonRange, f):0;}
-static inline int            Cba_FonRange( Cba_Ntk_t * p, int f )            { assert(Cba_FonIsReal(f)); return Abc_Lit2Var( Cba_FonRangeId(p, f) );                       }
-static inline int            Cba_FonLeft( Cba_Ntk_t * p, int f )             { return Cba_NtkRangeLeft(p, Cba_FonRange(p, f));                                             }
-static inline int            Cba_FonRight( Cba_Ntk_t * p, int f )            { return Cba_NtkRangeRight(p, Cba_FonRange(p, f));                                            }
-static inline int            Cba_FonSigned( Cba_Ntk_t * p, int f )           { return Cba_FonIsConst(f) ? Cba_FonConstSigned(p, f) : Abc_LitIsCompl(Cba_FonRangeId(p, f)); }
-static inline int            Cba_FonRangeSize( Cba_Ntk_t * p, int f )        { return Cba_FonIsConst(f) ? Cba_FonConstRangeSize(p, f):Cba_NtkRangeSize(p, Cba_FonRange(p, f)); }
-static inline void           Cba_FonSetRangeSign( Cba_Ntk_t * p, int f, int x )  { assert(Cba_NtkHasFonRanges(p));  Vec_IntSetEntry(&p->vFonRange, f, x);                  }
-static inline void           Cba_FonSetRange( Cba_Ntk_t * p, int f, int x )  { assert(Cba_NtkHasFonRanges(p));  Vec_IntSetEntry(&p->vFonRange, f, Abc_Var2Lit(x,0));       }
-static inline void           Cba_FonHashRange( Cba_Ntk_t * p, int f, int l, int r ) { Cba_FonSetRange( p, f, Cba_NtkHashRange(p, l, r) );                                  }
-static inline int            Cba_FonCopy( Cba_Ntk_t * p, int f )             { return Cba_FonIsReal(f) ? Vec_IntEntry(&p->vFonCopy, f) : f;                                }
-static inline void           Cba_FonSetCopy( Cba_Ntk_t * p, int f, int x )   { assert(Cba_FonIsReal(f)); assert(Cba_FonCopy(p, f) == 0); Vec_IntWriteEntry(&p->vFonCopy, f, x); }
-static inline int            Cba_FonName( Cba_Ntk_t * p, int f )             { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); return Vec_IntGetEntry( &p->vFonName, f );                        }
-static inline char *         Cba_FonNameStr( Cba_Ntk_t * p, int f )          { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); return Cba_NtkStr(p, Cba_FonName(p, f));                          }
-static inline void           Cba_FonSetName( Cba_Ntk_t * p, int f, int x )   { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) == 0); Vec_IntSetEntry(&p->vFonName, f, x); }
-static inline void           Cba_FonCleanName( Cba_Ntk_t * p, int f )        { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) != 0); Vec_IntSetEntry(&p->vFonName, f, 0); }
-static inline void           Cba_FonPatchName( Cba_Ntk_t * p, int f, int x)  { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); Cba_FonCleanName(p, f); Cba_FonSetName(p, f, x);                  }
-static inline int            Cba_FonIndex( Cba_Ntk_t * p, int f )            { assert(Cba_FonIsReal(f)); return f - Cba_ObjFon0( p, Cba_FonObj(p, f) );                    }
-static inline int            Cba_FonNtkId( Cba_Ntk_t * p, int f )            { assert(Cba_FonIsReal(f)); return Cba_ObjNtkId( p, Cba_FonObj(p, f) );                       }
-static inline Cba_Ntk_t *    Cba_FonNtk( Cba_Ntk_t * p, int f )              { assert(Cba_FonIsReal(f)); return Cba_ObjNtk( p, Cba_FonObj(p, f) );                         }
-
-static inline int            Cba_ObjFanin( Cba_Ntk_t * p, int i, int k )     { assert(i>0); return Cba_FonObj( p, Cba_ObjFinFon(p, i, k) );                                }
-static inline int            Cba_ObjLeft( Cba_Ntk_t * p, int i )             { return Cba_FonLeft( p, Cba_ObjFon0(p, i) );                                                 }
-static inline int            Cba_ObjRight( Cba_Ntk_t * p, int i )            { return Cba_FonRight( p, Cba_ObjFon0(p, i) );                                                }
-static inline int            Cba_ObjRangeSize( Cba_Ntk_t * p, int i )        { return Cba_FonRangeSize( p, Cba_ObjFon0(p, i) );                                            }
-static inline int            Cba_ObjSigned( Cba_Ntk_t * p, int i )           { return Cba_FonSigned( p, Cba_ObjFon0(p, i) );                                               }
-static inline int            Cba_ObjSign( Cba_Ntk_t * p, int i )             { return Abc_Var2Lit( Cba_FonRangeSize(p, i), Cba_ObjSigned(p, i) );                          }
-
-////////////////////////////////////////////////////////////////////////
-///                          ITERATORS                               ///
-////////////////////////////////////////////////////////////////////////
-
-#define Cba_ManForEachNtk( p, pNtk, i )                                   \
-    for ( i = 1; (i <= Cba_ManNtkNum(p)) && (((pNtk) = Cba_ManNtk(p, i)), 1); i++ ) 
-
-#define Cba_NtkForEachPi( p, iObj, i )                                    \
-    for ( i = 0; (i < Cba_NtkPiNum(p))  && (((iObj) = Cba_NtkPi(p, i)), 1); i++ ) 
-#define Cba_NtkForEachPo( p, iObj, i )                                    \
-    for ( i = 0; (i < Cba_NtkPoNum(p))  && (((iObj) = Cba_NtkPo(p, i)), 1); i++ ) 
-#define Cba_NtkForEachBoxSeq( p, iObj, i )                                \
-    for ( i = 0; (i < Cba_NtkBoxSeqNum(p))  && (((iObj) = Cba_NtkBoxSeq(p, i)), 1); i++ ) 
-#define Cba_NtkForEachPioOrder( p, iObj, i )                              \
-    for ( i = 0; (i < Cba_NtkPioOrderNum(p))  && (((iObj) = Cba_NtkPioOrder(p, i)), 1); i++ ) 
-
-#define Cba_NtkForEachPiFon( p, iObj, iFon, i )                           \
-    for ( i = 0; (i < Cba_NtkPiNum(p))  && (((iObj) = Cba_NtkPi(p, i)), 1)  && (((iFon) = Cba_ObjFon0(p, iObj)), 1); i++ ) 
-#define Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )                     \
-    for ( i = 0; (i < Cba_NtkPoNum(p))  && (((iObj) = Cba_NtkPo(p, i)), 1)  && (((iFon) = Cba_ObjFinFon(p, iObj, 0)), 1); i++ ) 
-#define Cba_NtkForEachPoDriver( p, iObj, i )                              \
-    for ( i = 0; (i < Cba_NtkPoNum(p))  && (((iObj) = Cba_ObjFanin(p, Cba_NtkPo(p, i), 0)), 1); i++ ) 
-
-#define Cba_NtkForEachObj( p, i )                                         \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjType(p, i) ) {} else   
-#define Cba_NtkForEachObjType( p, Type, i )                               \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType)  && (((Type) = Cba_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
-#define Cba_NtkForEachBox( p, i )                                         \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBox(p, i) ) {} else
-#define Cba_NtkForEachBoxComb( p, i )                                     \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBox(p, i) || Cba_ObjIsSeq(p, i) ) {} else
-#define Cba_NtkForEachBoxUser( p, i )                                     \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxUser(p, i) ) {} else
-#define Cba_NtkForEachBoxPrim( p, i )                                     \
-    for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxPrim(p, i) ) {} else
-
-#define Cba_NtkForEachFon( p, i )                                         \
-    for ( i = 1; i < Vec_IntSize(&p->vFonObj); i++ )
-#define Cba_NtkForEachFinFon( p, iFon, iFin )                             \
-    for ( iFin = 1; iFin < Vec_IntSize(&p->vFinFon) && (((iFon) = Vec_IntEntry(&p->vFinFon, iFin)), 1); iFin++ ) if ( !iFon ) {} else   
-#define Cba_NtkForEachFonName( p, NameId, iFon )                          \
-    for ( iFon = 1; iFon < Vec_IntSize(&p->vFonName) && (((NameId) = Vec_IntEntry(&p->vFonName, iFon)), 1); iFon++ ) if ( !NameId ) {} else   
-
-#define Cba_ObjForEachFin( p, iObj, iFin, k )                             \
-    for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1); iFin++, k++ )
-#define Cba_ObjForEachFon( p, iObj, iFon, k )                             \
-    for ( k = 0, iFon = Cba_ObjFon0(p, iObj); iFon < Cba_ObjFon0(p, iObj+1); iFon++, k++ )
-#define Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )                    \
-    for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFon = Cba_FinFon(p, iFin)), 1); iFin++, k++ )
-#define Cba_ObjForEachFinFanin( p, iObj, iFin, iFanin, k )                \
-    for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFanin = Cba_FonObj(p, Cba_FinFon(p, iFin))), 1); iFin++, k++ )
-#define Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k )            \
-    for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFanin = Cba_FonObj(p, Cba_FinFon(p, iFin))), 1); iFin++, k++ ) if ( !iFanin ) {} else
-
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Object APIs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Cba_ObjAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int nFins, int nFons )
-{
-    int i, iObj = Vec_StrSize(&p->vObjType);
-    if ( Type == CBA_OBJ_PI )
-        Vec_IntPush( &p->vInputs, iObj );
-    else if ( Type == CBA_OBJ_PO )
-        Vec_IntPush( &p->vOutputs, iObj );
-    Vec_StrPush( &p->vObjType, (char)Type );
-    // add fins
-    for ( i = 0; i < nFins; i++ )
-        Vec_IntPush( &p->vFinFon, 0 );
-    if ( Vec_IntSize(&p->vObjFin0) )
-        Vec_IntPush( &p->vObjFin0, Vec_IntSize(&p->vFinFon) );
-    // add fons
-    for ( i = 0; i < nFons; i++ )
-        Vec_IntPush( &p->vFonObj, iObj );
-    if ( Vec_IntSize(&p->vObjFon0) )
-        Vec_IntPush( &p->vObjFon0, Vec_IntSize(&p->vFonObj) );
-    return iObj;
-}
-static inline int Cba_ObjDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int i )
-{
-    int iObj = Cba_ObjAlloc( pNew, Cba_ObjType(p, i), Cba_ObjFinNum(p, i), Cba_ObjFonNum(p, i) );
-    Cba_ObjSetCopy( p, i, iObj );
-    return iObj;
-}
-static inline void Cba_ObjDelete( Cba_Ntk_t * p, int i )
-{
-    int k, iFin, iFon;
-    Cba_ObjCleanType( p, i );
-    Cba_ObjForEachFin( p, i, iFin, k )
-        Vec_IntWriteEntry( &p->vFinFon, iFin, 0 );
-    Cba_ObjForEachFon( p, i, iFon, k )
-        Vec_IntWriteEntry( &p->vFonObj, iFon, 0 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Network APIs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline Cba_Ntk_t *  Cba_NtkAlloc( Cba_Man_t * p, int NameId, int nIns, int nOuts, int nObjs, int nFins, int nFons )
-{    
-    Cba_Ntk_t * pNew = ABC_CALLOC( Cba_Ntk_t, 1 );
-    assert( nIns >= 0 && nOuts >= 0 && nObjs >= 0 && nFins >= 0 && nFons >= 0 );
-    pNew->Id      = Vec_PtrSize(&p->vNtks);   Vec_PtrPush( &p->vNtks, pNew );
-    pNew->NameId  = NameId;
-    pNew->pDesign = p;
-    Vec_IntGrow( &pNew->vInputs,  nIns );
-    Vec_IntGrow( &pNew->vOutputs, nOuts );
-    Vec_StrGrow( &pNew->vObjType, nObjs+1 );  Vec_StrPush( &pNew->vObjType,  (char)CBA_OBJ_NONE );
-    Vec_IntGrow( &pNew->vObjFin0, nObjs+2 );  Vec_IntPush( &pNew->vObjFin0,  0 ); Vec_IntPush( &pNew->vObjFin0, 1 );
-    Vec_IntGrow( &pNew->vObjFon0, nObjs+2 );  Vec_IntPush( &pNew->vObjFon0,  0 ); Vec_IntPush( &pNew->vObjFon0, 1 );
-    Vec_IntGrow( &pNew->vFinFon,  nFins+1 );  Vec_IntPush( &pNew->vFinFon,   0 );
-    Vec_IntGrow( &pNew->vFonObj,  nFons+1 );  Vec_IntPush( &pNew->vFonObj,   0 );
-    return pNew;
-}
-static inline void Cba_NtkFree( Cba_Ntk_t * p )
-{
-    // interface
-    Vec_IntErase( &p->vInputs );
-    Vec_IntErase( &p->vOutputs );
-    Vec_IntErase( &p->vOrder );
-    Vec_IntErase( &p->vSeq );
-    // stucture
-    Vec_StrErase( &p->vObjType );
-    Vec_IntErase( &p->vObjFin0 );    
-    Vec_IntErase( &p->vObjFon0 );
-    Vec_IntErase( &p->vFinFon );    
-    Vec_IntErase( &p->vFonObj );    
-    // optional
-    Vec_IntErase( &p->vObjCopy );    
-    Vec_IntErase( &p->vObjFunc );    
-    Vec_IntErase( &p->vObjName );    
-    Vec_IntErase( &p->vObjAttr );    
-    Vec_IntErase( &p->vAttrSto );    
-    Vec_IntErase( &p->vFonCopy );    
-    Vec_IntErase( &p->vFonName );    
-    Vec_IntErase( &p->vFonRange );    
-    Vec_IntErase( &p->vFonPrev );    
-    Vec_IntErase( &p->vFonNext );    
-    Vec_IntErase( &p->vFinFon0 );    
-    Vec_IntErase( &p->vFinObj );    
-    Vec_IntErase( &p->vNtkObjs );    
-    Vec_IntErase( &p->vFonBits );    
-    // other
-    Vec_IntErase( &p->vArray0 );    
-    Vec_IntErase( &p->vArray1 );    
-    if ( p->vOther ) Vec_VecFree( (Vec_Vec_t *)p->vOther );
-    ABC_FREE( p );
-}
-static inline int Cba_NtkNewStrId( Cba_Ntk_t * pNtk, const char * format, ...  )
-{
-    Abc_Nam_t * p = Cba_NtkNam( pNtk );
-    Vec_Str_t * vBuf = Abc_NamBuffer( p );
-    int nAdded, nSize = 1000; 
-    va_list args;   va_start( args, format );
-    Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nSize );
-    nAdded = vsnprintf( Vec_StrLimit(vBuf), nSize, format, args );
-    if ( nAdded > nSize )
-    {
-        Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nAdded + nSize );
-        nSize = vsnprintf( Vec_StrLimit(vBuf), nAdded, format, args );
-        assert( nSize == nAdded );
-    }
-    va_end( args );
-    return Abc_NamStrFindOrAddLim( p, Vec_StrLimit(vBuf), Vec_StrLimit(vBuf) + nAdded, NULL );
-}
-static inline int Cba_ManNewConstId( Cba_Ntk_t * p, Vec_Str_t * vBits ) 
-{ 
-    Vec_Str_t * vOut = Abc_NamBuffer(Cba_NtkNam(p)); 
-    Vec_StrPrintF( vOut, "%d\'b%s", Vec_StrSize(vBits)-1, Vec_StrArray(vBits) );
-    return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
-}
-static inline int Cba_ManNewConstZero( Cba_Ntk_t * p, int nBits ) 
-{ 
-    Vec_Str_t * vOut = Abc_NamBuffer(Cba_NtkNam(p)); 
-    Vec_StrPrintF( vOut, "%d\'b%0s", nBits, "" );
-    return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
-}
-static inline void Cba_NtkAdd( Cba_Man_t * p, Cba_Ntk_t * pNtk )
-{    
-    int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Cba_NtkName(pNtk), &fFound );
-    if ( fFound )
-        printf( "Network with name \"%s\" already exists.\n", Cba_NtkName(pNtk) );
-    else
-        assert( NtkId == pNtk->Id );
-}
-static inline void Cba_NtkUpdate( Cba_Man_t * p, Cba_Ntk_t * pNtk )
-{
-    int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Cba_NtkName(pNtk), &fFound );
-    if ( !fFound )
-        printf( "Network with name \"%s\" does not exist.\n", Cba_NtkName(pNtk) );
-    else
-    {
-        Cba_NtkFree( Cba_ManNtk(p, NtkId) );
-        Vec_PtrWriteEntry( &p->vNtks, NtkId, pNtk );
-    }
-}
-static inline Vec_Int_t * Cba_NtkCollect( Cba_Ntk_t * p )
-{
-    int iObj;
-    Vec_Int_t * vObjs = Vec_IntAlloc( Cba_NtkObjNum(p) );
-    Cba_NtkForEachObj( p, iObj )
-        Vec_IntPush( vObjs, iObj );
-    return vObjs;
-}
-static inline int Cba_NtkIsSeq( Cba_Ntk_t * p )
-{
-    int iObj;
-    if ( p->fSeq )
-        return 1;
-    if ( p->fComb )
-        return 0;
-    assert( !p->fSeq && !p->fComb );
-    Cba_NtkForEachBox( p, iObj )
-        if ( Cba_ObjIsBoxUser(p, iObj) )
-        {
-            if ( Cba_NtkIsSeq( Cba_ObjNtk(p, iObj) ) )
-            {
-                p->fSeq = 1;
-                return 1;
-            }
-        }
-        else if ( Cba_ObjIsSeq(p, iObj) )
-        {
-            p->fSeq = 1;
-            return 1;
-        }
-    p->fComb = 1;
-    return 0;
-}
-static inline void Cba_NtkPrepareSeq( Cba_Ntk_t * p )
-{
-    int iObj;
-    assert( Cba_NtkBoxSeqNum(p) == 0 );
-    if ( !Cba_NtkIsSeq(p) )
-        return;
-    Cba_NtkForEachBox( p, iObj )
-        if ( Cba_ObjIsSeq(p, iObj) )
-            Vec_IntPush( &p->vSeq, iObj );
-    // Cba_NtkObjOrder( p, &p->vSeq, NULL );
-}
-static inline void Cba_NtkCountParams( Cba_Ntk_t * p, Vec_Int_t * vObjs, int * nPis, int * nPos, int * nFins, int * nFons )
-{
-    int i, iObj;
-    *nPis = *nPos = *nFins = *nFons = 0;
-    Vec_IntForEachEntry( vObjs, iObj, i )
-    {
-        *nPis += Cba_ObjIsPi(p, iObj);
-        *nPos += Cba_ObjIsPo(p, iObj);
-        *nFins += Cba_ObjFinNum(p, iObj);
-        *nFons += Cba_ObjFonNum(p, iObj);
-    }
-}
-static inline Cba_Ntk_t * Cba_NtkDup( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t * vObjs )
-{
-    Cba_Ntk_t * pNew;
-    int i, k, iObj, iObjNew, iFin, iFon;
-    int nPis, nPos, nFins, nFons;
-    Cba_NtkCountParams( p, vObjs, &nPis, &nPos, &nFins, &nFons );
-    pNew = Cba_NtkAlloc( pMan, Cba_NtkNameId(p), nPis, nPos, Vec_IntSize(vObjs), nFins, nFons );
-    Cba_NtkCleanObjCopies( p );
-    Cba_NtkCleanFonCopies( p );
-    Vec_IntForEachEntry( vObjs, iObj, i )
-    {
-        iObjNew = Cba_ObjDup( pNew, p, iObj );
-        Cba_ObjForEachFon( p, iObj, iFon, k )
-            Cba_FonSetCopy( p, iFon, Cba_ObjFon(pNew, iObjNew, k) );
-    }
-    Vec_IntForEachEntry( vObjs, iObj, i )
-    {
-        iObjNew = Cba_ObjCopy( p, iObj );
-        Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
-            Cba_ObjSetFinFon( pNew, iObjNew, k, Cba_FonCopy(p, iFon) );
-    }
-    //Cba_NtkFreeObjCopies( p );
-    //Cba_NtkFreeFonCopies( p );
-    assert( Cba_NtkObjNum(pNew) == Cba_NtkObjNumAlloc(pNew) );
-    Cba_NtkSetCopy( p, Cba_NtkId(pNew) );
-    return pNew;
-}
-static inline Cba_Ntk_t * Cba_NtkDupOrder( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
-{
-    Cba_Ntk_t * pNew;
-    Vec_Int_t * vObjs = pFuncOrder ? pFuncOrder(p) : Cba_NtkCollect(p);
-    if ( vObjs == NULL )
-        return NULL;
-    pNew = Cba_NtkDup( pMan, p, vObjs );
-    Vec_IntFree( vObjs );
-    //Cba_NtkPrepareSeq( pNew );
-    return pNew;
-}
-static inline void Cba_NtkDupAttrs( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
-{
-    int i, iObj;
-    assert( Vec_IntSize(&pNew->vOrder) == 0 );
-    Cba_NtkForEachPioOrder( p, iObj, i )
-        Vec_IntPush( &pNew->vOrder, Cba_ObjCopy(p, iObj) );
-//    Vec_IntRemapArray( &p->vObjCopy, &p->vOrder,    &pNew->vOrder,    Cba_NtkPioOrderNum(p) );
-//    Vec_IntRemapArray( &p->vObjCopy, &p->vSeq,      &pNew->vSeq,      Cba_NtkBoxSeqNum(p) );
-    // transfer object attributes
-    Vec_IntRemapArray( &p->vObjCopy, &p->vObjFunc,  &pNew->vObjFunc,  Cba_NtkObjNum(pNew) + 1 );
-    Vec_IntRemapArray( &p->vObjCopy, &p->vObjName,  &pNew->vObjName,  Cba_NtkObjNum(pNew) + 1 );
-    Vec_IntRemapArray( &p->vObjCopy, &p->vObjAttr,  &pNew->vObjAttr,  Cba_NtkObjNum(pNew) + 1 );
-    // transfer fon attributes
-    Vec_IntRemapArray( &p->vFonCopy, &p->vFonName,  &pNew->vFonName,  Cba_NtkFonNum(pNew) + 1 );
-    Vec_IntRemapArray( &p->vFonCopy, &p->vFonRange, &pNew->vFonRange, Cba_NtkFonNum(pNew) + 1 );
-    // duplicate attributes
-    Vec_IntAppend( &pNew->vAttrSto, &p->vAttrSto );
-    pNew->vOther = p->vOther ? (Vec_Ptr_t *)Vec_VecDup( (Vec_Vec_t *)p->vOther ) : NULL;
-}
-static inline int Cba_NtkMemory( Cba_Ntk_t * p )
-{
-    int nMem = sizeof(Cba_Ntk_t);
-    // interface
-    nMem += (int)Vec_IntMemory(&p->vInputs);
-    nMem += (int)Vec_IntMemory(&p->vOutputs);
-    nMem += (int)Vec_IntMemory(&p->vOrder);
-    nMem += (int)Vec_IntMemory(&p->vSeq);
-    // stucture
-    nMem += (int)Vec_StrMemory(&p->vObjType);
-    nMem += (int)Vec_IntMemory(&p->vObjFin0);
-    nMem += (int)Vec_IntMemory(&p->vObjFon0);
-    nMem += (int)Vec_IntMemory(&p->vFinFon);
-    nMem += (int)Vec_IntMemory(&p->vFonObj);
-    // optional
-    nMem += (int)Vec_IntMemory(&p->vObjCopy );  
-    nMem += (int)Vec_IntMemory(&p->vObjFunc );  
-    nMem += (int)Vec_IntMemory(&p->vObjName );  
-    nMem += (int)Vec_IntMemory(&p->vObjAttr );  
-    nMem += (int)Vec_IntMemory(&p->vAttrSto );  
-    nMem += (int)Vec_IntMemory(&p->vFonCopy );  
-    nMem += (int)Vec_IntMemory(&p->vFonName );  
-    nMem += (int)Vec_IntMemory(&p->vFonRange ); 
-    nMem += (int)Vec_IntMemory(&p->vFonPrev );  
-    nMem += (int)Vec_IntMemory(&p->vFonNext );  
-    nMem += (int)Vec_IntMemory(&p->vFinFon0 );  
-    nMem += (int)Vec_IntMemory(&p->vFinObj );   
-    nMem += (int)Vec_IntMemory(&p->vNtkObjs );  
-    nMem += (int)Vec_IntMemory(&p->vFonBits );  
-    // other
-    nMem += (int)Vec_IntMemory(&p->vArray1 );
-    nMem += (int)Vec_IntMemory(&p->vArray1 );
-    return nMem;
-}
-static inline void Cba_NtkPrintStats( Cba_Ntk_t * p )
-{
-    printf( "pi =%5d  ",   Cba_NtkPiNum(p) );
-    printf( "po =%5d  ",   Cba_NtkPoNum(p) );
-    printf( "seq =%5d  ",  Cba_NtkBoxSeqNum(p) );
-    printf( "box =%5d  ",  Cba_NtkBoxNum(p) );
-    printf( "prim =%5d  ", Cba_NtkBoxPrimNum(p) );
-    printf( "user =%5d  ", Cba_NtkBoxUserNum(p) );
-    //printf( "topo =%4s  ", Cba_NtkIsTopoOrder(p) ? "yes" : "no" );
-    printf( "  %s ",       Cba_NtkName(p) );
-    if ( Vec_IntSize(&p->vNtkObjs) )
-        printf( "-> %s",   Cba_NtkName(Cba_NtkNtk(p, Vec_IntEntry(&p->vNtkObjs, 0))) );
-    printf( "\n" );
-//    Vec_StrIntPrint( &p->vObjType );
-}
-static inline void Cba_NtkPrint( Cba_Ntk_t * p )
-{
-    int i, Type;
-    printf( "Interface (%d):\n", Cba_NtkPioNum(p) );
-    printf( "Objects (%d):\n", Cba_NtkObjNum(p) );
-    Cba_NtkForEachObjType( p, Type, i )
-    {
-        printf( "%6d : ", i );
-        printf( "Type =%3d  ", Type );
-        printf( "Fins = %d  ", Cba_ObjFinNum(p, i) );
-        printf( "Fons = %d  ", Cba_ObjFonNum(p, i) );
-        if ( Cba_NtkHasObjNames(p) && Cba_ObjName(p, i) )
-            printf( "%s", Cba_ObjNameStr(p, i) );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Manager APIs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline Cba_Man_t * Cba_ManAlloc( char * pFileName, int nNtks, Abc_Nam_t * pStrs, Abc_Nam_t * pFuns, Abc_Nam_t * pMods, Hash_IntMan_t * vHash )
-{
-    Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
-    pNew->pName = Extra_FileDesignName( pFileName );
-    pNew->pSpec = Abc_UtilStrsav( pFileName );
-    pNew->pStrs = pStrs ? pStrs : Abc_NamStart( 1000, 24 );
-    pNew->pFuns = pFuns ? pFuns : Abc_NamStart( 100, 24 );
-    pNew->pMods = pMods ? pMods : Abc_NamStart( 100, 24 );
-    pNew->vHash = vHash ? vHash : Hash_IntManStart( 1000 );
-    if ( pFuns == NULL )
-    {
-        Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b0", NULL);
-        Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b1", NULL);
-        Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bx", NULL);
-        Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bz", NULL);
-    }
-//    if ( vHash == NULL )
-//        Hash_Int2ManInsert( pNew->vHash, 0, 0, 0 );
-    Vec_PtrGrow( &pNew->vNtks,  nNtks+1 ); Vec_PtrPush( &pNew->vNtks, NULL );
-    // set default root module
-    pNew->iRoot = 1;
-    return pNew;
-}
-static inline void Cba_ManDupTypeNames( Cba_Man_t * pNew, Cba_Man_t * p )
-{
-   memcpy( pNew->pTypeNames, p->pTypeNames, sizeof(void *) * CBA_BOX_LAST );
-}
-static inline Cba_Man_t * Cba_ManDup( Cba_Man_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
-{
-    Cba_Ntk_t * pNtk, * pNtkNew; int i;
-    Cba_Man_t * pNew = Cba_ManAlloc( p->pSpec, Cba_ManNtkNum(p), Abc_NamRef(p->pStrs), Abc_NamRef(p->pFuns), Abc_NamStart(100, 24), Hash_IntManRef(p->vHash) );
-    Cba_ManDupTypeNames( pNew, p );
-    Cba_ManForEachNtk( p, pNtk, i )
-    {
-        pNtkNew = Cba_NtkDupOrder( pNew, pNtk, pFuncOrder );
-        Cba_NtkAdd( pNew, pNtkNew );
-        Cba_NtkDupAttrs( pNtkNew, pNtk );
-    }
-//    Cba_ManForEachNtk( p, pNtk, i )
-//        if ( (pHost = Cba_NtkHostNtk(pNtk)) )
-//            Cba_NtkSetHost( Cba_NtkCopyNtk(pNew, pNtk), Cba_NtkCopy(pHost), Cba_ObjCopy(pHost, Cba_NtkHostObj(pNtk)) );
-    pNew->iRoot = Cba_ManNtkNum(pNew);
-    return pNew;
-}
-static inline void Cba_ManPrepareSeq( Cba_Man_t * p )
-{
-    Cba_Ntk_t * pNtk; int i;
-    Cba_ManForEachNtk( p, pNtk, i )
-        Cba_NtkPrepareSeq( pNtk );
-}
-static inline void Cba_ManFree( Cba_Man_t * p )
-{
-    Cba_Ntk_t * pNtk; int i;
-    Cba_ManForEachNtk( p, pNtk, i )
-        Cba_NtkFree( pNtk );
-    ABC_FREE( p->vNtks.pArray );
-    Abc_NamDeref( p->pStrs );
-    Abc_NamDeref( p->pFuns );
-    Abc_NamDeref( p->pMods );
-    Hash_IntManDeref( p->vHash );
-    Vec_IntErase( &p->vNameMap );
-    Vec_IntErase( &p->vUsed );
-    Vec_IntErase( &p->vNameMap2 );
-    Vec_IntErase( &p->vUsed2 );
-    Vec_StrErase( &p->vOut );
-    Vec_StrErase( &p->vOut2 );
-    ABC_FREE( p->pName );
-    ABC_FREE( p->pSpec );
-    ABC_FREE( p );
-}
-static inline int Cba_ManGetMap( Cba_Man_t * p, int i )
-{
-    return Vec_IntGetEntry(&p->vNameMap, i);
-}
-static inline void Cba_ManSetMap( Cba_Man_t * p, int i, int x )
-{
-    assert( Vec_IntGetEntry(&p->vNameMap, i) == 0 );
-    Vec_IntSetEntry( &p->vNameMap, i, x );
-    Vec_IntPush( &p->vUsed, i );
-}
-static inline void Cba_ManUnsetMap( Cba_Man_t * p, int i )
-{
-    Vec_IntSetEntry( &p->vNameMap, i, 0 );
-}
-static inline void Cba_ManCleanMap( Cba_Man_t * p )
-{
-    int i, Entry;
-    Vec_IntForEachEntry( &p->vUsed, Entry, i )
-        Vec_IntWriteEntry( &p->vNameMap, Entry, 0 );
-    Vec_IntClear( &p->vUsed );
-}
-static inline int  Cba_NtkGetMap( Cba_Ntk_t * p, int i )          { return Cba_ManGetMap(p->pDesign, i); }
-static inline void Cba_NtkSetMap( Cba_Ntk_t * p, int i, int x )   { Cba_ManSetMap(p->pDesign, i, x);     }
-static inline void Cba_NtkUnsetMap( Cba_Ntk_t * p, int i )        { Cba_ManUnsetMap(p->pDesign, i);      }
-static inline void Cba_NtkCleanMap( Cba_Ntk_t * p )               { Cba_ManCleanMap(p->pDesign);         }
-
-static inline int Cba_ManGetMap2( Cba_Man_t * p, int i )
-{
-    return Vec_IntGetEntry(&p->vNameMap2, i);
-}
-static inline void Cba_ManSetMap2( Cba_Man_t * p, int i, int x )
-{
-    assert( Vec_IntGetEntry(&p->vNameMap2, i) == 0 );
-    Vec_IntSetEntry( &p->vNameMap2, i, x );
-    Vec_IntPush( &p->vUsed2, i );
-}
-static inline void Cba_ManUnsetMap2( Cba_Man_t * p, int i )
-{
-    Vec_IntSetEntry( &p->vNameMap2, i, 0 );
-}
-static inline void Cba_ManCleanMap2( Cba_Man_t * p )
-{
-    int i, Entry;
-    Vec_IntForEachEntry( &p->vUsed2, Entry, i )
-        Vec_IntWriteEntry( &p->vNameMap2, Entry, 0 );
-    Vec_IntClear( &p->vUsed2 );
-}
-static inline int  Cba_NtkGetMap2( Cba_Ntk_t * p, int i )          { return Cba_ManGetMap2(p->pDesign, i); }
-static inline void Cba_NtkSetMap2( Cba_Ntk_t * p, int i, int x )   { Cba_ManSetMap2(p->pDesign, i, x);     }
-static inline void Cba_NtkUnsetMap2( Cba_Ntk_t * p, int i )        { Cba_ManUnsetMap2(p->pDesign, i);      }
-static inline void Cba_NtkCleanMap2( Cba_Ntk_t * p )               { Cba_ManCleanMap2(p->pDesign);         }
-
-static inline int Cba_ManMemory( Cba_Man_t * p )
-{
-    Cba_Ntk_t * pNtk; int i;
-    int nMem = sizeof(Cba_Man_t);
-    nMem += p->pName ? (int)strlen(p->pName) : 0;
-    nMem += p->pSpec ? (int)strlen(p->pSpec) : 0;
-    nMem += Abc_NamMemUsed(p->pStrs);
-    nMem += Abc_NamMemUsed(p->pFuns);
-    nMem += Abc_NamMemUsed(p->pMods);
-    nMem += (int)Vec_IntMemory(&p->vNameMap );   
-    nMem += (int)Vec_IntMemory(&p->vUsed );  
-    nMem += (int)Vec_StrMemory(&p->vOut );   
-    nMem += (int)Vec_StrMemory(&p->vOut2 );  
-    nMem += (int)Vec_PtrMemory(&p->vNtks);
-    Cba_ManForEachNtk( p, pNtk, i )
-        nMem += Cba_NtkMemory( pNtk );
-    return nMem;
-}
-static inline int Cba_ManObjNum( Cba_Man_t * p )
-{
-    Cba_Ntk_t * pNtk; int i, Count = 0;
-    Cba_ManForEachNtk( p, pNtk, i )
-        Count += Cba_NtkObjNum(pNtk);
-    return Count;
-}
-static inline int Cba_ManBoxNum( Cba_Man_t * p )
-{
-    Cba_Ntk_t * pNtk; int i, Count = 0;
-    Cba_ManForEachNtk( p, pNtk, i )
-        Count += Cba_NtkBoxNum( pNtk );
-    return Count;
-}
-static inline void Cba_ManBoxNumRec_rec( Cba_Ntk_t * p, int * pCountP, int * pCountU )
-{
-    int iObj, Id = Cba_NtkId(p);
-    if ( pCountP[Id] >= 0 )
-        return;
-    pCountP[Id] = pCountU[Id] = 0;
-    Cba_NtkForEachObj( p, iObj )
-    {
-        if ( Cba_ObjIsBoxUser(p, iObj) )
-        {
-            Cba_ManBoxNumRec_rec( Cba_ObjNtk(p, iObj), pCountP, pCountU );
-            pCountP[Id] += pCountP[Cba_ObjNtkId(p, iObj)];
-            pCountU[Id] += pCountU[Cba_ObjNtkId(p, iObj)] + 1;
-        }
-        else
-            pCountP[Id] += 1;
-    }
-}
-static inline void Cba_ManBoxNumRec( Cba_Man_t * p, int * pnPrims, int * pnUsers )
-{
-    Cba_Ntk_t * pNtk = Cba_ManRoot(p);
-    int * pCountP = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
-    int * pCountU = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
-    Cba_ManBoxNumRec_rec( pNtk, pCountP, pCountU );
-    *pnPrims = pCountP[Cba_NtkId(pNtk)];
-    *pnUsers = pCountU[Cba_NtkId(pNtk)];
-    ABC_FREE( pCountP );
-    ABC_FREE( pCountU );
-}
-static inline void Cba_ManPrintStats( Cba_Man_t * p, int nModules, int fVerbose )
-{
-    Cba_Ntk_t * pNtk; int i, nPrims, nUsers;
-    Cba_Ntk_t * pRoot = Cba_ManRoot( p );
-    Cba_ManBoxNumRec( p, &nPrims, &nUsers );
-    printf( "%-12s : ",     Cba_ManName(p) );
-    printf( "pi =%5d  ",    Cba_NtkPiNum(pRoot) );
-    printf( "po =%5d  ",    Cba_NtkPoNum(pRoot) );
-    printf( "mod =%5d  ",   Cba_ManNtkNum(p) );
-    printf( "box =%5d  ",   nPrims + nUsers );
-    printf( "prim =%5d  ",  nPrims );
-    printf( "user =%5d  ",  nUsers );
-    printf( "mem =%6.3f MB", 1.0*Cba_ManMemory(p)/(1<<20) );
-    printf( "\n" );
-    Cba_ManForEachNtk( p, pNtk, i )
-    {
-        if ( i == nModules+1 )
-            break;
-        printf( "Module %5d : ", i );
-        Cba_NtkPrintStats( pNtk );
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Name handling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline void Cba_NtkAddMissingFonNames( Cba_Ntk_t * p, char * pPref )
-{
-    int iFon, NameId, Index;
-    // populate map
-    Cba_ManCleanMap( p->pDesign );
-    Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
-        if ( NameId )
-            Cba_ManSetMap( p->pDesign, NameId, iFon );
-    // check remaining ones
-    Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
-    {
-        if ( NameId )
-            continue;
-        NameId = Cba_NtkNewStrId(p, "%s%d", pPref, iFon);
-        for ( Index = 1; Cba_ManGetMap(p->pDesign, NameId); Index++ )
-            NameId = Cba_NtkNewStrId(p, "%s%d_%d", pPref, iFon, Index);
-        Cba_FonSetName( p, iFon, NameId );
-        Cba_ManSetMap( p->pDesign, NameId, iFon );
-    }
-}
-static inline void Cba_NtkCreateFonNames( Cba_Ntk_t * p, char * pPref )
-{
-    int i, iObj, iFon;//, NameId;
-    Cba_NtkCleanFonNames( p );
-    Cba_NtkForEachPiFon( p, iObj, iFon, i )
-        if ( !Cba_FonName(p, iFon) )
-            Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
-    Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )
-        if ( Cba_FonIsReal(iFon) && !Cba_FonName(p, iFon) )
-            Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
-//    Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
-//        if ( NameId == 0 )
-//            Vec_IntWriteEntry( &p->vFonName, iFon, Cba_NtkNewStrId(p, "%s%d", pPref, iFon) );
-    Cba_NtkAddMissingFonNames( p, pPref );
-}
-static inline void Cba_NtkMissingFonNames( Cba_Ntk_t * p, char * pPref )
-{
-    int i, iObj, iFon;//, NameId;
-    Cba_NtkForEachPiFon( p, iObj, iFon, i )
-        if ( !Cba_FonName(p, iFon) )
-            Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
-    Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )
-        if ( Cba_FonIsReal(iFon) && !Cba_FonName(p, iFon) )
-            Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
-//    Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
-//        if ( NameId == 0 )
-//            Cba_FonSetName( p, iFon, Cba_NtkNewStrId(p, "%s%d", pPref, iFon) );
-    Cba_NtkAddMissingFonNames( p, pPref );
-}
-
-
-/*=== cbaBlast.c =============================================================*/
-extern Gia_Man_t *   Cba_ManBlast( Cba_Man_t * p, int fBarBufs, int fSeq, int fVerbose );
-extern Cba_Man_t *   Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia );
-extern Cba_Man_t *   Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc );
-/*=== cbaCba.c ===============================================================*/
-extern Cba_Man_t *   Cba_ManReadCba( char * pFileName );
-extern void          Cba_ManWriteCba( char * pFileName, Cba_Man_t * p );
-/*=== cbaCom.c ===============================================================*/
-/*=== cbaNtk.c ===============================================================*/
-extern void          Cba_NtkPrintStatsFull( Cba_Ntk_t * p, int fDistrib, int fVerbose );
-extern void          Cba_NtkPrintNodes( Cba_Ntk_t * p, int Type );
-extern void          Cba_NtkPrintDistribOld( Cba_Ntk_t * p );
-extern void          Cba_ManPrintDistrib( Cba_Man_t * p );
-//extern void           Cba_ManPrepareTypeNames( Cba_Man_t * p );
-extern void          Cba_NtkObjOrder( Cba_Ntk_t * p, Vec_Int_t * vObjs, Vec_Int_t * vNameIds );
-extern int           Cba_NtkCiFonNum( Cba_Ntk_t * p );
-extern int           Cba_NtkCoFinNum( Cba_Ntk_t * p );
-extern int           Cba_NtkCheckComboLoop( Cba_Ntk_t * p );
-extern int           Cba_ManIsTopoOrder( Cba_Man_t * p );
-extern Vec_Int_t *   Cba_NtkCollectDfs( Cba_Ntk_t * p );
-extern Cba_Man_t *   Cba_ManCollapse( Cba_Man_t * p );
-extern Cba_Man_t *   Cba_ManExtractGroup( Cba_Man_t * p, Vec_Int_t * vObjs );
-extern Cba_Man_t *   Cba_ManDeriveFromGia( Cba_Man_t * p, Gia_Man_t * pGia, int fUseXor );
-extern Cba_Man_t *   Cba_ManInsertGroup( Cba_Man_t * p, Vec_Int_t * vObjs, Cba_Ntk_t * pSyn );
-/*=== cbaReadBlif.c ==========================================================*/
-extern Cba_Man_t *   Prs_ManBuildCbaBlif( char * pFileName, Vec_Ptr_t * vDes );
-extern void          Prs_ManReadBlifTest( char * pFileName );
-extern Cba_Man_t *   Cba_ManReadBlif( char * pFileName );
-/*=== cbaReadVer.c ===========================================================*/
-extern Cba_Man_t *   Prs_ManBuildCbaVerilog( char * pFileName, Vec_Ptr_t * vDes );
-extern void          Prs_ManReadVerilogTest( char * pFileName );
-extern Cba_Man_t *   Cba_ManReadVerilog( char * pFileName );
-/*=== cbaWriteBlif.c =========================================================*/
-extern void          Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
-extern void          Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p );
-/*=== cbaWriteVer.c ==========================================================*/
-extern void          Cba_ManCreatePrimMap( char ** pMap );
-extern char *        Cba_ManGetSliceName( Cba_Ntk_t * p, int iFon, int RangeId );
-extern void          Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
-extern void          Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fInlineConcat );
-
-ABC_NAMESPACE_HEADER_END
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-