ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
gia.h
Go to the documentation of this file.
1
20
21#ifndef ABC__aig__gia__gia_h
22#define ABC__aig__gia__gia_h
23
24
28
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <assert.h>
33
34#include "misc/vec/vec.h"
35#include "misc/vec/vecWec.h"
36#include "misc/util/utilCex.h"
37
41
42
43ABC_NAMESPACE_HEADER_START
44
45#define GIA_NONE 0x1FFFFFFF
46#define GIA_VOID 0x0FFFFFFF
47
51
52typedef struct Gia_MmFixed_t_ Gia_MmFixed_t;
53typedef struct Gia_MmFlex_t_ Gia_MmFlex_t;
54typedef struct Gia_MmStep_t_ Gia_MmStep_t;
55typedef struct Gia_Dat_t_ Gia_Dat_t;
56
57typedef struct Gia_Rpr_t_ Gia_Rpr_t;
58struct Gia_Rpr_t_
59{
60 unsigned iRepr : 28; // representative node
61 unsigned fProved : 1; // marks the proved equivalence
62 unsigned fFailed : 1; // marks the failed equivalence
63 unsigned fColorA : 1; // marks cone of A
64 unsigned fColorB : 1; // marks cone of B
65};
66
67typedef struct Gia_Plc_t_ Gia_Plc_t;
68struct Gia_Plc_t_
69{
70 unsigned fFixed : 1; // the placement of this object is fixed
71 unsigned xCoord : 15; // x-ooordinate of the placement
72 unsigned fUndef : 1; // the placement of this object is not assigned
73 unsigned yCoord : 15; // y-ooordinate of the placement
74};
75
76typedef struct Gia_Obj_t_ Gia_Obj_t;
77struct Gia_Obj_t_
78{
79 unsigned iDiff0 : 29; // the diff of the first fanin
80 unsigned fCompl0: 1; // the complemented attribute
81 unsigned fMark0 : 1; // first user-controlled mark
82 unsigned fTerm : 1; // terminal node (CI/CO)
83
84 unsigned iDiff1 : 29; // the diff of the second fanin
85 unsigned fCompl1: 1; // the complemented attribute
86 unsigned fMark1 : 1; // second user-controlled mark
87 unsigned fPhase : 1; // value under 000 pattern
88
89 unsigned Value; // application-specific value
90};
91// Value is currently used to store several types of information
92// - pointer to the next node in the hash table during structural hashing
93// - pointer to the node copy during duplication
94
95// new AIG manager
96typedef struct Gia_Man_t_ Gia_Man_t;
97struct Gia_Man_t_
98{
99 char * pName; // name of the AIG
100 char * pSpec; // name of the input file
101 int nRegs; // number of registers
102 int nRegsAlloc; // number of allocated registers
103 int nObjs; // number of objects
104 int nObjsAlloc; // number of allocated objects
105 Gia_Obj_t * pObjs; // the array of objects
106 unsigned * pMuxes; // control signals of MUXes
107 int nXors; // the number of XORs
108 int nMuxes; // the number of MUXes
109 int nBufs; // the number of buffers
110 Vec_Int_t * vCis; // the vector of CIs (PIs + LOs)
111 Vec_Int_t * vCos; // the vector of COs (POs + LIs)
112 Vec_Int_t vHash; // hash links
113 Vec_Int_t vHTable; // hash table
114 int fAddStrash; // performs additional structural hashing
115 int fSweeper; // sweeper is running
116 int fGiaSimple; // simple mode (no const-propagation and strashing)
117 Vec_Int_t vRefs; // the reference count
118 int * pRefs; // the reference count
119 int * pLutRefs; // the reference count
120 Vec_Int_t * vLevels; // levels of the nodes
121 int nLevels; // the mamixum level
122 int nConstrs; // the number of constraints
123 int nTravIds; // the current traversal ID
124 int nFront; // frontier size
125 int * pReprsOld; // representatives (for CIs and ANDs)
126 Gia_Rpr_t * pReprs; // representatives (for CIs and ANDs)
127 int * pNexts; // next nodes in the equivalence classes
128 int * pSibls; // next nodes in the choice nodes
129 int * pIso; // pairs of structurally isomorphic nodes
130 int nTerLoop; // the state where loop begins
131 int nTerStates; // the total number of ternary states
132 int * pFanData; // the database to store fanout information
133 int nFansAlloc; // the size of fanout representation
134 Vec_Int_t * vFanoutNums; // static fanout
135 Vec_Int_t * vFanout; // static fanout
136 Vec_Int_t * vMapping; // mapping for each node
137 Vec_Wec_t * vMapping2; // mapping for each node
138 Vec_Wec_t * vFanouts2; // mapping fanouts
139 Vec_Int_t * vCellMapping; // mapping for each node
140 void * pSatlutWinman; // windowing for SAT-based mapping
141 Vec_Int_t * vPacking; // packing information
142 Vec_Int_t * vConfigs; // cell configurations
143 char * pCellStr; // cell description
144 Vec_Int_t * vLutConfigs; // LUT configurations
145 Vec_Int_t * vEdgeDelay; // special edge information
146 Vec_Int_t * vEdgeDelayR; // special edge information
147 Vec_Int_t * vEdge1; // special edge information
148 Vec_Int_t * vEdge2; // special edge information
149 Abc_Cex_t * pCexComb; // combinational counter-example
150 Abc_Cex_t * pCexSeq; // sequential counter-example
151 Vec_Ptr_t * vSeqModelVec; // sequential counter-examples
152 Vec_Int_t vCopies; // intermediate copies
153 Vec_Int_t vCopies2; // intermediate copies
154 Vec_Int_t * vVar2Obj; // mapping of variables into objects
155 Vec_Int_t * vTruths; // used for truth table computation
156 Vec_Int_t * vFlopClasses; // classes of flops for retiming/merging/etc
157 Vec_Int_t * vGateClasses; // classes of gates for abstraction
158 Vec_Int_t * vObjClasses; // classes of objects for abstraction
159 Vec_Int_t * vInitClasses; // classes of flops for retiming/merging/etc
160 Vec_Int_t * vRegClasses; // classes of registers for sequential synthesis
161 Vec_Int_t * vRegInits; // initial state
162 Vec_Int_t * vDoms; // dominators
163 Vec_Int_t * vBarBufs; // barrier buffers
164 Vec_Int_t * vXors; // temporary XORs
165 unsigned char* pSwitching; // switching activity for each object
166 Gia_Plc_t * pPlacement; // placement of the objects
167 Gia_Man_t * pAigExtra; // combinational logic of holes
168 Vec_Flt_t * vInArrs; // PI arrival times
169 Vec_Flt_t * vOutReqs; // PO required times
170 Vec_Int_t * vCiArrs; // CI arrival times
171 Vec_Int_t * vCoReqs; // CO required times
172 Vec_Int_t * vCoArrs; // CO arrival times
173 Vec_Int_t * vCoAttrs; // CO attributes
174 Vec_Int_t * vWeights; // object attributes
175 int And2Delay; // delay of the AND gate
176 float DefInArrs; // default PI arrival times
177 float DefOutReqs; // default PO required times
178 Vec_Int_t * vSwitching; // switching activity
179 int * pTravIds; // separate traversal ID representation
180 int nTravIdsAlloc; // the number of trav IDs allocated
181 Vec_Ptr_t * vNamesIn; // the input names
182 Vec_Ptr_t * vNamesOut; // the output names
183 Vec_Ptr_t * vNamesNode; // the node names
184 Vec_Int_t * vUserPiIds; // numbers assigned to PIs by the user
185 Vec_Int_t * vUserPoIds; // numbers assigned to POs by the user
186 Vec_Int_t * vUserFfIds; // numbers assigned to FFs by the user
187 Vec_Int_t * vCiNumsOrig; // original CI names
188 Vec_Int_t * vCoNumsOrig; // original CO names
189 Vec_Int_t * vIdsOrig; // original object IDs
190 Vec_Int_t * vIdsEquiv; // original object IDs proved equivalent
191 Vec_Int_t * vCofVars; // cofactoring variables
192 Vec_Vec_t * vClockDoms; // clock domains
193 Vec_Flt_t * vTiming; // arrival/required/slack
194 void * pManTime; // the timing manager
195 void * pLutLib; // LUT library
196 word nHashHit; // hash table hit
197 word nHashMiss; // hash table miss
198 void * pData; // various user data
199 unsigned * pData2; // various user data
200 int iData; // various user data
201 int iData2; // various user data
202 int nAnd2Delay; // AND2 delay scaled to match delay numbers used
203 int fVerbose; // verbose reports
204 int MappedArea; // area after mapping
205 int MappedDelay; // delay after mapping
206 // bit-parallel simulation
207 int fBuiltInSim;
208 int iPatsPi;
209 int nSimWords;
210 int nSimWordsT;
211 int iPastPiMax;
212 int nSimWordsMax;
213 Vec_Wrd_t * vSims;
214 Vec_Wrd_t * vSimsT;
215 Vec_Wrd_t * vSimsPi;
216 Vec_Wrd_t * vSimsPo;
217 Vec_Int_t * vClassOld;
218 Vec_Int_t * vClassNew;
219 Vec_Int_t * vPats;
220 Vec_Bit_t * vPolars;
221 // incremental simulation
222 int fIncrSim;
223 int iNextPi;
224 int iTimeStamp;
225 Vec_Int_t * vTimeStamps;
226 // truth table computation for small functions
227 int nTtVars; // truth table variables
228 int nTtWords; // truth table words
229 Vec_Int_t * vTtNums; // object numbers
230 Vec_Int_t * vTtNodes; // internal nodes
231 Vec_Ptr_t * vTtInputs; // truth tables for constant and primary inputs
232 Vec_Wrd_t * vTtMemory; // truth tables for internal nodes
233 // balancing
234 Vec_Int_t * vSuper; // supergate
235 Vec_Int_t * vStore; // node storage
236 // existential quantification
237 int iSuppPi; // the number of support variables
238 int nSuppWords; // the number of support words
239 Vec_Wrd_t * vSuppWords; // support information
240 Vec_Int_t vCopiesTwo; // intermediate copies
241 Vec_Int_t vSuppVars; // used variables
242 Vec_Int_t vVarMap; // used variables
243 Gia_Dat_t * pUData;
244 // retiming data
245 Vec_Str_t * vStopsF;
246 Vec_Str_t * vStopsB;
247 // iteration with boxes
248 int iFirstNonPiId;
249 int iFirstPoId;
250 int iFirstAndObj;
251 int iFirstPoObj;
252 Vec_Str_t * vTTISOPs; // truth tables from ISOP computation
253 Vec_Int_t * vTTLut; // truth tables from ISOP computation
254 Vec_Int_t * vMFFCsInfo; // MFFC information
255 Vec_Int_t * vMFFCsLuts; // MFFCs for each lut
256 Vec_Ptr_t * vLutsRankings; // LUTs rankings of inputs
257};
258
259
260typedef struct Gps_Par_t_ Gps_Par_t;
276
277typedef struct Emb_Par_t_ Emb_Par_t;
278struct Emb_Par_t_
279{
280 int nDims; // the number of dimension
281 int nSols; // the number of solutions (typically, 2)
282 int nIters; // the number of iterations of FORCE
283 int fRefine; // use refinement by FORCE
284 int fCluster; // use clustered representation
285 int fDump; // dump Gnuplot file
286 int fDumpLarge; // dump Gnuplot file for large benchmarks
287 int fShowImage; // shows image if Gnuplot is installed
288 int fVerbose; // verbose flag
289};
290
291
292// frames parameters
293typedef struct Gia_ParFra_t_ Gia_ParFra_t;
294struct Gia_ParFra_t_
295{
296 int nFrames; // the number of frames to unroll
297 int fInit; // initialize the timeframes
298 int fSaveLastLit; // adds POs for outputs of each frame
299 int fDisableSt; // disables strashing
300 int fOrPos; // ORs respective POs in each timeframe
301 int fVerbose; // enables verbose output
302};
303
304
305// simulation parameters
306typedef struct Gia_ParSim_t_ Gia_ParSim_t;
307struct Gia_ParSim_t_
308{
309 // user-controlled parameters
310 int nWords; // the number of machine words
311 int nIters; // the number of timeframes
312 int RandSeed; // seed to generate random numbers
313 int TimeLimit; // time limit in seconds
314 int fCheckMiter; // check if miter outputs are non-zero
315 int fVerbose; // enables verbose output
316 int iOutFail; // index of the failed output
317};
318
319typedef struct Gia_ManSim_t_ Gia_ManSim_t;
320struct Gia_ManSim_t_
321{
322 Gia_Man_t * pAig;
323 Gia_ParSim_t * pPars;
324 int nWords;
325 Vec_Int_t * vCis2Ids;
326 Vec_Int_t * vConsts;
327 // simulation information
328 unsigned * pDataSim; // simulation data
329 unsigned * pDataSimCis; // simulation data for CIs
330 unsigned * pDataSimCos; // simulation data for COs
331};
332
333typedef struct Jf_Par_t_ Jf_Par_t;
393
394static inline unsigned Gia_ObjCutSign( unsigned ObjId ) { return (1 << (ObjId & 31)); }
395static inline int Gia_WordHasOneBit( unsigned uWord ) { return (uWord & (uWord-1)) == 0; }
396static inline int Gia_WordHasOnePair( unsigned uWord ) { return Gia_WordHasOneBit(uWord & (uWord>>1) & 0x55555555); }
397static inline int Gia_WordCountOnes( unsigned uWord )
398{
399 uWord = (uWord & 0x55555555) + ((uWord>>1) & 0x55555555);
400 uWord = (uWord & 0x33333333) + ((uWord>>2) & 0x33333333);
401 uWord = (uWord & 0x0F0F0F0F) + ((uWord>>4) & 0x0F0F0F0F);
402 uWord = (uWord & 0x00FF00FF) + ((uWord>>8) & 0x00FF00FF);
403 return (uWord & 0x0000FFFF) + (uWord>>16);
404}
405static inline int Gia_WordFindFirstBit( unsigned uWord )
406{
407 int i;
408 for ( i = 0; i < 32; i++ )
409 if ( uWord & (1 << i) )
410 return i;
411 return -1;
412}
413
414static inline int Gia_ManTruthIsConst0( unsigned * pIn, int nVars )
415{
416 int w;
417 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
418 if ( pIn[w] )
419 return 0;
420 return 1;
421}
422static inline int Gia_ManTruthIsConst1( unsigned * pIn, int nVars )
423{
424 int w;
425 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
426 if ( pIn[w] != ~(unsigned)0 )
427 return 0;
428 return 1;
429}
430static inline void Gia_ManTruthCopy( unsigned * pOut, unsigned * pIn, int nVars )
431{
432 int w;
433 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
434 pOut[w] = pIn[w];
435}
436static inline void Gia_ManTruthClear( unsigned * pOut, int nVars )
437{
438 int w;
439 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
440 pOut[w] = 0;
441}
442static inline void Gia_ManTruthFill( unsigned * pOut, int nVars )
443{
444 int w;
445 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
446 pOut[w] = ~(unsigned)0;
447}
448static inline void Gia_ManTruthNot( unsigned * pOut, unsigned * pIn, int nVars )
449{
450 int w;
451 for ( w = Abc_TruthWordNum(nVars)-1; w >= 0; w-- )
452 pOut[w] = ~pIn[w];
453}
454
455static inline int Gia_ManConst0Lit() { return 0; }
456static inline int Gia_ManConst1Lit() { return 1; }
457static inline int Gia_ManIsConst0Lit( int iLit ) { return (iLit == 0); }
458static inline int Gia_ManIsConst1Lit( int iLit ) { return (iLit == 1); }
459static inline int Gia_ManIsConstLit( int iLit ) { return (iLit <= 1); }
460
461static inline Gia_Obj_t * Gia_Regular( Gia_Obj_t * p ) { return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) & ~01); }
462static inline Gia_Obj_t * Gia_Not( Gia_Obj_t * p ) { return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) ^ 01); }
463static inline Gia_Obj_t * Gia_NotCond( Gia_Obj_t * p, int c ) { return (Gia_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c)); }
464static inline int Gia_IsComplement( Gia_Obj_t * p ) { return (int)((ABC_PTRUINT_T)(p) & 01); }
465
466static inline char * Gia_ManName( Gia_Man_t * p ) { return p->pName; }
467static inline int Gia_ManCiNum( Gia_Man_t * p ) { return Vec_IntSize(p->vCis); }
468static inline int Gia_ManCoNum( Gia_Man_t * p ) { return Vec_IntSize(p->vCos); }
469static inline int Gia_ManPiNum( Gia_Man_t * p ) { return Vec_IntSize(p->vCis) - p->nRegs; }
470static inline int Gia_ManPoNum( Gia_Man_t * p ) { return Vec_IntSize(p->vCos) - p->nRegs; }
471static inline int Gia_ManRegNum( Gia_Man_t * p ) { return p->nRegs; }
472static inline int Gia_ManObjNum( Gia_Man_t * p ) { return p->nObjs; }
473static inline int Gia_ManAndNum( Gia_Man_t * p ) { return p->nObjs - Vec_IntSize(p->vCis) - Vec_IntSize(p->vCos) - 1; }
474static inline int Gia_ManXorNum( Gia_Man_t * p ) { return p->nXors; }
475static inline int Gia_ManMuxNum( Gia_Man_t * p ) { return p->nMuxes; }
476static inline int Gia_ManBufNum( Gia_Man_t * p ) { return p->nBufs; }
477static inline int Gia_ManAndNotBufNum( Gia_Man_t * p ){ return Gia_ManAndNum(p) - Gia_ManBufNum(p); }
478static inline int Gia_ManCandNum( Gia_Man_t * p ) { return Gia_ManCiNum(p) + Gia_ManAndNum(p); }
479static inline int Gia_ManConstrNum( Gia_Man_t * p ) { return p->nConstrs; }
480static inline void Gia_ManFlipVerbose( Gia_Man_t * p ) { p->fVerbose ^= 1; }
481static inline int Gia_ManHasChoices( Gia_Man_t * p ) { return p->pSibls != NULL; }
482static inline int Gia_ManChoiceNum( Gia_Man_t * p ) { int c = 0; if (p->pSibls) { int i; for (i = 0; i < p->nObjs; i++) c += (int)(p->pSibls[i] > 0); } return c; }
483
484static inline Gia_Obj_t * Gia_ManConst0( Gia_Man_t * p ) { return p->pObjs; }
485static inline Gia_Obj_t * Gia_ManConst1( Gia_Man_t * p ) { return Gia_Not(Gia_ManConst0(p)); }
486static inline Gia_Obj_t * Gia_ManObj( Gia_Man_t * p, int v ) { assert( v >= 0 && v < p->nObjs ); return p->pObjs + v; }
487static inline Gia_Obj_t * Gia_ManCi( Gia_Man_t * p, int v ) { return Gia_ManObj( p, Vec_IntEntry(p->vCis,v) ); }
488static inline Gia_Obj_t * Gia_ManCo( Gia_Man_t * p, int v ) { return Gia_ManObj( p, Vec_IntEntry(p->vCos,v) ); }
489static inline Gia_Obj_t * Gia_ManPi( Gia_Man_t * p, int v ) { assert( v < Gia_ManPiNum(p) ); return Gia_ManCi( p, v ); }
490static inline Gia_Obj_t * Gia_ManPo( Gia_Man_t * p, int v ) { assert( v < Gia_ManPoNum(p) ); return Gia_ManCo( p, v ); }
491static inline Gia_Obj_t * Gia_ManRo( Gia_Man_t * p, int v ) { assert( v < Gia_ManRegNum(p) ); return Gia_ManCi( p, Gia_ManPiNum(p)+v ); }
492static inline Gia_Obj_t * Gia_ManRi( Gia_Man_t * p, int v ) { assert( v < Gia_ManRegNum(p) ); return Gia_ManCo( p, Gia_ManPoNum(p)+v ); }
493
494static inline int Gia_ObjId( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( p->pObjs <= pObj && pObj < p->pObjs + p->nObjs ); return pObj - p->pObjs; }
495static inline int Gia_ObjCioId( Gia_Obj_t * pObj ) { assert( pObj->fTerm ); return pObj->iDiff1; }
496static inline void Gia_ObjSetCioId( Gia_Obj_t * pObj, int v ) { assert( pObj->fTerm ); pObj->iDiff1 = v; }
497static inline int Gia_ObjValue( Gia_Obj_t * pObj ) { return pObj->Value; }
498static inline void Gia_ObjSetValue( Gia_Obj_t * pObj, int i ) { pObj->Value = i; }
499static inline int Gia_ObjPhase( Gia_Obj_t * pObj ) { return pObj->fPhase; }
500static inline int Gia_ObjPhaseReal( Gia_Obj_t * pObj ) { return Gia_Regular(pObj)->fPhase ^ Gia_IsComplement(pObj); }
501static inline int Gia_ObjPhaseDiff( Gia_Man_t * p, int i, int k ) { return Gia_ManObj(p, i)->fPhase ^ Gia_ManObj(p, k)->fPhase; }
502static inline char * Gia_ObjCiName( Gia_Man_t * p, int i ) { return p->vNamesIn ? (char*)Vec_PtrEntry(p->vNamesIn, i) : NULL; }
503static inline char * Gia_ObjCoName( Gia_Man_t * p, int i ) { return p->vNamesOut ? (char*)Vec_PtrEntry(p->vNamesOut, i) : NULL; }
504static inline char * Gia_ObjName( Gia_Man_t * p, int i ) { return p->vNamesNode ? (char*)Vec_PtrEntry(p->vNamesNode, i) : NULL; }
505static inline char * Gia_ObjNameObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return p->vNamesNode ? (char*)Vec_PtrEntry(p->vNamesNode, Gia_ObjId(p, pObj)) : NULL; }
506
507static inline int Gia_ObjIsTerm( Gia_Obj_t * pObj ) { return pObj->fTerm; }
508static inline int Gia_ObjIsAndOrConst0( Gia_Obj_t * pObj ) { return!pObj->fTerm; }
509static inline int Gia_ObjIsCi( Gia_Obj_t * pObj ) { return pObj->fTerm && pObj->iDiff0 == GIA_NONE; }
510static inline int Gia_ObjIsCo( Gia_Obj_t * pObj ) { return pObj->fTerm && pObj->iDiff0 != GIA_NONE; }
511static inline int Gia_ObjIsAnd( Gia_Obj_t * pObj ) { return!pObj->fTerm && pObj->iDiff0 != GIA_NONE; }
512static inline int Gia_ObjIsXor( Gia_Obj_t * pObj ) { return Gia_ObjIsAnd(pObj) && pObj->iDiff0 < pObj->iDiff1; }
513static inline int Gia_ObjIsMuxId( Gia_Man_t * p, int iObj ) { return p->pMuxes && p->pMuxes[iObj] > 0; }
514static inline int Gia_ObjIsMux( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsMuxId( p, Gia_ObjId(p, pObj) ); }
515static inline int Gia_ObjIsAndReal( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsAnd(pObj) && pObj->iDiff0 > pObj->iDiff1 && !Gia_ObjIsMux(p, pObj); }
516static inline int Gia_ObjIsBuf( Gia_Obj_t * pObj ) { return pObj->iDiff0 == pObj->iDiff1 && pObj->iDiff0 != GIA_NONE && !pObj->fTerm; }
517static inline int Gia_ObjIsAndNotBuf( Gia_Obj_t * pObj ) { return Gia_ObjIsAnd(pObj) && pObj->iDiff0 != pObj->iDiff1; }
518static inline int Gia_ObjIsCand( Gia_Obj_t * pObj ) { return Gia_ObjIsAnd(pObj) || Gia_ObjIsCi(pObj); }
519static inline int Gia_ObjIsConst0( Gia_Obj_t * pObj ) { return pObj->iDiff0 == GIA_NONE && pObj->iDiff1 == GIA_NONE; }
520static inline int Gia_ManObjIsConst0( Gia_Man_t * p, Gia_Obj_t * pObj){ return pObj == p->pObjs; }
521
522static inline int Gia_Obj2Lit( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Abc_Var2Lit(Gia_ObjId(p, Gia_Regular(pObj)), Gia_IsComplement(pObj)); }
523static inline Gia_Obj_t * Gia_Lit2Obj( Gia_Man_t * p, int iLit ) { return Gia_NotCond(Gia_ManObj(p, Abc_Lit2Var(iLit)), Abc_LitIsCompl(iLit)); }
524static inline int Gia_ManCiLit( Gia_Man_t * p, int CiId ) { return Gia_Obj2Lit( p, Gia_ManCi(p, CiId) ); }
525
526static inline int Gia_ManIdToCioId( Gia_Man_t * p, int Id ) { return Gia_ObjCioId( Gia_ManObj(p, Id) ); }
527static inline int Gia_ManCiIdToId( Gia_Man_t * p, int CiId ) { return Gia_ObjId( p, Gia_ManCi(p, CiId) ); }
528static inline int Gia_ManCoIdToId( Gia_Man_t * p, int CoId ) { return Gia_ObjId( p, Gia_ManCo(p, CoId) ); }
529
530static inline int Gia_ObjIsPi( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) < Gia_ManPiNum(p); }
531static inline int Gia_ObjIsPo( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsCo(pObj) && Gia_ObjCioId(pObj) < Gia_ManPoNum(p); }
532static inline int Gia_ObjIsRo( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) >= Gia_ManPiNum(p); }
533static inline int Gia_ObjIsRi( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjIsCo(pObj) && Gia_ObjCioId(pObj) >= Gia_ManPoNum(p); }
534
535static inline Gia_Obj_t * Gia_ObjRoToRi( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsRo(p, pObj) ); return Gia_ManCo(p, Gia_ManCoNum(p) - Gia_ManCiNum(p) + Gia_ObjCioId(pObj)); }
536static inline Gia_Obj_t * Gia_ObjRiToRo( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsRi(p, pObj) ); return Gia_ManCi(p, Gia_ManCiNum(p) - Gia_ManCoNum(p) + Gia_ObjCioId(pObj)); }
537static inline int Gia_ObjRoToRiId( Gia_Man_t * p, int ObjId ) { return Gia_ObjId( p, Gia_ObjRoToRi( p, Gia_ManObj(p, ObjId) ) ); }
538static inline int Gia_ObjRiToRoId( Gia_Man_t * p, int ObjId ) { return Gia_ObjId( p, Gia_ObjRiToRo( p, Gia_ManObj(p, ObjId) ) ); }
539
540static inline int Gia_ObjDiff0( Gia_Obj_t * pObj ) { return pObj->iDiff0; }
541static inline int Gia_ObjDiff1( Gia_Obj_t * pObj ) { return pObj->iDiff1; }
542static inline int Gia_ObjFaninC0( Gia_Obj_t * pObj ) { return pObj->fCompl0; }
543static inline int Gia_ObjFaninC1( Gia_Obj_t * pObj ) { return pObj->fCompl1; }
544static inline int Gia_ObjFaninC2( Gia_Man_t * p, Gia_Obj_t * pObj ) { return p->pMuxes && Abc_LitIsCompl(p->pMuxes[Gia_ObjId(p, pObj)]); }
545static inline int Gia_ObjFaninC( Gia_Obj_t * pObj, int n ) { return n ? Gia_ObjFaninC1(pObj) : Gia_ObjFaninC0(pObj); }
546static inline Gia_Obj_t * Gia_ObjFanin0( Gia_Obj_t * pObj ) { return pObj - pObj->iDiff0; }
547static inline Gia_Obj_t * Gia_ObjFanin1( Gia_Obj_t * pObj ) { return pObj - pObj->iDiff1; }
548static inline Gia_Obj_t * Gia_ObjFanin2( Gia_Man_t * p, Gia_Obj_t * pObj ) { return p->pMuxes ? Gia_ManObj(p, Abc_Lit2Var(p->pMuxes[Gia_ObjId(p, pObj)])) : NULL; }
549static inline Gia_Obj_t * Gia_ObjFanin( Gia_Obj_t * pObj, int n ) { return n ? Gia_ObjFanin1(pObj) : Gia_ObjFanin0(pObj); }
550static inline Gia_Obj_t * Gia_ObjChild0( Gia_Obj_t * pObj ) { return Gia_NotCond( Gia_ObjFanin0(pObj), Gia_ObjFaninC0(pObj) ); }
551static inline Gia_Obj_t * Gia_ObjChild1( Gia_Obj_t * pObj ) { return Gia_NotCond( Gia_ObjFanin1(pObj), Gia_ObjFaninC1(pObj) ); }
552static inline Gia_Obj_t * Gia_ObjChild2( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_NotCond( Gia_ObjFanin2(p, pObj), Gia_ObjFaninC2(p, pObj) ); }
553static inline int Gia_ObjFaninId0( Gia_Obj_t * pObj, int ObjId ) { return ObjId - pObj->iDiff0; }
554static inline int Gia_ObjFaninId1( Gia_Obj_t * pObj, int ObjId ) { return ObjId - pObj->iDiff1; }
555static inline int Gia_ObjFaninId2( Gia_Man_t * p, int ObjId ) { return (p->pMuxes && p->pMuxes[ObjId]) ? Abc_Lit2Var(p->pMuxes[ObjId]) : -1; }
556static inline int Gia_ObjFaninId( Gia_Obj_t * pObj, int ObjId, int n ){ return n ? Gia_ObjFaninId1(pObj, ObjId) : Gia_ObjFaninId0(pObj, ObjId); }
557static inline int Gia_ObjFaninId0p( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjFaninId0( pObj, Gia_ObjId(p, pObj) ); }
558static inline int Gia_ObjFaninId1p( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjFaninId1( pObj, Gia_ObjId(p, pObj) ); }
559static inline int Gia_ObjFaninId2p( Gia_Man_t * p, Gia_Obj_t * pObj ) { return (p->pMuxes && p->pMuxes[Gia_ObjId(p, pObj)]) ? Abc_Lit2Var(p->pMuxes[Gia_ObjId(p, pObj)]) : -1; }
560static inline int Gia_ObjFaninIdp( Gia_Man_t * p, Gia_Obj_t * pObj, int n){ return n ? Gia_ObjFaninId1p(p, pObj) : Gia_ObjFaninId0p(p, pObj); }
561static inline int Gia_ObjFaninLit0( Gia_Obj_t * pObj, int ObjId ) { return Abc_Var2Lit( Gia_ObjFaninId0(pObj, ObjId), Gia_ObjFaninC0(pObj) ); }
562static inline int Gia_ObjFaninLit1( Gia_Obj_t * pObj, int ObjId ) { return Abc_Var2Lit( Gia_ObjFaninId1(pObj, ObjId), Gia_ObjFaninC1(pObj) ); }
563static inline int Gia_ObjFaninLit2( Gia_Man_t * p, int ObjId ) { return (p->pMuxes && p->pMuxes[ObjId]) ? p->pMuxes[ObjId] : -1; }
564static inline int Gia_ObjFaninLit( Gia_Obj_t * pObj, int ObjId, int n ){ return n ? Gia_ObjFaninLit1(pObj, ObjId) : Gia_ObjFaninLit0(pObj, ObjId);}
565static inline int Gia_ObjFaninLit0p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Abc_Var2Lit( Gia_ObjFaninId0p(p, pObj), Gia_ObjFaninC0(pObj) ); }
566static inline int Gia_ObjFaninLit1p( Gia_Man_t * p, Gia_Obj_t * pObj) { return Abc_Var2Lit( Gia_ObjFaninId1p(p, pObj), Gia_ObjFaninC1(pObj) ); }
567static inline int Gia_ObjFaninLit2p( Gia_Man_t * p, Gia_Obj_t * pObj) { return (p->pMuxes && p->pMuxes[Gia_ObjId(p, pObj)]) ? p->pMuxes[Gia_ObjId(p, pObj)] : -1; }
568static inline int Gia_ObjFaninLitp( Gia_Man_t * p, Gia_Obj_t * pObj, int n ){ return n ? Gia_ObjFaninLit1p(p, pObj) : Gia_ObjFaninLit0p(p, pObj);}
569static inline void Gia_ObjFlipFaninC0( Gia_Obj_t * pObj ) { assert( Gia_ObjIsCo(pObj) ); pObj->fCompl0 ^= 1; }
570static inline int Gia_ObjFaninNum( Gia_Man_t * p, Gia_Obj_t * pObj ) { if ( Gia_ObjIsMux(p, pObj) ) return 3; if ( Gia_ObjIsAnd(pObj) ) return 2; if ( Gia_ObjIsCo(pObj) ) return 1; return 0; }
571static inline int Gia_ObjWhatFanin( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanin ) { if ( Gia_ObjFanin0(pObj) == pFanin ) return 0; if ( Gia_ObjFanin1(pObj) == pFanin ) return 1; if ( Gia_ObjFanin2(p, pObj) == pFanin ) return 2; assert(0); return -1; }
572
573static inline int Gia_ManCoDriverId( Gia_Man_t * p, int iCoIndex ) { return Gia_ObjFaninId0p(p, Gia_ManCo(p, iCoIndex)); }
574static inline int Gia_ManPoIsConst( Gia_Man_t * p, int iPoIndex ) { return Gia_ObjFaninId0p(p, Gia_ManPo(p, iPoIndex)) == 0; }
575static inline int Gia_ManPoIsConst0( Gia_Man_t * p, int iPoIndex ) { return Gia_ManIsConst0Lit( Gia_ObjFaninLit0p(p, Gia_ManPo(p, iPoIndex)) ); }
576static inline int Gia_ManPoIsConst1( Gia_Man_t * p, int iPoIndex ) { return Gia_ManIsConst1Lit( Gia_ObjFaninLit0p(p, Gia_ManPo(p, iPoIndex)) ); }
577
578static inline Gia_Obj_t * Gia_ObjCopy( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ManObj( p, Abc_Lit2Var(pObj->Value) ); }
579static inline int Gia_ObjLitCopy( Gia_Man_t * p, int iLit ) { return Abc_LitNotCond( Gia_ManObj(p, Abc_Lit2Var(iLit))->Value, Abc_LitIsCompl(iLit)); }
580
581static inline int Gia_ObjFanin0Copy( Gia_Obj_t * pObj ) { return Abc_LitNotCond( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) ); }
582static inline int Gia_ObjFanin1Copy( Gia_Obj_t * pObj ) { return Abc_LitNotCond( Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC1(pObj) ); }
583static inline int Gia_ObjFanin2Copy( Gia_Man_t * p, Gia_Obj_t * pObj ){ return Abc_LitNotCond(Gia_ObjFanin2(p, pObj)->Value, Gia_ObjFaninC2(p, pObj)); }
584
585static inline int Gia_ObjCopyF( Gia_Man_t * p, int f, Gia_Obj_t * pObj ) { return Vec_IntEntry(&p->vCopies, Gia_ManObjNum(p) * f + Gia_ObjId(p,pObj)); }
586static inline void Gia_ObjSetCopyF( Gia_Man_t * p, int f, Gia_Obj_t * pObj, int iLit ) { Vec_IntWriteEntry(&p->vCopies, Gia_ManObjNum(p) * f + Gia_ObjId(p,pObj), iLit); }
587static inline int Gia_ObjCopyArray( Gia_Man_t * p, int iObj ) { return Vec_IntEntry(&p->vCopies, iObj); }
588static inline void Gia_ObjSetCopyArray( Gia_Man_t * p, int iObj, int iLit ) { Vec_IntWriteEntry(&p->vCopies, iObj, iLit); }
589static inline void Gia_ManCleanCopyArray( Gia_Man_t * p ) { Vec_IntFill( &p->vCopies, Gia_ManObjNum(p), -1 ); }
590
591static inline int Gia_ObjCopy2Array( Gia_Man_t * p, int iObj ) { return Vec_IntEntry(&p->vCopies2, iObj); }
592static inline void Gia_ObjSetCopy2Array( Gia_Man_t * p, int iObj, int iLit ) { Vec_IntWriteEntry(&p->vCopies2, iObj, iLit); }
593static inline void Gia_ManCleanCopy2Array( Gia_Man_t * p ) { Vec_IntFill( &p->vCopies2, Gia_ManObjNum(p), -1 ); }
594
595static inline int Gia_ObjFanin0CopyF( Gia_Man_t * p, int f, Gia_Obj_t * pObj ) { return Abc_LitNotCond(Gia_ObjCopyF(p, f, Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj)); }
596static inline int Gia_ObjFanin1CopyF( Gia_Man_t * p, int f, Gia_Obj_t * pObj ) { return Abc_LitNotCond(Gia_ObjCopyF(p, f, Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj)); }
597static inline int Gia_ObjFanin0CopyArray( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Abc_LitNotCond(Gia_ObjCopyArray(p, Gia_ObjFaninId0p(p,pObj)), Gia_ObjFaninC0(pObj)); }
598static inline int Gia_ObjFanin1CopyArray( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Abc_LitNotCond(Gia_ObjCopyArray(p, Gia_ObjFaninId1p(p,pObj)), Gia_ObjFaninC1(pObj)); }
599
600static inline Gia_Obj_t * Gia_ObjFromLit( Gia_Man_t * p, int iLit ) { return Gia_NotCond( Gia_ManObj(p, Abc_Lit2Var(iLit)), Abc_LitIsCompl(iLit) ); }
601static inline int Gia_ObjToLit( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Abc_Var2Lit( Gia_ObjId(p, Gia_Regular(pObj)), Gia_IsComplement(pObj) ); }
602static inline int Gia_ObjPhaseRealLit( Gia_Man_t * p, int iLit ) { return Gia_ObjPhaseReal( Gia_ObjFromLit(p, iLit) ); }
603
604static inline int Gia_ObjLevelId( Gia_Man_t * p, int Id ) { return Vec_IntGetEntry(p->vLevels, Id); }
605static inline int Gia_ObjLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjLevelId( p, Gia_ObjId(p,pObj) ); }
606static inline void Gia_ObjUpdateLevelId( Gia_Man_t * p, int Id, int l ) { Vec_IntSetEntry(p->vLevels, Id, Abc_MaxInt(Vec_IntEntry(p->vLevels, Id), l)); }
607static inline void Gia_ObjSetLevelId( Gia_Man_t * p, int Id, int l ) { Vec_IntSetEntry(p->vLevels, Id, l); }
608static inline void Gia_ObjSetLevel( Gia_Man_t * p, Gia_Obj_t * pObj, int l ) { Gia_ObjSetLevelId( p, Gia_ObjId(p,pObj), l ); }
609static inline void Gia_ObjSetCoLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsCo(pObj) ); Gia_ObjSetLevel( p, pObj, Gia_ObjLevel(p,Gia_ObjFanin0(pObj)) ); }
610static inline void Gia_ObjSetBufLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsAnd(pObj) ); Gia_ObjSetLevel( p, pObj, Gia_ObjLevel(p,Gia_ObjFanin0(pObj)) ); }
611static inline void Gia_ObjSetAndLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsAnd(pObj) ); Gia_ObjSetLevel( p, pObj, 1+Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))) ); }
612static inline void Gia_ObjSetXorLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsXor(pObj) ); Gia_ObjSetLevel( p, pObj, 2+Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))) ); }
613static inline void Gia_ObjSetMuxLevel( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjIsMux(p,pObj) ); Gia_ObjSetLevel( p, pObj, 2+Abc_MaxInt( Abc_MaxInt(Gia_ObjLevel(p,Gia_ObjFanin0(pObj)),Gia_ObjLevel(p,Gia_ObjFanin1(pObj))), Gia_ObjLevel(p,Gia_ObjFanin2(p,pObj))) ); }
614static inline void Gia_ObjSetGateLevel( Gia_Man_t * p, Gia_Obj_t * pObj ){ if ( !p->fGiaSimple && Gia_ObjIsBuf(pObj) ) Gia_ObjSetBufLevel(p, pObj); else if ( Gia_ObjIsMux(p,pObj) ) Gia_ObjSetMuxLevel(p, pObj); else if ( Gia_ObjIsXor(pObj) ) Gia_ObjSetXorLevel(p, pObj); else if ( Gia_ObjIsAnd(pObj) ) Gia_ObjSetAndLevel(p, pObj); }
615
616static inline int Gia_ObjHasNumId( Gia_Man_t * p, int Id ) { return Vec_IntEntry(p->vTtNums, Id) > -ABC_INFINITY; }
617static inline int Gia_ObjNumId( Gia_Man_t * p, int Id ) { return Vec_IntEntry(p->vTtNums, Id); }
618static inline int Gia_ObjNum( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Vec_IntEntry(p->vTtNums, Gia_ObjId(p,pObj)); }
619static inline void Gia_ObjSetNumId( Gia_Man_t * p, int Id, int n ) { Vec_IntWriteEntry(p->vTtNums, Id, n); }
620static inline void Gia_ObjSetNum( Gia_Man_t * p, Gia_Obj_t * pObj, int n ) { Vec_IntWriteEntry(p->vTtNums, Gia_ObjId(p,pObj), n); }
621static inline void Gia_ObjResetNumId( Gia_Man_t * p, int Id ) { Vec_IntWriteEntry(p->vTtNums, Id, -ABC_INFINITY); }
622
623static inline int Gia_ObjRefNumId( Gia_Man_t * p, int Id ) { return p->pRefs[Id]; }
624static inline int Gia_ObjRefIncId( Gia_Man_t * p, int Id ) { return p->pRefs[Id]++; }
625static inline int Gia_ObjRefDecId( Gia_Man_t * p, int Id ) { return --p->pRefs[Id]; }
626static inline int Gia_ObjRefNum( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjRefNumId( p, Gia_ObjId(p, pObj) ); }
627static inline int Gia_ObjRefInc( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjRefIncId( p, Gia_ObjId(p, pObj) ); }
628static inline int Gia_ObjRefDec( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjRefDecId( p, Gia_ObjId(p, pObj) ); }
629static inline void Gia_ObjRefFanin0Inc(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefInc(p, Gia_ObjFanin0(pObj)); }
630static inline void Gia_ObjRefFanin1Inc(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefInc(p, Gia_ObjFanin1(pObj)); }
631static inline void Gia_ObjRefFanin2Inc(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefInc(p, Gia_ObjFanin2(p, pObj)); }
632static inline void Gia_ObjRefFanin0Dec(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefDec(p, Gia_ObjFanin0(pObj)); }
633static inline void Gia_ObjRefFanin1Dec(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefDec(p, Gia_ObjFanin1(pObj)); }
634static inline void Gia_ObjRefFanin2Dec(Gia_Man_t * p, Gia_Obj_t * pObj) { Gia_ObjRefDec(p, Gia_ObjFanin2(p, pObj)); }
635
636static inline int Gia_ObjLutRefNumId( Gia_Man_t * p, int Id ) { assert(p->pLutRefs); return p->pLutRefs[Id]; }
637static inline int Gia_ObjLutRefIncId( Gia_Man_t * p, int Id ) { assert(p->pLutRefs); return p->pLutRefs[Id]++; }
638static inline int Gia_ObjLutRefDecId( Gia_Man_t * p, int Id ) { assert(p->pLutRefs); return --p->pLutRefs[Id]; }
639static inline int Gia_ObjLutRefNum( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert(p->pLutRefs); return p->pLutRefs[Gia_ObjId(p, pObj)]; }
640static inline int Gia_ObjLutRefInc( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert(p->pLutRefs); return p->pLutRefs[Gia_ObjId(p, pObj)]++; }
641static inline int Gia_ObjLutRefDec( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert(p->pLutRefs); return --p->pLutRefs[Gia_ObjId(p, pObj)]; }
642
643static inline void Gia_ObjSetTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); p->pTravIds[Gia_ObjId(p, pObj)] = p->nTravIds; }
644static inline void Gia_ObjSetTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); p->pTravIds[Gia_ObjId(p, pObj)] = p->nTravIds - 1; }
645static inline int Gia_ObjIsTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); return (p->pTravIds[Gia_ObjId(p, pObj)] == p->nTravIds); }
646static inline int Gia_ObjIsTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { assert( Gia_ObjId(p, pObj) < p->nTravIdsAlloc ); return (p->pTravIds[Gia_ObjId(p, pObj)] == p->nTravIds - 1); }
647static inline int Gia_ObjUpdateTravIdCurrent( Gia_Man_t * p, Gia_Obj_t * pObj ) { if ( Gia_ObjIsTravIdCurrent(p, pObj) ) return 1; Gia_ObjSetTravIdCurrent(p, pObj); return 0; }
648static inline int Gia_ObjUpdateTravIdPrevious( Gia_Man_t * p, Gia_Obj_t * pObj ) { if ( Gia_ObjIsTravIdPrevious(p, pObj) ) return 1; Gia_ObjSetTravIdPrevious(p, pObj); return 0; }
649static inline void Gia_ObjSetTravIdCurrentId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); p->pTravIds[Id] = p->nTravIds; }
650static inline void Gia_ObjSetTravIdPreviousId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); p->pTravIds[Id] = p->nTravIds - 1; }
651static inline int Gia_ObjIsTravIdCurrentId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); return (p->pTravIds[Id] == p->nTravIds); }
652static inline int Gia_ObjIsTravIdPreviousId( Gia_Man_t * p, int Id ) { assert( Id < p->nTravIdsAlloc ); return (p->pTravIds[Id] == p->nTravIds - 1); }
653static inline int Gia_ObjUpdateTravIdCurrentId( Gia_Man_t * p, int Id ) { if ( Gia_ObjIsTravIdCurrentId(p, Id) ) return 1; Gia_ObjSetTravIdCurrentId(p, Id); return 0; }
654static inline int Gia_ObjUpdateTravIdPreviousId( Gia_Man_t * p, int Id ) { if ( Gia_ObjIsTravIdPreviousId(p, Id) ) return 1; Gia_ObjSetTravIdPreviousId(p, Id); return 0; }
655
656static inline void Gia_ManTimeClean( Gia_Man_t * p ) { int i; assert( p->vTiming != NULL ); Vec_FltFill(p->vTiming, 3*Gia_ManObjNum(p), 0); for ( i = 0; i < Gia_ManObjNum(p); i++ ) Vec_FltWriteEntry( p->vTiming, 3*i+1, (float)(ABC_INFINITY) ); }
657static inline void Gia_ManTimeStart( Gia_Man_t * p ) { assert( p->vTiming == NULL ); p->vTiming = Vec_FltAlloc(0); Gia_ManTimeClean( p ); }
658static inline void Gia_ManTimeStop( Gia_Man_t * p ) { assert( p->vTiming != NULL ); Vec_FltFreeP(&p->vTiming); }
659static inline float Gia_ObjTimeArrival( Gia_Man_t * p, int Id ) { return Vec_FltEntry(p->vTiming, 3*Id+0); }
660static inline float Gia_ObjTimeRequired( Gia_Man_t * p, int Id ) { return Vec_FltEntry(p->vTiming, 3*Id+1); }
661static inline float Gia_ObjTimeSlack( Gia_Man_t * p, int Id ) { return Vec_FltEntry(p->vTiming, 3*Id+2); }
662static inline float Gia_ObjTimeArrivalObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjTimeArrival( p, Gia_ObjId(p, pObj) ); }
663static inline float Gia_ObjTimeRequiredObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjTimeRequired( p, Gia_ObjId(p, pObj) ); }
664static inline float Gia_ObjTimeSlackObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjTimeSlack( p, Gia_ObjId(p, pObj) ); }
665static inline void Gia_ObjSetTimeArrival( Gia_Man_t * p, int Id, float t ) { Vec_FltWriteEntry( p->vTiming, 3*Id+0, t ); }
666static inline void Gia_ObjSetTimeRequired( Gia_Man_t * p, int Id, float t ) { Vec_FltWriteEntry( p->vTiming, 3*Id+1, t ); }
667static inline void Gia_ObjSetTimeSlack( Gia_Man_t * p, int Id, float t ) { Vec_FltWriteEntry( p->vTiming, 3*Id+2, t ); }
668static inline void Gia_ObjSetTimeArrivalObj( Gia_Man_t * p, Gia_Obj_t * pObj, float t ) { Gia_ObjSetTimeArrival( p, Gia_ObjId(p, pObj), t ); }
669static inline void Gia_ObjSetTimeRequiredObj( Gia_Man_t * p, Gia_Obj_t * pObj, float t ) { Gia_ObjSetTimeRequired( p, Gia_ObjId(p, pObj), t ); }
670static inline void Gia_ObjSetTimeSlackObj( Gia_Man_t * p, Gia_Obj_t * pObj, float t ) { Gia_ObjSetTimeSlack( p, Gia_ObjId(p, pObj), t ); }
671
672static inline int Gia_ObjSimWords( Gia_Man_t * p ) { return Vec_WrdSize( p->vSimsPi ) / Gia_ManPiNum( p ); }
673static inline word * Gia_ObjSimPi( Gia_Man_t * p, int PiId ) { return Vec_WrdEntryP( p->vSimsPi, PiId * Gia_ObjSimWords(p) ); }
674static inline word * Gia_ObjSim( Gia_Man_t * p, int Id ) { return Vec_WrdEntryP( p->vSims, Id * Gia_ObjSimWords(p) ); }
675static inline word * Gia_ObjSimObj( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjSim( p, Gia_ObjId(p, pObj) ); }
676
677// AIG construction
678extern void Gia_ObjAddFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout );
679static inline Gia_Obj_t * Gia_ManAppendObj( Gia_Man_t * p )
680{
681 if ( p->nObjs == p->nObjsAlloc )
682 {
683 int nObjNew = Abc_MinInt( 2 * p->nObjsAlloc, (1 << 29) );
684 if ( p->nObjs == (1 << 29) )
685 printf( "Hard limit on the number of nodes (2^29) is reached. Quitting...\n" ), exit(1);
686 assert( p->nObjs < nObjNew );
687 if ( p->fVerbose )
688 printf("Extending GIA object storage: %d -> %d.\n", p->nObjsAlloc, nObjNew );
689 assert( p->nObjsAlloc > 0 );
690 p->pObjs = ABC_REALLOC( Gia_Obj_t, p->pObjs, nObjNew );
691 memset( p->pObjs + p->nObjsAlloc, 0, sizeof(Gia_Obj_t) * (nObjNew - p->nObjsAlloc) );
692 if ( p->pMuxes )
693 {
694 p->pMuxes = ABC_REALLOC( unsigned, p->pMuxes, nObjNew );
695 memset( p->pMuxes + p->nObjsAlloc, 0, sizeof(unsigned) * (nObjNew - p->nObjsAlloc) );
696 }
697 p->nObjsAlloc = nObjNew;
698 }
699 if ( Vec_IntSize(&p->vHTable) ) Vec_IntPush( &p->vHash, 0 );
700 return Gia_ManObj( p, p->nObjs++ );
701}
702static inline int Gia_ManAppendCi( Gia_Man_t * p )
703{
704 Gia_Obj_t * pObj = Gia_ManAppendObj( p );
705 pObj->fTerm = 1;
706 pObj->iDiff0 = GIA_NONE;
707 pObj->iDiff1 = Vec_IntSize( p->vCis );
708 Vec_IntPush( p->vCis, Gia_ObjId(p, pObj) );
709 return Gia_ObjId( p, pObj ) << 1;
710}
711
712extern void Gia_ManQuantSetSuppAnd( Gia_Man_t * p, Gia_Obj_t * pObj );
713extern void Gia_ManBuiltInSimPerform( Gia_Man_t * p, int iObj );
714
715static inline int Gia_ManAppendAnd( Gia_Man_t * p, int iLit0, int iLit1 )
716{
717 Gia_Obj_t * pObj = Gia_ManAppendObj( p );
718 assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
719 assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
720 assert( p->fGiaSimple || Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
721 if ( iLit0 < iLit1 )
722 {
723 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
724 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit0));
725 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
726 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit1));
727 }
728 else
729 {
730 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
731 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit0));
732 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
733 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit1));
734 }
735 if ( p->pFanData )
736 {
737 Gia_ObjAddFanout( p, Gia_ObjFanin0(pObj), pObj );
738 Gia_ObjAddFanout( p, Gia_ObjFanin1(pObj), pObj );
739 }
740 if ( p->fSweeper )
741 {
742 Gia_Obj_t * pFan0 = Gia_ObjFanin0(pObj);
743 Gia_Obj_t * pFan1 = Gia_ObjFanin1(pObj);
744 if ( pFan0->fMark0 ) pFan0->fMark1 = 1; else pFan0->fMark0 = 1;
745 if ( pFan1->fMark0 ) pFan1->fMark1 = 1; else pFan1->fMark0 = 1;
746 pObj->fPhase = (Gia_ObjPhase(pFan0) ^ Gia_ObjFaninC0(pObj)) & (Gia_ObjPhase(pFan1) ^ Gia_ObjFaninC1(pObj));
747 }
748 if ( p->fBuiltInSim )
749 {
750 Gia_Obj_t * pFan0 = Gia_ObjFanin0(pObj);
751 Gia_Obj_t * pFan1 = Gia_ObjFanin1(pObj);
752 pObj->fPhase = (Gia_ObjPhase(pFan0) ^ Gia_ObjFaninC0(pObj)) & (Gia_ObjPhase(pFan1) ^ Gia_ObjFaninC1(pObj));
753 Gia_ManBuiltInSimPerform( p, Gia_ObjId( p, pObj ) );
754 }
755 if ( p->vSuppWords )
756 Gia_ManQuantSetSuppAnd( p, pObj );
757 return Gia_ObjId( p, pObj ) << 1;
758}
759static inline int Gia_ManAppendXorReal( Gia_Man_t * p, int iLit0, int iLit1 )
760{
761 Gia_Obj_t * pObj = Gia_ManAppendObj( p );
762 assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
763 assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
764 assert( Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
765 //assert( !Abc_LitIsCompl(iLit0) );
766 //assert( !Abc_LitIsCompl(iLit1) );
767 if ( Abc_Lit2Var(iLit0) > Abc_Lit2Var(iLit1) )
768 {
769 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
770 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit0));
771 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
772 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit1));
773 }
774 else
775 {
776 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
777 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit0));
778 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
779 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit1));
780 }
781 p->nXors++;
782 return Gia_ObjId( p, pObj ) << 1;
783}
784static inline int Gia_ManAppendMuxReal( Gia_Man_t * p, int iLitC, int iLit1, int iLit0 )
785{
786 Gia_Obj_t * pObj = Gia_ManAppendObj( p );
787 assert( p->pMuxes != NULL );
788 assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
789 assert( iLit1 >= 0 && Abc_Lit2Var(iLit1) < Gia_ManObjNum(p) );
790 assert( iLitC >= 0 && Abc_Lit2Var(iLitC) < Gia_ManObjNum(p) );
791 assert( Abc_Lit2Var(iLit0) != Abc_Lit2Var(iLit1) );
792 assert( Abc_Lit2Var(iLitC) != Abc_Lit2Var(iLit0) );
793 assert( Abc_Lit2Var(iLitC) != Abc_Lit2Var(iLit1) );
794 assert( !Vec_IntSize(&p->vHTable) || !Abc_LitIsCompl(iLit1) );
795 if ( Abc_Lit2Var(iLit0) < Abc_Lit2Var(iLit1) )
796 {
797 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
798 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit0));
799 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
800 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit1));
801 p->pMuxes[Gia_ObjId(p, pObj)] = iLitC;
802 }
803 else
804 {
805 pObj->iDiff1 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0));
806 pObj->fCompl1 = (unsigned)(Abc_LitIsCompl(iLit0));
807 pObj->iDiff0 = (unsigned)(Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit1));
808 pObj->fCompl0 = (unsigned)(Abc_LitIsCompl(iLit1));
809 p->pMuxes[Gia_ObjId(p, pObj)] = Abc_LitNot(iLitC);
810 }
811 p->nMuxes++;
812 return Gia_ObjId( p, pObj ) << 1;
813}
814static inline int Gia_ManAppendBuf( Gia_Man_t * p, int iLit )
815{
816 Gia_Obj_t * pObj = Gia_ManAppendObj( p );
817 assert( iLit >= 0 && Abc_Lit2Var(iLit) < Gia_ManObjNum(p) );
818 pObj->iDiff0 = pObj->iDiff1 = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit);
819 pObj->fCompl0 = pObj->fCompl1 = Abc_LitIsCompl(iLit);
820 p->nBufs++;
821 return Gia_ObjId( p, pObj ) << 1;
822}
823static inline int Gia_ManAppendCo( Gia_Man_t * p, int iLit0 )
824{
825 Gia_Obj_t * pObj;
826 assert( iLit0 >= 0 && Abc_Lit2Var(iLit0) < Gia_ManObjNum(p) );
827 assert( !Gia_ObjIsCo(Gia_ManObj(p, Abc_Lit2Var(iLit0))) );
828 pObj = Gia_ManAppendObj( p );
829 pObj->fTerm = 1;
830 pObj->iDiff0 = Gia_ObjId(p, pObj) - Abc_Lit2Var(iLit0);
831 pObj->fCompl0 = Abc_LitIsCompl(iLit0);
832 pObj->iDiff1 = Vec_IntSize( p->vCos );
833 Vec_IntPush( p->vCos, Gia_ObjId(p, pObj) );
834 if ( p->pFanData )
835 Gia_ObjAddFanout( p, Gia_ObjFanin0(pObj), pObj );
836 return Gia_ObjId( p, pObj ) << 1;
837}
838static inline int Gia_ManAppendOr( Gia_Man_t * p, int iLit0, int iLit1 )
839{
840 return Abc_LitNot(Gia_ManAppendAnd( p, Abc_LitNot(iLit0), Abc_LitNot(iLit1) ));
841}
842static inline int Gia_ManAppendMux( Gia_Man_t * p, int iCtrl, int iData1, int iData0 )
843{
844 int iTemp0 = Gia_ManAppendAnd( p, Abc_LitNot(iCtrl), iData0 );
845 int iTemp1 = Gia_ManAppendAnd( p, iCtrl, iData1 );
846 return Abc_LitNotCond( Gia_ManAppendAnd( p, Abc_LitNot(iTemp0), Abc_LitNot(iTemp1) ), 1 );
847}
848static inline int Gia_ManAppendMaj( Gia_Man_t * p, int iData0, int iData1, int iData2 )
849{
850 int iTemp0 = Gia_ManAppendOr( p, iData1, iData2 );
851 int iTemp1 = Gia_ManAppendAnd( p, iData0, iTemp0 );
852 int iTemp2 = Gia_ManAppendAnd( p, iData1, iData2 );
853 return Gia_ManAppendOr( p, iTemp1, iTemp2 );
854}
855static inline int Gia_ManAppendXor( Gia_Man_t * p, int iLit0, int iLit1 )
856{
857 return Gia_ManAppendMux( p, iLit0, Abc_LitNot(iLit1), iLit1 );
858}
859
860static inline int Gia_ManAppendAnd2( Gia_Man_t * p, int iLit0, int iLit1 )
861{
862 if ( !p->fGiaSimple )
863 {
864 if ( iLit0 < 2 )
865 return iLit0 ? iLit1 : 0;
866 if ( iLit1 < 2 )
867 return iLit1 ? iLit0 : 0;
868 if ( iLit0 == iLit1 )
869 return iLit1;
870 if ( iLit0 == Abc_LitNot(iLit1) )
871 return 0;
872 }
873 return Gia_ManAppendAnd( p, iLit0, iLit1 );
874}
875static inline int Gia_ManAppendOr2( Gia_Man_t * p, int iLit0, int iLit1 )
876{
877 return Abc_LitNot(Gia_ManAppendAnd2( p, Abc_LitNot(iLit0), Abc_LitNot(iLit1) ));
878}
879static inline int Gia_ManAppendMux2( Gia_Man_t * p, int iCtrl, int iData1, int iData0 )
880{
881 int iTemp0 = Gia_ManAppendAnd2( p, Abc_LitNot(iCtrl), iData0 );
882 int iTemp1 = Gia_ManAppendAnd2( p, iCtrl, iData1 );
883 return Abc_LitNotCond( Gia_ManAppendAnd2( p, Abc_LitNot(iTemp0), Abc_LitNot(iTemp1) ), 1 );
884}
885static inline int Gia_ManAppendMaj2( Gia_Man_t * p, int iData0, int iData1, int iData2 )
886{
887 int iTemp0 = Gia_ManAppendOr2( p, iData1, iData2 );
888 int iTemp1 = Gia_ManAppendAnd2( p, iData0, iTemp0 );
889 int iTemp2 = Gia_ManAppendAnd2( p, iData1, iData2 );
890 return Gia_ManAppendOr2( p, iTemp1, iTemp2 );
891}
892static inline int Gia_ManAppendXor2( Gia_Man_t * p, int iLit0, int iLit1 )
893{
894 return Gia_ManAppendMux2( p, iLit0, Abc_LitNot(iLit1), iLit1 );
895}
896
897static inline int Gia_ManAppendXorReal2( Gia_Man_t * p, int iLit0, int iLit1 )
898{
899 if ( !p->fGiaSimple )
900 {
901 if ( iLit0 < 2 )
902 return iLit0 ? Abc_LitNot(iLit1) : iLit1;
903 if ( iLit1 < 2 )
904 return iLit1 ? Abc_LitNot(iLit0) : iLit0;
905 if ( iLit0 == iLit1 )
906 return 0;
907 if ( iLit0 == Abc_LitNot(iLit1) )
908 return 1;
909 }
910 return Gia_ManAppendXorReal( p, iLit0, iLit1 );
911}
912
913static inline void Gia_ManPatchCoDriver( Gia_Man_t * p, int iCoIndex, int iLit0 )
914{
915 Gia_Obj_t * pObjCo = Gia_ManCo( p, iCoIndex );
916 assert( Gia_ObjId(p, pObjCo) > Abc_Lit2Var(iLit0) );
917 pObjCo->iDiff0 = Gia_ObjId(p, pObjCo) - Abc_Lit2Var(iLit0);
918 pObjCo->fCompl0 = Abc_LitIsCompl(iLit0);
919}
920
921#define GIA_ZER 1
922#define GIA_ONE 2
923#define GIA_UND 3
924
925static inline int Gia_XsimNotCond( int Value, int fCompl )
926{
927 if ( Value == GIA_UND )
928 return GIA_UND;
929 if ( Value == GIA_ZER + fCompl )
930 return GIA_ZER;
931 return GIA_ONE;
932}
933static inline int Gia_XsimAndCond( int Value0, int fCompl0, int Value1, int fCompl1 )
934{
935 if ( Value0 == GIA_ZER + fCompl0 || Value1 == GIA_ZER + fCompl1 )
936 return GIA_ZER;
937 if ( Value0 == GIA_UND || Value1 == GIA_UND )
938 return GIA_UND;
939 return GIA_ONE;
940}
941
942
943static inline void Gia_ObjTerSimSetC( Gia_Obj_t * pObj ) { pObj->fMark0 = 0; pObj->fMark1 = 0; }
944static inline void Gia_ObjTerSimSet0( Gia_Obj_t * pObj ) { pObj->fMark0 = 1; pObj->fMark1 = 0; }
945static inline void Gia_ObjTerSimSet1( Gia_Obj_t * pObj ) { pObj->fMark0 = 0; pObj->fMark1 = 1; }
946static inline void Gia_ObjTerSimSetX( Gia_Obj_t * pObj ) { pObj->fMark0 = 1; pObj->fMark1 = 1; }
947
948static inline int Gia_ObjTerSimGetC( Gia_Obj_t * pObj ) { return !pObj->fMark0 && !pObj->fMark1; }
949static inline int Gia_ObjTerSimGet0( Gia_Obj_t * pObj ) { return pObj->fMark0 && !pObj->fMark1; }
950static inline int Gia_ObjTerSimGet1( Gia_Obj_t * pObj ) { return !pObj->fMark0 && pObj->fMark1; }
951static inline int Gia_ObjTerSimGetX( Gia_Obj_t * pObj ) { return pObj->fMark0 && pObj->fMark1; }
952
953static inline int Gia_ObjTerSimGet0Fanin0( Gia_Obj_t * pObj ) { return (Gia_ObjTerSimGet1(Gia_ObjFanin0(pObj)) && Gia_ObjFaninC0(pObj)) || (Gia_ObjTerSimGet0(Gia_ObjFanin0(pObj)) && !Gia_ObjFaninC0(pObj)); }
954static inline int Gia_ObjTerSimGet1Fanin0( Gia_Obj_t * pObj ) { return (Gia_ObjTerSimGet0(Gia_ObjFanin0(pObj)) && Gia_ObjFaninC0(pObj)) || (Gia_ObjTerSimGet1(Gia_ObjFanin0(pObj)) && !Gia_ObjFaninC0(pObj)); }
955
956static inline int Gia_ObjTerSimGet0Fanin1( Gia_Obj_t * pObj ) { return (Gia_ObjTerSimGet1(Gia_ObjFanin1(pObj)) && Gia_ObjFaninC1(pObj)) || (Gia_ObjTerSimGet0(Gia_ObjFanin1(pObj)) && !Gia_ObjFaninC1(pObj)); }
957static inline int Gia_ObjTerSimGet1Fanin1( Gia_Obj_t * pObj ) { return (Gia_ObjTerSimGet0(Gia_ObjFanin1(pObj)) && Gia_ObjFaninC1(pObj)) || (Gia_ObjTerSimGet1(Gia_ObjFanin1(pObj)) && !Gia_ObjFaninC1(pObj)); }
958
959static inline void Gia_ObjTerSimAnd( Gia_Obj_t * pObj )
960{
961 assert( Gia_ObjIsAnd(pObj) );
962 assert( !Gia_ObjTerSimGetC( Gia_ObjFanin0(pObj) ) );
963 assert( !Gia_ObjTerSimGetC( Gia_ObjFanin1(pObj) ) );
964 if ( Gia_ObjTerSimGet0Fanin0(pObj) || Gia_ObjTerSimGet0Fanin1(pObj) )
965 Gia_ObjTerSimSet0( pObj );
966 else if ( Gia_ObjTerSimGet1Fanin0(pObj) && Gia_ObjTerSimGet1Fanin1(pObj) )
967 Gia_ObjTerSimSet1( pObj );
968 else
969 Gia_ObjTerSimSetX( pObj );
970}
971static inline void Gia_ObjTerSimCo( Gia_Obj_t * pObj )
972{
973 assert( Gia_ObjIsCo(pObj) );
974 assert( !Gia_ObjTerSimGetC( Gia_ObjFanin0(pObj) ) );
975 if ( Gia_ObjTerSimGet0Fanin0(pObj) )
976 Gia_ObjTerSimSet0( pObj );
977 else if ( Gia_ObjTerSimGet1Fanin0(pObj) )
978 Gia_ObjTerSimSet1( pObj );
979 else
980 Gia_ObjTerSimSetX( pObj );
981}
982static inline void Gia_ObjTerSimRo( Gia_Man_t * p, Gia_Obj_t * pObj )
983{
984 Gia_Obj_t * pTemp = Gia_ObjRoToRi(p, pObj);
985 assert( Gia_ObjIsRo(p, pObj) );
986 assert( !Gia_ObjTerSimGetC( pTemp ) );
987 pObj->fMark0 = pTemp->fMark0;
988 pObj->fMark1 = pTemp->fMark1;
989}
990
991static inline void Gia_ObjTerSimPrint( Gia_Obj_t * pObj )
992{
993 if ( Gia_ObjTerSimGet0(pObj) )
994 printf( "0" );
995 else if ( Gia_ObjTerSimGet1(pObj) )
996 printf( "1" );
997 else if ( Gia_ObjTerSimGetX(pObj) )
998 printf( "X" );
999}
1000
1001static inline int Gia_AigerReadInt( unsigned char * pPos )
1002{
1003 int i, Value = 0;
1004 for ( i = 0; i < 4; i++ )
1005 Value = (Value << 8) | *pPos++;
1006 return Value;
1007}
1008static inline void Gia_AigerWriteInt( unsigned char * pPos, int Value )
1009{
1010 int i;
1011 for ( i = 3; i >= 0; i-- )
1012 *pPos++ = (Value >> (8*i)) & 255;
1013}
1014static inline unsigned Gia_AigerReadUnsigned( unsigned char ** ppPos )
1015{
1016 unsigned x = 0, i = 0;
1017 unsigned char ch;
1018 while ((ch = *(*ppPos)++) & 0x80)
1019 x |= (ch & 0x7f) << (7 * i++);
1020 return x | (ch << (7 * i));
1021}
1022static inline void Gia_AigerWriteUnsigned( Vec_Str_t * vStr, unsigned x )
1023{
1024 unsigned char ch;
1025 while (x & ~0x7f)
1026 {
1027 ch = (x & 0x7f) | 0x80;
1028 Vec_StrPush( vStr, ch );
1029 x >>= 7;
1030 }
1031 ch = x;
1032 Vec_StrPush( vStr, ch );
1033}
1034static inline void Gia_AigerWriteUnsignedFile( FILE * pFile, unsigned x )
1035{
1036 unsigned char ch;
1037 while (x & ~0x7f)
1038 {
1039 ch = (x & 0x7f) | 0x80;
1040 fputc( ch, pFile );
1041 x >>= 7;
1042 }
1043 ch = x;
1044 fputc( ch, pFile );
1045}
1046static inline int Gia_AigerWriteUnsignedBuffer( unsigned char * pBuffer, int Pos, unsigned x )
1047{
1048 unsigned char ch;
1049 while (x & ~0x7f)
1050 {
1051 ch = (x & 0x7f) | 0x80;
1052 pBuffer[Pos++] = ch;
1053 x >>= 7;
1054 }
1055 ch = x;
1056 pBuffer[Pos++] = ch;
1057 return Pos;
1058}
1059
1060static inline Gia_Obj_t * Gia_ObjReprObj( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr == GIA_VOID ? NULL : Gia_ManObj( p, p->pReprs[Id].iRepr ); }
1061static inline int Gia_ObjRepr( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr; }
1062static inline void Gia_ObjSetRepr( Gia_Man_t * p, int Id, int Num ) { assert( Num == GIA_VOID || Num < Id ); p->pReprs[Id].iRepr = Num; }
1063static inline void Gia_ObjSetReprRev( Gia_Man_t * p, int Id, int Num ){ assert( Num == GIA_VOID || Num > Id ); p->pReprs[Id].iRepr = Num; }
1064static inline void Gia_ObjUnsetRepr( Gia_Man_t * p, int Id ) { p->pReprs[Id].iRepr = GIA_VOID; }
1065static inline int Gia_ObjHasRepr( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr != GIA_VOID; }
1066static inline int Gia_ObjReprSelf( Gia_Man_t * p, int Id ) { return Gia_ObjHasRepr(p, Id) ? Gia_ObjRepr(p, Id) : Id; }
1067static inline int Gia_ObjSibl( Gia_Man_t * p, int Id ) { return p->pSibls ? p->pSibls[Id] : 0; }
1068static inline Gia_Obj_t * Gia_ObjSiblObj( Gia_Man_t * p, int Id ) { return (p->pSibls && p->pSibls[Id]) ? Gia_ManObj(p, p->pSibls[Id]) : NULL; }
1069
1070static inline int Gia_ObjProved( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fProved; }
1071static inline void Gia_ObjSetProved( Gia_Man_t * p, int Id ) { p->pReprs[Id].fProved = 1; }
1072static inline void Gia_ObjUnsetProved( Gia_Man_t * p, int Id ) { p->pReprs[Id].fProved = 0; }
1073
1074static inline int Gia_ObjFailed( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fFailed; }
1075static inline void Gia_ObjSetFailed( Gia_Man_t * p, int Id ) { p->pReprs[Id].fFailed = 1; }
1076
1077static inline int Gia_ObjColor( Gia_Man_t * p, int Id, int c ) { return c? p->pReprs[Id].fColorB : p->pReprs[Id].fColorA; }
1078static inline int Gia_ObjColors( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fColorB * 2 + p->pReprs[Id].fColorA; }
1079static inline void Gia_ObjSetColor( Gia_Man_t * p, int Id, int c ) { if (c) p->pReprs[Id].fColorB = 1; else p->pReprs[Id].fColorA = 1; }
1080static inline void Gia_ObjSetColors( Gia_Man_t * p, int Id ) { p->pReprs[Id].fColorB = p->pReprs[Id].fColorA = 1; }
1081static inline int Gia_ObjVisitColor( Gia_Man_t * p, int Id, int c ) { int x; if (c) { x = p->pReprs[Id].fColorB; p->pReprs[Id].fColorB = 1; } else { x = p->pReprs[Id].fColorA; p->pReprs[Id].fColorA = 1; } return x; }
1082static inline int Gia_ObjDiffColors( Gia_Man_t * p, int i, int j ) { return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) && (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); }
1083static inline int Gia_ObjDiffColors2( Gia_Man_t * p, int i, int j ) { return (p->pReprs[i].fColorA ^ p->pReprs[j].fColorA) || (p->pReprs[i].fColorB ^ p->pReprs[j].fColorB); }
1084
1085static inline Gia_Obj_t * Gia_ObjNextObj( Gia_Man_t * p, int Id ) { return p->pNexts[Id] == 0 ? NULL : Gia_ManObj( p, p->pNexts[Id] );}
1086static inline int Gia_ObjNext( Gia_Man_t * p, int Id ) { return p->pNexts[Id]; }
1087static inline void Gia_ObjSetNext( Gia_Man_t * p, int Id, int Num ) { p->pNexts[Id] = Num; }
1088
1089static inline int Gia_ObjIsConst( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == 0; }
1090static inline int Gia_ObjIsHead( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) > 0; }
1091static inline int Gia_ObjIsNone( Gia_Man_t * p, int Id ) { return Gia_ObjRepr(p, Id) == GIA_VOID && Gia_ObjNext(p, Id) <= 0; }
1092static inline int Gia_ObjIsTail( Gia_Man_t * p, int Id ) { return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) && Gia_ObjNext(p, Id) <= 0; }
1093static inline int Gia_ObjIsClass( Gia_Man_t * p, int Id ) { return (Gia_ObjRepr(p, Id) > 0 && Gia_ObjRepr(p, Id) != GIA_VOID) || Gia_ObjNext(p, Id) > 0; }
1094static inline int Gia_ObjHasSameRepr( Gia_Man_t * p, int i, int k ) { assert( k ); return i? (Gia_ObjRepr(p, i) == Gia_ObjRepr(p, k) && Gia_ObjRepr(p, i) != GIA_VOID) : Gia_ObjRepr(p, k) == 0; }
1095static inline int Gia_ObjIsFailedPair( Gia_Man_t * p, int i, int k ) { assert( k ); return i? (Gia_ObjFailed(p, i) || Gia_ObjFailed(p, k)) : Gia_ObjFailed(p, k); }
1096static inline int Gia_ClassIsPair( Gia_Man_t * p, int i ) { assert( Gia_ObjIsHead(p, i) ); assert( Gia_ObjNext(p, i) ); return Gia_ObjNext(p, Gia_ObjNext(p, i)) <= 0; }
1097static inline void Gia_ClassUndoPair( Gia_Man_t * p, int i ) { assert( Gia_ClassIsPair(p,i) ); Gia_ObjSetRepr(p, Gia_ObjNext(p, i), GIA_VOID); Gia_ObjSetNext(p, i, 0); }
1098
1099#define Gia_ManForEachConst( p, i ) \
1100 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsConst(p, i) ) {} else
1101#define Gia_ManForEachClass( p, i ) \
1102 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else
1103#define Gia_ManForEachClass0( p, i ) \
1104 for ( i = 0; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsHead(p, i) ) {} else
1105#define Gia_ManForEachClassReverse( p, i ) \
1106 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsHead(p, i) ) {} else
1107#define Gia_ClassForEachObj( p, i, iObj ) \
1108 for ( assert(Gia_ObjIsHead(p, i) && i), iObj = i; iObj > 0; iObj = Gia_ObjNext(p, iObj) )
1109#define Gia_ClassForEachObj1( p, i, iObj ) \
1110 for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, i); iObj > 0; iObj = Gia_ObjNext(p, iObj) )
1111#define Gia_ClassForEachObjStart( p, i, iObj, Start ) \
1112 for ( assert(Gia_ObjIsHead(p, i)), iObj = Gia_ObjNext(p, Start); iObj > 0; iObj = Gia_ObjNext(p, iObj) )
1113
1114
1115static inline int Gia_ObjFoffsetId( Gia_Man_t * p, int Id ) { return Vec_IntEntry( p->vFanout, Id ); }
1116static inline int Gia_ObjFoffset( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjFoffsetId( p, Gia_ObjId(p, pObj) ); }
1117static inline int Gia_ObjFanoutNumId( Gia_Man_t * p, int Id ) { return Vec_IntEntry( p->vFanoutNums, Id ); }
1118static inline int Gia_ObjFanoutNum( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ObjFanoutNumId( p, Gia_ObjId(p, pObj) ); }
1119static inline int Gia_ObjFanoutId( Gia_Man_t * p, int Id, int i ) { return Vec_IntEntry( p->vFanout, Gia_ObjFoffsetId(p, Id) + i ); }
1120static inline Gia_Obj_t * Gia_ObjFanout0( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ManObj( p, Gia_ObjFanoutId(p, Gia_ObjId(p, pObj), 0) ); }
1121static inline Gia_Obj_t * Gia_ObjFanout( Gia_Man_t * p, Gia_Obj_t * pObj, int i ) { return Gia_ManObj( p, Gia_ObjFanoutId(p, Gia_ObjId(p, pObj), i) ); }
1122static inline void Gia_ObjSetFanout( Gia_Man_t * p, Gia_Obj_t * pObj, int i, Gia_Obj_t * pFan ) { Vec_IntWriteEntry( p->vFanout, Gia_ObjFoffset(p, pObj) + i, Gia_ObjId(p, pFan) ); }
1123static inline void Gia_ObjSetFanoutInt( Gia_Man_t * p, Gia_Obj_t * pObj, int i, int x ) { Vec_IntWriteEntry( p->vFanout, Gia_ObjFoffset(p, pObj) + i, x ); }
1124
1125#define Gia_ObjForEachFanoutStatic( p, pObj, pFanout, i ) \
1126 for ( i = 0; (i < Gia_ObjFanoutNum(p, pObj)) && (((pFanout) = Gia_ObjFanout(p, pObj, i)), 1); i++ )
1127#define Gia_ObjForEachFanoutStaticId( p, Id, FanId, i ) \
1128 for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && ((FanId = Gia_ObjFanoutId(p, Id, i)), 1); i++ )
1129#define Gia_ObjForEachFanoutStaticIndex( p, Id, FanId, i, Index ) \
1130 for ( i = 0; (i < Gia_ObjFanoutNumId(p, Id)) && (Index = Vec_IntEntry(p->vFanout, Id)+i) && ((FanId = Vec_IntEntry(p->vFanout, Index)), 1); i++ )
1131
1132static inline int Gia_ManHasMapping( Gia_Man_t * p ) { return p->vMapping != NULL; }
1133static inline int Gia_ObjIsLut( Gia_Man_t * p, int Id ) { return Vec_IntEntry(p->vMapping, Id) != 0; }
1134static inline int Gia_ObjLutSize( Gia_Man_t * p, int Id ) { return Vec_IntEntry(p->vMapping, Vec_IntEntry(p->vMapping, Id)); }
1135static inline int * Gia_ObjLutFanins( Gia_Man_t * p, int Id ) { return Vec_IntEntryP(p->vMapping, Vec_IntEntry(p->vMapping, Id)) + 1; }
1136static inline int Gia_ObjLutFanin( Gia_Man_t * p, int Id, int i ) { return Gia_ObjLutFanins(p, Id)[i]; }
1137static inline int Gia_ObjLutMuxId( Gia_Man_t * p, int Id ) { return Gia_ObjLutFanins(p, Id)[Gia_ObjLutSize(p, Id)]; }
1138static inline int Gia_ObjLutIsMux( Gia_Man_t * p, int Id ) { return (int)(Gia_ObjLutMuxId(p, Id) < 0); }
1139
1140static inline int Gia_ManHasMapping2( Gia_Man_t * p ) { return p->vMapping2 != NULL; }
1141static inline int Gia_ObjIsLut2( Gia_Man_t * p, int Id ) { return Vec_IntSize(Vec_WecEntry(p->vMapping2, Id)) != 0; }
1142static inline int Gia_ObjLutSize2( Gia_Man_t * p, int Id ) { return Vec_IntSize(Vec_WecEntry(p->vMapping2, Id)); }
1143static inline Vec_Int_t * Gia_ObjLutFanins2( Gia_Man_t * p, int Id ) { return Vec_WecEntry(p->vMapping2, Id); }
1144static inline int Gia_ObjLutFanin2( Gia_Man_t * p, int Id, int i ) { return Vec_IntEntry(Vec_WecEntry(p->vMapping2, Id), i); }
1145static inline int Gia_ObjLutFanoutNum2( Gia_Man_t * p, int Id ) { return Vec_IntSize(Vec_WecEntry(p->vFanouts2, Id)); }
1146static inline int Gia_ObjLutFanout2( Gia_Man_t * p, int Id, int i ) { return Vec_IntEntry(Vec_WecEntry(p->vFanouts2, Id), i); }
1147
1148static inline int Gia_ManHasCellMapping( Gia_Man_t * p ) { return p->vCellMapping != NULL; }
1149static inline int Gia_ObjIsCell( Gia_Man_t * p, int iLit ) { return Vec_IntEntry(p->vCellMapping, iLit) != 0; }
1150static inline int Gia_ObjIsCellInv( Gia_Man_t * p, int iLit ) { return Vec_IntEntry(p->vCellMapping, iLit) == -1; }
1151static inline int Gia_ObjIsCellBuf( Gia_Man_t * p, int iLit ) { return Vec_IntEntry(p->vCellMapping, iLit) == -2; }
1152static inline int Gia_ObjCellSize( Gia_Man_t * p, int iLit ) { return Vec_IntEntry(p->vCellMapping, Vec_IntEntry(p->vCellMapping, iLit)); }
1153static inline int * Gia_ObjCellFanins( Gia_Man_t * p, int iLit ) { return Vec_IntEntryP(p->vCellMapping, Vec_IntEntry(p->vCellMapping, iLit))+1; }
1154static inline int Gia_ObjCellFanin( Gia_Man_t * p, int iLit, int i ){ return Gia_ObjCellFanins(p, iLit)[i]; }
1155static inline int Gia_ObjCellId( Gia_Man_t * p, int iLit ) { return Gia_ObjCellFanins(p, iLit)[Gia_ObjCellSize(p, iLit)]; }
1156
1157#define Gia_ManForEachLut( p, i ) \
1158 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut(p, i) ) {} else
1159#define Gia_ManForEachLutReverse( p, i ) \
1160 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut(p, i) ) {} else
1161#define Gia_LutForEachFanin( p, i, iFan, k ) \
1162 for ( k = 0; k < Gia_ObjLutSize(p,i) && ((iFan = Gia_ObjLutFanins(p,i)[k]),1); k++ )
1163#define Gia_LutForEachFaninIndex( p, i, iFan, k, Index ) \
1164 for ( k = 0; k < Gia_ObjLutSize(p,i) && (Index = Vec_IntEntry(p->vMapping, i)+1+k) && ((iFan = Vec_IntEntry(p->vMapping, Index)),1); k++ )
1165#define Gia_LutForEachFaninObj( p, i, pFanin, k ) \
1166 for ( k = 0; k < Gia_ObjLutSize(p,i) && ((pFanin = Gia_ManObj(p, Gia_ObjLutFanins(p,i)[k])),1); k++ )
1167
1168#define Gia_ManForEachLut2( p, i ) \
1169 for ( i = 1; i < Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsLut2(p, i) ) {} else
1170#define Gia_ManForEachLut2Reverse( p, i ) \
1171 for ( i = Gia_ManObjNum(p) - 1; i > 0; i-- ) if ( !Gia_ObjIsLut2(p, i) ) {} else
1172#define Gia_ManForEachLut2Vec( vIds, p, vVec, iObj, i ) \
1173 for ( i = 0; i < Vec_IntSize(vIds) && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i++ )
1174#define Gia_ManForEachLut2VecReverse( vIds, p, vVec, iObj, i ) \
1175 for ( i = Vec_IntSize(vIds)-1; i >= 0 && (vVec = Vec_WecEntry(p->vMapping2, (iObj = Vec_IntEntry(vIds, i)))); i-- )
1176#define Gia_LutForEachFanin2( p, i, iFan, k ) \
1177 for ( k = 0; k < Gia_ObjLutSize2(p,i) && ((iFan = Gia_ObjLutFanin2(p,i,k)),1); k++ )
1178#define Gia_LutForEachFanout2( p, i, iFan, k ) \
1179 for ( k = 0; k < Gia_ObjLutFanoutNum2(p,i) && ((iFan = Gia_ObjLutFanout2(p,i,k)),1); k++ )
1180
1181#define Gia_ManForEachCell( p, i ) \
1182 for ( i = 2; i < 2*Gia_ManObjNum(p); i++ ) if ( !Gia_ObjIsCell(p, i) ) {} else
1183#define Gia_CellForEachFanin( p, i, iFanLit, k ) \
1184 for ( k = 0; k < Gia_ObjCellSize(p,i) && ((iFanLit = Gia_ObjCellFanins(p,i)[k]),1); k++ )
1185
1189
1190#define Gia_ManForEachObj( p, pObj, i ) \
1191 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )
1192#define Gia_ManForEachObj1( p, pObj, i ) \
1193 for ( i = 1; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ )
1194#define Gia_ManForEachObjVec( vVec, p, pObj, i ) \
1195 for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
1196#define Gia_ManForEachObjVecStart( vVec, p, pObj, i, Start ) \
1197 for ( i = Start; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
1198#define Gia_ManForEachObjVecStop( vVec, p, pObj, i, Stop ) \
1199 for ( i = 0; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
1200#define Gia_ManForEachObjVecStartStop( vVec, p, pObj, i, Start, Stop ) \
1201 for ( i = Start; (i < Stop) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i++ )
1202#define Gia_ManForEachObjVecReverse( vVec, p, pObj, i ) \
1203 for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, Vec_IntEntry(vVec,i))); i-- )
1204#define Gia_ManForEachObjVecLit( vVec, p, pObj, fCompl, i ) \
1205 for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManObj(p, Abc_Lit2Var(Vec_IntEntry(vVec,i)))) && (((fCompl) = Abc_LitIsCompl(Vec_IntEntry(vVec,i))),1); i++ )
1206#define Gia_ManForEachObjReverse( p, pObj, i ) \
1207 for ( i = p->nObjs - 1; (i >= 0) && ((pObj) = Gia_ManObj(p, i)); i-- )
1208#define Gia_ManForEachObjReverse1( p, pObj, i ) \
1209 for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- )
1210#define Gia_ManForEachBuf( p, pObj, i ) \
1211 for ( i = Gia_ManBufNum(p) ? 0 : p->nObjs; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsBuf(pObj) ) {} else
1212#define Gia_ManForEachBufId( p, i ) \
1213 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsBuf(Gia_ManObj(p, i)) ) {} else
1214#define Gia_ManForEachAnd( p, pObj, i ) \
1215 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsAnd(pObj) ) {} else
1216#define Gia_ManForEachAndId( p, i ) \
1217 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else
1218#define Gia_ManForEachMuxId( p, i ) \
1219 for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else
1220#define Gia_ManForEachCand( p, pObj, i ) \
1221 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsCand(pObj) ) {} else
1222#define Gia_ManForEachAndReverse( p, pObj, i ) \
1223 for ( i = p->nObjs - 1; (i > 0) && ((pObj) = Gia_ManObj(p, i)); i-- ) if ( !Gia_ObjIsAnd(pObj) ) {} else
1224#define Gia_ManForEachAndReverseId( p, i ) \
1225 for ( i = p->nObjs - 1; (i > 0); i-- ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else
1226#define Gia_ManForEachMux( p, pObj, i ) \
1227 for ( i = 0; (i < p->nObjs) && ((pObj) = Gia_ManObj(p, i)); i++ ) if ( !Gia_ObjIsMuxId(p, i) ) {} else
1228#define Gia_ManForEachCi( p, pObj, i ) \
1229 for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((pObj) = Gia_ManCi(p, i)); i++ )
1230#define Gia_ManForEachCiId( p, Id, i ) \
1231 for ( i = 0; (i < Vec_IntSize(p->vCis)) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )
1232#define Gia_ManForEachCiVec( vVec, p, pObj, i ) \
1233 for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManCi(p, Vec_IntEntry(vVec,i))); i++ )
1234#define Gia_ManForEachCiReverse( p, pObj, i ) \
1235 for ( i = Vec_IntSize(p->vCis) - 1; (i >= 0) && ((pObj) = Gia_ManCi(p, i)); i-- )
1236#define Gia_ManForEachCo( p, pObj, i ) \
1237 for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ManCo(p, i)); i++ )
1238#define Gia_ManForEachCoVec( vVec, p, pObj, i ) \
1239 for ( i = 0; (i < Vec_IntSize(vVec)) && ((pObj) = Gia_ManCo(p, Vec_IntEntry(vVec,i))); i++ )
1240#define Gia_ManForEachCoId( p, Id, i ) \
1241 for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((Id) = Gia_ObjId(p, Gia_ManCo(p, i))); i++ )
1242#define Gia_ManForEachCoReverse( p, pObj, i ) \
1243 for ( i = Vec_IntSize(p->vCos) - 1; (i >= 0) && ((pObj) = Gia_ManCo(p, i)); i-- )
1244#define Gia_ManForEachCoDriver( p, pObj, i ) \
1245 for ( i = 0; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ObjFanin0(Gia_ManCo(p, i))); i++ )
1246#define Gia_ManForEachCoDriverId( p, DriverId, i ) \
1247 for ( i = 0; (i < Vec_IntSize(p->vCos)) && (((DriverId) = Gia_ObjFaninId0p(p, Gia_ManCo(p, i))), 1); i++ )
1248#define Gia_ManForEachPi( p, pObj, i ) \
1249 for ( i = 0; (i < Gia_ManPiNum(p)) && ((pObj) = Gia_ManCi(p, i)); i++ )
1250#define Gia_ManForEachPo( p, pObj, i ) \
1251 for ( i = 0; (i < Gia_ManPoNum(p)) && ((pObj) = Gia_ManCo(p, i)); i++ )
1252#define Gia_ManForEachRo( p, pObj, i ) \
1253 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )
1254#define Gia_ManForEachRi( p, pObj, i ) \
1255 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObj) = Gia_ManCo(p, Gia_ManPoNum(p)+i)); i++ )
1256#define Gia_ManForEachRiRo( p, pObjRi, pObjRo, i ) \
1257 for ( i = 0; (i < Gia_ManRegNum(p)) && ((pObjRi) = Gia_ManCo(p, Gia_ManPoNum(p)+i)) && ((pObjRo) = Gia_ManCi(p, Gia_ManPiNum(p)+i)); i++ )
1258#define Gia_ManForEachRoToRiVec( vRoIds, p, pObj, i ) \
1259 for ( i = 0; (i < Vec_IntSize(vRoIds)) && ((pObj) = Gia_ObjRoToRi(p, Gia_ManObj(p, Vec_IntEntry(vRoIds, i)))); i++ )
1260
1261#define Gia_ManForEachObjWithBoxes( p, pObj, i ) \
1262 for ( i = p->iFirstAndObj; (i < p->iFirstPoObj) && ((pObj) = Gia_ManObj(p, i)); i++ )
1263#define Gia_ManForEachObjReverseWithBoxes( p, pObj, i ) \
1264 for ( i = p->iFirstPoObj - 1; (i >= p->iFirstAndObj) && ((pObj) = Gia_ManObj(p, i)); i-- )
1265#define Gia_ManForEachCiIdWithBoxes( p, Id, i ) \
1266 for ( i = 0; (i < p->iFirstNonPiId) && ((Id) = Gia_ObjId(p, Gia_ManCi(p, i))); i++ )
1267#define Gia_ManForEachCoWithBoxes( p, pObj, i ) \
1268 for ( i = p->iFirstPoId; (i < Vec_IntSize(p->vCos)) && ((pObj) = Gia_ManCo(p, i)); i++ )
1269
1273
1274/*=== giaAiger.c ===========================================================*/
1275extern int Gia_FileSize( char * pFileName );
1276extern Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSimple, int fSkipStrash, int fCheck );
1277extern Gia_Man_t * Gia_AigerRead( char * pFileName, int fGiaSimple, int fSkipStrash, int fCheck );
1278extern void Gia_AigerWrite( Gia_Man_t * p, char * pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine );
1279extern void Gia_AigerWriteS( Gia_Man_t * p, char * pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine, int fSkipComment );
1280extern void Gia_DumpAiger( Gia_Man_t * p, char * pFilePrefix, int iFileNum, int nFileNumDigits );
1281extern Vec_Str_t * Gia_AigerWriteIntoMemoryStr( Gia_Man_t * p );
1282extern Vec_Str_t * Gia_AigerWriteIntoMemoryStrPart( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs );
1283extern void Gia_AigerWriteSimple( Gia_Man_t * pInit, char * pFileName );
1284/*=== giaBalance.c ===========================================================*/
1285extern Gia_Man_t * Gia_ManBalance( Gia_Man_t * p, int fSimpleAnd, int fStrict, int fVerbose );
1286extern Gia_Man_t * Gia_ManAreaBalance( Gia_Man_t * p, int fSimpleAnd, int nNewNodesMax, int fVerbose, int fVeryVerbose );
1287extern Gia_Man_t * Gia_ManAigSyn2( Gia_Man_t * p, int fOldAlgo, int fCoarsen, int fCutMin, int nRelaxRatio, int fDelayMin, int fVerbose, int fVeryVerbose );
1288extern Gia_Man_t * Gia_ManAigSyn3( Gia_Man_t * p, int fVerbose, int fVeryVerbose );
1289extern Gia_Man_t * Gia_ManAigSyn4( Gia_Man_t * p, int fVerbose, int fVeryVerbose );
1290/*=== giaBidec.c ===========================================================*/
1291extern unsigned * Gia_ManConvertAigToTruth( Gia_Man_t * p, Gia_Obj_t * pRoot, Vec_Int_t * vLeaves, Vec_Int_t * vTruth, Vec_Int_t * vVisited );
1292extern Gia_Man_t * Gia_ManPerformBidec( Gia_Man_t * p, int fVerbose );
1293/*=== giaCex.c ============================================================*/
1294extern int Gia_ManVerifyCex( Gia_Man_t * pAig, Abc_Cex_t * p, int fDualOut );
1295extern int Gia_ManFindFailedPoCex( Gia_Man_t * pAig, Abc_Cex_t * p, int nOutputs );
1296extern int Gia_ManSetFailedPoCex( Gia_Man_t * pAig, Abc_Cex_t * p );
1297extern void Gia_ManCounterExampleValueStart( Gia_Man_t * pGia, Abc_Cex_t * pCex );
1298extern void Gia_ManCounterExampleValueStop( Gia_Man_t * pGia );
1299extern int Gia_ManCounterExampleValueLookup( Gia_Man_t * pGia, int Id, int iFrame );
1300extern Abc_Cex_t * Gia_ManCexExtendToIncludeCurrentStates( Gia_Man_t * p, Abc_Cex_t * pCex );
1301extern Abc_Cex_t * Gia_ManCexExtendToIncludeAllObjects( Gia_Man_t * p, Abc_Cex_t * pCex );
1302/*=== giaCsatOld.c ============================================================*/
1303extern Vec_Int_t * Cbs_ManSolveMiter( Gia_Man_t * pGia, int nConfs, Vec_Str_t ** pvStatus, int fVerbose );
1304/*=== giaCsat.c ============================================================*/
1305typedef struct Cbs_Man_t_ Cbs_Man_t;
1306extern Cbs_Man_t * Cbs_ManAlloc( Gia_Man_t * pGia );
1307extern void Cbs_ManStop( Cbs_Man_t * p );
1308extern int Cbs_ManSolve( Cbs_Man_t * p, Gia_Obj_t * pObj );
1309extern int Cbs_ManSolve2( Cbs_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pObj2 );
1310extern Vec_Int_t * Cbs_ManSolveMiterNc( Gia_Man_t * pGia, int nConfs, Vec_Str_t ** pvStatus, int f0Proved, int fVerbose );
1311extern void Cbs_ManSetConflictNum( Cbs_Man_t * p, int Num );
1312extern Vec_Int_t * Cbs_ReadModel( Cbs_Man_t * p );
1313/*=== giaCTas.c ============================================================*/
1314extern Vec_Int_t * Tas_ManSolveMiterNc( Gia_Man_t * pGia, int nConfs, Vec_Str_t ** pvStatus, int fVerbose );
1315/*=== giaCof.c =============================================================*/
1316extern void Gia_ManPrintFanio( Gia_Man_t * pGia, int nNodes );
1317extern Gia_Man_t * Gia_ManDupCof( Gia_Man_t * p, int iVar );
1318extern Gia_Man_t * Gia_ManDupCofAllInt( Gia_Man_t * p, Vec_Int_t * vSigs, int fVerbose );
1319extern Gia_Man_t * Gia_ManDupCofAll( Gia_Man_t * p, int nFanLim, int fVerbose );
1320/*=== giaDecs.c ============================================================*/
1321extern int Gia_ResubVarNum( Vec_Int_t * vResub );
1322extern word Gia_ResubToTruth6( Vec_Int_t * vResub );
1323extern int Gia_ManEvalSolutionOne( Gia_Man_t * p, Vec_Wrd_t * vSims, Vec_Wrd_t * vIsfs, Vec_Int_t * vCands, Vec_Int_t * vSet, int nWords, int fVerbose );
1324extern Vec_Int_t * Gia_ManDeriveSolutionOne( Gia_Man_t * p, Vec_Wrd_t * vSims, Vec_Wrd_t * vIsfs, Vec_Int_t * vCands, Vec_Int_t * vSet, int nWords, int Type );
1325/*=== giaDfs.c ============================================================*/
1326extern void Gia_ManCollectCis( Gia_Man_t * p, int * pNodes, int nNodes, Vec_Int_t * vSupp );
1327extern void Gia_ManCollectAnds_rec( Gia_Man_t * p, int iObj, Vec_Int_t * vNodes );
1328extern void Gia_ManCollectAnds( Gia_Man_t * p, int * pNodes, int nNodes, Vec_Int_t * vNodes, Vec_Int_t * vLeaves );
1329extern Vec_Int_t * Gia_ManCollectAndsAll( Gia_Man_t * p );
1330extern Vec_Int_t * Gia_ManCollectNodesCis( Gia_Man_t * p, int * pNodes, int nNodes );
1331extern int Gia_ManSuppSize( Gia_Man_t * p, int * pNodes, int nNodes );
1332extern int Gia_ManConeSize( Gia_Man_t * p, int * pNodes, int nNodes );
1333extern Vec_Vec_t * Gia_ManLevelize( Gia_Man_t * p );
1334extern Vec_Wec_t * Gia_ManLevelizeR( Gia_Man_t * p );
1335extern Vec_Int_t * Gia_ManOrderReverse( Gia_Man_t * p );
1336extern void Gia_ManCollectTfi( Gia_Man_t * p, Vec_Int_t * vRoots, Vec_Int_t * vNodes );
1337extern void Gia_ManCollectTfo( Gia_Man_t * p, Vec_Int_t * vRoots, Vec_Int_t * vNodes );
1338/*=== giaDup.c ============================================================*/
1339extern void Gia_ManDupRemapLiterals( Vec_Int_t * vLits, Gia_Man_t * p );
1340extern void Gia_ManDupRemapEquiv( Gia_Man_t * pNew, Gia_Man_t * p );
1341extern Gia_Man_t * Gia_ManDupOrderDfs( Gia_Man_t * p );
1342extern Gia_Man_t * Gia_ManDupOrderDfsChoices( Gia_Man_t * p );
1343extern Gia_Man_t * Gia_ManDupOrderDfsReverse( Gia_Man_t * p, int fRevFans, int fRevOuts );
1344extern Gia_Man_t * Gia_ManDupOutputGroup( Gia_Man_t * p, int iOutStart, int iOutStop );
1345extern Gia_Man_t * Gia_ManDupOutputVec( Gia_Man_t * p, Vec_Int_t * vOutPres );
1346extern Gia_Man_t * Gia_ManDupSelectedOutputs( Gia_Man_t * p, Vec_Int_t * vOutsLeft );
1347extern Gia_Man_t * Gia_ManDupOrderAiger( Gia_Man_t * p );
1348extern Gia_Man_t * Gia_ManDupLastPis( Gia_Man_t * p, int nLastPis );
1349extern Gia_Man_t * Gia_ManDupFlip( Gia_Man_t * p, int * pInitState );
1350extern Gia_Man_t * Gia_ManDupCycled( Gia_Man_t * pAig, Abc_Cex_t * pCex, int nFrames );
1351extern Gia_Man_t * Gia_ManDup( Gia_Man_t * p );
1352extern Gia_Man_t * Gia_ManDupNoBuf( Gia_Man_t * p );
1353extern Gia_Man_t * Gia_ManDupMap( Gia_Man_t * p, Vec_Int_t * vMap );
1354extern Gia_Man_t * Gia_ManDup2( Gia_Man_t * p1, Gia_Man_t * p2 );
1355extern Gia_Man_t * Gia_ManDupWithAttributes( Gia_Man_t * p );
1356extern Gia_Man_t * Gia_ManDupRemovePis( Gia_Man_t * p, int nRemPis );
1357extern Gia_Man_t * Gia_ManDupZero( Gia_Man_t * p );
1358extern Gia_Man_t * Gia_ManDupPerm( Gia_Man_t * p, Vec_Int_t * vPiPerm );
1359extern Gia_Man_t * Gia_ManDupPermFlop( Gia_Man_t * p, Vec_Int_t * vFfPerm );
1360extern Gia_Man_t * Gia_ManDupPermFlopGap( Gia_Man_t * p, Vec_Int_t * vFfPerm );
1361extern void Gia_ManDupAppend( Gia_Man_t * p, Gia_Man_t * pTwo );
1362extern void Gia_ManDupAppendShare( Gia_Man_t * p, Gia_Man_t * pTwo );
1363extern Gia_Man_t * Gia_ManDupAppendNew( Gia_Man_t * pOne, Gia_Man_t * pTwo );
1364extern Gia_Man_t * Gia_ManDupAppendCones( Gia_Man_t * p, Gia_Man_t ** ppCones, int nCones, int fOnlyRegs );
1365extern Gia_Man_t * Gia_ManDupSelf( Gia_Man_t * p );
1366extern Gia_Man_t * Gia_ManDupFlopClass( Gia_Man_t * p, int iClass );
1367extern Gia_Man_t * Gia_ManDupMarked( Gia_Man_t * p );
1368extern Gia_Man_t * Gia_ManDupTimes( Gia_Man_t * p, int nTimes );
1369extern Gia_Man_t * Gia_ManDupDfs( Gia_Man_t * p );
1370extern Gia_Man_t * Gia_ManDupDfsOnePo( Gia_Man_t * p, int iPo );
1371extern Gia_Man_t * Gia_ManDupDfsRehash( Gia_Man_t * p );
1372extern Gia_Man_t * Gia_ManDupCofactorVar( Gia_Man_t * p, int iVar, int Value );
1373extern Gia_Man_t * Gia_ManDupCofactorObj( Gia_Man_t * p, int iObj, int Value );
1374extern Gia_Man_t * Gia_ManDupMux( int iVar, Gia_Man_t * pCof1, Gia_Man_t * pCof0 );
1375extern Gia_Man_t * Gia_ManDupBlock( Gia_Man_t * p, int nBlock );
1376extern Gia_Man_t * Gia_ManDupExist( Gia_Man_t * p, int iVar );
1377extern Gia_Man_t * Gia_ManDupUniv( Gia_Man_t * p, int iVar );
1378extern Gia_Man_t * Gia_ManDupDfsSkip( Gia_Man_t * p );
1379extern Gia_Man_t * Gia_ManDupDfsCone( Gia_Man_t * p, Gia_Obj_t * pObj );
1380extern Gia_Man_t * Gia_ManDupConeSupp( Gia_Man_t * p, int iLit, Vec_Int_t * vCiIds );
1381extern int Gia_ManDupConeBack( Gia_Man_t * p, Gia_Man_t * pNew, Vec_Int_t * vCiIds );
1382extern int Gia_ManDupConeBackObjs( Gia_Man_t * p, Gia_Man_t * pNew, Vec_Int_t * vObjs );
1383extern Gia_Man_t * Gia_ManDupDfsNode( Gia_Man_t * p, Gia_Obj_t * pObj );
1384extern Gia_Man_t * Gia_ManDupDfsLitArray( Gia_Man_t * p, Vec_Int_t * vLits );
1385extern Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p, int fTrimCis, int fTrimCos, int fDualOut, int OutValue );
1386extern Gia_Man_t * Gia_ManDupOntop( Gia_Man_t * p, Gia_Man_t * p2 );
1387extern Gia_Man_t * Gia_ManDupWithNewPo( Gia_Man_t * p1, Gia_Man_t * p2 );
1388extern Gia_Man_t * Gia_ManDupDfsCiMap( Gia_Man_t * p, int * pCi2Lit, Vec_Int_t * vLits );
1389extern Gia_Man_t * Gia_ManPermuteInputs( Gia_Man_t * p, int nPpis, int nExtra );
1390extern Gia_Man_t * Gia_ManDupDfsClasses( Gia_Man_t * p );
1391extern Gia_Man_t * Gia_ManDupTopAnd( Gia_Man_t * p, int fVerbose );
1392extern Gia_Man_t * Gia_ManMiter( Gia_Man_t * pAig0, Gia_Man_t * pAig1, int nInsDup, int fDualOut, int fSeq, int fImplic, int fVerbose );
1393extern Gia_Man_t * Gia_ManMiterInverse( Gia_Man_t * pBot, Gia_Man_t * pTop, int fDualOut, int fVerbose );
1394extern Gia_Man_t * Gia_ManDupAndOr( Gia_Man_t * p, int nOuts, int fUseOr, int fCompl );
1395extern Gia_Man_t * Gia_ManDupZeroUndc( Gia_Man_t * p, char * pInit, int nNewPis, int fGiaSimple, int fVerbose );
1396extern Gia_Man_t * Gia_ManMiter2( Gia_Man_t * p, char * pInit, int fVerbose );
1397extern Gia_Man_t * Gia_ManTransformMiter( Gia_Man_t * p );
1398extern Gia_Man_t * Gia_ManTransformMiter2( Gia_Man_t * p );
1399extern Gia_Man_t * Gia_ManTransformToDual( Gia_Man_t * p );
1400extern Gia_Man_t * Gia_ManTransformTwoWord2DualOutput( Gia_Man_t * p );
1401extern Gia_Man_t * Gia_ManChoiceMiter( Vec_Ptr_t * vGias );
1402extern Gia_Man_t * Gia_ManDupWithConstraints( Gia_Man_t * p, Vec_Int_t * vPoTypes );
1403extern Gia_Man_t * Gia_ManDupCones( Gia_Man_t * p, int * pPos, int nPos, int fTrimPis );
1404extern Gia_Man_t * Gia_ManDupAndCones( Gia_Man_t * p, int * pAnds, int nAnds, int fTrimPis );
1405extern Gia_Man_t * Gia_ManDupAndConesLimit( Gia_Man_t * p, int * pAnds, int nAnds, int Level );
1406extern Gia_Man_t * Gia_ManDupAndConesLimit2( Gia_Man_t * p, int * pAnds, int nAnds, int Level );
1407extern Gia_Man_t * Gia_ManDupOneHot( Gia_Man_t * p );
1408extern Gia_Man_t * Gia_ManDupLevelized( Gia_Man_t * p );
1409extern Gia_Man_t * Gia_ManDupFromVecs( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs );
1410extern Gia_Man_t * Gia_ManDupSliced( Gia_Man_t * p, int nSuppMax );
1411extern Gia_Man_t * Gia_ManDupDemiter( Gia_Man_t * p, int fVerbose );
1412extern Gia_Man_t * Gia_ManDemiterToDual( Gia_Man_t * p );
1413extern int Gia_ManDemiterDual( Gia_Man_t * p, Gia_Man_t ** pp0, Gia_Man_t ** pp1 );
1414extern int Gia_ManDemiterTwoWords( Gia_Man_t * p, Gia_Man_t ** pp0, Gia_Man_t ** pp1 );
1415extern void Gia_ManProdAdderGen( int nArgA, int nArgB, int Seed, int fSigned, int fCla );
1416typedef struct Gia_ChMan_t_ Gia_ChMan_t;
1417extern Gia_ChMan_t * Gia_ManDupChoicesStart( Gia_Man_t * pGia );
1418extern void Gia_ManDupChoicesAdd( Gia_ChMan_t * pMan, Gia_Man_t * pGia );
1419extern Gia_Man_t * Gia_ManDupChoicesFinish( Gia_ChMan_t * pMan );
1420/*=== giaEdge.c ==========================================================*/
1421extern void Gia_ManEdgeFromArray( Gia_Man_t * p, Vec_Int_t * vArray );
1422extern Vec_Int_t * Gia_ManEdgeToArray( Gia_Man_t * p );
1423extern void Gia_ManConvertPackingToEdges( Gia_Man_t * p );
1424extern int Gia_ObjCheckEdge( Gia_Man_t * p, int iObj, int iNext );
1425extern int Gia_ManEvalEdgeDelay( Gia_Man_t * p );
1426extern int Gia_ManEvalEdgeCount( Gia_Man_t * p );
1427extern int Gia_ManComputeEdgeDelay( Gia_Man_t * p, int fUseTwo );
1428extern int Gia_ManComputeEdgeDelay2( Gia_Man_t * p );
1429extern void Gia_ManUpdateMapping( Gia_Man_t * p, Vec_Int_t * vNodes, Vec_Wec_t * vWin );
1430extern int Gia_ManEvalWindow( Gia_Man_t * p, Vec_Int_t * vLeaves, Vec_Int_t * vNodes, Vec_Wec_t * vWin, Vec_Int_t * vTemp, int fUseTwo );
1431/*=== giaEnable.c ==========================================================*/
1432extern void Gia_ManDetectSeqSignals( Gia_Man_t * p, int fSetReset, int fVerbose );
1433extern Gia_Man_t * Gia_ManUnrollAndCofactor( Gia_Man_t * p, int nFrames, int nFanMax, int fVerbose );
1434extern Gia_Man_t * Gia_ManRemoveEnables( Gia_Man_t * p );
1435/*=== giaEquiv.c ==========================================================*/
1436extern void Gia_ManOrigIdsInit( Gia_Man_t * p );
1437extern void Gia_ManOrigIdsStart( Gia_Man_t * p );
1438extern void Gia_ManOrigIdsRemap( Gia_Man_t * p, Gia_Man_t * pNew );
1439extern Gia_Man_t * Gia_ManOrigIdsReduce( Gia_Man_t * p, Vec_Int_t * vPairs );
1440extern Gia_Man_t * Gia_ManComputeGiaEquivs( Gia_Man_t * pGia, int nConfs, int fVerbose );
1441extern void Gia_ManEquivFixOutputPairs( Gia_Man_t * p );
1442extern int Gia_ManCheckTopoOrder( Gia_Man_t * p );
1443extern int * Gia_ManDeriveNexts( Gia_Man_t * p );
1444extern void Gia_ManDeriveReprs( Gia_Man_t * p );
1445extern void Gia_ManDeriveReprsFromSibls( Gia_Man_t *p );
1446extern int Gia_ManEquivCountLits( Gia_Man_t * p );
1447extern int Gia_ManEquivCountLitsAll( Gia_Man_t * p );
1448extern int Gia_ManEquivCountClasses( Gia_Man_t * p );
1449extern void Gia_ManEquivPrintOne( Gia_Man_t * p, int i, int Counter );
1450extern void Gia_ManEquivPrintClasses( Gia_Man_t * p, int fVerbose, float Mem );
1451extern Gia_Man_t * Gia_ManEquivReduce( Gia_Man_t * p, int fUseAll, int fDualOut, int fSkipPhase, int fVerbose );
1452extern Gia_Man_t * Gia_ManEquivReduceAndRemap( Gia_Man_t * p, int fSeq, int fMiterPairs );
1453extern int Gia_ManEquivSetColors( Gia_Man_t * p, int fVerbose );
1454extern Gia_Man_t * Gia_ManSpecReduce( Gia_Man_t * p, int fDualOut, int fSynthesis, int fReduce, int fSkipSome, int fVerbose );
1455extern Gia_Man_t * Gia_ManSpecReduceInit( Gia_Man_t * p, Abc_Cex_t * pInit, int nFrames, int fDualOut );
1456extern Gia_Man_t * Gia_ManSpecReduceInitFrames( Gia_Man_t * p, Abc_Cex_t * pInit, int nFramesMax, int * pnFrames, int fDualOut, int nMinOutputs );
1457extern void Gia_ManEquivTransform( Gia_Man_t * p, int fVerbose );
1458extern void Gia_ManEquivImprove( Gia_Man_t * p );
1459extern Gia_Man_t * Gia_ManEquivToChoices( Gia_Man_t * p, int nSnapshots );
1460extern int Gia_ManCountChoiceNodes( Gia_Man_t * p );
1461extern int Gia_ManCountChoices( Gia_Man_t * p );
1462extern int Gia_ManFilterEquivsForSpeculation( Gia_Man_t * pGia, char * pName1, char * pName2, int fLatchA, int fLatchB );
1463extern int Gia_ManFilterEquivsUsingParts( Gia_Man_t * pGia, char * pName1, char * pName2 );
1464extern void Gia_ManFilterEquivsUsingLatches( Gia_Man_t * pGia, int fFlopsOnly, int fFlopsWith, int fUseRiDrivers );
1465/*=== giaExist.c =========================================================*/
1466extern void Gia_ManQuantSetSuppStart( Gia_Man_t * p );
1467extern void Gia_ManQuantSetSuppZero( Gia_Man_t * p );
1468extern void Gia_ManQuantSetSuppCi( Gia_Man_t * p, Gia_Obj_t * pObj );
1469extern void Gia_ManQuantUpdateCiSupp( Gia_Man_t * p, int iObj );
1470extern int Gia_ManQuantExist( Gia_Man_t * p, int iLit, int(*pFuncCiToKeep)(void *, int), void * pData );
1471/*=== giaFanout.c =========================================================*/
1472extern void Gia_ObjAddFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout );
1473extern void Gia_ObjRemoveFanout( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pFanout );
1474extern void Gia_ManFanoutStart( Gia_Man_t * p );
1475extern void Gia_ManFanoutStop( Gia_Man_t * p );
1476extern void Gia_ManStaticFanoutStart( Gia_Man_t * p );
1477extern void Gia_ManStaticFanoutStop( Gia_Man_t * p );
1478extern void Gia_ManStaticMappingFanoutStart( Gia_Man_t * p, Vec_Int_t ** pvIndex );
1479/*=== giaForce.c =========================================================*/
1480extern void For_ManExperiment( Gia_Man_t * pGia, int nIters, int fClustered, int fVerbose );
1481/*=== giaFrames.c =========================================================*/
1482extern Gia_Man_t * Gia_ManUnrollDup( Gia_Man_t * p, Vec_Int_t * vLimit );
1483extern Vec_Ptr_t * Gia_ManUnrollAbs( Gia_Man_t * p, int nFrames );
1484extern void * Gia_ManUnrollStart( Gia_Man_t * pAig, Gia_ParFra_t * pPars );
1485extern void * Gia_ManUnrollAdd( void * pMan, int fMax );
1486extern void Gia_ManUnrollStop( void * pMan );
1487extern int Gia_ManUnrollLastLit( void * pMan );
1488extern void Gia_ManFraSetDefaultParams( Gia_ParFra_t * p );
1489extern Gia_Man_t * Gia_ManFrames( Gia_Man_t * pAig, Gia_ParFra_t * pPars );
1490extern Gia_Man_t * Gia_ManFramesInitSpecial( Gia_Man_t * pAig, int nFrames, int fVerbose );
1491/*=== giaFront.c ==========================================================*/
1492extern Gia_Man_t * Gia_ManFront( Gia_Man_t * p );
1493extern void Gia_ManFrontTest( Gia_Man_t * p );
1494/*=== giaFx.c ==========================================================*/
1495extern Gia_Man_t * Gia_ManPerformFx( Gia_Man_t * p, int nNewNodesMax, int LitCountMax, int fReverse, int fVerbose, int fVeryVerbose );
1496/*=== giaHash.c ===========================================================*/
1497extern void Gia_ManHashAlloc( Gia_Man_t * p );
1498extern void Gia_ManHashStart( Gia_Man_t * p );
1499extern void Gia_ManHashStop( Gia_Man_t * p );
1500extern int Gia_ManHashXorReal( Gia_Man_t * p, int iLit0, int iLit1 );
1501extern int Gia_ManHashMuxReal( Gia_Man_t * p, int iLitC, int iLit1, int iLit0 );
1502extern int Gia_ManHashAnd( Gia_Man_t * p, int iLit0, int iLit1 );
1503extern int Gia_ManHashOr( Gia_Man_t * p, int iLit0, int iLit1 );
1504extern int Gia_ManHashXor( Gia_Man_t * p, int iLit0, int iLit1 );
1505extern int Gia_ManHashMux( Gia_Man_t * p, int iCtrl, int iData1, int iData0 );
1506extern int Gia_ManHashMaj( Gia_Man_t * p, int iData0, int iData1, int iData2 );
1507extern int Gia_ManHashAndTry( Gia_Man_t * p, int iLit0, int iLit1 );
1508extern Gia_Man_t * Gia_ManRehash( Gia_Man_t * p, int fAddStrash );
1509extern void Gia_ManHashProfile( Gia_Man_t * p );
1510extern int Gia_ManHashLookupInt( Gia_Man_t * p, int iLit0, int iLit1 );
1511extern int Gia_ManHashLookup( Gia_Man_t * p, Gia_Obj_t * p0, Gia_Obj_t * p1 );
1512extern int Gia_ManHashAndMulti( Gia_Man_t * p, Vec_Int_t * vLits );
1513extern int Gia_ManHashAndMulti2( Gia_Man_t * p, Vec_Int_t * vLits );
1514extern int Gia_ManHashDualMiter( Gia_Man_t * p, Vec_Int_t * vOuts );
1515/*=== giaIf.c ===========================================================*/
1516extern void Gia_ManPrintOutputLutStats( Gia_Man_t * p );
1517extern void Gia_ManPrintMappingStats( Gia_Man_t * p, char * pDumpFile );
1518extern void Gia_ManPrintPackingStats( Gia_Man_t * p );
1519extern void Gia_ManPrintLutStats( Gia_Man_t * p );
1520extern int Gia_ManLutFaninCount( Gia_Man_t * p );
1521extern int Gia_ManLutSizeMax( Gia_Man_t * p );
1522extern int Gia_ManLutNum( Gia_Man_t * p );
1523extern int Gia_ManLutLevel( Gia_Man_t * p, int ** ppLevels );
1524extern void Gia_ManLutParams( Gia_Man_t * p, int * pnCurLuts, int * pnCurEdges, int * pnCurLevels );
1525extern void Gia_ManSetRefsMapped( Gia_Man_t * p );
1526extern void Gia_ManSetLutRefs( Gia_Man_t * p );
1527extern void Gia_ManSetIfParsDefault( void * pIfPars );
1528extern void Gia_ManMappingVerify( Gia_Man_t * p );
1529extern void Gia_ManTransferMapping( Gia_Man_t * p, Gia_Man_t * pGia );
1530extern void Gia_ManTransferPacking( Gia_Man_t * p, Gia_Man_t * pGia );
1531extern void Gia_ManTransferTiming( Gia_Man_t * p, Gia_Man_t * pGia );
1532extern Gia_Man_t * Gia_ManPerformMapping( Gia_Man_t * p, void * pIfPars );
1533extern Gia_Man_t * Gia_ManPerformSopBalance( Gia_Man_t * p, int nCutNum, int nRelaxRatio, int fVerbose );
1534extern Gia_Man_t * Gia_ManPerformDsdBalance( Gia_Man_t * p, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose );
1535extern Gia_Man_t * Gia_ManDupHashMapping( Gia_Man_t * p );
1536/*=== giaJf.c ===========================================================*/
1537extern void Jf_ManSetDefaultPars( Jf_Par_t * pPars );
1538extern Gia_Man_t * Jf_ManPerformMapping( Gia_Man_t * pGia, Jf_Par_t * pPars );
1539extern Gia_Man_t * Jf_ManDeriveCnf( Gia_Man_t * p, int fCnfObjIds );
1540/*=== giaIso.c ===========================================================*/
1541extern Gia_Man_t * Gia_ManIsoCanonicize( Gia_Man_t * p, int fVerbose );
1542extern Gia_Man_t * Gia_ManIsoReduce( Gia_Man_t * p, Vec_Ptr_t ** pvPosEquivs, Vec_Ptr_t ** pvPiPerms, int fEstimate, int fDualOut, int fVerbose, int fVeryVerbose );
1543extern Gia_Man_t * Gia_ManIsoReduce2( Gia_Man_t * p, Vec_Ptr_t ** pvPosEquivs, Vec_Ptr_t ** pvPiPerms, int fEstimate, int fBetterQual, int fDualOut, int fVerbose, int fVeryVerbose );
1544/*=== giaLf.c ===========================================================*/
1545extern void Lf_ManSetDefaultPars( Jf_Par_t * pPars );
1546extern Gia_Man_t * Lf_ManPerformMapping( Gia_Man_t * pGia, Jf_Par_t * pPars );
1547extern Gia_Man_t * Gia_ManPerformLfMapping( Gia_Man_t * p, Jf_Par_t * pPars, int fNormalized );
1548/*=== giaLogic.c ===========================================================*/
1549extern void Gia_ManTestDistance( Gia_Man_t * p );
1550extern void Gia_ManSolveProblem( Gia_Man_t * pGia, Emb_Par_t * pPars );
1551 /*=== giaMan.c ===========================================================*/
1552extern Gia_Man_t * Gia_ManStart( int nObjsMax );
1553extern void Gia_ManStop( Gia_Man_t * p );
1554extern void Gia_ManStopP( Gia_Man_t ** p );
1555extern double Gia_ManMemory( Gia_Man_t * p );
1556extern void Gia_ManPrintStats( Gia_Man_t * p, Gps_Par_t * pPars );
1557extern void Gia_ManPrintStatsShort( Gia_Man_t * p );
1558extern void Gia_ManPrintMiterStatus( Gia_Man_t * p );
1559extern void Gia_ManPrintStatsMiter( Gia_Man_t * p, int fVerbose );
1560extern void Gia_ManSetRegNum( Gia_Man_t * p, int nRegs );
1561extern void Gia_ManReportImprovement( Gia_Man_t * p, Gia_Man_t * pNew );
1562extern void Gia_ManPrintNpnClasses( Gia_Man_t * p );
1563extern void Gia_ManDumpVerilog( Gia_Man_t * p, char * pFileName, Vec_Int_t * vObjs, int fVerBufs, int fInter, int fInterComb, int fAssign, int fReverse );
1564extern void Gia_ManDumpVerilogNand( Gia_Man_t * p, char * pFileName );
1565/*=== giaMem.c ===========================================================*/
1566extern Gia_MmFixed_t * Gia_MmFixedStart( int nEntrySize, int nEntriesMax );
1567extern void Gia_MmFixedStop( Gia_MmFixed_t * p, int fVerbose );
1568extern char * Gia_MmFixedEntryFetch( Gia_MmFixed_t * p );
1569extern void Gia_MmFixedEntryRecycle( Gia_MmFixed_t * p, char * pEntry );
1570extern void Gia_MmFixedRestart( Gia_MmFixed_t * p );
1571extern int Gia_MmFixedReadMemUsage( Gia_MmFixed_t * p );
1572extern int Gia_MmFixedReadMaxEntriesUsed( Gia_MmFixed_t * p );
1573extern Gia_MmFlex_t * Gia_MmFlexStart();
1574extern void Gia_MmFlexStop( Gia_MmFlex_t * p, int fVerbose );
1575extern char * Gia_MmFlexEntryFetch( Gia_MmFlex_t * p, int nBytes );
1576extern void Gia_MmFlexRestart( Gia_MmFlex_t * p );
1577extern int Gia_MmFlexReadMemUsage( Gia_MmFlex_t * p );
1578extern Gia_MmStep_t * Gia_MmStepStart( int nSteps );
1579extern void Gia_MmStepStop( Gia_MmStep_t * p, int fVerbose );
1580extern char * Gia_MmStepEntryFetch( Gia_MmStep_t * p, int nBytes );
1581extern void Gia_MmStepEntryRecycle( Gia_MmStep_t * p, char * pEntry, int nBytes );
1582extern int Gia_MmStepReadMemUsage( Gia_MmStep_t * p );
1583/*=== giaMf.c ===========================================================*/
1584extern void Mf_ManSetDefaultPars( Jf_Par_t * pPars );
1585extern Gia_Man_t * Mf_ManPerformMapping( Gia_Man_t * pGia, Jf_Par_t * pPars );
1586extern void * Mf_ManGenerateCnf( Gia_Man_t * pGia, int nLutSize, int fCnfObjIds, int fAddOrCla, int fMapping, int fVerbose );
1587/*=== giaMini.c ===========================================================*/
1588extern Gia_Man_t * Gia_ManReadMiniAig( char * pFileName, int fGiaSimple );
1589extern void Gia_ManWriteMiniAig( Gia_Man_t * pGia, char * pFileName );
1590extern Gia_Man_t * Gia_ManReadMiniLut( char * pFileName );
1591extern void Gia_ManWriteMiniLut( Gia_Man_t * pGia, char * pFileName );
1592/*=== giaMinLut.c ===========================================================*/
1593extern word * Gia_ManCountFraction( Gia_Man_t * p, Vec_Wrd_t * vSimI, Vec_Int_t * vSupp, int Thresh, int fVerbose, int * pCare );
1594extern Vec_Int_t * Gia_ManCollectSuppNew( Gia_Man_t * p, int iOut, int nOuts );
1595/*=== giaMuxes.c ===========================================================*/
1596extern void Gia_ManCountMuxXor( Gia_Man_t * p, int * pnMuxes, int * pnXors );
1597extern void Gia_ManPrintMuxStats( Gia_Man_t * p );
1598extern Gia_Man_t * Gia_ManDupMuxes( Gia_Man_t * p, int Limit );
1599extern Gia_Man_t * Gia_ManDupNoMuxes( Gia_Man_t * p, int fSkipBufs );
1600/*=== giaPat.c ===========================================================*/
1601extern void Gia_SatVerifyPattern( Gia_Man_t * p, Gia_Obj_t * pRoot, Vec_Int_t * vCex, Vec_Int_t * vVisit );
1602/*=== giaRetime.c ===========================================================*/
1603extern Gia_Man_t * Gia_ManRetimeForward( Gia_Man_t * p, int nMaxIters, int fVerbose );
1604/*=== giaSat.c ============================================================*/
1605extern int Sat_ManTest( Gia_Man_t * pGia, Gia_Obj_t * pObj, int nConfsMax );
1606/*=== giaScl.c ============================================================*/
1607extern int Gia_ManSeqMarkUsed( Gia_Man_t * p );
1608extern int Gia_ManCombMarkUsed( Gia_Man_t * p );
1609extern Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p );
1610extern Gia_Man_t * Gia_ManCleanupOutputs( Gia_Man_t * p, int nOutputs );
1611extern Gia_Man_t * Gia_ManSeqCleanup( Gia_Man_t * p );
1612extern Gia_Man_t * Gia_ManSeqStructSweep( Gia_Man_t * p, int fConst, int fEquiv, int fVerbose );
1613/*=== giaShow.c ===========================================================*/
1614extern void Gia_ManShow( Gia_Man_t * pMan, Vec_Int_t * vBold, int fAdders, int fFadds, int fPath );
1615/*=== giaShrink.c ===========================================================*/
1616extern Gia_Man_t * Gia_ManMapShrink4( Gia_Man_t * p, int fKeepLevel, int fVerbose );
1617extern Gia_Man_t * Gia_ManMapShrink6( Gia_Man_t * p, int nFanoutMax, int fKeepLevel, int fVerbose );
1618/*=== giaSopb.c ============================================================*/
1619extern Gia_Man_t * Gia_ManExtractWindow( Gia_Man_t * p, int LevelMax, int nTimeWindow, int fVerbose );
1620extern Gia_Man_t * Gia_ManPerformSopBalanceWin( Gia_Man_t * p, int LevelMax, int nTimeWindow, int nCutNum, int nRelaxRatio, int fVerbose );
1621extern Gia_Man_t * Gia_ManPerformDsdBalanceWin( Gia_Man_t * p, int LevelMax, int nTimeWindow, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose );
1622/*=== giaSort.c ============================================================*/
1623extern int * Gia_SortFloats( float * pArray, int * pPerm, int nSize );
1624/*=== giaSim.c ============================================================*/
1625extern void Gia_ManSimSetDefaultParams( Gia_ParSim_t * p );
1626extern int Gia_ManSimSimulate( Gia_Man_t * pAig, Gia_ParSim_t * pPars );
1627extern unsigned * Gia_SimDataExt( Gia_ManSim_t * p, int i );
1628extern unsigned * Gia_SimDataCiExt( Gia_ManSim_t * p, int i );
1629extern unsigned * Gia_SimDataCoExt( Gia_ManSim_t * p, int i );
1630extern void Gia_ManSimInfoInit( Gia_ManSim_t * p );
1631extern void Gia_ManSimInfoTransfer( Gia_ManSim_t * p );
1632extern void Gia_ManSimulateRound( Gia_ManSim_t * p );
1633extern void Gia_ManBuiltInSimStart( Gia_Man_t * p, int nWords, int nObjs );
1634extern void Gia_ManBuiltInSimPerform( Gia_Man_t * p, int iObj );
1635extern int Gia_ManBuiltInSimCheckOver( Gia_Man_t * p, int iLit0, int iLit1 );
1636extern int Gia_ManBuiltInSimCheckEqual( Gia_Man_t * p, int iLit0, int iLit1 );
1637extern void Gia_ManBuiltInSimResimulateCone( Gia_Man_t * p, int iLit0, int iLit1 );
1638extern void Gia_ManBuiltInSimResimulate( Gia_Man_t * p );
1639extern int Gia_ManBuiltInSimAddPat( Gia_Man_t * p, Vec_Int_t * vPat );
1640extern void Gia_ManIncrSimStart( Gia_Man_t * p, int nWords, int nObjs );
1641extern void Gia_ManIncrSimSet( Gia_Man_t * p, Vec_Int_t * vObjLits );
1642extern int Gia_ManIncrSimCheckOver( Gia_Man_t * p, int iLit0, int iLit1 );
1643extern int Gia_ManIncrSimCheckEqual( Gia_Man_t * p, int iLit0, int iLit1 );
1644/*=== giaSimBase.c ============================================================*/
1645extern Vec_Wrd_t * Gia_ManSimPatSim( Gia_Man_t * p );
1646extern Vec_Wrd_t * Gia_ManSimPatSimOut( Gia_Man_t * pGia, Vec_Wrd_t * vSimsPi, int fOuts );
1647extern void Gia_ManSim2ArrayOne( Vec_Wrd_t * vSimsPi, Vec_Int_t * vRes );
1648extern Vec_Wec_t * Gia_ManSim2Array( Vec_Ptr_t * vSims );
1649extern Vec_Wrd_t * Gia_ManArray2SimOne( Vec_Int_t * vRes );
1650extern Vec_Ptr_t * Gia_ManArray2Sim( Vec_Wec_t * vRes );
1651extern void Gia_ManPtrWrdDumpBin( char * pFileName, Vec_Ptr_t * p, int fVerbose );
1652extern Vec_Ptr_t * Gia_ManPtrWrdReadBin( char * pFileName, int fVerbose );
1653extern Vec_Str_t * Gia_ManComputeRange( Gia_Man_t * p );
1654/*=== giaSpeedup.c ============================================================*/
1655extern float Gia_ManDelayTraceLut( Gia_Man_t * p );
1656extern float Gia_ManDelayTraceLutPrint( Gia_Man_t * p, int fVerbose );
1657extern Gia_Man_t * Gia_ManSpeedup( Gia_Man_t * p, int Percentage, int Degree, int fVerbose, int fVeryVerbose );
1658/*=== giaSplit.c ============================================================*/
1659extern void Gia_ManComputeOneWinStart( Gia_Man_t * p, int nAnds, int fReverse );
1660extern int Gia_ManComputeOneWin( Gia_Man_t * p, int iPivot, Vec_Int_t ** pvRoots, Vec_Int_t ** pvNodes, Vec_Int_t ** pvLeaves, Vec_Int_t ** pvAnds );
1661/*=== giaStg.c ============================================================*/
1662extern void Gia_ManStgPrint( FILE * pFile, Vec_Int_t * vLines, int nIns, int nOuts, int nStates );
1663extern Gia_Man_t * Gia_ManStgRead( char * pFileName, int kHot, int fVerbose );
1664/*=== giaSupp.c ============================================================*/
1665typedef struct Gia_ManMin_t_ Gia_ManMin_t;
1666extern Gia_ManMin_t * Gia_ManSuppStart( Gia_Man_t * pGia );
1667extern void Gia_ManSuppStop( Gia_ManMin_t * p );
1668extern int Gia_ManSupportAnd( Gia_ManMin_t * p, int iLit0, int iLit1 );
1669typedef struct Gia_Man2Min_t_ Gia_Man2Min_t;
1670extern Gia_Man2Min_t * Gia_Man2SuppStart( Gia_Man_t * pGia );
1671extern void Gia_Man2SuppStop( Gia_Man2Min_t * p );
1672extern int Gia_Man2SupportAnd( Gia_Man2Min_t * p, int iLit0, int iLit1 );
1673/*=== giaSweep.c ============================================================*/
1674extern Gia_Man_t * Gia_ManFraigSweepSimple( Gia_Man_t * p, void * pPars );
1675extern Gia_Man_t * Gia_ManSweepWithBoxes( Gia_Man_t * p, void * pParsC, void * pParsS, int fConst, int fEquiv, int fVerbose, int fVerbEquivs );
1676extern void Gia_ManCheckIntegrityWithBoxes( Gia_Man_t * p );
1677/*=== giaSweeper.c ============================================================*/
1678extern Gia_Man_t * Gia_SweeperStart( Gia_Man_t * p );
1679extern void Gia_SweeperStop( Gia_Man_t * p );
1680extern int Gia_SweeperIsRunning( Gia_Man_t * p );
1681extern void Gia_SweeperPrintStats( Gia_Man_t * p );
1682extern void Gia_SweeperSetConflictLimit( Gia_Man_t * p, int nConfMax );
1683extern void Gia_SweeperSetRuntimeLimit( Gia_Man_t * p, int nSeconds );
1684extern Vec_Int_t * Gia_SweeperGetCex( Gia_Man_t * p );
1685extern int Gia_SweeperProbeCreate( Gia_Man_t * p, int iLit );
1686extern int Gia_SweeperProbeDelete( Gia_Man_t * p, int ProbeId );
1687extern int Gia_SweeperProbeUpdate( Gia_Man_t * p, int ProbeId, int iLitNew );
1688extern int Gia_SweeperProbeLit( Gia_Man_t * p, int ProbeId );
1689extern Vec_Int_t * Gia_SweeperCollectValidProbeIds( Gia_Man_t * p );
1690extern int Gia_SweeperCondPop( Gia_Man_t * p );
1691extern void Gia_SweeperCondPush( Gia_Man_t * p, int ProbeId );
1692extern Vec_Int_t * Gia_SweeperCondVector( Gia_Man_t * p );
1693extern int Gia_SweeperCondCheckUnsat( Gia_Man_t * p );
1694extern int Gia_SweeperCheckEquiv( Gia_Man_t * p, int ProbeId1, int ProbeId2 );
1695extern Gia_Man_t * Gia_SweeperExtractUserLogic( Gia_Man_t * p, Vec_Int_t * vProbeIds, Vec_Ptr_t * vInNames, Vec_Ptr_t * vOutNames );
1696extern void Gia_SweeperLogicDump( Gia_Man_t * p, Vec_Int_t * vProbeIds, int fDumpConds, char * pFileName );
1697extern Gia_Man_t * Gia_SweeperCleanup( Gia_Man_t * p, char * pCommLime );
1698extern Vec_Int_t * Gia_SweeperGraft( Gia_Man_t * pDst, Vec_Int_t * vProbes, Gia_Man_t * pSrc );
1699extern int Gia_SweeperFraig( Gia_Man_t * p, Vec_Int_t * vProbeIds, char * pCommLime, int nWords, int nConfs, int fVerify, int fVerbose );
1700extern int Gia_SweeperRun( Gia_Man_t * p, Vec_Int_t * vProbeIds, char * pCommLime, int fVerbose );
1701/*=== giaSwitch.c ============================================================*/
1702extern float Gia_ManEvaluateSwitching( Gia_Man_t * p );
1703extern float Gia_ManComputeSwitching( Gia_Man_t * p, int nFrames, int nPref, int fProbOne );
1704extern Vec_Int_t * Gia_ManComputeSwitchProbs( Gia_Man_t * pGia, int nFrames, int nPref, int fProbOne );
1705extern Vec_Int_t * Gia_ManComputeSwitchProbs2( Gia_Man_t * pGia, int nFrames, int nPref, int fProbOne, int nRandPiFactor );
1706extern Vec_Flt_t * Gia_ManPrintOutputProb( Gia_Man_t * p );
1707/*=== giaTim.c ===========================================================*/
1708extern int Gia_ManBoxNum( Gia_Man_t * p );
1709extern int Gia_ManRegBoxNum( Gia_Man_t * p );
1710extern int Gia_ManNonRegBoxNum( Gia_Man_t * p );
1711extern int Gia_ManBlackBoxNum( Gia_Man_t * p );
1712extern int Gia_ManBoxCiNum( Gia_Man_t * p );
1713extern int Gia_ManBoxCoNum( Gia_Man_t * p );
1714extern int Gia_ManClockDomainNum( Gia_Man_t * p );
1715extern int Gia_ManIsSeqWithBoxes( Gia_Man_t * p );
1716extern int Gia_ManIsNormalized( Gia_Man_t * p );
1717extern Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p );
1718extern Gia_Man_t * Gia_ManDupNormalize( Gia_Man_t * p, int fHashMapping );
1719extern Gia_Man_t * Gia_ManDupUnnormalize( Gia_Man_t * p );
1720extern Gia_Man_t * Gia_ManDupUnshuffleInputs( Gia_Man_t * p );
1721extern int Gia_ManLevelWithBoxes( Gia_Man_t * p );
1722extern int Gia_ManLutLevelWithBoxes( Gia_Man_t * p );
1723extern void * Gia_ManUpdateTimMan( Gia_Man_t * p, Vec_Int_t * vBoxPres );
1724extern void * Gia_ManUpdateTimMan2( Gia_Man_t * p, Vec_Int_t * vBoxesLeft, int nTermsDiff );
1725extern Gia_Man_t * Gia_ManUpdateExtraAig( void * pTime, Gia_Man_t * pAig, Vec_Int_t * vBoxPres );
1726extern Gia_Man_t * Gia_ManUpdateExtraAig2( void * pTime, Gia_Man_t * pAig, Vec_Int_t * vBoxesLeft );
1727extern Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * vBoxPres, int fSeq );
1728extern int Gia_ManVerifyWithBoxes( Gia_Man_t * pGia, int nBTLimit, int nTimeLim, int fSeq, int fDumpFiles, int fVerbose, char * pFileSpec );
1729/*=== giaTruth.c ===========================================================*/
1730extern word Gia_LutComputeTruth6( Gia_Man_t * p, int iObj, Vec_Wrd_t * vTruths );
1731extern word Gia_ObjComputeTruthTable6Lut( Gia_Man_t * p, int iObj, Vec_Wrd_t * vTemp );
1732extern word Gia_ObjComputeTruthTable6( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSupp, Vec_Wrd_t * vTruths );
1733extern word Gia_ObjComputeTruth6Cis( Gia_Man_t * p, int iLit, Vec_Int_t * vSupp, Vec_Wrd_t * vTemp );
1734extern void Gia_ObjCollectInternal( Gia_Man_t * p, Gia_Obj_t * pObj );
1735extern word * Gia_ObjComputeTruthTable( Gia_Man_t * p, Gia_Obj_t * pObj );
1736extern void Gia_ObjComputeTruthTableStart( Gia_Man_t * p, int nVarsMax );
1737extern void Gia_ObjComputeTruthTableStop( Gia_Man_t * p );
1738extern word * Gia_ObjComputeTruthTableCut( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vLeaves );
1739/*=== giaTsim.c ============================================================*/
1740extern Gia_Man_t * Gia_ManReduceConst( Gia_Man_t * pAig, int fVerbose );
1741/*=== giaUtil.c ===========================================================*/
1742extern unsigned Gia_ManRandom( int fReset );
1743extern word Gia_ManRandomW( int fReset );
1744extern void Gia_ManRandomInfo( Vec_Ptr_t * vInfo, int iInputStart, int iWordStart, int iWordStop );
1745extern char * Gia_TimeStamp();
1746extern char * Gia_FileNameGenericAppend( char * pBase, char * pSuffix );
1747extern Vec_Ptr_t * Gia_GetFakeNames( int nNames, int fCaps );
1748extern void Gia_ManIncrementTravId( Gia_Man_t * p );
1749extern void Gia_ManCleanMark01( Gia_Man_t * p );
1750extern void Gia_ManSetMark0( Gia_Man_t * p );
1751extern void Gia_ManCleanMark0( Gia_Man_t * p );
1752extern void Gia_ManCheckMark0( Gia_Man_t * p );
1753extern void Gia_ManSetMark1( Gia_Man_t * p );
1754extern void Gia_ManCleanMark1( Gia_Man_t * p );
1755extern void Gia_ManCheckMark1( Gia_Man_t * p );
1756extern void Gia_ManCleanValue( Gia_Man_t * p );
1757extern void Gia_ManCleanLevels( Gia_Man_t * p, int Size );
1758extern void Gia_ManCleanTruth( Gia_Man_t * p );
1759extern void Gia_ManFillValue( Gia_Man_t * p );
1760extern void Gia_ObjSetPhase( Gia_Man_t * p, Gia_Obj_t * pObj );
1761extern void Gia_ManSetPhase( Gia_Man_t * p );
1762extern void Gia_ManSetPhasePattern( Gia_Man_t * p, Vec_Int_t * vCiValues );
1763extern void Gia_ManSetPhase1( Gia_Man_t * p );
1764extern void Gia_ManCleanPhase( Gia_Man_t * p );
1765extern int Gia_ManCheckCoPhase( Gia_Man_t * p );
1766extern int Gia_ManLevelNum( Gia_Man_t * p );
1767extern int Gia_ManLevelRNum( Gia_Man_t * p );
1768extern Vec_Int_t * Gia_ManGetCiLevels( Gia_Man_t * p );
1769extern int Gia_ManSetLevels( Gia_Man_t * p, Vec_Int_t * vCiLevels );
1770extern Vec_Int_t * Gia_ManReverseLevel( Gia_Man_t * p );
1771extern Vec_Int_t * Gia_ManRequiredLevel( Gia_Man_t * p );
1772extern void Gia_ManCreateValueRefs( Gia_Man_t * p );
1773extern void Gia_ManCreateRefs( Gia_Man_t * p );
1774extern void Gia_ManCreateLitRefs( Gia_Man_t * p );
1775extern int * Gia_ManCreateMuxRefs( Gia_Man_t * p );
1776extern int Gia_ManCrossCut( Gia_Man_t * p, int fReverse );
1777extern Vec_Int_t * Gia_ManCollectPoIds( Gia_Man_t * p );
1778extern int Gia_ObjIsMuxType( Gia_Obj_t * pNode );
1779extern int Gia_ObjRecognizeExor( Gia_Obj_t * pObj, Gia_Obj_t ** ppFan0, Gia_Obj_t ** ppFan1 );
1780extern Gia_Obj_t * Gia_ObjRecognizeMux( Gia_Obj_t * pNode, Gia_Obj_t ** ppNodeT, Gia_Obj_t ** ppNodeE );
1781extern int Gia_ObjRecognizeMuxLits( Gia_Man_t * p, Gia_Obj_t * pNode, int * iLitT, int * iLitE );
1782extern int Gia_NodeMffcSize( Gia_Man_t * p, Gia_Obj_t * pNode );
1783extern int Gia_NodeMffcSizeMark( Gia_Man_t * p, Gia_Obj_t * pNode );
1784extern int Gia_NodeMffcSizeSupp( Gia_Man_t * p, Gia_Obj_t * pNode, Vec_Int_t * vSupp );
1785extern int Gia_NodeMffcMapping( Gia_Man_t * p );
1786extern int Gia_ManHasDangling( Gia_Man_t * p );
1787extern int Gia_ManMarkDangling( Gia_Man_t * p );
1788extern Vec_Int_t * Gia_ManGetDangling( Gia_Man_t * p );
1789extern void Gia_ObjPrint( Gia_Man_t * p, Gia_Obj_t * pObj );
1790extern void Gia_ManPrint( Gia_Man_t * p );
1791extern void Gia_ManPrintCo( Gia_Man_t * p, Gia_Obj_t * pObj );
1792extern void Gia_ManPrintCone( Gia_Man_t * p, Gia_Obj_t * pObj, int * pLeaves, int nLeaves, Vec_Int_t * vNodes );
1793extern void Gia_ManPrintConeMulti( Gia_Man_t * p, Vec_Int_t * vObjs, Vec_Int_t * vLeaves, Vec_Int_t * vNodes );
1794extern void Gia_ManPrintCone2( Gia_Man_t * p, Gia_Obj_t * pObj );
1795extern void Gia_ManInvertConstraints( Gia_Man_t * pAig );
1796extern void Gia_ManInvertPos( Gia_Man_t * pAig );
1797extern int Gia_ManCompare( Gia_Man_t * p1, Gia_Man_t * p2 );
1798extern void Gia_ManMarkFanoutDrivers( Gia_Man_t * p );
1799extern void Gia_ManSwapPos( Gia_Man_t * p, int i );
1800extern Vec_Int_t * Gia_ManSaveValue( Gia_Man_t * p );
1801extern void Gia_ManLoadValue( Gia_Man_t * p, Vec_Int_t * vValues );
1802extern Vec_Int_t * Gia_ManFirstFanouts( Gia_Man_t * p );
1803extern int Gia_ManCheckSuppOverlap( Gia_Man_t * p, int iNode1, int iNode2 );
1804extern int Gia_ManCountPisWithFanout( Gia_Man_t * p );
1805extern int Gia_ManCountPosWithNonZeroDrivers( Gia_Man_t * p );
1806extern void Gia_ManUpdateCopy( Vec_Int_t * vCopy, Gia_Man_t * p );
1807extern Vec_Int_t * Gia_ManComputeDistance( Gia_Man_t * p, int iObj, Vec_Int_t * vObjs, int fVerbose );
1808
1809/*=== giaTtopt.cpp ===========================================================*/
1810extern Gia_Man_t * Gia_ManTtopt( Gia_Man_t * p, int nIns, int nOuts, int nRounds );
1811extern Gia_Man_t * Gia_ManTtoptCare( Gia_Man_t * p, int nIns, int nOuts, int nRounds, char * pFileName, int nRarity );
1812
1813/*=== giaTransduction.cpp ===========================================================*/
1814extern Gia_Man_t * Gia_ManTransductionBdd( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int fNewLine, int nVerbose );
1815extern Gia_Man_t * Gia_ManTransductionTt( Gia_Man_t * pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t * pExdc, int fNewLine, int nVerbose );
1816
1817/*=== giaRrr.cpp ===========================================================*/
1818extern Gia_Man_t * Gia_ManRrr( Gia_Man_t *pGia, int iSeed, int nWords, int nTimeout, int nSchedulerVerbose, int nPartitionerVerbose, int nOptimizerVerbose, int nAnalyzerVerbose, int nSimulatorVerbose, int nSatSolverVerbose, int fUseBddCspf, int fUseBddMspf, int nConflictLimit, int nSortType, int nOptimizerFlow, int nSchedulerFlow, int nPartitionType, int nDistance, int nJobs, int nThreads, int nPartitionSize, int nPartitionSizeMin, int fDeterministic, int nParallelPartitions, int fOptOnInsert, int fGreedy );
1819
1820/*=== giaCTas.c ===========================================================*/
1821typedef struct Tas_Man_t_ Tas_Man_t;
1822extern Tas_Man_t * Tas_ManAlloc( Gia_Man_t * pAig, int nBTLimit );
1823extern void Tas_ManStop( Tas_Man_t * p );
1824extern Vec_Int_t * Tas_ReadModel( Tas_Man_t * p );
1825extern void Tas_ManSatPrintStats( Tas_Man_t * p );
1826extern int Tas_ManSolve( Tas_Man_t * p, Gia_Obj_t * pObj, Gia_Obj_t * pObj2 );
1827extern int Tas_ManSolveArray( Tas_Man_t * p, Vec_Ptr_t * vObjs );
1828
1829/*=== giaBound.c ===========================================================*/
1830typedef struct Bnd_Man_t_ Bnd_Man_t;
1831
1832extern Bnd_Man_t* Bnd_ManStart( Gia_Man_t *pSpec, Gia_Man_t *pImpl, int fVerbose );
1833extern void Bnd_ManStop();
1834
1835// getter
1836extern int Bnd_ManGetNInternal();
1837extern int Bnd_ManGetNExtra();
1838
1839//for fraig
1840extern void Bnd_ManMap( int iLit, int id, int spec );
1841extern void Bnd_ManMerge( int id1, int id2, int phaseDiff );
1842extern void Bnd_ManFinalizeMappings();
1843extern void Bnd_ManPrintMappings();
1844extern Gia_Man_t* Bnd_ManStackGias( Gia_Man_t *pSpec, Gia_Man_t *pImpl );
1845extern int Bnd_ManCheckCoMerged( Gia_Man_t *p );
1846
1847// for eco
1848extern int Bnd_ManCheckBound( Gia_Man_t *p, int fVerbose );
1849extern void Bnd_ManFindBound( Gia_Man_t *p, Gia_Man_t *pImpl );
1850extern Gia_Man_t* Bnd_ManGenSpecOut( Gia_Man_t *p );
1851extern Gia_Man_t* Bnd_ManGenImplOut( Gia_Man_t *p );
1852extern Gia_Man_t* Bnd_ManGenPatched( Gia_Man_t *pOut, Gia_Man_t *pSpec, Gia_Man_t *pPatch );
1853extern Gia_Man_t* Bnd_ManGenPatched1( Gia_Man_t *pOut, Gia_Man_t *pSpec );
1854extern Gia_Man_t* Bnd_ManGenPatched2( Gia_Man_t *pImpl, Gia_Man_t *pPatch, int fSkiptStrash, int fVerbose );
1855extern void Bnd_ManSetEqOut( int eq );
1856extern void Bnd_ManSetEqRes( int eq );
1857extern void Bnd_ManPrintStats();
1858
1859// util
1860extern Gia_Man_t* Bnd_ManCutBoundary( Gia_Man_t *p, Vec_Int_t* vEI, Vec_Int_t* vEO, Vec_Bit_t* vEI_phase, Vec_Bit_t* vEO_phase );
1861
1862extern int Gia_ObjCheckMffc( Gia_Man_t * p, Gia_Obj_t * pRoot, int Limit, Vec_Int_t * vNodes, Vec_Int_t * vLeaves, Vec_Int_t * vInners );
1863
1864ABC_NAMESPACE_HEADER_END
1865
1866
1867#endif
1868
1872
nWords
int nWords
Definition abcNpn.c:127
ABC_REALLOC
#define ABC_REALLOC(type, obj, num)
Definition abc_global.h:268
ABC_INFINITY
#define ABC_INFINITY
MACRO DEFINITIONS ///.
Definition abc_global.h:250
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition abc_namespaces.h:51
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition abc_namespaces.h:50
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
Vec_Str_t
struct Vec_Str_t_ Vec_Str_t
Definition bblif.c:46
Pos
ush Pos
Definition deflate.h:88
p
Cube * p
Definition exorList.c:222
Gia_ManLevelizeR
Vec_Wec_t * Gia_ManLevelizeR(Gia_Man_t *p)
Definition giaDfs.c:430
Gia_ManCountPisWithFanout
int Gia_ManCountPisWithFanout(Gia_Man_t *p)
Definition giaUtil.c:2301
Gia_Rpr_t
struct Gia_Rpr_t_ Gia_Rpr_t
Definition gia.h:57
Bnd_ManStop
void Bnd_ManStop()
Definition giaBound.c:153
Gia_ManStop
void Gia_ManStop(Gia_Man_t *p)
Definition giaMan.c:82
Gia_ManDup
Gia_Man_t * Gia_ManDup(Gia_Man_t *p)
Definition giaDup.c:720
Gia_ManPtrWrdReadBin
Vec_Ptr_t * Gia_ManPtrWrdReadBin(char *pFileName, int fVerbose)
Definition giaSimBase.c:2682
Gia_ManSimPatSimOut
Vec_Wrd_t * Gia_ManSimPatSimOut(Gia_Man_t *pGia, Vec_Wrd_t *vSimsPi, int fOuts)
Definition giaSimBase.c:138
Gia_ManCombMarkUsed
int Gia_ManCombMarkUsed(Gia_Man_t *p)
Definition giaScl.c:60
Gia_ManDupMuxes
Gia_Man_t * Gia_ManDupMuxes(Gia_Man_t *p, int Limit)
Definition giaMuxes.c:98
Gia_ManDupAppendCones
Gia_Man_t * Gia_ManDupAppendCones(Gia_Man_t *p, Gia_Man_t **ppCones, int nCones, int fOnlyRegs)
Definition giaDup.c:1305
Gia_MmFixedRestart
void Gia_MmFixedRestart(Gia_MmFixed_t *p)
Definition giaMem.c:232
Gia_ManPerformSopBalanceWin
Gia_Man_t * Gia_ManPerformSopBalanceWin(Gia_Man_t *p, int LevelMax, int nTimeWindow, int nCutNum, int nRelaxRatio, int fVerbose)
Definition giaBalMap.c:265
Jf_ManSetDefaultPars
void Jf_ManSetDefaultPars(Jf_Par_t *pPars)
Definition giaJf.c:1682
Gia_ManLutFaninCount
int Gia_ManLutFaninCount(Gia_Man_t *p)
Definition giaIf.c:108
Gia_ManEvalWindow
int Gia_ManEvalWindow(Gia_Man_t *p, Vec_Int_t *vLeaves, Vec_Int_t *vNodes, Vec_Wec_t *vWin, Vec_Int_t *vTemp, int fUseTwo)
Definition giaEdge.c:633
Cbs_Man_t
struct Cbs_Man_t_ Cbs_Man_t
Definition gia.h:1305
Gia_ManReportImprovement
void Gia_ManReportImprovement(Gia_Man_t *p, Gia_Man_t *pNew)
Definition giaMan.c:782
Gia_ObjComputeTruthTableCut
word * Gia_ObjComputeTruthTableCut(Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vLeaves)
Definition giaTruth.c:628
Gia_ManUnrollStop
void Gia_ManUnrollStop(void *pMan)
Definition giaFrames.c:310
Tas_ManSatPrintStats
void Tas_ManSatPrintStats(Tas_Man_t *p)
Definition giaCTas.c:1487
Gia_ManEquivImprove
void Gia_ManEquivImprove(Gia_Man_t *p)
Definition giaEquiv.c:1780
Gia_ManDupCof
Gia_Man_t * Gia_ManDupCof(Gia_Man_t *p, int iVar)
Definition giaCof.c:862
Gia_ManFanoutStart
void Gia_ManFanoutStart(Gia_Man_t *p)
FUNCTION DEFINITIONS ///.
Definition giaFanout.c:66
Gia_MmFixedEntryRecycle
void Gia_MmFixedEntryRecycle(Gia_MmFixed_t *p, char *pEntry)
Definition giaMem.c:212
Gia_ManNonRegBoxNum
int Gia_ManNonRegBoxNum(Gia_Man_t *p)
Definition giaTim.c:58
Gia_ManDupCycled
Gia_Man_t * Gia_ManDupCycled(Gia_Man_t *pAig, Abc_Cex_t *pCex, int nFrames)
Definition giaDup.c:691
Gia_SweeperStart
Gia_Man_t * Gia_SweeperStart(Gia_Man_t *p)
Definition giaSweeper.c:145
Gia_ManCreateMuxRefs
int * Gia_ManCreateMuxRefs(Gia_Man_t *p)
Definition giaUtil.c:828
Gia_ManConvertAigToTruth
unsigned * Gia_ManConvertAigToTruth(Gia_Man_t *p, Gia_Obj_t *pRoot, Vec_Int_t *vLeaves, Vec_Int_t *vTruth, Vec_Int_t *vVisited)
Definition giaBidec.c:90
Gia_ManTestDistance
void Gia_ManTestDistance(Gia_Man_t *p)
Definition giaEmbed.c:904
Gia_ObjSetPhase
void Gia_ObjSetPhase(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaUtil.c:387
Gia_SweeperCheckEquiv
int Gia_SweeperCheckEquiv(Gia_Man_t *p, int ProbeId1, int ProbeId2)
Definition giaSweeper.c:789
Gia_ManPerformFx
Gia_Man_t * Gia_ManPerformFx(Gia_Man_t *p, int nNewNodesMax, int LitCountMax, int fReverse, int fVerbose, int fVeryVerbose)
Definition giaFx.c:465
Gia_ManStaticFanoutStart
void Gia_ManStaticFanoutStart(Gia_Man_t *p)
Definition giaFanout.c:238
Gia_ManHashStart
void Gia_ManHashStart(Gia_Man_t *p)
Definition giaHash.c:125
Gia_FileSize
int Gia_FileSize(char *pFileName)
FUNCTION DECLARATIONS ///.
Definition giaAiger.c:64
Gia_ManFraSetDefaultParams
void Gia_ManFraSetDefaultParams(Gia_ParFra_t *p)
Definition giaFrames.c:631
Gia_ManSuppSize
int Gia_ManSuppSize(Gia_Man_t *p, int *pNodes, int nNodes)
Definition giaDfs.c:324
Gia_ManSwapPos
void Gia_ManSwapPos(Gia_Man_t *p, int i)
Definition giaUtil.c:1808
Gia_ManPermuteInputs
Gia_Man_t * Gia_ManPermuteInputs(Gia_Man_t *p, int nPpis, int nExtra)
Definition giaDup.c:2758
Gia_ManFindFailedPoCex
int Gia_ManFindFailedPoCex(Gia_Man_t *pAig, Abc_Cex_t *p, int nOutputs)
Definition giaCex.c:91
Gia_ManEquivFixOutputPairs
void Gia_ManEquivFixOutputPairs(Gia_Man_t *p)
Definition giaEquiv.c:882
Gia_SweeperExtractUserLogic
Gia_Man_t * Gia_SweeperExtractUserLogic(Gia_Man_t *p, Vec_Int_t *vProbeIds, Vec_Ptr_t *vInNames, Vec_Ptr_t *vOutNames)
Definition giaSweeper.c:358
Gia_ManStaticFanoutStop
void Gia_ManStaticFanoutStop(Gia_Man_t *p)
Definition giaFanout.c:393
Gia_NodeMffcSizeSupp
int Gia_NodeMffcSizeSupp(Gia_Man_t *p, Gia_Obj_t *pNode, Vec_Int_t *vSupp)
Definition giaUtil.c:1279
Gia_ManCheckTopoOrder
int Gia_ManCheckTopoOrder(Gia_Man_t *p)
Definition giaEquiv.c:236
Gia_MmStepStop
void Gia_MmStepStop(Gia_MmStep_t *p, int fVerbose)
Definition giaMem.c:507
Gia_ManMemory
double Gia_ManMemory(Gia_Man_t *p)
Definition giaMan.c:194
Gia_ManCreateLitRefs
void Gia_ManCreateLitRefs(Gia_Man_t *p)
Definition giaUtil.c:799
Gia_ManDupFlopClass
Gia_Man_t * Gia_ManDupFlopClass(Gia_Man_t *p, int iClass)
Definition giaDup.c:1399
Gia_ManDupChoicesAdd
void Gia_ManDupChoicesAdd(Gia_ChMan_t *pMan, Gia_Man_t *pGia)
Definition giaDup.c:6411
Bnd_ManSetEqRes
void Bnd_ManSetEqRes(int eq)
Definition giaBound.c:68
Gia_ManDupDfsCiMap
Gia_Man_t * Gia_ManDupDfsCiMap(Gia_Man_t *p, int *pCi2Lit, Vec_Int_t *vLits)
Definition giaDup.c:2708
Gia_MmFlexStart
Gia_MmFlex_t * Gia_MmFlexStart()
Definition giaMem.c:305
Gia_ObjCheckMffc
int Gia_ObjCheckMffc(Gia_Man_t *p, Gia_Obj_t *pRoot, int Limit, Vec_Int_t *vNodes, Vec_Int_t *vLeaves, Vec_Int_t *vInners)
Definition giaResub.c:71
Gia_ManDupDfsCone
Gia_Man_t * Gia_ManDupDfsCone(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaDup.c:2188
Gia_ManHasDangling
int Gia_ManHasDangling(Gia_Man_t *p)
Definition giaUtil.c:1353
Gia_ManPrintFanio
void Gia_ManPrintFanio(Gia_Man_t *pGia, int nNodes)
Definition giaCof.c:746
Gia_ManPrintMappingStats
void Gia_ManPrintMappingStats(Gia_Man_t *p, char *pDumpFile)
Definition giaIf.c:532
Gia_ManSupportAnd
int Gia_ManSupportAnd(Gia_ManMin_t *p, int iLit0, int iLit1)
Definition giaSupp.c:280
Gia_ManQuantSetSuppCi
void Gia_ManQuantSetSuppCi(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaExist.c:117
Gia_ManSeqMarkUsed
int Gia_ManSeqMarkUsed(Gia_Man_t *p)
Definition giaScl.c:156
GIA_ZER
#define GIA_ZER
Definition gia.h:921
Gia_ManPrintCone2
void Gia_ManPrintCone2(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaUtil.c:1618
Gia_ObjComputeTruthTable6
word Gia_ObjComputeTruthTable6(Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vSupp, Vec_Wrd_t *vTruths)
Definition giaTruth.c:386
Gia_ManEquivCountLits
int Gia_ManEquivCountLits(Gia_Man_t *p)
Definition giaEquiv.c:450
Gia_ManConvertPackingToEdges
void Gia_ManConvertPackingToEdges(Gia_Man_t *p)
Definition giaEdge.c:118
Gia_ObjRecognizeMux
Gia_Obj_t * Gia_ObjRecognizeMux(Gia_Obj_t *pNode, Gia_Obj_t **ppNodeT, Gia_Obj_t **ppNodeE)
Definition giaUtil.c:1056
Gia_ManSetPhasePattern
void Gia_ManSetPhasePattern(Gia_Man_t *p, Vec_Int_t *vCiValues)
Definition giaUtil.c:427
Gia_ManRegBoxNum
int Gia_ManRegBoxNum(Gia_Man_t *p)
Definition giaTim.c:54
Gia_ManComputeDistance
Vec_Int_t * Gia_ManComputeDistance(Gia_Man_t *p, int iObj, Vec_Int_t *vObjs, int fVerbose)
Definition giaUtil.c:2508
Gia_ManIsNormalized
int Gia_ManIsNormalized(Gia_Man_t *p)
Definition giaTim.c:114
Gia_ManDupFlip
Gia_Man_t * Gia_ManDupFlip(Gia_Man_t *p, int *pInitState)
Definition giaDup.c:628
Gia_ManDupWithAttributes
Gia_Man_t * Gia_ManDupWithAttributes(Gia_Man_t *p)
Definition giaDup.c:776
Gia_ManEquivCountLitsAll
int Gia_ManEquivCountLitsAll(Gia_Man_t *p)
Definition giaEquiv.c:357
Gia_ManFrontTest
void Gia_ManFrontTest(Gia_Man_t *p)
Definition giaFront.c:262
Tas_Man_t
struct Tas_Man_t_ Tas_Man_t
Definition gia.h:1821
Gia_ManUpdateTimMan
void * Gia_ManUpdateTimMan(Gia_Man_t *p, Vec_Int_t *vBoxPres)
Definition giaTim.c:668
Gia_ManStaticMappingFanoutStart
void Gia_ManStaticMappingFanoutStart(Gia_Man_t *p, Vec_Int_t **pvIndex)
Definition giaFanout.c:335
Gia_MmStepStart
Gia_MmStep_t * Gia_MmStepStart(int nSteps)
Definition giaMem.c:468
Gia_ManDupConeBackObjs
int Gia_ManDupConeBackObjs(Gia_Man_t *p, Gia_Man_t *pNew, Vec_Int_t *vObjs)
Definition giaDup.c:2282
Gia_ManUpdateExtraAig
Gia_Man_t * Gia_ManUpdateExtraAig(void *pTime, Gia_Man_t *pAig, Vec_Int_t *vBoxPres)
Definition giaTim.c:694
Gia_ManDupTrimmed
Gia_Man_t * Gia_ManDupTrimmed(Gia_Man_t *p, int fTrimCis, int fTrimCos, int fDualOut, int OutValue)
Definition giaDup.c:2431
Gia_ResubToTruth6
word Gia_ResubToTruth6(Vec_Int_t *vResub)
Definition giaDecs.c:73
Gia_MmStepEntryRecycle
void Gia_MmStepEntryRecycle(Gia_MmStep_t *p, char *pEntry, int nBytes)
Definition giaMem.c:563
Gia_ManDupDfsClasses
Gia_Man_t * Gia_ManDupDfsClasses(Gia_Man_t *p)
Definition giaDup.c:2795
Gia_ManEquivReduce
Gia_Man_t * Gia_ManEquivReduce(Gia_Man_t *p, int fUseAll, int fDualOut, int fSkipPhase, int fVerbose)
Definition giaEquiv.c:677
Gia_ManSetRefsMapped
void Gia_ManSetRefsMapped(Gia_Man_t *p)
Definition giaIf.c:271
Gia_ManHashMuxReal
int Gia_ManHashMuxReal(Gia_Man_t *p, int iLitC, int iLit1, int iLit0)
Definition giaHash.c:521
Gia_SweeperCondCheckUnsat
int Gia_SweeperCondCheckUnsat(Gia_Man_t *p)
Definition giaSweeper.c:924
Gia_ManCollectPoIds
Vec_Int_t * Gia_ManCollectPoIds(Gia_Man_t *p)
Definition giaUtil.c:960
Bnd_ManGenPatched1
Gia_Man_t * Bnd_ManGenPatched1(Gia_Man_t *pOut, Gia_Man_t *pSpec)
Definition giaBound.c:1059
Gia_SweeperSetRuntimeLimit
void Gia_SweeperSetRuntimeLimit(Gia_Man_t *p, int nSeconds)
Definition giaSweeper.c:225
Gia_ManDeriveSolutionOne
Vec_Int_t * Gia_ManDeriveSolutionOne(Gia_Man_t *p, Vec_Wrd_t *vSims, Vec_Wrd_t *vIsfs, Vec_Int_t *vCands, Vec_Int_t *vSet, int nWords, int Type)
Definition giaDecs.c:318
Gia_ManLutLevel
int Gia_ManLutLevel(Gia_Man_t *p, int **ppLevels)
Definition giaIf.c:165
Gia_ManDupAndConesLimit2
Gia_Man_t * Gia_ManDupAndConesLimit2(Gia_Man_t *p, int *pAnds, int nAnds, int Level)
Definition giaDup.c:4054
Gia_ManBoxCiNum
int Gia_ManBoxCiNum(Gia_Man_t *p)
Definition giaTim.c:66
Gia_ManDupWithNewPo
Gia_Man_t * Gia_ManDupWithNewPo(Gia_Man_t *p1, Gia_Man_t *p2)
Definition giaDup.c:2634
Gia_ManPerformMapping
Gia_Man_t * Gia_ManPerformMapping(Gia_Man_t *p, void *pIfPars)
Definition giaIf.c:2598
Gia_ManDemiterTwoWords
int Gia_ManDemiterTwoWords(Gia_Man_t *p, Gia_Man_t **pp0, Gia_Man_t **pp1)
Definition giaDup.c:5082
Gia_ManCountChoiceNodes
int Gia_ManCountChoiceNodes(Gia_Man_t *p)
Definition giaEquiv.c:2091
Gia_ManSim2ArrayOne
void Gia_ManSim2ArrayOne(Vec_Wrd_t *vSimsPi, Vec_Int_t *vRes)
Definition giaSimBase.c:2558
Gia_ManDupLastPis
Gia_Man_t * Gia_ManDupLastPis(Gia_Man_t *p, int nLastPis)
Definition giaDup.c:597
Gia_AigerWriteIntoMemoryStr
Vec_Str_t * Gia_AigerWriteIntoMemoryStr(Gia_Man_t *p)
Definition giaAiger.c:1062
Gia_ManDemiterDual
int Gia_ManDemiterDual(Gia_Man_t *p, Gia_Man_t **pp0, Gia_Man_t **pp1)
Definition giaDup.c:5030
Gia_ResubVarNum
int Gia_ResubVarNum(Vec_Int_t *vResub)
FUNCTION DEFINITIONS ///.
Definition giaDecs.c:51
Gia_ManHashLookup
int Gia_ManHashLookup(Gia_Man_t *p, Gia_Obj_t *p0, Gia_Obj_t *p1)
Definition giaHash.c:87
Gia_ManReadMiniAig
Gia_Man_t * Gia_ManReadMiniAig(char *pFileName, int fGiaSimple)
Definition giaMini.c:220
Gia_ManDupRemovePis
Gia_Man_t * Gia_ManDupRemovePis(Gia_Man_t *p, int nRemPis)
Definition giaDup.c:802
Gia_ManDupOutputGroup
Gia_Man_t * Gia_ManDupOutputGroup(Gia_Man_t *p, int iOutStart, int iOutStop)
Definition giaDup.c:313
Bnd_ManStart
Bnd_Man_t * Bnd_ManStart(Gia_Man_t *pSpec, Gia_Man_t *pImpl, int fVerbose)
Definition giaBound.c:88
Gia_ManOrigIdsStart
void Gia_ManOrigIdsStart(Gia_Man_t *p)
Definition giaEquiv.c:51
Gia_SweeperCleanup
Gia_Man_t * Gia_SweeperCleanup(Gia_Man_t *p, char *pCommLime)
Definition giaSweeper.c:461
Gia_ManDupTimes
Gia_Man_t * Gia_ManDupTimes(Gia_Man_t *p, int nTimes)
Definition giaDup.c:1547
Gia_ManDeriveReprsFromSibls
void Gia_ManDeriveReprsFromSibls(Gia_Man_t *p)
Definition giaEquiv.c:325
Gia_ManRequiredLevel
Vec_Int_t * Gia_ManRequiredLevel(Gia_Man_t *p)
Definition giaUtil.c:702
Gia_SortFloats
int * Gia_SortFloats(float *pArray, int *pPerm, int nSize)
Definition giaSort.c:251
Gia_ManBuiltInSimStart
void Gia_ManBuiltInSimStart(Gia_Man_t *p, int nWords, int nObjs)
Definition giaSim.c:776
Cbs_ManAlloc
Cbs_Man_t * Cbs_ManAlloc(Gia_Man_t *pGia)
Definition giaCSat.c:153
Gia_ManDelayTraceLutPrint
float Gia_ManDelayTraceLutPrint(Gia_Man_t *p, int fVerbose)
Definition giaSpeedup.c:444
Gia_MmFlex_t
struct Gia_MmFlex_t_ Gia_MmFlex_t
Definition gia.h:53
Gia_ManDupZero
Gia_Man_t * Gia_ManDupZero(Gia_Man_t *p)
Definition giaDup.c:905
Gia_ManTransformMiter
Gia_Man_t * Gia_ManTransformMiter(Gia_Man_t *p)
Definition giaDup.c:3376
Gia_ManLutParams
void Gia_ManLutParams(Gia_Man_t *p, int *pnCurLuts, int *pnCurEdges, int *pnCurLevels)
Definition giaIf.c:203
Gia_ManEdgeToArray
Vec_Int_t * Gia_ManEdgeToArray(Gia_Man_t *p)
Definition giaEdge.c:88
Gia_ManComputeOneWin
int Gia_ManComputeOneWin(Gia_Man_t *p, int iPivot, Vec_Int_t **pvRoots, Vec_Int_t **pvNodes, Vec_Int_t **pvLeaves, Vec_Int_t **pvAnds)
Definition giaSplit.c:516
Gia_SweeperIsRunning
int Gia_SweeperIsRunning(Gia_Man_t *p)
Definition giaSweeper.c:164
Gia_ManDupUnshuffleInputs
Gia_Man_t * Gia_ManDupUnshuffleInputs(Gia_Man_t *p)
Definition giaTim.c:203
Gia_ManDeriveReprs
void Gia_ManDeriveReprs(Gia_Man_t *p)
Definition giaEquiv.c:293
Gia_ManRandomW
word Gia_ManRandomW(int fReset)
Definition giaUtil.c:67
Gia_ManStopP
void Gia_ManStopP(Gia_Man_t **p)
Definition giaMan.c:224
Gia_ManDupUniv
Gia_Man_t * Gia_ManDupUniv(Gia_Man_t *p, int iVar)
Definition giaDup.c:2059
Gia_ManSetPhase1
void Gia_ManSetPhase1(Gia_Man_t *p)
Definition giaUtil.c:450
Gia_ManRandomInfo
void Gia_ManRandomInfo(Vec_Ptr_t *vInfo, int iInputStart, int iWordStart, int iWordStop)
Definition giaUtil.c:85
Gia_ManCreateValueRefs
void Gia_ManCreateValueRefs(Gia_Man_t *p)
Definition giaUtil.c:750
Gia_ManDetectSeqSignals
void Gia_ManDetectSeqSignals(Gia_Man_t *p, int fSetReset, int fVerbose)
Definition giaEnable.c:130
Gia_ManSetMark1
void Gia_ManSetMark1(Gia_Man_t *p)
Definition giaUtil.c:294
Gia_ManPrintStatsMiter
void Gia_ManPrintStatsMiter(Gia_Man_t *p, int fVerbose)
Definition giaMan.c:730
Gia_ManHashDualMiter
int Gia_ManHashDualMiter(Gia_Man_t *p, Vec_Int_t *vOuts)
Definition giaHash.c:809
Gia_ManSim2Array
Vec_Wec_t * Gia_ManSim2Array(Vec_Ptr_t *vSims)
Definition giaSimBase.c:2570
Gia_ManComputeRange
Vec_Str_t * Gia_ManComputeRange(Gia_Man_t *p)
Definition giaSimBase.c:3685
Gia_AigerRead
Gia_Man_t * Gia_AigerRead(char *pFileName, int fGiaSimple, int fSkipStrash, int fCheck)
Definition giaAiger.c:1017
Gia_ManSetRegNum
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition giaMan.c:764
Gia_ManGetCiLevels
Vec_Int_t * Gia_ManGetCiLevels(Gia_Man_t *p)
Definition giaUtil.c:609
Gia_ManHashAndMulti
int Gia_ManHashAndMulti(Gia_Man_t *p, Vec_Int_t *vLits)
Definition giaHash.c:783
Gia_ManDelayTraceLut
float Gia_ManDelayTraceLut(Gia_Man_t *p)
Definition giaSpeedup.c:230
Gia_ManDeriveNexts
int * Gia_ManDeriveNexts(Gia_Man_t *p)
Definition giaEquiv.c:260
Gia_ManWriteMiniAig
void Gia_ManWriteMiniAig(Gia_Man_t *pGia, char *pFileName)
Definition giaMini.c:237
Gia_ManCounterExampleValueStop
void Gia_ManCounterExampleValueStop(Gia_Man_t *pGia)
Definition giaCex.c:246
Gia_ManDupOneHot
Gia_Man_t * Gia_ManDupOneHot(Gia_Man_t *p)
Definition giaDup.c:4108
Gia_ManComputeSwitching
float Gia_ManComputeSwitching(Gia_Man_t *p, int nFrames, int nPref, int fProbOne)
Definition giaSwitch.c:808
Gia_ManFraigSweepSimple
Gia_Man_t * Gia_ManFraigSweepSimple(Gia_Man_t *p, void *pPars)
Definition giaSweep.c:606
Tas_ManAlloc
Tas_Man_t * Tas_ManAlloc(Gia_Man_t *pAig, int nBTLimit)
Definition giaCTas.c:187
Gia_ManCollectTfo
void Gia_ManCollectTfo(Gia_Man_t *p, Vec_Int_t *vRoots, Vec_Int_t *vNodes)
Definition giaDfs.c:615
Gia_ManAreaBalance
Gia_Man_t * Gia_ManAreaBalance(Gia_Man_t *p, int fSimpleAnd, int nNewNodesMax, int fVerbose, int fVeryVerbose)
Definition giaBalAig.c:1047
Gia_ManDup2
Gia_Man_t * Gia_ManDup2(Gia_Man_t *p1, Gia_Man_t *p2)
Definition giaDup.c:751
Gia_SweeperProbeUpdate
int Gia_SweeperProbeUpdate(Gia_Man_t *p, int ProbeId, int iLitNew)
Definition giaSweeper.c:267
Gia_ManEquivSetColors
int Gia_ManEquivSetColors(Gia_Man_t *p, int fVerbose)
Definition giaEquiv.c:1097
Gia_ManHashProfile
void Gia_ManHashProfile(Gia_Man_t *p)
Definition giaHash.c:207
Gia_Dat_t
struct Gia_Dat_t_ Gia_Dat_t
Definition gia.h:55
Gia_ManIncrSimStart
void Gia_ManIncrSimStart(Gia_Man_t *p, int nWords, int nObjs)
Definition giaSim.c:1150
Bnd_ManMap
void Bnd_ManMap(int iLit, int id, int spec)
Definition giaBound.c:178
Gia_MmFixedStart
Gia_MmFixed_t * Gia_MmFixedStart(int nEntrySize, int nEntriesMax)
FUNCTION DEFINITIONS ///.
Definition giaMem.c:96
Gia_ManPrintCo
void Gia_ManPrintCo(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaUtil.c:1563
Gia_ManCounterExampleValueLookup
int Gia_ManCounterExampleValueLookup(Gia_Man_t *pGia, int Id, int iFrame)
Definition giaCex.c:266
Gia_ManHashAndMulti2
int Gia_ManHashAndMulti2(Gia_Man_t *p, Vec_Int_t *vLits)
Definition giaHash.c:802
Gia_ManHashAlloc
void Gia_ManHashAlloc(Gia_Man_t *p)
Definition giaHash.c:105
Gia_ManDupCofactorVar
Gia_Man_t * Gia_ManDupCofactorVar(Gia_Man_t *p, int iVar, int Value)
Definition giaDup.c:1861
Gia_ManPrintMiterStatus
void Gia_ManPrintMiterStatus(Gia_Man_t *p)
Definition giaMan.c:679
Gia_ManMarkDangling
int Gia_ManMarkDangling(Gia_Man_t *p)
Definition giaUtil.c:1391
Gia_ManDupDfsNode
Gia_Man_t * Gia_ManDupDfsNode(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaDup.c:2321
Gia_ManDupRemapEquiv
void Gia_ManDupRemapEquiv(Gia_Man_t *pNew, Gia_Man_t *p)
Definition giaDup.c:82
Gia_ManLevelWithBoxes
int Gia_ManLevelWithBoxes(Gia_Man_t *p)
Definition giaTim.c:478
Gia_ManPrintStatsShort
void Gia_ManPrintStatsShort(Gia_Man_t *p)
Definition giaMan.c:658
Gia_SweeperPrintStats
void Gia_SweeperPrintStats(Gia_Man_t *p)
Definition giaSweeper.c:181
Gia_Plc_t
struct Gia_Plc_t_ Gia_Plc_t
Definition gia.h:67
Gia_ManPrintNpnClasses
void Gia_ManPrintNpnClasses(Gia_Man_t *p)
Definition giaMan.c:804
Gia_ManDupMux
Gia_Man_t * Gia_ManDupMux(int iVar, Gia_Man_t *pCof1, Gia_Man_t *pCof0)
Definition giaDup.c:1887
Gia_NodeMffcMapping
int Gia_NodeMffcMapping(Gia_Man_t *p)
Definition giaUtil.c:1324
Gia_ParFra_t
struct Gia_ParFra_t_ Gia_ParFra_t
Definition gia.h:293
Gia_ManPrintPackingStats
void Gia_ManPrintPackingStats(Gia_Man_t *p)
Definition giaIf.c:663
Gia_ManBuiltInSimCheckEqual
int Gia_ManBuiltInSimCheckEqual(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaSim.c:902
Gia_MmFixed_t
struct Gia_MmFixed_t_ Gia_MmFixed_t
BASIC TYPES ///.
Definition gia.h:52
Gia_MmFixedEntryFetch
char * Gia_MmFixedEntryFetch(Gia_MmFixed_t *p)
Definition giaMem.c:161
Gia_SweeperCondPush
void Gia_SweeperCondPush(Gia_Man_t *p, int ProbeId)
Definition giaSweeper.c:319
Tas_ManSolveMiterNc
Vec_Int_t * Tas_ManSolveMiterNc(Gia_Man_t *pGia, int nConfs, Vec_Str_t **pvStatus, int fVerbose)
Definition giaCTas.c:1517
Gia_ManMiter2
Gia_Man_t * Gia_ManMiter2(Gia_Man_t *p, char *pInit, int fVerbose)
Definition giaDup.c:3651
Gia_ManCountPosWithNonZeroDrivers
int Gia_ManCountPosWithNonZeroDrivers(Gia_Man_t *p)
Definition giaUtil.c:2332
Gia_ManDupPermFlop
Gia_Man_t * Gia_ManDupPermFlop(Gia_Man_t *p, Vec_Int_t *vFfPerm)
Definition giaDup.c:962
Bnd_ManGenImplOut
Gia_Man_t * Bnd_ManGenImplOut(Gia_Man_t *p)
Definition giaBound.c:873
Gia_SweeperCollectValidProbeIds
Vec_Int_t * Gia_SweeperCollectValidProbeIds(Gia_Man_t *p)
Definition giaSweeper.c:295
Gia_ManPrintLutStats
void Gia_ManPrintLutStats(Gia_Man_t *p)
Definition giaIf.c:727
Gia_ManRehash
Gia_Man_t * Gia_ManRehash(Gia_Man_t *p, int fAddStrash)
Definition giaHash.c:739
Gia_ObjRecognizeMuxLits
int Gia_ObjRecognizeMuxLits(Gia_Man_t *p, Gia_Obj_t *pNode, int *iLitT, int *iLitE)
Definition giaUtil.c:1133
Gia_SimDataExt
unsigned * Gia_SimDataExt(Gia_ManSim_t *p, int i)
Definition giaSim.c:35
Gia_ManUnrollAbs
Vec_Ptr_t * Gia_ManUnrollAbs(Gia_Man_t *p, int nFrames)
Definition giaFrames.c:155
Gia_ManLevelRNum
int Gia_ManLevelRNum(Gia_Man_t *p)
Definition giaUtil.c:566
Gia_ManStart
Gia_Man_t * Gia_ManStart(int nObjsMax)
FUNCTION DEFINITIONS ///.
Definition giaMan.c:57
Gia_ManHashOr
int Gia_ManHashOr(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:621
Gia_ManChoiceMiter
Gia_Man_t * Gia_ManChoiceMiter(Vec_Ptr_t *vGias)
Definition giaDup.c:3763
Gia_ManUpdateCopy
void Gia_ManUpdateCopy(Vec_Int_t *vCopy, Gia_Man_t *p)
Definition giaUtil.c:2352
Gia_ManDupBlock
Gia_Man_t * Gia_ManDupBlock(Gia_Man_t *p, int nBlock)
Definition giaDup.c:1976
Gia_ManIsSeqWithBoxes
int Gia_ManIsSeqWithBoxes(Gia_Man_t *p)
Definition giaTim.c:98
Gia_ManBoxNum
int Gia_ManBoxNum(Gia_Man_t *p)
DECLARATIONS ///.
Definition giaTim.c:50
Gia_Obj_t
struct Gia_Obj_t_ Gia_Obj_t
Definition gia.h:76
Gia_ManCompare
int Gia_ManCompare(Gia_Man_t *p1, Gia_Man_t *p2)
Definition giaUtil.c:1737
Sat_ManTest
int Sat_ManTest(Gia_Man_t *pGia, Gia_Obj_t *pObj, int nConfsMax)
Cbs_ManSolve2
int Cbs_ManSolve2(Cbs_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pObj2)
Definition giaCSat.c:970
Gia_Man2SuppStart
Gia_Man2Min_t * Gia_Man2SuppStart(Gia_Man_t *pGia)
Definition giaSupp.c:375
Gia_AigerReadFromMemory
Gia_Man_t * Gia_AigerReadFromMemory(char *pContents, int nFileSize, int fGiaSimple, int fSkipStrash, int fCheck)
Definition giaAiger.c:176
For_ManExperiment
void For_ManExperiment(Gia_Man_t *pGia, int nIters, int fClustered, int fVerbose)
Definition giaForce.c:1039
Gia_ManPrint
void Gia_ManPrint(Gia_Man_t *p)
Definition giaUtil.c:1543
Gia_ManEvalEdgeCount
int Gia_ManEvalEdgeCount(Gia_Man_t *p)
Definition giaEdge.c:284
Tas_ReadModel
Vec_Int_t * Tas_ReadModel(Tas_Man_t *p)
Definition giaCTas.c:250
Gia_ManDumpVerilogNand
void Gia_ManDumpVerilogNand(Gia_Man_t *p, char *pFileName)
Definition giaMan.c:2151
Gia_ManEquivPrintClasses
void Gia_ManEquivPrintClasses(Gia_Man_t *p, int fVerbose, float Mem)
Definition giaEquiv.c:501
Gia_ManDupPerm
Gia_Man_t * Gia_ManDupPerm(Gia_Man_t *p, Vec_Int_t *vPiPerm)
Definition giaDup.c:929
Gia_SweeperGetCex
Vec_Int_t * Gia_SweeperGetCex(Gia_Man_t *p)
Definition giaSweeper.c:230
Gia_ManLoadValue
void Gia_ManLoadValue(Gia_Man_t *p, Vec_Int_t *vValues)
Definition giaUtil.c:1841
Bnd_ManGetNExtra
int Bnd_ManGetNExtra()
Definition giaBound.c:176
Mf_ManPerformMapping
Gia_Man_t * Mf_ManPerformMapping(Gia_Man_t *pGia, Jf_Par_t *pPars)
Definition giaMf.c:1822
Gia_ManDupNoMuxes
Gia_Man_t * Gia_ManDupNoMuxes(Gia_Man_t *p, int fSkipBufs)
Definition giaMuxes.c:228
Gia_ManUnrollAdd
void * Gia_ManUnrollAdd(void *pMan, int fMax)
Definition giaFrames.c:437
Gia_ManCheckMark0
void Gia_ManCheckMark0(Gia_Man_t *p)
Definition giaUtil.c:275
Gia_ManDupExist
Gia_Man_t * Gia_ManDupExist(Gia_Man_t *p, int iVar)
Definition giaDup.c:2012
Gia_ManDupPermFlopGap
Gia_Man_t * Gia_ManDupPermFlopGap(Gia_Man_t *p, Vec_Int_t *vFfPerm)
Definition giaDup.c:1026
Gia_SweeperProbeCreate
int Gia_SweeperProbeCreate(Gia_Man_t *p, int iLit)
Definition giaSweeper.c:249
Tas_ManSolveArray
int Tas_ManSolveArray(Tas_Man_t *p, Vec_Ptr_t *vObjs)
Definition giaCTas.c:1423
Gia_ManDupMarked
Gia_Man_t * Gia_ManDupMarked(Gia_Man_t *p)
Definition giaDup.c:1444
Gia_ManUpdateTimMan2
void * Gia_ManUpdateTimMan2(Gia_Man_t *p, Vec_Int_t *vBoxesLeft, int nTermsDiff)
Definition giaTim.c:675
Gia_ManSim_t
struct Gia_ManSim_t_ Gia_ManSim_t
Definition gia.h:319
Gia_ManRrr
Gia_Man_t * Gia_ManRrr(Gia_Man_t *pGia, int iSeed, int nWords, int nTimeout, int nSchedulerVerbose, int nPartitionerVerbose, int nOptimizerVerbose, int nAnalyzerVerbose, int nSimulatorVerbose, int nSatSolverVerbose, int fUseBddCspf, int fUseBddMspf, int nConflictLimit, int nSortType, int nOptimizerFlow, int nSchedulerFlow, int nPartitionType, int nDistance, int nJobs, int nThreads, int nPartitionSize, int nPartitionSizeMin, int fDeterministic, int nParallelPartitions, int fOptOnInsert, int fGreedy)
Definition giaRrr.cpp:8
Gia_ManHashXor
int Gia_ManHashXor(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:668
Gia_ManSimSetDefaultParams
void Gia_ManSimSetDefaultParams(Gia_ParSim_t *p)
Definition giaSim.c:165
Gia_ManDupDfsSkip
Gia_Man_t * Gia_ManDupDfsSkip(Gia_Man_t *p)
Definition giaDup.c:2158
Gia_ManCexExtendToIncludeAllObjects
Abc_Cex_t * Gia_ManCexExtendToIncludeAllObjects(Gia_Man_t *p, Abc_Cex_t *pCex)
Definition giaCex.c:353
Gia_ManDupCofactorObj
Gia_Man_t * Gia_ManDupCofactorObj(Gia_Man_t *p, int iObj, int Value)
Definition giaDup.c:1935
Gia_ManDupCollapse
Gia_Man_t * Gia_ManDupCollapse(Gia_Man_t *p, Gia_Man_t *pBoxes, Vec_Int_t *vBoxPres, int fSeq)
Definition giaTim.c:802
Gia_ManInvertPos
void Gia_ManInvertPos(Gia_Man_t *pAig)
Definition giaUtil.c:1651
Gia_ManDupAndConesLimit
Gia_Man_t * Gia_ManDupAndConesLimit(Gia_Man_t *p, int *pAnds, int nAnds, int Level)
Definition giaDup.c:4021
Gia_ManBuiltInSimPerform
void Gia_ManBuiltInSimPerform(Gia_Man_t *p, int iObj)
Definition giaSim.c:824
Gia_ManComputeEdgeDelay
int Gia_ManComputeEdgeDelay(Gia_Man_t *p, int fUseTwo)
Definition giaEdge.c:390
Gia_ManDupRemapLiterals
void Gia_ManDupRemapLiterals(Vec_Int_t *vLits, Gia_Man_t *p)
FUNCTION DEFINITIONS ///.
Definition giaDup.c:54
Gia_ObjIsMuxType
int Gia_ObjIsMuxType(Gia_Obj_t *pNode)
Definition giaUtil.c:982
Gia_ManRemoveEnables
Gia_Man_t * Gia_ManRemoveEnables(Gia_Man_t *p)
Definition giaEnable.c:514
Gia_ManCexExtendToIncludeCurrentStates
Abc_Cex_t * Gia_ManCexExtendToIncludeCurrentStates(Gia_Man_t *p, Abc_Cex_t *pCex)
Definition giaCex.c:306
Gia_ObjPrint
void Gia_ObjPrint(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaUtil.c:1456
Gia_ManFillValue
void Gia_ManFillValue(Gia_Man_t *p)
Definition giaUtil.c:369
Gia_Man_t
struct Gia_Man_t_ Gia_Man_t
Definition gia.h:96
Gia_ManEquivPrintOne
void Gia_ManEquivPrintOne(Gia_Man_t *p, int i, int Counter)
Definition giaEquiv.c:489
Gia_LutComputeTruth6
word Gia_LutComputeTruth6(Gia_Man_t *p, int iObj, Vec_Wrd_t *vTruths)
Definition giaTruth.c:249
Gia_ManCounterExampleValueStart
void Gia_ManCounterExampleValueStart(Gia_Man_t *pGia, Abc_Cex_t *pCex)
Definition giaCex.c:188
Gia_ManPerformBidec
Gia_Man_t * Gia_ManPerformBidec(Gia_Man_t *p, int fVerbose)
Definition giaBidec.c:233
Gia_ManUnrollAndCofactor
Gia_Man_t * Gia_ManUnrollAndCofactor(Gia_Man_t *p, int nFrames, int nFanMax, int fVerbose)
Definition giaEnable.c:403
GIA_NONE
#define GIA_NONE
INCLUDES ///.
Definition gia.h:45
Gia_ManCheckCoPhase
int Gia_ManCheckCoPhase(Gia_Man_t *p)
Definition giaUtil.c:491
Gia_ManSimPatSim
Vec_Wrd_t * Gia_ManSimPatSim(Gia_Man_t *p)
Definition giaSimBase.c:125
Lf_ManPerformMapping
Gia_Man_t * Lf_ManPerformMapping(Gia_Man_t *pGia, Jf_Par_t *pPars)
Definition giaLf.c:2242
Gia_ManDupMap
Gia_Man_t * Gia_ManDupMap(Gia_Man_t *p, Vec_Int_t *vMap)
Definition giaDup.c:846
Jf_ManPerformMapping
Gia_Man_t * Jf_ManPerformMapping(Gia_Man_t *pGia, Jf_Par_t *pPars)
Definition giaJf.c:1715
Gia_ManDupFromVecs
Gia_Man_t * Gia_ManDupFromVecs(Gia_Man_t *p, Vec_Int_t *vCis, Vec_Int_t *vAnds, Vec_Int_t *vCos, int nRegs)
Definition giaDup.c:4176
Gps_Par_t
struct Gps_Par_t_ Gps_Par_t
Definition gia.h:260
Gia_ManDupAppend
void Gia_ManDupAppend(Gia_Man_t *p, Gia_Man_t *pTwo)
Definition giaDup.c:1137
Gia_ManTransformTwoWord2DualOutput
Gia_Man_t * Gia_ManTransformTwoWord2DualOutput(Gia_Man_t *p)
Definition giaDup.c:3465
Gia_MmStepReadMemUsage
int Gia_MmStepReadMemUsage(Gia_MmStep_t *p)
Definition giaMem.c:586
Gia_ManPrintOutputLutStats
void Gia_ManPrintOutputLutStats(Gia_Man_t *p)
Definition giaIf.c:497
Cbs_ManSolveMiterNc
Vec_Int_t * Cbs_ManSolveMiterNc(Gia_Man_t *pGia, int nConfs, Vec_Str_t **pvStatus, int f0Proved, int fVerbose)
Definition giaCSat.c:1037
Gia_SweeperGraft
Vec_Int_t * Gia_SweeperGraft(Gia_Man_t *pDst, Vec_Int_t *vProbes, Gia_Man_t *pSrc)
Definition giaSweeper.c:985
Gia_ManDupCofAllInt
Gia_Man_t * Gia_ManDupCofAllInt(Gia_Man_t *p, Vec_Int_t *vSigs, int fVerbose)
Definition giaCof.c:936
Gia_ManPerformDsdBalanceWin
Gia_Man_t * Gia_ManPerformDsdBalanceWin(Gia_Man_t *p, int LevelMax, int nTimeWindow, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose)
Definition giaBalMap.c:298
Gia_NodeMffcSize
int Gia_NodeMffcSize(Gia_Man_t *p, Gia_Obj_t *pNode)
Definition giaUtil.c:1230
Gia_AigerWriteSimple
void Gia_AigerWriteSimple(Gia_Man_t *pInit, char *pFileName)
Definition giaAiger.c:1629
Gia_ManTransductionTt
Gia_Man_t * Gia_ManTransductionTt(Gia_Man_t *pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t *pExdc, int fNewLine, int nVerbose)
Definition giaTransduction.cpp:91
Gia_ManIncrSimCheckEqual
int Gia_ManIncrSimCheckEqual(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaSim.c:1214
Cbs_ReadModel
Vec_Int_t * Cbs_ReadModel(Cbs_Man_t *p)
Definition giaCSat.c:203
Gia_ManPrintMuxStats
void Gia_ManPrintMuxStats(Gia_Man_t *p)
Definition giaMuxes.c:63
Gia_ManHashMux
int Gia_ManHashMux(Gia_Man_t *p, int iCtrl, int iData1, int iData0)
Definition giaHash.c:692
Gia_TimeStamp
char * Gia_TimeStamp()
Definition giaUtil.c:106
Gia_ManEvalSolutionOne
int Gia_ManEvalSolutionOne(Gia_Man_t *p, Vec_Wrd_t *vSims, Vec_Wrd_t *vIsfs, Vec_Int_t *vCands, Vec_Int_t *vSet, int nWords, int fVerbose)
Definition giaDecs.c:277
Gia_ManTransductionBdd
Gia_Man_t * Gia_ManTransductionBdd(Gia_Man_t *pGia, int nType, int fMspf, int nRandom, int nSortType, int nPiShuffle, int nParameter, int fLevel, Gia_Man_t *pExdc, int fNewLine, int nVerbose)
Definition giaTransduction.cpp:35
Gia_ManOrigIdsInit
void Gia_ManOrigIdsInit(Gia_Man_t *p)
DECLARATIONS ///.
Definition giaEquiv.c:46
Gia_ManDupCones
Gia_Man_t * Gia_ManDupCones(Gia_Man_t *p, int *pPos, int nPos, int fTrimPis)
Definition giaDup.c:3880
Gia_ManComputeOneWinStart
void Gia_ManComputeOneWinStart(Gia_Man_t *p, int nAnds, int fReverse)
Definition giaSplit.c:541
Gia_ManQuantSetSuppAnd
void Gia_ManQuantSetSuppAnd(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaExist.c:144
GIA_UND
#define GIA_UND
Definition gia.h:923
Bnd_ManGenPatched
Gia_Man_t * Bnd_ManGenPatched(Gia_Man_t *pOut, Gia_Man_t *pSpec, Gia_Man_t *pPatch)
Definition giaBound.c:922
Gia_SweeperCondVector
Vec_Int_t * Gia_SweeperCondVector(Gia_Man_t *p)
Definition giaSweeper.c:329
Gia_ManBuiltInSimCheckOver
int Gia_ManBuiltInSimCheckOver(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaSim.c:859
Gia_ManEquivCountClasses
int Gia_ManEquivCountClasses(Gia_Man_t *p)
Definition giaEquiv.c:376
Gia_ManCleanValue
void Gia_ManCleanValue(Gia_Man_t *p)
Definition giaUtil.c:351
Gia_ManCleanup
Gia_Man_t * Gia_ManCleanup(Gia_Man_t *p)
Definition giaScl.c:84
Gia_ManSpeedup
Gia_Man_t * Gia_ManSpeedup(Gia_Man_t *p, int Percentage, int Degree, int fVerbose, int fVeryVerbose)
Definition giaSpeedup.c:629
Gia_ManSuppStart
Gia_ManMin_t * Gia_ManSuppStart(Gia_Man_t *pGia)
DECLARATIONS ///.
Definition giaSupp.c:279
Gia_ObjRemoveFanout
void Gia_ObjRemoveFanout(Gia_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pFanout)
Definition giaFanout.c:163
Gia_ManOrderReverse
Vec_Int_t * Gia_ManOrderReverse(Gia_Man_t *p)
Definition giaDfs.c:459
Gia_ManCleanPhase
void Gia_ManCleanPhase(Gia_Man_t *p)
Definition giaUtil.c:472
Gia_ManTtopt
Gia_Man_t * Gia_ManTtopt(Gia_Man_t *p, int nIns, int nOuts, int nRounds)
Definition giaTtopt.cpp:1109
Gia_ManCheckSuppOverlap
int Gia_ManCheckSuppOverlap(Gia_Man_t *p, int iNode1, int iNode2)
Definition giaUtil.c:2278
Gia_MmStepEntryFetch
char * Gia_MmStepEntryFetch(Gia_MmStep_t *p, int nBytes)
Definition giaMem.c:534
Gia_ManDupNoBuf
Gia_Man_t * Gia_ManDupNoBuf(Gia_Man_t *p)
Definition giaDup.c:823
Gia_ManTransformMiter2
Gia_Man_t * Gia_ManTransformMiter2(Gia_Man_t *p)
Definition giaDup.c:3409
Gia_SimDataCiExt
unsigned * Gia_SimDataCiExt(Gia_ManSim_t *p, int i)
Definition giaSim.c:36
Gia_ManComputeGiaEquivs
Gia_Man_t * Gia_ManComputeGiaEquivs(Gia_Man_t *pGia, int nConfs, int fVerbose)
Definition giaEquiv.c:183
Bnd_ManSetEqOut
void Bnd_ManSetEqOut(int eq)
FUNCTION DEFINITIONS ///.
Definition giaBound.c:67
Bnd_ManCheckCoMerged
int Bnd_ManCheckCoMerged(Gia_Man_t *p)
Definition giaBound.c:1352
Gia_MmFlexStop
void Gia_MmFlexStop(Gia_MmFlex_t *p, int fVerbose)
Definition giaMem.c:337
Gia_ManMapShrink4
Gia_Man_t * Gia_ManMapShrink4(Gia_Man_t *p, int fKeepLevel, int fVerbose)
FUNCTION DEFINITIONS ///.
Definition giaShrink.c:49
Gia_ManDupDfs
Gia_Man_t * Gia_ManDupDfs(Gia_Man_t *p)
Definition giaDup.c:1748
Gia_ManSimInfoTransfer
void Gia_ManSimInfoTransfer(Gia_ManSim_t *p)
Definition giaSim.c:453
Gia_ManPerformDsdBalance
Gia_Man_t * Gia_ManPerformDsdBalance(Gia_Man_t *p, int nLutSize, int nCutNum, int nRelaxRatio, int fVerbose)
Definition giaIf.c:2678
Gia_SweeperStop
void Gia_SweeperStop(Gia_Man_t *p)
Definition giaSweeper.c:157
Gia_ManCleanMark0
void Gia_ManCleanMark0(Gia_Man_t *p)
Definition giaUtil.c:256
Gia_ManCountChoices
int Gia_ManCountChoices(Gia_Man_t *p)
Definition giaEquiv.c:2113
Gia_ManLevelize
Vec_Vec_t * Gia_ManLevelize(Gia_Man_t *p)
Definition giaDfs.c:403
Bnd_ManPrintStats
void Bnd_ManPrintStats()
Definition giaBound.c:310
Gia_DumpAiger
void Gia_DumpAiger(Gia_Man_t *p, char *pFilePrefix, int iFileNum, int nFileNumDigits)
Definition giaAiger.c:1611
Gia_ManCollectAnds_rec
void Gia_ManCollectAnds_rec(Gia_Man_t *p, int iObj, Vec_Int_t *vNodes)
Definition giaDfs.c:99
Gia_ManCleanTruth
void Gia_ManCleanTruth(Gia_Man_t *p)
Definition giaUtil.c:528
Gia_ManCrossCut
int Gia_ManCrossCut(Gia_Man_t *p, int fReverse)
Definition giaUtil.c:916
Gia_ManPerformLfMapping
Gia_Man_t * Gia_ManPerformLfMapping(Gia_Man_t *p, Jf_Par_t *pPars, int fNormalized)
Definition giaLf.c:2292
Gia_SweeperProbeLit
int Gia_SweeperProbeLit(Gia_Man_t *p, int ProbeId)
Definition giaSweeper.c:276
Gia_ObjComputeTruthTableStart
void Gia_ObjComputeTruthTableStart(Gia_Man_t *p, int nVarsMax)
Definition giaTruth.c:552
Gia_ManUpdateMapping
void Gia_ManUpdateMapping(Gia_Man_t *p, Vec_Int_t *vNodes, Vec_Wec_t *vWin)
Definition giaEdge.c:610
Gia_ManDupChoicesFinish
Gia_Man_t * Gia_ManDupChoicesFinish(Gia_ChMan_t *pMan)
Definition giaDup.c:6464
Gia_ManLutSizeMax
int Gia_ManLutSizeMax(Gia_Man_t *p)
Definition giaIf.c:127
Gia_ManFanoutStop
void Gia_ManFanoutStop(Gia_Man_t *p)
Definition giaFanout.c:98
Bnd_ManCheckBound
int Bnd_ManCheckBound(Gia_Man_t *p, int fVerbose)
Definition giaBound.c:379
Gia_ManWriteMiniLut
void Gia_ManWriteMiniLut(Gia_Man_t *pGia, char *pFileName)
Definition giaMini.c:596
Gia_ManEvalEdgeDelay
int Gia_ManEvalEdgeDelay(Gia_Man_t *p)
Definition giaEdge.c:201
Gia_ManEquivTransform
void Gia_ManEquivTransform(Gia_Man_t *p, int fVerbose)
Definition giaEquiv.c:1519
Cbs_ManSolve
int Cbs_ManSolve(Cbs_Man_t *p, Gia_Obj_t *pObj)
Definition giaCSat.c:947
Gia_ManUnrollStart
void * Gia_ManUnrollStart(Gia_Man_t *pAig, Gia_ParFra_t *pPars)
Definition giaFrames.c:402
Gia_ManSeqStructSweep
Gia_Man_t * Gia_ManSeqStructSweep(Gia_Man_t *p, int fConst, int fEquiv, int fVerbose)
Definition giaScl.c:258
Mf_ManSetDefaultPars
void Mf_ManSetDefaultPars(Jf_Par_t *pPars)
Definition giaMf.c:1441
Gia_MmFlexEntryFetch
char * Gia_MmFlexEntryFetch(Gia_MmFlex_t *p, int nBytes)
Definition giaMem.c:366
Bnd_Man_t
struct Bnd_Man_t_ Bnd_Man_t
Definition gia.h:1830
Gia_ManSpecReduce
Gia_Man_t * Gia_ManSpecReduce(Gia_Man_t *p, int fDualOut, int fSynthesis, int fReduce, int fSkipSome, int fVerbose)
Definition giaEquiv.c:1253
Gia_SweeperProbeDelete
int Gia_SweeperProbeDelete(Gia_Man_t *p, int ProbeId)
Definition giaSweeper.c:258
Gia_ManEquivToChoices
Gia_Man_t * Gia_ManEquivToChoices(Gia_Man_t *p, int nSnapshots)
Definition giaEquiv.c:2034
Gia_ManPtrWrdDumpBin
void Gia_ManPtrWrdDumpBin(char *pFileName, Vec_Ptr_t *p, int fVerbose)
Definition giaSimBase.c:2660
Gia_ManCollectSuppNew
Vec_Int_t * Gia_ManCollectSuppNew(Gia_Man_t *p, int iOut, int nOuts)
Definition giaMinLut.c:632
Gia_ManVerifyCex
int Gia_ManVerifyCex(Gia_Man_t *pAig, Abc_Cex_t *p, int fDualOut)
DECLARATIONS ///.
Definition giaCex.c:48
Gia_ManStgPrint
void Gia_ManStgPrint(FILE *pFile, Vec_Int_t *vLines, int nIns, int nOuts, int nStates)
Definition giaStg.c:407
Gia_ManTransferTiming
void Gia_ManTransferTiming(Gia_Man_t *p, Gia_Man_t *pGia)
Definition giaIf.c:2370
Bnd_ManCutBoundary
Gia_Man_t * Bnd_ManCutBoundary(Gia_Man_t *p, Vec_Int_t *vEI, Vec_Int_t *vEO, Vec_Bit_t *vEI_phase, Vec_Bit_t *vEO_phase)
Definition giaBound.c:780
Gia_ManSetIfParsDefault
void Gia_ManSetIfParsDefault(void *pIfPars)
FUNCTION DEFINITIONS ///.
Definition giaIf.c:59
Gia_ManFront
Gia_Man_t * Gia_ManFront(Gia_Man_t *p)
Definition giaFront.c:147
Gia_ManAigSyn3
Gia_Man_t * Gia_ManAigSyn3(Gia_Man_t *p, int fVerbose, int fVeryVerbose)
Definition giaScript.c:157
Gia_ManLutNum
int Gia_ManLutNum(Gia_Man_t *p)
Definition giaIf.c:146
Gia_ManIsoReduce
Gia_Man_t * Gia_ManIsoReduce(Gia_Man_t *p, Vec_Ptr_t **pvPosEquivs, Vec_Ptr_t **pvPiPerms, int fEstimate, int fDualOut, int fVerbose, int fVeryVerbose)
Definition giaIso.c:1075
Gia_ManMappingVerify
void Gia_ManMappingVerify(Gia_Man_t *p)
Definition giaIf.c:2257
Gia_ManDupAndOr
Gia_Man_t * Gia_ManDupAndOr(Gia_Man_t *p, int nOuts, int fUseOr, int fCompl)
Definition giaDup.c:3216
Lf_ManSetDefaultPars
void Lf_ManSetDefaultPars(Jf_Par_t *pPars)
Definition giaLf.c:2021
Gia_SimDataCoExt
unsigned * Gia_SimDataCoExt(Gia_ManSim_t *p, int i)
Definition giaSim.c:37
Gia_ManSimInfoInit
void Gia_ManSimInfoInit(Gia_ManSim_t *p)
Definition giaSim.c:430
Gia_ManQuantSetSuppZero
void Gia_ManQuantSetSuppZero(Gia_Man_t *p)
Definition giaExist.c:110
Gia_ManSetLevels
int Gia_ManSetLevels(Gia_Man_t *p, Vec_Int_t *vCiLevels)
Definition giaUtil.c:621
Gia_ManCollectTfi
void Gia_ManCollectTfi(Gia_Man_t *p, Vec_Int_t *vRoots, Vec_Int_t *vNodes)
Definition giaDfs.c:581
Gia_ManTtoptCare
Gia_Man_t * Gia_ManTtoptCare(Gia_Man_t *p, int nIns, int nOuts, int nRounds, char *pFileName, int nRarity)
Definition giaTtopt.cpp:1157
Gia_ManSolveProblem
void Gia_ManSolveProblem(Gia_Man_t *pGia, Emb_Par_t *pPars)
Definition giaEmbed.c:1791
Gia_ManArray2Sim
Vec_Ptr_t * Gia_ManArray2Sim(Vec_Wec_t *vRes)
Definition giaSimBase.c:2596
Gia_Man2Min_t
struct Gia_Man2Min_t_ Gia_Man2Min_t
Definition gia.h:1669
Gia_ManDupOntop
Gia_Man_t * Gia_ManDupOntop(Gia_Man_t *p, Gia_Man_t *p2)
Definition giaDup.c:2590
Gia_ManVerifyWithBoxes
int Gia_ManVerifyWithBoxes(Gia_Man_t *pGia, int nBTLimit, int nTimeLim, int fSeq, int fDumpFiles, int fVerbose, char *pFileSpec)
Definition giaTim.c:955
Gia_ManDupTopAnd
Gia_Man_t * Gia_ManDupTopAnd(Gia_Man_t *p, int fVerbose)
Definition giaDup.c:2930
Gia_SweeperRun
int Gia_SweeperRun(Gia_Man_t *p, Vec_Int_t *vProbeIds, char *pCommLime, int fVerbose)
Definition giaSweeper.c:1106
Gia_ManExtractWindow
Gia_Man_t * Gia_ManExtractWindow(Gia_Man_t *p, int LevelMax, int nTimeWindow, int fVerbose)
Definition giaBalMap.c:236
Gia_ManFilterEquivsUsingParts
int Gia_ManFilterEquivsUsingParts(Gia_Man_t *pGia, char *pName1, char *pName2)
Definition giaEquiv.c:2404
Gia_ManPrintOutputProb
Vec_Flt_t * Gia_ManPrintOutputProb(Gia_Man_t *p)
Definition giaSwitch.c:848
Gia_ManLutLevelWithBoxes
int Gia_ManLutLevelWithBoxes(Gia_Man_t *p)
Definition giaTim.c:581
Gia_ManStgRead
Gia_Man_t * Gia_ManStgRead(char *pFileName, int kHot, int fVerbose)
Definition giaStg.c:508
Gia_ObjComputeTruthTableStop
void Gia_ObjComputeTruthTableStop(Gia_Man_t *p)
Definition giaTruth.c:568
Gia_ObjRecognizeExor
int Gia_ObjRecognizeExor(Gia_Obj_t *pObj, Gia_Obj_t **ppFan0, Gia_Obj_t **ppFan1)
Definition giaUtil.c:1018
Gia_ManGetDangling
Vec_Int_t * Gia_ManGetDangling(Gia_Man_t *p)
Definition giaUtil.c:1422
Gia_ManCreateRefs
void Gia_ManCreateRefs(Gia_Man_t *p)
Definition giaUtil.c:779
Gia_ManCleanLevels
void Gia_ManCleanLevels(Gia_Man_t *p, int Size)
Definition giaUtil.c:511
Gia_ChMan_t
struct Gia_ChMan_t_ Gia_ChMan_t
Definition gia.h:1416
Gia_SweeperSetConflictLimit
void Gia_SweeperSetConflictLimit(Gia_Man_t *p, int nConfMax)
Definition giaSweeper.c:220
Tas_ManStop
void Tas_ManStop(Tas_Man_t *p)
Definition giaCTas.c:223
Gia_ManQuantSetSuppStart
void Gia_ManQuantSetSuppStart(Gia_Man_t *p)
Definition giaExist.c:100
Gia_ManDupNormalize
Gia_Man_t * Gia_ManDupNormalize(Gia_Man_t *p, int fHashMapping)
Definition giaTim.c:139
Gia_ObjCheckEdge
int Gia_ObjCheckEdge(Gia_Man_t *p, int iObj, int iNext)
Definition giaEdge.c:172
Gia_ManArray2SimOne
Vec_Wrd_t * Gia_ManArray2SimOne(Vec_Int_t *vRes)
Definition giaSimBase.c:2579
Gia_Man2SuppStop
void Gia_Man2SuppStop(Gia_Man2Min_t *p)
Definition giaSupp.c:394
Gia_ManDupSelf
Gia_Man_t * Gia_ManDupSelf(Gia_Man_t *p)
Definition giaDup.c:1359
Gia_ManHashAnd
int Gia_ManHashAnd(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:576
Gia_ManDupDemiter
Gia_Man_t * Gia_ManDupDemiter(Gia_Man_t *p, int fVerbose)
Definition giaDup.c:4675
Gia_MmStep_t
struct Gia_MmStep_t_ Gia_MmStep_t
Definition gia.h:54
Gia_ManDupWithConstraints
Gia_Man_t * Gia_ManDupWithConstraints(Gia_Man_t *p, Vec_Int_t *vPoTypes)
Definition giaDup.c:3816
Gia_ManSetFailedPoCex
int Gia_ManSetFailedPoCex(Gia_Man_t *pAig, Abc_Cex_t *p)
Definition giaCex.c:139
Gia_ManDupSelectedOutputs
Gia_Man_t * Gia_ManDupSelectedOutputs(Gia_Man_t *p, Vec_Int_t *vOutsLeft)
Definition giaDup.c:376
Gia_ManDupOrderDfsChoices
Gia_Man_t * Gia_ManDupOrderDfsChoices(Gia_Man_t *p)
Definition giaDup.c:438
Bnd_ManStackGias
Gia_Man_t * Bnd_ManStackGias(Gia_Man_t *pSpec, Gia_Man_t *pImpl)
Definition giaBound.c:1252
Gia_ManDupLevelized
Gia_Man_t * Gia_ManDupLevelized(Gia_Man_t *p)
Definition giaDup.c:4135
Gia_ManAigSyn2
Gia_Man_t * Gia_ManAigSyn2(Gia_Man_t *p, int fOldAlgo, int fCoarsen, int fCutMin, int nRelaxRatio, int fDelayMin, int fVerbose, int fVeryVerbose)
Definition giaScript.c:69
Gia_ManIncrementTravId
void Gia_ManIncrementTravId(Gia_Man_t *p)
Definition giaUtil.c:190
Gia_ManCleanupOutputs
Gia_Man_t * Gia_ManCleanupOutputs(Gia_Man_t *p, int nOutputs)
Definition giaScl.c:101
Gia_ManProdAdderGen
void Gia_ManProdAdderGen(int nArgA, int nArgB, int Seed, int fSigned, int fCla)
Definition giaDup.c:5609
Gia_ObjComputeTruth6Cis
word Gia_ObjComputeTruth6Cis(Gia_Man_t *p, int iLit, Vec_Int_t *vSupp, Vec_Wrd_t *vTemp)
Definition giaTruth.c:345
Gia_ObjAddFanout
void Gia_ObjAddFanout(Gia_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pFanout)
Definition giaFanout.c:116
Gia_ManCheckMark1
void Gia_ManCheckMark1(Gia_Man_t *p)
Definition giaUtil.c:332
Gia_ObjCollectInternal
void Gia_ObjCollectInternal(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaTruth.c:429
Jf_Par_t
struct Jf_Par_t_ Jf_Par_t
Definition gia.h:333
Gia_ManMiterInverse
Gia_Man_t * Gia_ManMiterInverse(Gia_Man_t *pBot, Gia_Man_t *pTop, int fDualOut, int fVerbose)
Definition giaDup.c:3130
Gia_ManAigSyn4
Gia_Man_t * Gia_ManAigSyn4(Gia_Man_t *p, int fVerbose, int fVeryVerbose)
Definition giaScript.c:194
Gia_ManTransformToDual
Gia_Man_t * Gia_ManTransformToDual(Gia_Man_t *p)
Definition giaDup.c:3440
Gia_ManConeSize
int Gia_ManConeSize(Gia_Man_t *p, int *pNodes, int nNodes)
Definition giaDfs.c:375
Gia_ManReverseLevel
Vec_Int_t * Gia_ManReverseLevel(Gia_Man_t *p)
Definition giaUtil.c:658
Gia_ManEvaluateSwitching
float Gia_ManEvaluateSwitching(Gia_Man_t *p)
Definition giaSwitch.c:746
Gia_ManMiter
Gia_Man_t * Gia_ManMiter(Gia_Man_t *pAig0, Gia_Man_t *pAig1, int nInsDup, int fDualOut, int fSeq, int fImplic, int fVerbose)
Definition giaDup.c:2983
Bnd_ManFinalizeMappings
void Bnd_ManFinalizeMappings()
Definition giaBound.c:232
Bnd_ManGenPatched2
Gia_Man_t * Bnd_ManGenPatched2(Gia_Man_t *pImpl, Gia_Man_t *pPatch, int fSkiptStrash, int fVerbose)
Definition giaBound.c:1156
Gia_ManDupConeSupp
Gia_Man_t * Gia_ManDupConeSupp(Gia_Man_t *p, int iLit, Vec_Int_t *vCiIds)
Definition giaDup.c:2235
Gia_MmFixedReadMaxEntriesUsed
int Gia_MmFixedReadMaxEntriesUsed(Gia_MmFixed_t *p)
Definition giaMem.c:287
Gia_ManHashAndTry
int Gia_ManHashAndTry(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:637
Gia_ManMin_t
struct Gia_ManMin_t_ Gia_ManMin_t
Definition gia.h:1665
Gia_ManHashXorReal
int Gia_ManHashXorReal(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:469
Gia_MmFixedStop
void Gia_MmFixedStop(Gia_MmFixed_t *p, int fVerbose)
Definition giaMem.c:132
Gia_ManUnrollLastLit
int Gia_ManUnrollLastLit(void *pMan)
Definition giaFrames.c:490
Gia_ManClockDomainNum
int Gia_ManClockDomainNum(Gia_Man_t *p)
Definition giaTim.c:74
Gia_ManHashLookupInt
int Gia_ManHashLookupInt(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:81
Gia_ManCountFraction
word * Gia_ManCountFraction(Gia_Man_t *p, Vec_Wrd_t *vSimI, Vec_Int_t *vSupp, int Thresh, int fVerbose, int *pCare)
Definition giaMinLut.c:531
Gia_ManFrames
Gia_Man_t * Gia_ManFrames(Gia_Man_t *pAig, Gia_ParFra_t *pPars)
Definition giaFrames.c:840
Gia_ManDupOutputVec
Gia_Man_t * Gia_ManDupOutputVec(Gia_Man_t *p, Vec_Int_t *vOutPres)
Definition giaDup.c:342
Bnd_ManPrintMappings
void Bnd_ManPrintMappings()
Definition giaBound.c:274
Bnd_ManGenSpecOut
Gia_Man_t * Bnd_ManGenSpecOut(Gia_Man_t *p)
Definition giaBound.c:867
Gia_SweeperFraig
int Gia_SweeperFraig(Gia_Man_t *p, Vec_Int_t *vProbeIds, char *pCommLime, int nWords, int nConfs, int fVerify, int fVerbose)
Definition giaSweeper.c:1064
Gia_ManCheckIntegrityWithBoxes
void Gia_ManCheckIntegrityWithBoxes(Gia_Man_t *p)
Definition giaSweep.c:441
Gia_ManOrderWithBoxes
Vec_Int_t * Gia_ManOrderWithBoxes(Gia_Man_t *p)
Definition giaTim.c:286
Gia_ManEdgeFromArray
void Gia_ManEdgeFromArray(Gia_Man_t *p, Vec_Int_t *vArray)
FUNCTION DEFINITIONS ///.
Definition giaEdge.c:72
Gia_ManSimulateRound
void Gia_ManSimulateRound(Gia_ManSim_t *p)
Definition giaSim.c:476
Bnd_ManMerge
void Bnd_ManMerge(int id1, int id2, int phaseDiff)
Definition giaBound.c:193
Cbs_ManSetConflictNum
void Cbs_ManSetConflictNum(Cbs_Man_t *p, int Num)
Definition giaCSat.c:137
Gia_ManDupCofAll
Gia_Man_t * Gia_ManDupCofAll(Gia_Man_t *p, int nFanLim, int fVerbose)
Definition giaCof.c:987
Gia_ManBlackBoxNum
int Gia_ManBlackBoxNum(Gia_Man_t *p)
Definition giaTim.c:62
Gia_ManIncrSimSet
void Gia_ManIncrSimSet(Gia_Man_t *p, Vec_Int_t *vObjLits)
Definition giaSim.c:1174
Gia_ManSetLutRefs
void Gia_ManSetLutRefs(Gia_Man_t *p)
Definition giaIf.c:295
Gia_ManReadMiniLut
Gia_Man_t * Gia_ManReadMiniLut(char *pFileName)
Definition giaMini.c:587
Tas_ManSolve
int Tas_ManSolve(Tas_Man_t *p, Gia_Obj_t *pObj, Gia_Obj_t *pObj2)
Definition giaCTas.c:1366
Gia_ManBalance
Gia_Man_t * Gia_ManBalance(Gia_Man_t *p, int fSimpleAnd, int fStrict, int fVerbose)
Definition giaBalAig.c:441
Gia_ManIncrSimCheckOver
int Gia_ManIncrSimCheckOver(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaSim.c:1205
Gia_ManDupHashMapping
Gia_Man_t * Gia_ManDupHashMapping(Gia_Man_t *p)
Definition giaIf.c:2772
Emb_Par_t
struct Emb_Par_t_ Emb_Par_t
Definition gia.h:277
Gia_ManBuiltInSimAddPat
int Gia_ManBuiltInSimAddPat(Gia_Man_t *p, Vec_Int_t *vPat)
Definition giaSim.c:963
Gia_ManFilterEquivsUsingLatches
void Gia_ManFilterEquivsUsingLatches(Gia_Man_t *pGia, int fFlopsOnly, int fFlopsWith, int fUseRiDrivers)
Definition giaEquiv.c:2552
Gia_ManRetimeForward
Gia_Man_t * Gia_ManRetimeForward(Gia_Man_t *p, int nMaxIters, int fVerbose)
Definition giaRetime.c:267
Gia_ManQuantUpdateCiSupp
void Gia_ManQuantUpdateCiSupp(Gia_Man_t *p, int iObj)
Definition giaExist.c:157
Gia_ManUnrollDup
Gia_Man_t * Gia_ManUnrollDup(Gia_Man_t *p, Vec_Int_t *vLimit)
Definition giaFrames.c:107
Gia_ManBuiltInSimResimulate
void Gia_ManBuiltInSimResimulate(Gia_Man_t *p)
Definition giaSim.c:852
Gia_ObjComputeTruthTable
word * Gia_ObjComputeTruthTable(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition giaTruth.c:447
Gia_ManInvertConstraints
void Gia_ManInvertConstraints(Gia_Man_t *pAig)
Definition giaUtil.c:1641
Gia_ManSetPhase
void Gia_ManSetPhase(Gia_Man_t *p)
Definition giaUtil.c:420
Gia_ManDupZeroUndc
Gia_Man_t * Gia_ManDupZeroUndc(Gia_Man_t *p, char *pInit, int nNewPis, int fGiaSimple, int fVerbose)
Definition giaDup.c:3569
Gia_ManFirstFanouts
Vec_Int_t * Gia_ManFirstFanouts(Gia_Man_t *p)
Definition giaUtil.c:1861
Gia_ManFilterEquivsForSpeculation
int Gia_ManFilterEquivsForSpeculation(Gia_Man_t *pGia, char *pName1, char *pName2, int fLatchA, int fLatchB)
Definition giaEquiv.c:2267
GIA_VOID
#define GIA_VOID
Definition gia.h:46
Gia_ManComputeSwitchProbs
Vec_Int_t * Gia_ManComputeSwitchProbs(Gia_Man_t *pGia, int nFrames, int nPref, int fProbOne)
Definition giaSwitch.c:658
Gia_ManHashStop
void Gia_ManHashStop(Gia_Man_t *p)
Definition giaHash.c:149
Gia_ManDumpVerilog
void Gia_ManDumpVerilog(Gia_Man_t *p, char *pFileName, Vec_Int_t *vObjs, int fVerBufs, int fInter, int fInterComb, int fAssign, int fReverse)
Definition giaMan.c:1415
Gia_ManIsoCanonicize
Gia_Man_t * Gia_ManIsoCanonicize(Gia_Man_t *p, int fVerbose)
Definition giaIso.c:958
Gia_MmFlexReadMemUsage
int Gia_MmFlexReadMemUsage(Gia_MmFlex_t *p)
Definition giaMem.c:439
Gia_ManDupOrderAiger
Gia_Man_t * Gia_ManDupOrderAiger(Gia_Man_t *p)
Definition giaDup.c:532
Gia_ManCollectNodesCis
Vec_Int_t * Gia_ManCollectNodesCis(Gia_Man_t *p, int *pNodes, int nNodes)
Definition giaDfs.c:202
Gia_ManPrintStats
void Gia_ManPrintStats(Gia_Man_t *p, Gps_Par_t *pPars)
Definition giaMan.c:495
Gia_ManDupUnnormalize
Gia_Man_t * Gia_ManDupUnnormalize(Gia_Man_t *p)
Definition giaTim.c:382
Gia_ManComputeSwitchProbs2
Vec_Int_t * Gia_ManComputeSwitchProbs2(Gia_Man_t *pGia, int nFrames, int nPref, int fProbOne, int nRandPiFactor)
Definition giaSwitch.c:684
Gia_ManDemiterToDual
Gia_Man_t * Gia_ManDemiterToDual(Gia_Man_t *p)
Definition giaDup.c:4956
Gia_ObjComputeTruthTable6Lut
word Gia_ObjComputeTruthTable6Lut(Gia_Man_t *p, int iObj, Vec_Wrd_t *vTemp)
Definition giaTruth.c:289
Gia_ManSimSimulate
int Gia_ManSimSimulate(Gia_Man_t *pAig, Gia_ParSim_t *pPars)
Definition giaSim.c:599
Gia_ManDupAppendNew
Gia_Man_t * Gia_ManDupAppendNew(Gia_Man_t *pOne, Gia_Man_t *pTwo)
Definition giaDup.c:1174
Gia_MmFixedReadMemUsage
int Gia_MmFixedReadMemUsage(Gia_MmFixed_t *p)
Definition giaMem.c:271
Gia_ParSim_t
struct Gia_ParSim_t_ Gia_ParSim_t
Definition gia.h:306
Gia_ManCollectCis
void Gia_ManCollectCis(Gia_Man_t *p, int *pNodes, int nNodes, Vec_Int_t *vSupp)
Definition giaDfs.c:71
Gia_ManHashMaj
int Gia_ManHashMaj(Gia_Man_t *p, int iData0, int iData1, int iData2)
Definition giaHash.c:720
Gia_ManPrintCone
void Gia_ManPrintCone(Gia_Man_t *p, Gia_Obj_t *pObj, int *pLeaves, int nLeaves, Vec_Int_t *vNodes)
Definition giaUtil.c:1582
GIA_ONE
#define GIA_ONE
Definition gia.h:922
Gia_ManDupDfsOnePo
Gia_Man_t * Gia_ManDupDfsOnePo(Gia_Man_t *p, int iPo)
Definition giaDup.c:1770
Gia_ManReduceConst
Gia_Man_t * Gia_ManReduceConst(Gia_Man_t *pAig, int fVerbose)
Definition giaTsim.c:737
Gia_ManCleanMark01
void Gia_ManCleanMark01(Gia_Man_t *p)
Definition giaUtil.c:218
Gia_ManSweepWithBoxes
Gia_Man_t * Gia_ManSweepWithBoxes(Gia_Man_t *p, void *pParsC, void *pParsS, int fConst, int fEquiv, int fVerbose, int fVerbEquivs)
Definition giaSweep.c:739
Gia_ManLevelNum
int Gia_ManLevelNum(Gia_Man_t *p)
Definition giaUtil.c:546
Gia_ManMapShrink6
Gia_Man_t * Gia_ManMapShrink6(Gia_Man_t *p, int nFanoutMax, int fKeepLevel, int fVerbose)
Definition giaShrink6.c:401
Cbs_ManSolveMiter
Vec_Int_t * Cbs_ManSolveMiter(Gia_Man_t *pGia, int nConfs, Vec_Str_t **pvStatus, int fVerbose)
Definition giaCSatOld.c:708
Gia_FileNameGenericAppend
char * Gia_FileNameGenericAppend(char *pBase, char *pSuffix)
Definition giaUtil.c:130
Gia_ManDupConeBack
int Gia_ManDupConeBack(Gia_Man_t *p, Gia_Man_t *pNew, Vec_Int_t *vCiIds)
Definition giaDup.c:2270
Gia_ManTransferMapping
void Gia_ManTransferMapping(Gia_Man_t *p, Gia_Man_t *pGia)
Definition giaIf.c:2305
Gia_AigerWriteIntoMemoryStrPart
Vec_Str_t * Gia_AigerWriteIntoMemoryStrPart(Gia_Man_t *p, Vec_Int_t *vCis, Vec_Int_t *vAnds, Vec_Int_t *vCos, int nRegs)
Definition giaAiger.c:1136
Gia_ManPrintConeMulti
void Gia_ManPrintConeMulti(Gia_Man_t *p, Vec_Int_t *vObjs, Vec_Int_t *vLeaves, Vec_Int_t *vNodes)
Definition giaUtil.c:1593
Gia_ManComputeEdgeDelay2
int Gia_ManComputeEdgeDelay2(Gia_Man_t *p)
Definition giaEdge.c:568
Gia_ManBoxCoNum
int Gia_ManBoxCoNum(Gia_Man_t *p)
Definition giaTim.c:70
Gia_SweeperCondPop
int Gia_SweeperCondPop(Gia_Man_t *p)
Definition giaSweeper.c:324
Gia_ManDupOrderDfsReverse
Gia_Man_t * Gia_ManDupOrderDfsReverse(Gia_Man_t *p, int fRevFans, int fRevOuts)
Definition giaDup.c:482
Bnd_ManFindBound
void Bnd_ManFindBound(Gia_Man_t *p, Gia_Man_t *pImpl)
Definition giaBound.c:549
Gia_ManOrigIdsRemap
void Gia_ManOrigIdsRemap(Gia_Man_t *p, Gia_Man_t *pNew)
Definition giaEquiv.c:56
Gia_ManDupDfsLitArray
Gia_Man_t * Gia_ManDupDfsLitArray(Gia_Man_t *p, Vec_Int_t *vLits)
Definition giaDup.c:2346
Gia_SatVerifyPattern
void Gia_SatVerifyPattern(Gia_Man_t *p, Gia_Obj_t *pRoot, Vec_Int_t *vCex, Vec_Int_t *vVisit)
Definition giaPat.c:93
Gia_SweeperLogicDump
void Gia_SweeperLogicDump(Gia_Man_t *p, Vec_Int_t *vProbeIds, int fDumpConds, char *pFileName)
Definition giaSweeper.c:428
Gia_ManRandom
unsigned Gia_ManRandom(int fReset)
FUNCTION DEFINITIONS ///.
Definition giaUtil.c:49
Bnd_ManGetNInternal
int Bnd_ManGetNInternal()
Definition giaBound.c:175
Gia_GetFakeNames
Vec_Ptr_t * Gia_GetFakeNames(int nNames, int fCaps)
Definition giaUtil.c:154
Gia_ManSetMark0
void Gia_ManSetMark0(Gia_Man_t *p)
Definition giaUtil.c:237
Gia_NodeMffcSizeMark
int Gia_NodeMffcSizeMark(Gia_Man_t *p, Gia_Obj_t *pNode)
Definition giaUtil.c:1241
Gia_ManPerformSopBalance
Gia_Man_t * Gia_ManPerformSopBalance(Gia_Man_t *p, int nCutNum, int nRelaxRatio, int fVerbose)
Definition giaIf.c:2651
Gia_ManUpdateExtraAig2
Gia_Man_t * Gia_ManUpdateExtraAig2(void *pTime, Gia_Man_t *pAig, Vec_Int_t *vBoxesLeft)
Definition giaTim.c:713
Gia_ManMarkFanoutDrivers
void Gia_ManMarkFanoutDrivers(Gia_Man_t *p)
Definition giaUtil.c:1779
Gia_ManTransferPacking
void Gia_ManTransferPacking(Gia_Man_t *p, Gia_Man_t *pGia)
Definition giaIf.c:2336
Gia_ManSpecReduceInitFrames
Gia_Man_t * Gia_ManSpecReduceInitFrames(Gia_Man_t *p, Abc_Cex_t *pInit, int nFramesMax, int *pnFrames, int fDualOut, int nMinOutputs)
Definition giaEquiv.c:1480
Gia_ManDupOrderDfs
Gia_Man_t * Gia_ManDupOrderDfs(Gia_Man_t *p)
Definition giaDup.c:206
Gia_ManSeqCleanup
Gia_Man_t * Gia_ManSeqCleanup(Gia_Man_t *p)
Definition giaScl.c:183
Gia_AigerWriteS
void Gia_AigerWriteS(Gia_Man_t *p, char *pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine, int fSkipComment)
Definition giaAiger.c:1220
Gia_ManBuiltInSimResimulateCone
void Gia_ManBuiltInSimResimulateCone(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaSim.c:846
Cbs_ManStop
void Cbs_ManStop(Cbs_Man_t *p)
Definition giaCSat.c:181
Gia_ManDupAndCones
Gia_Man_t * Gia_ManDupAndCones(Gia_Man_t *p, int *pAnds, int nAnds, int fTrimPis)
Definition giaDup.c:3941
Gia_ManFramesInitSpecial
Gia_Man_t * Gia_ManFramesInitSpecial(Gia_Man_t *pAig, int nFrames, int fVerbose)
Definition giaFrames.c:941
Gia_ManDupSliced
Gia_Man_t * Gia_ManDupSliced(Gia_Man_t *p, int nSuppMax)
Definition giaDup.c:4211
Gia_ManDupAppendShare
void Gia_ManDupAppendShare(Gia_Man_t *p, Gia_Man_t *pTwo)
Definition giaDup.c:1156
Gia_ManShow
void Gia_ManShow(Gia_Man_t *pMan, Vec_Int_t *vBold, int fAdders, int fFadds, int fPath)
Definition giaShow.c:1126
Gia_ManCollectAndsAll
Vec_Int_t * Gia_ManCollectAndsAll(Gia_Man_t *p)
Definition giaDfs.c:155
Jf_ManDeriveCnf
Gia_Man_t * Jf_ManDeriveCnf(Gia_Man_t *p, int fCnfObjIds)
Definition giaJf.c:1749
Gia_ManCountMuxXor
void Gia_ManCountMuxXor(Gia_Man_t *p, int *pnMuxes, int *pnXors)
DECLARATIONS ///.
Definition giaMuxes.c:49
Gia_Man2SupportAnd
int Gia_Man2SupportAnd(Gia_Man2Min_t *p, int iLit0, int iLit1)
Definition giaSupp.c:815
Mf_ManGenerateCnf
void * Mf_ManGenerateCnf(Gia_Man_t *pGia, int nLutSize, int fCnfObjIds, int fAddOrCla, int fMapping, int fVerbose)
Definition giaMf.c:1877
Gia_ManOrigIdsReduce
Gia_Man_t * Gia_ManOrigIdsReduce(Gia_Man_t *p, Vec_Int_t *vPairs)
Definition giaEquiv.c:106
Gia_ManSuppStop
void Gia_ManSuppStop(Gia_ManMin_t *p)
Definition giaSupp.c:281
Gia_AigerWrite
void Gia_AigerWrite(Gia_Man_t *p, char *pFileName, int fWriteSymbols, int fCompact, int fWriteNewLine)
Definition giaAiger.c:1595
Gia_ManEquivReduceAndRemap
Gia_Man_t * Gia_ManEquivReduceAndRemap(Gia_Man_t *p, int fSeq, int fMiterPairs)
Definition giaEquiv.c:1040
Gia_ManCollectAnds
void Gia_ManCollectAnds(Gia_Man_t *p, int *pNodes, int nNodes, Vec_Int_t *vNodes, Vec_Int_t *vLeaves)
Definition giaDfs.c:125
Gia_ManSpecReduceInit
Gia_Man_t * Gia_ManSpecReduceInit(Gia_Man_t *p, Abc_Cex_t *pInit, int nFrames, int fDualOut)
Definition giaEquiv.c:1390
Gia_ManDupChoicesStart
Gia_ChMan_t * Gia_ManDupChoicesStart(Gia_Man_t *pGia)
Definition giaDup.c:6425
Gia_MmFlexRestart
void Gia_MmFlexRestart(Gia_MmFlex_t *p)
Definition giaMem.c:411
Gia_ManIsoReduce2
Gia_Man_t * Gia_ManIsoReduce2(Gia_Man_t *p, Vec_Ptr_t **pvPosEquivs, Vec_Ptr_t **pvPiPerms, int fEstimate, int fBetterQual, int fDualOut, int fVerbose, int fVeryVerbose)
Definition giaIso2.c:718
Gia_ManSaveValue
Vec_Int_t * Gia_ManSaveValue(Gia_Man_t *p)
Definition giaUtil.c:1831
Gia_ManCleanMark1
void Gia_ManCleanMark1(Gia_Man_t *p)
Definition giaUtil.c:313
Gia_ManQuantExist
int Gia_ManQuantExist(Gia_Man_t *p, int iLit, int(*pFuncCiToKeep)(void *, int), void *pData)
Definition giaExist.c:505
Gia_ManDupDfsRehash
Gia_Man_t * Gia_ManDupDfsRehash(Gia_Man_t *p)
Definition giaDup.c:1815
word
unsigned __int64 word
DECLARATIONS ///.
Definition kitPerm.c:36
nSuppMax
int nSuppMax
Definition llb3Image.c:83
Bnd_Man_t_
Definition giaBound.c:16
Bnd_Man_t_::vEI_phase
Vec_Bit_t * vEI_phase
Definition giaBound.c:56
Bnd_Man_t_::vEO_phase
Vec_Bit_t * vEO_phase
Definition giaBound.c:57
Bnd_Man_t_::fVerbose
int fVerbose
Definition giaBound.c:31
Cbs_Man_t_
Definition giaCSat.c:64
Cbs_Man_t_::pAig
Gia_Man_t * pAig
Definition giaCSat.c:66
Emb_Par_t_
Definition gia.h:279
Emb_Par_t_::nIters
int nIters
Definition gia.h:282
Emb_Par_t_::fDumpLarge
int fDumpLarge
Definition gia.h:286
Emb_Par_t_::nDims
int nDims
Definition gia.h:280
Emb_Par_t_::fRefine
int fRefine
Definition gia.h:283
Emb_Par_t_::fVerbose
int fVerbose
Definition gia.h:288
Emb_Par_t_::fDump
int fDump
Definition gia.h:285
Emb_Par_t_::fCluster
int fCluster
Definition gia.h:284
Emb_Par_t_::nSols
int nSols
Definition gia.h:281
Emb_Par_t_::fShowImage
int fShowImage
Definition gia.h:287
Gia_ChMan_t_
Definition giaDup.c:6347
Gia_ChMan_t_::pNew
Gia_Man_t * pNew
Definition giaDup.c:6348
Gia_Man2Min_t_
Definition giaSupp.c:337
Gia_Man2Min_t_::pGia
Gia_Man_t * pGia
Definition giaSupp.c:339
Gia_Man2Min_t_::vObjs
Vec_Int_t * vObjs[2]
Definition giaSupp.c:343
Gia_ManSim_t_
Definition gia.h:321
Gia_ManSim_t_::vCis2Ids
Vec_Int_t * vCis2Ids
Definition gia.h:325
Gia_ManSim_t_::vConsts
Vec_Int_t * vConsts
Definition gia.h:326
Gia_ManSim_t_::pAig
Gia_Man_t * pAig
Definition gia.h:322
Gia_ManSim_t_::pDataSim
unsigned * pDataSim
Definition gia.h:328
Gia_ManSim_t_::pPars
Gia_ParSim_t * pPars
Definition gia.h:323
Gia_ManSim_t_::pDataSimCos
unsigned * pDataSimCos
Definition gia.h:330
Gia_ManSim_t_::nWords
int nWords
Definition gia.h:324
Gia_ManSim_t_::pDataSimCis
unsigned * pDataSimCis
Definition gia.h:329
Gia_Man_t_
Definition gia.h:98
Gia_Man_t_::vCoAttrs
Vec_Int_t * vCoAttrs
Definition gia.h:173
Gia_Man_t_::pAigExtra
Gia_Man_t * pAigExtra
Definition gia.h:167
Gia_Man_t_::nFront
int nFront
Definition gia.h:124
Gia_Man_t_::And2Delay
int And2Delay
Definition gia.h:175
Gia_Man_t_::vLevels
Vec_Int_t * vLevels
Definition gia.h:120
Gia_Man_t_::vSims
Vec_Wrd_t * vSims
Definition gia.h:213
Gia_Man_t_::vNamesIn
Vec_Ptr_t * vNamesIn
Definition gia.h:181
Gia_Man_t_::nSimWords
int nSimWords
Definition gia.h:209
Gia_Man_t_::iFirstPoId
int iFirstPoId
Definition gia.h:249
Gia_Man_t_::fIncrSim
int fIncrSim
Definition gia.h:222
Gia_Man_t_::iPastPiMax
int iPastPiMax
Definition gia.h:211
Gia_Man_t_::vCopies2
Vec_Int_t vCopies2
Definition gia.h:153
Gia_Man_t_::vCoNumsOrig
Vec_Int_t * vCoNumsOrig
Definition gia.h:188
Gia_Man_t_::vSwitching
Vec_Int_t * vSwitching
Definition gia.h:178
Gia_Man_t_::vTtNodes
Vec_Int_t * vTtNodes
Definition gia.h:230
Gia_Man_t_::pSibls
int * pSibls
Definition gia.h:128
Gia_Man_t_::nLevels
int nLevels
Definition gia.h:121
Gia_Man_t_::vEdgeDelay
Vec_Int_t * vEdgeDelay
Definition gia.h:145
Gia_Man_t_::nMuxes
int nMuxes
Definition gia.h:108
Gia_Man_t_::nTtVars
int nTtVars
Definition gia.h:227
Gia_Man_t_::iNextPi
int iNextPi
Definition gia.h:223
Gia_Man_t_::iFirstAndObj
int iFirstAndObj
Definition gia.h:250
Gia_Man_t_::vCoArrs
Vec_Int_t * vCoArrs
Definition gia.h:172
Gia_Man_t_::fBuiltInSim
int fBuiltInSim
Definition gia.h:207
Gia_Man_t_::vTiming
Vec_Flt_t * vTiming
Definition gia.h:193
Gia_Man_t_::pSatlutWinman
void * pSatlutWinman
Definition gia.h:140
Gia_Man_t_::DefOutReqs
float DefOutReqs
Definition gia.h:177
Gia_Man_t_::nAnd2Delay
int nAnd2Delay
Definition gia.h:202
Gia_Man_t_::vStopsF
Vec_Str_t * vStopsF
Definition gia.h:245
Gia_Man_t_::vSuppWords
Vec_Wrd_t * vSuppWords
Definition gia.h:239
Gia_Man_t_::iTimeStamp
int iTimeStamp
Definition gia.h:224
Gia_Man_t_::pUData
Gia_Dat_t * pUData
Definition gia.h:243
Gia_Man_t_::vTTLut
Vec_Int_t * vTTLut
Definition gia.h:253
Gia_Man_t_::vSuper
Vec_Int_t * vSuper
Definition gia.h:234
Gia_Man_t_::pMuxes
unsigned * pMuxes
Definition gia.h:106
Gia_Man_t_::vStopsB
Vec_Str_t * vStopsB
Definition gia.h:246
Gia_Man_t_::nXors
int nXors
Definition gia.h:107
Gia_Man_t_::vEdge2
Vec_Int_t * vEdge2
Definition gia.h:148
Gia_Man_t_::vCos
Vec_Int_t * vCos
Definition gia.h:111
Gia_Man_t_::fVerbose
int fVerbose
Definition gia.h:203
Gia_Man_t_::vTTISOPs
Vec_Str_t * vTTISOPs
Definition gia.h:252
Gia_Man_t_::nHashMiss
word nHashMiss
Definition gia.h:197
Gia_Man_t_::vSuppVars
Vec_Int_t vSuppVars
Definition gia.h:241
Gia_Man_t_::pPlacement
Gia_Plc_t * pPlacement
Definition gia.h:166
Gia_Man_t_::nTerStates
int nTerStates
Definition gia.h:131
Gia_Man_t_::vPolars
Vec_Bit_t * vPolars
Definition gia.h:220
Gia_Man_t_::pSpec
char * pSpec
Definition gia.h:100
Gia_Man_t_::vSimsT
Vec_Wrd_t * vSimsT
Definition gia.h:214
Gia_Man_t_::vOutReqs
Vec_Flt_t * vOutReqs
Definition gia.h:169
Gia_Man_t_::vInArrs
Vec_Flt_t * vInArrs
Definition gia.h:168
Gia_Man_t_::pReprs
Gia_Rpr_t * pReprs
Definition gia.h:126
Gia_Man_t_::vCellMapping
Vec_Int_t * vCellMapping
Definition gia.h:139
Gia_Man_t_::vTtMemory
Vec_Wrd_t * vTtMemory
Definition gia.h:232
Gia_Man_t_::vSeqModelVec
Vec_Ptr_t * vSeqModelVec
Definition gia.h:151
Gia_Man_t_::vCoReqs
Vec_Int_t * vCoReqs
Definition gia.h:171
Gia_Man_t_::nTravIds
int nTravIds
Definition gia.h:123
Gia_Man_t_::vRegInits
Vec_Int_t * vRegInits
Definition gia.h:161
Gia_Man_t_::vMFFCsInfo
Vec_Int_t * vMFFCsInfo
Definition gia.h:254
Gia_Man_t_::iSuppPi
int iSuppPi
Definition gia.h:237
Gia_Man_t_::vFanoutNums
Vec_Int_t * vFanoutNums
Definition gia.h:134
Gia_Man_t_::vUserPoIds
Vec_Int_t * vUserPoIds
Definition gia.h:185
Gia_Man_t_::vPacking
Vec_Int_t * vPacking
Definition gia.h:141
Gia_Man_t_::nSimWordsMax
int nSimWordsMax
Definition gia.h:212
Gia_Man_t_::pFanData
int * pFanData
Definition gia.h:132
Gia_Man_t_::pLutRefs
int * pLutRefs
Definition gia.h:119
Gia_Man_t_::pTravIds
int * pTravIds
Definition gia.h:179
Gia_Man_t_::nSimWordsT
int nSimWordsT
Definition gia.h:210
Gia_Man_t_::vSimsPi
Vec_Wrd_t * vSimsPi
Definition gia.h:215
Gia_Man_t_::nTerLoop
int nTerLoop
Definition gia.h:130
Gia_Man_t_::pData2
unsigned * pData2
Definition gia.h:199
Gia_Man_t_::pNexts
int * pNexts
Definition gia.h:127
Gia_Man_t_::pLutLib
void * pLutLib
Definition gia.h:195
Gia_Man_t_::iFirstPoObj
int iFirstPoObj
Definition gia.h:251
Gia_Man_t_::vHTable
Vec_Int_t vHTable
Definition gia.h:113
Gia_Man_t_::vIdsOrig
Vec_Int_t * vIdsOrig
Definition gia.h:189
Gia_Man_t_::vNamesOut
Vec_Ptr_t * vNamesOut
Definition gia.h:182
Gia_Man_t_::vLutsRankings
Vec_Ptr_t * vLutsRankings
Definition gia.h:256
Gia_Man_t_::vMapping2
Vec_Wec_t * vMapping2
Definition gia.h:137
Gia_Man_t_::fAddStrash
int fAddStrash
Definition gia.h:114
Gia_Man_t_::fGiaSimple
int fGiaSimple
Definition gia.h:116
Gia_Man_t_::nObjsAlloc
int nObjsAlloc
Definition gia.h:104
Gia_Man_t_::vClassNew
Vec_Int_t * vClassNew
Definition gia.h:218
Gia_Man_t_::vDoms
Vec_Int_t * vDoms
Definition gia.h:162
Gia_Man_t_::pIso
int * pIso
Definition gia.h:129
Gia_Man_t_::vCofVars
Vec_Int_t * vCofVars
Definition gia.h:191
Gia_Man_t_::nTravIdsAlloc
int nTravIdsAlloc
Definition gia.h:180
Gia_Man_t_::vTtNums
Vec_Int_t * vTtNums
Definition gia.h:229
Gia_Man_t_::vMapping
Vec_Int_t * vMapping
Definition gia.h:136
Gia_Man_t_::nSuppWords
int nSuppWords
Definition gia.h:238
Gia_Man_t_::nHashHit
word nHashHit
Definition gia.h:196
Gia_Man_t_::vFanouts2
Vec_Wec_t * vFanouts2
Definition gia.h:138
Gia_Man_t_::fSweeper
int fSweeper
Definition gia.h:115
Gia_Man_t_::vFanout
Vec_Int_t * vFanout
Definition gia.h:135
Gia_Man_t_::vEdgeDelayR
Vec_Int_t * vEdgeDelayR
Definition gia.h:146
Gia_Man_t_::iFirstNonPiId
int iFirstNonPiId
Definition gia.h:248
Gia_Man_t_::vHash
Vec_Int_t vHash
Definition gia.h:112
Gia_Man_t_::vMFFCsLuts
Vec_Int_t * vMFFCsLuts
Definition gia.h:255
Gia_Man_t_::nFansAlloc
int nFansAlloc
Definition gia.h:133
Gia_Man_t_::pData
void * pData
Definition gia.h:198
Gia_Man_t_::vLutConfigs
Vec_Int_t * vLutConfigs
Definition gia.h:144
Gia_Man_t_::vRegClasses
Vec_Int_t * vRegClasses
Definition gia.h:160
Gia_Man_t_::pManTime
void * pManTime
Definition gia.h:194
Gia_Man_t_::vCiNumsOrig
Vec_Int_t * vCiNumsOrig
Definition gia.h:187
Gia_Man_t_::vClockDoms
Vec_Vec_t * vClockDoms
Definition gia.h:192
Gia_Man_t_::nRegsAlloc
int nRegsAlloc
Definition gia.h:102
Gia_Man_t_::nRegs
int nRegs
Definition gia.h:101
Gia_Man_t_::vObjClasses
Vec_Int_t * vObjClasses
Definition gia.h:158
Gia_Man_t_::pCexComb
Abc_Cex_t * pCexComb
Definition gia.h:149
Gia_Man_t_::DefInArrs
float DefInArrs
Definition gia.h:176
Gia_Man_t_::vGateClasses
Vec_Int_t * vGateClasses
Definition gia.h:157
Gia_Man_t_::vTtInputs
Vec_Ptr_t * vTtInputs
Definition gia.h:231
Gia_Man_t_::pCexSeq
Abc_Cex_t * pCexSeq
Definition gia.h:150
Gia_Man_t_::nBufs
int nBufs
Definition gia.h:109
Gia_Man_t_::vSimsPo
Vec_Wrd_t * vSimsPo
Definition gia.h:216
Gia_Man_t_::iData2
int iData2
Definition gia.h:201
Gia_Man_t_::vCis
Vec_Int_t * vCis
Definition gia.h:110
Gia_Man_t_::vBarBufs
Vec_Int_t * vBarBufs
Definition gia.h:163
Gia_Man_t_::vFlopClasses
Vec_Int_t * vFlopClasses
Definition gia.h:156
Gia_Man_t_::pName
char * pName
Definition gia.h:99
Gia_Man_t_::vVarMap
Vec_Int_t vVarMap
Definition gia.h:242
Gia_Man_t_::vNamesNode
Vec_Ptr_t * vNamesNode
Definition gia.h:183
Gia_Man_t_::pReprsOld
int * pReprsOld
Definition gia.h:125
Gia_Man_t_::MappedDelay
int MappedDelay
Definition gia.h:205
Gia_Man_t_::vIdsEquiv
Vec_Int_t * vIdsEquiv
Definition gia.h:190
Gia_Man_t_::vCopies
Vec_Int_t vCopies
Definition gia.h:152
Gia_Man_t_::vUserPiIds
Vec_Int_t * vUserPiIds
Definition gia.h:184
Gia_Man_t_::pObjs
Gia_Obj_t * pObjs
Definition gia.h:105
Gia_Man_t_::nTtWords
int nTtWords
Definition gia.h:228
Gia_Man_t_::pRefs
int * pRefs
Definition gia.h:118
Gia_Man_t_::iData
int iData
Definition gia.h:200
Gia_Man_t_::vWeights
Vec_Int_t * vWeights
Definition gia.h:174
Gia_Man_t_::vPats
Vec_Int_t * vPats
Definition gia.h:219
Gia_Man_t_::vVar2Obj
Vec_Int_t * vVar2Obj
Definition gia.h:154
Gia_Man_t_::pSwitching
unsigned char * pSwitching
Definition gia.h:165
Gia_Man_t_::vInitClasses
Vec_Int_t * vInitClasses
Definition gia.h:159
Gia_Man_t_::vTruths
Vec_Int_t * vTruths
Definition gia.h:155
Gia_Man_t_::vTimeStamps
Vec_Int_t * vTimeStamps
Definition gia.h:225
Gia_Man_t_::vClassOld
Vec_Int_t * vClassOld
Definition gia.h:217
Gia_Man_t_::vStore
Vec_Int_t * vStore
Definition gia.h:235
Gia_Man_t_::pCellStr
char * pCellStr
Definition gia.h:143
Gia_Man_t_::nObjs
int nObjs
Definition gia.h:103
Gia_Man_t_::vUserFfIds
Vec_Int_t * vUserFfIds
Definition gia.h:186
Gia_Man_t_::vXors
Vec_Int_t * vXors
Definition gia.h:164
Gia_Man_t_::iPatsPi
int iPatsPi
Definition gia.h:208
Gia_Man_t_::nConstrs
int nConstrs
Definition gia.h:122
Gia_Man_t_::MappedArea
int MappedArea
Definition gia.h:204
Gia_Man_t_::vConfigs
Vec_Int_t * vConfigs
Definition gia.h:142
Gia_Man_t_::vCopiesTwo
Vec_Int_t vCopiesTwo
Definition gia.h:240
Gia_Man_t_::vCiArrs
Vec_Int_t * vCiArrs
Definition gia.h:170
Gia_Man_t_::vRefs
Vec_Int_t vRefs
Definition gia.h:117
Gia_Man_t_::vEdge1
Vec_Int_t * vEdge1
Definition gia.h:147
Gia_MmFixed_t_
DECLARATIONS ///.
Definition giaMem.c:31
Gia_MmFlex_t_
Definition giaMem.c:51
Gia_MmStep_t_
Definition giaMem.c:69
Gia_Obj_t_
Definition gia.h:78
Gia_Obj_t_::iDiff1
unsigned iDiff1
Definition gia.h:84
Gia_Obj_t_::fMark1
unsigned fMark1
Definition gia.h:86
Gia_Obj_t_::fCompl1
unsigned fCompl1
Definition gia.h:85
Gia_Obj_t_::fCompl0
unsigned fCompl0
Definition gia.h:80
Gia_Obj_t_::iDiff0
unsigned iDiff0
Definition gia.h:79
Gia_Obj_t_::Value
unsigned Value
Definition gia.h:89
Gia_Obj_t_::fPhase
unsigned fPhase
Definition gia.h:87
Gia_Obj_t_::fMark0
unsigned fMark0
Definition gia.h:81
Gia_Obj_t_::fTerm
unsigned fTerm
Definition gia.h:82
Gia_ParFra_t_
Definition gia.h:295
Gia_ParFra_t_::fInit
int fInit
Definition gia.h:297
Gia_ParFra_t_::fSaveLastLit
int fSaveLastLit
Definition gia.h:298
Gia_ParFra_t_::nFrames
int nFrames
Definition gia.h:296
Gia_ParFra_t_::fDisableSt
int fDisableSt
Definition gia.h:299
Gia_ParFra_t_::fVerbose
int fVerbose
Definition gia.h:301
Gia_ParFra_t_::fOrPos
int fOrPos
Definition gia.h:300
Gia_ParSim_t_
Definition gia.h:308
Gia_ParSim_t_::nWords
int nWords
Definition gia.h:310
Gia_ParSim_t_::fCheckMiter
int fCheckMiter
Definition gia.h:314
Gia_ParSim_t_::RandSeed
int RandSeed
Definition gia.h:312
Gia_ParSim_t_::TimeLimit
int TimeLimit
Definition gia.h:313
Gia_ParSim_t_::iOutFail
int iOutFail
Definition gia.h:316
Gia_ParSim_t_::nIters
int nIters
Definition gia.h:311
Gia_ParSim_t_::fVerbose
int fVerbose
Definition gia.h:315
Gia_Plc_t_
Definition gia.h:69
Gia_Plc_t_::yCoord
unsigned yCoord
Definition gia.h:73
Gia_Plc_t_::fUndef
unsigned fUndef
Definition gia.h:72
Gia_Plc_t_::fFixed
unsigned fFixed
Definition gia.h:70
Gia_Plc_t_::xCoord
unsigned xCoord
Definition gia.h:71
Gia_Rpr_t_
Definition gia.h:59
Gia_Rpr_t_::fColorB
unsigned fColorB
Definition gia.h:64
Gia_Rpr_t_::fColorA
unsigned fColorA
Definition gia.h:63
Gia_Rpr_t_::fProved
unsigned fProved
Definition gia.h:61
Gia_Rpr_t_::fFailed
unsigned fFailed
Definition gia.h:62
Gia_Rpr_t_::iRepr
unsigned iRepr
Definition gia.h:60
Gps_Par_t_
Definition gia.h:262
Gps_Par_t_::fMiter
int fMiter
Definition gia.h:269
Gps_Par_t_::pDumpFile
char * pDumpFile
Definition gia.h:274
Gps_Par_t_::fTents
int fTents
Definition gia.h:263
Gps_Par_t_::fNpn
int fNpn
Definition gia.h:266
Gps_Par_t_::fLutProf
int fLutProf
Definition gia.h:267
Gps_Par_t_::fCut
int fCut
Definition gia.h:265
Gps_Par_t_::fSlacks
int fSlacks
Definition gia.h:271
Gps_Par_t_::fMuxXor
int fMuxXor
Definition gia.h:268
Gps_Par_t_::fSwitch
int fSwitch
Definition gia.h:264
Gps_Par_t_::fSkipMap
int fSkipMap
Definition gia.h:270
Gps_Par_t_::fNoColor
int fNoColor
Definition gia.h:272
Gps_Par_t_::fMapOutStats
int fMapOutStats
Definition gia.h:273
Jf_Par_t_
Definition gia.h:335
Jf_Par_t_::MapDelayTarget
float MapDelayTarget
Definition gia.h:387
Jf_Par_t_::MapAreaF
float MapAreaF
Definition gia.h:386
Jf_Par_t_::nReqTimeFlex
int nReqTimeFlex
Definition gia.h:344
Jf_Par_t_::nProcNumMax
int nProcNumMax
Definition gia.h:374
Jf_Par_t_::MapArea
float MapArea
Definition gia.h:385
Jf_Par_t_::WordMapArea
word WordMapArea
Definition gia.h:382
Jf_Par_t_::nDelayLut2
int nDelayLut2
Definition gia.h:347
Jf_Par_t_::nLutSizeMux
int nLutSizeMux
Definition gia.h:375
Jf_Par_t_::nDelayLut1
int nDelayLut1
Definition gia.h:346
Jf_Par_t_::fPinQuick
int fPinQuick
Definition gia.h:352
Jf_Par_t_::nRounds
int nRounds
Definition gia.h:339
Jf_Par_t_::fGenCnf
int fGenCnf
Definition gia.h:360
Jf_Par_t_::fFuncDsd
int fFuncDsd
Definition gia.h:359
Jf_Par_t_::nFastEdges
int nFastEdges
Definition gia.h:348
Jf_Par_t_::fCutSimple
int fCutSimple
Definition gia.h:368
Jf_Par_t_::nProcNum
int nProcNum
Definition gia.h:338
Jf_Par_t_::nRelaxRatio
int nRelaxRatio
Definition gia.h:341
Jf_Par_t_::Edge
word Edge
Definition gia.h:378
Jf_Par_t_::pTimesArr
float * pTimesArr
Definition gia.h:389
Jf_Par_t_::nCutNum
int nCutNum
Definition gia.h:337
Jf_Par_t_::nRoundsEla
int nRoundsEla
Definition gia.h:340
Jf_Par_t_::fOptEdge
int fOptEdge
Definition gia.h:354
Jf_Par_t_::Clause
word Clause
Definition gia.h:379
Jf_Par_t_::fCnfObjIds
int fCnfObjIds
Definition gia.h:362
Jf_Par_t_::fCnfMapping
int fCnfMapping
Definition gia.h:364
Jf_Par_t_::fAreaOnly
int fAreaOnly
Definition gia.h:350
Jf_Par_t_::nCutNumMax
int nCutNumMax
Definition gia.h:373
Jf_Par_t_::fCoarsen
int fCoarsen
Definition gia.h:357
Jf_Par_t_::pTimesReq
float * pTimesReq
Definition gia.h:390
Jf_Par_t_::Mux7
word Mux7
Definition gia.h:380
Jf_Par_t_::nLutSizeMax
int nLutSizeMax
Definition gia.h:372
Jf_Par_t_::ZFile
char * ZFile
Definition gia.h:391
Jf_Par_t_::fPinPerm
int fPinPerm
Definition gia.h:351
Jf_Par_t_::nLutSize
int nLutSize
Definition gia.h:336
Jf_Par_t_::WordMapDelay
word WordMapDelay
Definition gia.h:381
Jf_Par_t_::fDoAverage
int fDoAverage
Definition gia.h:366
Jf_Par_t_::fPinFilter
int fPinFilter
Definition gia.h:353
Jf_Par_t_::Delay
word Delay
Definition gia.h:376
Jf_Par_t_::nAreaTuner
int nAreaTuner
Definition gia.h:343
Jf_Par_t_::MapDelay
int MapDelay
Definition gia.h:384
Jf_Par_t_::fVeryVerbose
int fVeryVerbose
Definition gia.h:371
Jf_Par_t_::fCutMin
int fCutMin
Definition gia.h:358
Jf_Par_t_::Area
word Area
Definition gia.h:377
Jf_Par_t_::fUseMux7
int fUseMux7
Definition gia.h:355
Jf_Par_t_::fCutGroup
int fCutGroup
Definition gia.h:369
Jf_Par_t_::fPureAig
int fPureAig
Definition gia.h:365
Jf_Par_t_::fPower
int fPower
Definition gia.h:356
Jf_Par_t_::WordMapDelayTarget
word WordMapDelayTarget
Definition gia.h:383
Jf_Par_t_::fCutHashing
int fCutHashing
Definition gia.h:367
Jf_Par_t_::Epsilon
float Epsilon
Definition gia.h:388
Jf_Par_t_::nCoarseLimit
int nCoarseLimit
Definition gia.h:342
Jf_Par_t_::fVerbose
int fVerbose
Definition gia.h:370
Jf_Par_t_::nVerbLimit
int nVerbLimit
Definition gia.h:345
Jf_Par_t_::fGenLit
int fGenLit
Definition gia.h:361
Jf_Par_t_::fAddOrCla
int fAddOrCla
Definition gia.h:363
Jf_Par_t_::DelayTarget
int DelayTarget
Definition gia.h:349
Tas_Man_t_
Definition giaCTas.c:83
Tas_Man_t_::pAig
Gia_Man_t * pAig
Definition giaCTas.c:85
Abc_Cex_t
typedefABC_NAMESPACE_HEADER_START struct Abc_Cex_t_ Abc_Cex_t
INCLUDES ///.
Definition utilCex.h:39
assert
#define assert(ex)
Definition util_old.h:213
memset
char * memset()
exit
VOID_HACK exit()
Vec_Bit_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Bit_t_ Vec_Bit_t
INCLUDES ///.
Definition vecBit.h:42
Vec_Flt_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Flt_t_ Vec_Flt_t
INCLUDES ///.
Definition vecFlt.h:42
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_Vec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Vec_t_ Vec_Vec_t
INCLUDES ///.
Definition vecVec.h:42
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition vecWec.h:42
Vec_Wrd_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wrd_t_ Vec_Wrd_t
INCLUDES ///.
Definition vecWrd.h:42