ruby_abc 0.0.6 → 0.1.0

data/ext/abc/src/base/io/ioWriteBook.c

@@ -1,998 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [ioWriteBook.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Command processing package.]
-
-  Synopsis    [Procedures to write Bookshelf files.]
-
-  Author      [Myungchul Kim]
-  
-  Affiliation [U of Michigan]
-
-  Date        [Ver. 1.0. Started - October 25, 2008.]
-
-  Revision    [$Id: ioWriteBook.c,v 1.00 2005/11/10 00:00:00 mckima Exp $]
-
-***********************************************************************/
-
-#include <math.h>
-
-#include "base/main/main.h"
-#include "map/mio/mio.h"
-#include "ioAbc.h"
-
-ABC_NAMESPACE_IMPL_START
-
-#define	NODES	   0
-#define	PL	   1
-#define coreHeight 1
-#define termWidth  1
-#define termHeight 1
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static unsigned Io_NtkWriteNodes( FILE * pFile, Abc_Ntk_t * pNtk );
-static void Io_NtkWritePiPoNodes( FILE * pFile, Abc_Ntk_t * pNtk );
-static void Io_NtkWriteLatchNode( FILE * pFile, Abc_Obj_t * pLatch, int NodesOrPl );
-static unsigned Io_NtkWriteIntNode( FILE * pFile, Abc_Obj_t * pNode, int NodesOrPl );
-static unsigned Io_NtkWriteNodeGate( FILE * pFile, Abc_Obj_t * pNode );
-static void Io_NtkWriteNets( FILE * pFile, Abc_Ntk_t * pNtk );
-static void Io_NtkWriteIntNet( FILE * pFile, Abc_Obj_t * pNode );
-static void Io_NtkBuildLayout( FILE * pFile1, FILE *pFile2, Abc_Ntk_t * pNtk, double aspectRatio, double whiteSpace, unsigned coreCellArea );
-static void Io_NtkWriteScl( FILE * pFile, unsigned numCoreRows, double layoutWidth );
-static void Io_NtkWritePl( FILE * pFile, Abc_Ntk_t * pNtk, unsigned numTerms, double layoutHeight, double layoutWidth );
-static Vec_Ptr_t * Io_NtkOrderingPads( Abc_Ntk_t * pNtk, Vec_Ptr_t * vTerms ); 
-static Abc_Obj_t * Io_NtkBfsPads( Abc_Ntk_t * pNtk, Abc_Obj_t * pCurrEntry, unsigned numTerms, int * pOrdered );
-static int Abc_NodeIsNand2( Abc_Obj_t * pNode );
-static int Abc_NodeIsNor2( Abc_Obj_t * pNode );
-static int Abc_NodeIsAnd2( Abc_Obj_t * pNode );
-static int Abc_NodeIsOr2( Abc_Obj_t * pNode );
-static int Abc_NodeIsXor2( Abc_Obj_t * pNode );
-static int Abc_NodeIsXnor2( Abc_Obj_t * pNode );
-
-static inline double Abc_Rint( double x )   { return (double)(int)x;  }
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a Bookshelf file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_WriteBookLogic( Abc_Ntk_t * pNtk, char * FileName )
-{
-    Abc_Ntk_t * pNtkTemp;
-    // derive the netlist
-    pNtkTemp = Abc_NtkToNetlist(pNtk);
-    if ( pNtkTemp == NULL )
-    {
-        fprintf( stdout, "Writing BOOK has failed.\n" );
-        return;
-    }
-    Io_WriteBook( pNtkTemp, FileName );
-    Abc_NtkDelete( pNtkTemp );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a BOOK file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_WriteBook( Abc_Ntk_t * pNtk, char * FileName )
-{
-
-    FILE * pFileNodes, * pFileNets, * pFileAux;
-    FILE * pFileScl, * pFilePl, * pFileWts;
-    char * FileExt = ABC_CALLOC( char, strlen(FileName)+7 );
-    unsigned coreCellArea=0;
-    Abc_Ntk_t * pExdc, * pNtkTemp;
-    int i;
-
-    assert( Abc_NtkIsNetlist(pNtk) );
-    // start writing the files
-    strcpy(FileExt, FileName);
-    pFileNodes = fopen( strcat(FileExt,".nodes"), "w" );
-    strcpy(FileExt, FileName);
-    pFileNets  = fopen( strcat(FileExt,".nets"), "w" );
-    strcpy(FileExt, FileName);
-    pFileAux   = fopen( strcat(FileExt,".aux"), "w" );
-
-		// write the aux file
-    if ( (pFileNodes == NULL) || (pFileNets == NULL) || (pFileAux == NULL) )
-    {
-        fclose( pFileAux );
-        fprintf( stdout, "Io_WriteBook(): Cannot open the output files.\n" );
-        return;
-    }
-    fprintf( pFileAux, "RowBasedPlacement : %s.nodes %s.nets %s.scl %s.pl %s.wts", 
-	     FileName, FileName, FileName, FileName, FileName );
-    fclose( pFileAux );
-
-    // write the master network
-    coreCellArea+=Io_NtkWriteNodes( pFileNodes, pNtk );
-    Io_NtkWriteNets( pFileNets, pNtk );
-
-    // write EXDC network if it exists
-    pExdc = Abc_NtkExdc( pNtk );
-    if ( pExdc )
-    {
-	coreCellArea+=Io_NtkWriteNodes( pFileNodes, pNtk );
-        Io_NtkWriteNets( pFileNets, pNtk );
-    }
-
-    // make sure there is no logic hierarchy
-    assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
-
-    // write the hierarchy if present
-    if ( Abc_NtkBlackboxNum(pNtk) > 0 )
-    {
-        Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pNtkTemp, i )
-        {
-            if ( pNtkTemp == pNtk )
-                continue;
-            coreCellArea+=Io_NtkWriteNodes( pFileNodes, pNtkTemp );
-            Io_NtkWriteNets( pFileNets, pNtkTemp );
-        }
-    }
-    fclose( pFileNodes );
-    fclose( pFileNets );
-
-    strcpy(FileExt, FileName);
-    pFileScl = fopen( strcat(FileExt,".scl"), "w" );
-    strcpy(FileExt, FileName);
-    pFilePl  = fopen( strcat(FileExt,".pl"), "w" );
-    strcpy(FileExt, FileName);
-    pFileWts   = fopen( strcat(FileExt,".wts"), "w" );
-    ABC_FREE(FileExt);
-
-    Io_NtkBuildLayout( pFileScl, pFilePl, pNtk, 1.0, 10, coreCellArea );
-    fclose( pFileScl );
-    fclose( pFilePl );
-    fclose( pFileWts );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a BOOK file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-unsigned Io_NtkWriteNodes( FILE * pFile, Abc_Ntk_t * pNtk )
-{
-    ProgressBar * pProgress;
-    Abc_Obj_t * pLatch, * pNode;
-    unsigned numTerms, numNodes, coreCellArea=0;
-    int i;
-
-    assert( Abc_NtkIsNetlist(pNtk) );
-    // write the forehead
-    numTerms=Abc_NtkPiNum(pNtk)+Abc_NtkPoNum(pNtk);
-    numNodes=numTerms+Abc_NtkNodeNum(pNtk)+Abc_NtkLatchNum(pNtk);
-    printf("NumNodes : %d\t", numNodes );
-    printf("NumTerminals : %d\n", numTerms );
-    fprintf( pFile, "UCLA    nodes    1.0\n");
-    fprintf( pFile, "NumNodes : %d\n", numNodes );
-    fprintf( pFile, "NumTerminals : %d\n", numTerms );
-    // write the PI/POs
-    Io_NtkWritePiPoNodes( pFile, pNtk );
-    // write the latches
-    if ( !Abc_NtkIsComb(pNtk) )
-    {
-	    Abc_NtkForEachLatch( pNtk, pLatch, i )
-	    {
-	        Io_NtkWriteLatchNode( pFile, pLatch, NODES );
-	        coreCellArea+=6*coreHeight;
-	    }
-    }
-    // write each internal node
-    pProgress = Extra_ProgressBarStart( stdout, Abc_NtkNodeNum(pNtk) );
-    Abc_NtkForEachNode( pNtk, pNode, i )
-    {
-        Extra_ProgressBarUpdate( pProgress, i, NULL );
-        coreCellArea+=Io_NtkWriteIntNode( pFile, pNode, NODES );
-    }
-    Extra_ProgressBarStop( pProgress );
-    return coreCellArea;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Writes the primary input nodes into a file]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWritePiPoNodes( FILE * pFile, Abc_Ntk_t * pNtk )
-{
-    Abc_Obj_t * pTerm, * pNet;
-    int i;
-
-    Abc_NtkForEachPi( pNtk, pTerm, i )
-    {
-    	pNet = Abc_ObjFanout0(pTerm);
-	fprintf( pFile, "i%s_input\t", Abc_ObjName(pNet) ); 
-	fprintf( pFile, "terminal ");
-	fprintf( pFile, " %d %d\n", termWidth, termHeight );
-    }
-	
-    Abc_NtkForEachPo( pNtk, pTerm, i )
-    {
-	pNet = Abc_ObjFanin0(pTerm);
-	fprintf( pFile, "o%s_output\t", Abc_ObjName(pNet) ); 
-	fprintf( pFile, "terminal ");
-	fprintf( pFile, " %d %d\n", termWidth, termHeight );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the latch nodes into a file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWriteLatchNode( FILE * pFile, Abc_Obj_t * pLatch, int NodesOrPl )
-{
-    Abc_Obj_t * pNetLi, * pNetLo;
-    
-    pNetLi = Abc_ObjFanin0( Abc_ObjFanin0(pLatch) );
-    pNetLo = Abc_ObjFanout0( Abc_ObjFanout0(pLatch) );
-	/// write the latch line
-    fprintf( pFile, "%s_%s_latch\t", Abc_ObjName(pNetLi), Abc_ObjName(pNetLo) );
-    if (NodesOrPl == NODES)
-        fprintf( pFile, " %d %d\n", 6, 1 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the internal node into a file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-unsigned Io_NtkWriteIntNode( FILE * pFile, Abc_Obj_t * pNode, int NodesOrPl )
-{
-    unsigned sizex=0, sizey=coreHeight, isize=0;
-    //double nx, ny, xstep, ystep;	
-    Abc_Obj_t * pNeti, *pNeto;
-    int i;
-		
-    // write the network after mapping 
-    if ( Abc_NtkHasMapping(pNode->pNtk) )
-        sizex=Io_NtkWriteNodeGate( pFile, pNode );
-    else
-    {
-	Abc_ObjForEachFanin( pNode, pNeti, i )
-	    fprintf( pFile, "%s_", Abc_ObjName(pNeti) );
-	Abc_ObjForEachFanout( pNode, pNeto, i )
-	    fprintf( pFile, "%s_", Abc_ObjName(pNeto) );	
-	fprintf( pFile, "name\t" );
-	
-	if(NodesOrPl == NODES)
-	{
-	    isize=Abc_ObjFaninNum(pNode);
-	    if ( Abc_NodeIsConst0(pNode) || Abc_NodeIsConst1(pNode) ) 
-	        sizex=0;
-	    else if ( Abc_NodeIsInv(pNode) )
-	        sizex=1;
-	    else if ( Abc_NodeIsBuf(pNode) )
-	        sizex=2;
-	    else
-	    {
-	        assert( Abc_NtkHasSop(pNode->pNtk) );
-	        if ( Abc_NodeIsNand2(pNode) || Abc_NodeIsNor2(pNode) )
-		    sizex=2;
-		else if ( Abc_NodeIsAnd2(pNode) || Abc_NodeIsOr2(pNode) )
-		    sizex=3;
-		else if ( Abc_NodeIsXor2(pNode) || Abc_NodeIsXnor2(pNode) )
-		    sizex=5;
-		else
-		{
-		    assert( isize > 2 );
-		    sizex=isize+Abc_SopGetCubeNum((char *)pNode->pData);
-		}
-	    }
-	}
-    }
-    if(NodesOrPl == NODES)
-    {
-	fprintf( pFile, " %d %d\n", sizex, sizey );
-
-    // Equally place pins. Size pins needs /  isize+#output+1
-	isize= isize + Abc_ObjFanoutNum(pNode) + 1;
-    }
-    return sizex*sizey;
-	/*
-	xstep = sizex / isize;
-	ystep = sizey / isize;
-	nx= -0.5 * sizex;
-	ny= -0.5 * sizey;
-
-	Abc_ObjForEachFanin( pNode, pFanin, i )
-	{
-			nx+= xstep;
-			ny+= ystep;
-			if (fabs(nx) < 0.001)
-					nx= 0;
-			if (fabs(ny) < 0.001)
-					ny= 0;
-	}
-	Abc_ObjForEachFanout( pNode, pFanout, i )
-	{
-			nx+= xstep;
-			ny+= ystep;
-			if (fabs(nx) < 0.001)
-					nx= 0;
-			if (fabs(ny) < 0.001)
-					ny= 0;
-	}
-	*/
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Writes the internal node after tech mapping.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-unsigned Io_NtkWriteNodeGate( FILE * pFile, Abc_Obj_t * pNode )
-{
-    Mio_Gate_t * pGate = (Mio_Gate_t *)pNode->pData;
-    Mio_Pin_t * pGatePin;
-    int i;
-    // write the node gate
-    for ( pGatePin = Mio_GateReadPins(pGate), i = 0; pGatePin; pGatePin = Mio_PinReadNext(pGatePin), i++ )
-        fprintf( pFile, "%s_", Abc_ObjName( Abc_ObjFanin(pNode,i) ) );
-    assert ( i == Abc_ObjFaninNum(pNode) );
-    fprintf( pFile, "%s_%s\t", Abc_ObjName( Abc_ObjFanout0(pNode) ), Mio_GateReadName(pGate) );
-    return Mio_GateReadArea(pGate);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the nets into a file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWriteNets( FILE * pFile, Abc_Ntk_t * pNtk )
-{
-    ProgressBar * pProgress;
-    Abc_Obj_t * pNet;
-    unsigned numPin=0;
-    int i;
-
-    assert( Abc_NtkIsNetlist(pNtk) );
-    // write the head
-    Abc_NtkForEachNet( pNtk, pNet, i )
-    numPin+=Abc_ObjFaninNum(pNet)+Abc_ObjFanoutNum(pNet);
-    printf( "NumNets  : %d\t", Abc_NtkNetNum(pNtk) );
-    printf( "NumPins      : %d\n\n", numPin );
-    fprintf( pFile, "UCLA    nets    1.0\n");
-    fprintf( pFile, "NumNets : %d\n", Abc_NtkNetNum(pNtk) );
-    fprintf( pFile, "NumPins : %d\n", numPin );
-
-    // write nets
-    pProgress = Extra_ProgressBarStart( stdout, Abc_NtkNetNum(pNtk) );
-    Abc_NtkForEachNet( pNtk, pNet, i )
-    {
-        Extra_ProgressBarUpdate( pProgress, i, NULL );
-        Io_NtkWriteIntNet( pFile, pNet );
-    }
-    Extra_ProgressBarStop( pProgress );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the nets into a file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWriteIntNet( FILE * pFile, Abc_Obj_t * pNet )
-{
-    Abc_Obj_t * pFanin, * pFanout;
-    Abc_Obj_t * pNeti, * pNeto;
-    Abc_Obj_t * pNetLi, * pNetLo, * pLatch;
-    int i, j;
-    int NetDegree=Abc_ObjFaninNum(pNet)+Abc_ObjFanoutNum(pNet);
-
-    fprintf( pFile, "NetDegree\t:\t\t%d\t\t%s\n", NetDegree, Abc_ObjName(Abc_ObjFanin0(pNet)) );
-
-    pFanin=Abc_ObjFanin0(pNet);
-    if ( Abc_ObjIsPi(pFanin) )
-	fprintf( pFile, "i%s_input I\n", Abc_ObjName(pNet) );
-    else 
-    {
-	if(!Abc_NtkIsComb(pNet->pNtk) && Abc_ObjFaninNum(pFanin) && Abc_ObjIsLatch(Abc_ObjFanin0(pFanin)) )
-	{
-	    pLatch=Abc_ObjFanin0(pFanin);
-	    pNetLi=Abc_ObjFanin0(Abc_ObjFanin0(pLatch));
-	    pNetLo=Abc_ObjFanout0(Abc_ObjFanout0(pLatch));
-	    fprintf( pFile, "%s_%s_latch I : ", Abc_ObjName(pNetLi), Abc_ObjName(pNetLo) );
-	}
-	else
-	{
-	    Abc_ObjForEachFanin( pFanin, pNeti, j )
-	    fprintf( pFile, "%s_", Abc_ObjName(pNeti) );
-	    Abc_ObjForEachFanout( pFanin, pNeto, j )
-	    fprintf( pFile, "%s_", Abc_ObjName(pNeto) );	
-	    if ( Abc_NtkHasMapping(pNet->pNtk) )
-		fprintf( pFile, "%s : ", Mio_GateReadName((Mio_Gate_t *)pFanin->pData) ); 
-	    else
-		fprintf( pFile, "name I : " );								
-	}
-	// offsets are simlply 0.00 0.00 at the moment
-	fprintf( pFile, "%.2f %.2f\n", .0, .0 );
-    }
-
-    Abc_ObjForEachFanout( pNet, pFanout, i )
-    {
-	if ( Abc_ObjIsPo(pFanout) )
-	    fprintf( pFile, "o%s_output O\n", Abc_ObjName(pNet) );
-	else
-	{
-	    if(!Abc_NtkIsComb(pNet->pNtk) && Abc_ObjFanoutNum(pFanout) && Abc_ObjIsLatch( Abc_ObjFanout0(pFanout) ) )
-	    {
-		pLatch=Abc_ObjFanout0(pFanout);
-		pNetLi=Abc_ObjFanin0(Abc_ObjFanin0(pLatch));
-		pNetLo=Abc_ObjFanout0(Abc_ObjFanout0(pLatch));
-		fprintf( pFile, "%s_%s_latch O : ", Abc_ObjName(pNetLi), Abc_ObjName(pNetLo) );
-	    }
-	    else
-	    {
-		Abc_ObjForEachFanin( pFanout, pNeti, j )
-		fprintf( pFile, "%s_", Abc_ObjName(pNeti) );
-		Abc_ObjForEachFanout( pFanout, pNeto, j )
-		fprintf( pFile, "%s_", Abc_ObjName(pNeto) );	
-		if ( Abc_NtkHasMapping(pNet->pNtk) )
-		    fprintf( pFile, "%s : ", Mio_GateReadName((Mio_Gate_t *)pFanout->pData) ); 
-		else
-		    fprintf( pFile, "name O : " );
-	    }
-	// offsets are simlply 0.00 0.00 at the moment
-	fprintf( pFile, "%.2f %.2f\n", .0, .0 );
-	}
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a BOOK file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkBuildLayout( FILE * pFileScl, FILE * pFilePl, Abc_Ntk_t * pNtk, double aspectRatio, double whiteSpace, unsigned coreCellArea )
-{
-    unsigned numCoreCells=Abc_NtkNodeNum(pNtk)+Abc_NtkLatchNum(pNtk);
-    double targetLayoutArea = coreCellArea/(1.0-(whiteSpace/100.0));
-    unsigned numCoreRows=(aspectRatio>0.0) ? (Abc_Rint(sqrt(targetLayoutArea/aspectRatio)/coreHeight)) : 0;
-    unsigned numTerms=Abc_NtkPiNum(pNtk)+Abc_NtkPoNum(pNtk);
-    unsigned totalWidth=coreCellArea/coreHeight;
-    double layoutHeight = numCoreRows * coreHeight;
-    double layoutWidth = Abc_Rint(targetLayoutArea/layoutHeight);
-    double actualLayoutArea = layoutWidth * layoutHeight;
-
-    printf( "Core cell height(==site height) is %d\n", coreHeight );
-    printf( "Total core cell width is %d giving an ave width of %f\n", totalWidth, (double)(totalWidth/numCoreCells));
-    printf( "Target Dimensions:\n" );
-    printf( "  Area  :   %f\n", targetLayoutArea );
-    printf( "  WS%%   :   %f\n", whiteSpace );
-    printf( "  AR    :   %f\n", aspectRatio );
-    printf( "Actual Dimensions:\n" );
-    printf( "  Width :   %f\n", layoutWidth );
-    printf( "  Height:   %f (%d rows)\n", layoutHeight, numCoreRows);
-    printf( "  Area  :   %f\n", actualLayoutArea );
-    printf( "  WS%%   :   %f\n", 100*(actualLayoutArea-coreCellArea)/actualLayoutArea );
-    printf( "  AR    :   %f\n\n", layoutWidth/layoutHeight );	
-
-    Io_NtkWriteScl( pFileScl, numCoreRows, layoutWidth ); 
-    Io_NtkWritePl( pFilePl, pNtk, numTerms, layoutHeight, layoutWidth );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a BOOK file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWriteScl( FILE * pFile, unsigned numCoreRows, double layoutWidth )
-{
-    int origin_y=0;
-    char * rowOrients[2] = {"N", "FS"};
-    char symmetry='Y';
-    double sitewidth=1.0;
-    double spacing=1.0;
-		
-    unsigned rowId;
-    // write the forehead
-    fprintf( pFile, "UCLA    scl    1.0\n\n" );
-    fprintf( pFile, "Numrows : %d\n\n", numCoreRows );
-
-    for( rowId=0 ; rowId<numCoreRows ; rowId++, origin_y += coreHeight )
-    {
-	fprintf( pFile, "CoreRow Horizontal\n" );
-	fprintf( pFile, " Coordinate   : \t%d\n", origin_y);
-	fprintf( pFile, " Height       : \t%d\n", coreHeight);
-	fprintf( pFile, " Sitewidth    : \t%d\n", (unsigned)sitewidth );
-	fprintf( pFile, " Sitespacing  : \t%d\n", (unsigned)spacing );
-	fprintf( pFile, " Siteorient   : \t%s\n", rowOrients[rowId%2] );
-	//if( coreRow[i].site.symmetry.rot90 || coreRow[i].site.symmetry.y || coreRow[i].site.symmetry.x )
-	fprintf( pFile, " Sitesymmetry : \t%c\n", symmetry );
-	//else fprintf( pFile, "Sitesymmetry			: \t\t\t1\n" );
-	fprintf( pFile, " SubrowOrigin : \t%d Numsites :	\t%d\n", 0, (unsigned)layoutWidth );
-	fprintf( pFile, "End\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Write the network into a BOOK file with the given name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_NtkWritePl( FILE * pFile, Abc_Ntk_t * pNtk, unsigned numTerms, double layoutWidth, double layoutHeight )
-{
-    Abc_Obj_t * pTerm, * pLatch, * pNode;
-    Vec_Ptr_t * vTerms = Vec_PtrAlloc ( numTerms ); 
-    Vec_Ptr_t * vOrderedTerms = Vec_PtrAlloc ( numTerms ); 
-    double layoutPerim = 2*layoutWidth + 2*layoutHeight;
-    double nextLoc_x, nextLoc_y;
-    double delta;
-    unsigned termsOnTop, termsOnBottom, termsOnLeft, termsOnRight;
-    unsigned t;
-	int i;
-
-    termsOnTop = termsOnBottom = (unsigned)(Abc_Rint(numTerms*(layoutWidth/layoutPerim)));
-    termsOnLeft = numTerms - (termsOnTop+termsOnBottom);
-    termsOnRight = (unsigned)(ceil(termsOnLeft/2.0));
-    termsOnLeft -= termsOnRight;
-
-    Abc_NtkForEachPi( pNtk, pTerm, i )
-	Vec_PtrPush( vTerms, pTerm );	
-    Abc_NtkForEachPo( pNtk, pTerm, i )
-	Vec_PtrPush( vTerms, pTerm );
-    // Ordering Pads
-    vOrderedTerms=Io_NtkOrderingPads( pNtk, vTerms );
-    assert( termsOnTop+termsOnBottom+termsOnLeft+termsOnRight == (unsigned)Vec_PtrSize(vOrderedTerms) );
-
-    printf( "Done constructing layout region\n" );
-    printf( "Terminals: %d\n", numTerms );
-    printf( "  Top:     %d\n", termsOnTop );
-    printf( "  Bottom:  %d\n", termsOnBottom );
-    printf( "  Left:    %d\n", termsOnLeft );
-    printf( "  Right:   %d\n", termsOnRight );
-
-    fprintf( pFile, "UCLA    pl    1.0\n\n" );
-
-    nextLoc_x = floor(.0);
-    nextLoc_y = ceil(layoutHeight + 2*coreHeight);
-    delta   = layoutWidth / termsOnTop;
-    for(t = 0; t < termsOnTop; t++)
-    {
-	pTerm = (Abc_Obj_t *)Vec_PtrEntry( vOrderedTerms, t );
-	if( Abc_ObjIsPi(pTerm) )
-	    fprintf( pFile, "i%s_input\t\t", Abc_ObjName(Abc_ObjFanout0(pTerm)) ); 
-	else
-	    fprintf( pFile, "o%s_output\t\t", Abc_ObjName(Abc_ObjFanin0(pTerm)) ); 
-	if( t && Abc_Rint(nextLoc_x) < Abc_Rint(nextLoc_x-delta)+termWidth )
-	    nextLoc_x++;
-	fprintf( pFile, "%d\t\t%d\t: %s /FIXED\n", (int)Abc_Rint(nextLoc_x), (int)Abc_Rint(nextLoc_y), "FS" );	
-	nextLoc_x += delta;
-    }
-
-    nextLoc_x = floor(.0);
-    nextLoc_y = floor(.0 - 2*coreHeight - termHeight);
-    delta   = layoutWidth / termsOnBottom;
-    for(;t < termsOnTop+termsOnBottom; t++)
-    {
-	pTerm = (Abc_Obj_t *)Vec_PtrEntry( vOrderedTerms, t );
-	if( Abc_ObjIsPi(pTerm) )
-	    fprintf( pFile, "i%s_input\t\t", Abc_ObjName(Abc_ObjFanout0(pTerm)) ); 
-	else
-	    fprintf( pFile, "o%s_output\t\t", Abc_ObjName(Abc_ObjFanin0(pTerm)) ); 
-	if( t!=termsOnTop && Abc_Rint(nextLoc_x) < Abc_Rint(nextLoc_x-delta)+termWidth )
-	    nextLoc_x++;
-	fprintf( pFile, "%d\t\t%d\t: %s /FIXED\n", (int)Abc_Rint(nextLoc_x), (int)Abc_Rint(nextLoc_y), "N" );	
-	nextLoc_x     += delta;
-    }
-
-    nextLoc_x = floor(.0-2*coreHeight-termWidth);
-    nextLoc_y = floor(.0);
-    delta   = layoutHeight / termsOnLeft;
-    for(;t < termsOnTop+termsOnBottom+termsOnLeft; t++)
-    {
-	pTerm = (Abc_Obj_t *)Vec_PtrEntry( vOrderedTerms, t );
-	if( Abc_ObjIsPi(pTerm) )
-	    fprintf( pFile, "i%s_input\t\t", Abc_ObjName(Abc_ObjFanout0(pTerm)) ); 
-	else
-	    fprintf( pFile, "o%s_output\t\t", Abc_ObjName(Abc_ObjFanin0(pTerm)) ); 
-	if( Abc_Rint(nextLoc_y) < Abc_Rint(nextLoc_y-delta)+termHeight )
-	    nextLoc_y++;
-	fprintf( pFile, "%d\t\t%d\t: %s /FIXED\n", (int)Abc_Rint(nextLoc_x), (int)Abc_Rint(nextLoc_y), "E" );	
-	nextLoc_y     += delta;
-    }
-
-    nextLoc_x = ceil(layoutWidth+2*coreHeight);
-    nextLoc_y = floor(.0);
-    delta   = layoutHeight / termsOnRight;
-    for(;t < termsOnTop+termsOnBottom+termsOnLeft+termsOnRight; t++)
-    {
-       	pTerm = (Abc_Obj_t *)Vec_PtrEntry( vOrderedTerms, t );
-	if( Abc_ObjIsPi(pTerm) )
-	    fprintf( pFile, "i%s_input\t\t", Abc_ObjName(Abc_ObjFanout0(pTerm)) ); 
-	else
-	    fprintf( pFile, "o%s_output\t\t", Abc_ObjName(Abc_ObjFanin0(pTerm)) ); 
-	if( Abc_Rint(nextLoc_y) < Abc_Rint(nextLoc_y-delta)+termHeight )
-	    nextLoc_y++;
-	fprintf( pFile, "%d\t\t%d\t: %s /FIXED\n", (int)Abc_Rint(nextLoc_x), (int)Abc_Rint(nextLoc_y), "FW" );	
-	nextLoc_y     += delta;
-    }
-
-    if( !Abc_NtkIsComb(pNtk) )
-    {
-	Abc_NtkForEachLatch( pNtk, pLatch, i )
-	{
-	    Io_NtkWriteLatchNode( pFile, pLatch, PL );
-	    fprintf( pFile, "\t%d\t\t%d\t: %s\n", 0, 0, "N" );	
-	}
-    }
-    
-    Abc_NtkForEachNode( pNtk, pNode, i )
-    {
-	Io_NtkWriteIntNode( pFile, pNode, PL );
-	fprintf( pFile, "\t%d\t\t%d\t: %s\n", 0, 0, "N" );	
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the closest I/O to a given I/O.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Io_NtkOrderingPads( Abc_Ntk_t * pNtk, Vec_Ptr_t * vTerms )
-{ 
-    ProgressBar * pProgress;
-    unsigned numTerms=Vec_PtrSize(vTerms); 
-    unsigned termIdx=0, termCount=0;
-    int * pOrdered = ABC_ALLOC(int, numTerms); 
-    int newNeighbor=1;
-    Vec_Ptr_t * vOrderedTerms = Vec_PtrAlloc ( numTerms );
-    Abc_Obj_t * pNeighbor = NULL, * pNextTerm;     
-    unsigned i; 
-
-    for( i=0 ; i<numTerms ; i++ )
-	pOrdered[i]=0; 
-   
-    pNextTerm = (Abc_Obj_t *)Vec_PtrEntry(vTerms, termIdx++);
-    pProgress = Extra_ProgressBarStart( stdout, numTerms );
-    while( termCount < numTerms && termIdx < numTerms )
-    {
-	if( pOrdered[Abc_ObjId(pNextTerm)] && !newNeighbor )
-	{
-	    pNextTerm = (Abc_Obj_t *)Vec_PtrEntry( vTerms, termIdx++ );
-	    continue;
-	}
-	if(!Vec_PtrPushUnique( vOrderedTerms, pNextTerm ))
-	{
-	    pOrdered[Abc_ObjId(pNextTerm)]=1;
-	    termCount++; 
-	}
-	pNeighbor=Io_NtkBfsPads( pNtk, pNextTerm, numTerms, pOrdered );
-	if( (newNeighbor=!Vec_PtrPushUnique( vOrderedTerms, pNeighbor )) )
-	{
-	   pOrdered[Abc_ObjId(pNeighbor)]=1;
-	   termCount++;
-	   pNextTerm=pNeighbor;
-	}
-	else if(termIdx < numTerms)
-	    pNextTerm = (Abc_Obj_t *)Vec_PtrEntry( vTerms, termIdx++ );
-
-	Extra_ProgressBarUpdate( pProgress, termCount, NULL );
-    }
-    Extra_ProgressBarStop( pProgress );
-    assert(termCount==numTerms);
-    return vOrderedTerms;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the closest I/O to a given I/O.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Obj_t * Io_NtkBfsPads( Abc_Ntk_t * pNtk, Abc_Obj_t * pTerm, unsigned numTerms, int * pOrdered )
-{
-    Vec_Ptr_t * vNeighbors = Vec_PtrAlloc ( numTerms ); 
-    Abc_Obj_t * pNet, * pNode, * pNeighbor;
-    int foundNeighbor=0;
-    int i;
-
-    assert(Abc_ObjIsPi(pTerm) || Abc_ObjIsPo(pTerm) );
-    Abc_NtkIncrementTravId ( pNtk );
-    Abc_NodeSetTravIdCurrent( pTerm );
-    if(Abc_ObjIsPi(pTerm))
-    {
-	pNet = Abc_ObjFanout0(pTerm);
-	Abc_ObjForEachFanout( pNet, pNode, i ) 
-	    Vec_PtrPush( vNeighbors, pNode );
-    }
-    else 
-    {
-	pNet = Abc_ObjFanin0(pTerm);
-	Abc_ObjForEachFanin( pNet, pNode, i ) 
-	    Vec_PtrPush( vNeighbors, pNode );   
-    }
-
-    while ( Vec_PtrSize(vNeighbors) >0 )
-    {
-	pNeighbor = (Abc_Obj_t *)Vec_PtrEntry( vNeighbors, 0 );
-	assert( Abc_ObjIsNode(pNeighbor) || Abc_ObjIsTerm(pNeighbor) );
-	Vec_PtrRemove( vNeighbors, pNeighbor );
-
-	if( Abc_NodeIsTravIdCurrent( pNeighbor ) )
-	    continue;
-	Abc_NodeSetTravIdCurrent( pNeighbor );
-
-	if( ((Abc_ObjIsPi(pNeighbor) || Abc_ObjIsPo(pNeighbor))) && !pOrdered[Abc_ObjId(pNeighbor)] )
-	{
-	    foundNeighbor=1;
-	    break;
-	}
-	if( Abc_ObjFanoutNum( pNeighbor ) )
-	{   
-	    pNet=Abc_ObjFanout0( pNeighbor );
-	    if( !Abc_NtkIsComb(pNtk) && Abc_ObjIsLatch(pNet) )
-		pNet=Abc_ObjFanout0( Abc_ObjFanout0(pNet) );
-	    Abc_ObjForEachFanout( pNet, pNode, i )
-		if( !Abc_NodeIsTravIdCurrent(pNode) ) 
-		    Vec_PtrPush( vNeighbors, pNode ); 
-	}
-	if( Abc_ObjFaninNum( pNeighbor ) )
-	{
-	    if( !Abc_NtkIsComb(pNtk) && Abc_ObjIsLatch(Abc_ObjFanin0(pNeighbor)) )
-		pNeighbor=Abc_ObjFanin0( Abc_ObjFanin0(pNeighbor) );
-	    Abc_ObjForEachFanin( pNeighbor, pNet, i )
-		if( !Abc_NodeIsTravIdCurrent(pNode=Abc_ObjFanin0(pNet)) ) 
-		    Vec_PtrPush( vNeighbors, pNode );
-	}
-    }
-    return ( foundNeighbor ) ? pNeighbor : pTerm;
-} 
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is nand2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsNand2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-	return ( !strcmp(((char *)pNode->pData), "-0 1\n0- 1\n") || 
-		 !strcmp(((char *)pNode->pData), "0- 1\n-0 1\n") || 
-		 !strcmp(((char *)pNode->pData), "11 0\n") );
-    if ( Abc_NtkHasMapping(pNtk) )
-        return pNode->pData == (void *)Mio_LibraryReadNand2((Mio_Library_t *)Abc_FrameReadLibGen());
-    assert( 0 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is nand2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsNor2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-        return ( !strcmp(((char *)pNode->pData), "00 1\n") );
-    assert( 0 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is and2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsAnd2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-	return Abc_SopIsAndType(((char *)pNode->pData));
-    if ( Abc_NtkHasMapping(pNtk) )
-        return pNode->pData == (void *)Mio_LibraryReadAnd2((Mio_Library_t *)Abc_FrameReadLibGen());
-    assert( 0 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is or2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsOr2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-	return ( Abc_SopIsOrType(((char *)pNode->pData))   || 
-		 !strcmp(((char *)pNode->pData), "01 0\n") ||
-		 !strcmp(((char *)pNode->pData), "10 0\n") ||
-		 !strcmp(((char *)pNode->pData), "00 0\n") );
-		 //off-sets, too
-    assert( 0 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is xor2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsXor2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-	return ( !strcmp(((char *)pNode->pData), "01 1\n10 1\n") || !strcmp(((char *)pNode->pData), "10 1\n01 1\n")  );
-    assert( 0 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Test is the node is xnor2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Abc_NodeIsXnor2( Abc_Obj_t * pNode )
-{
-    Abc_Ntk_t * pNtk = pNode->pNtk;
-    assert( Abc_NtkIsNetlist(pNtk) );
-    assert( Abc_ObjIsNode(pNode) ); 
-    if ( Abc_ObjFaninNum(pNode) != 2 )
-        return 0;
-    if ( Abc_NtkHasSop(pNtk) )
-	return ( !strcmp(((char *)pNode->pData), "11 1\n00 1\n") || !strcmp(((char *)pNode->pData), "00 1\n11 1\n") );
-    assert( 0 );
-    return 0;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-