├── statement
    ├── boyd.png
    └── p1-circuit.pdf
├── Makefile
├── benchmarks
    ├── scriptSynth.bash
    └── comb
    │   ├── b1.bdnet
    │   ├── b9.bdnet
    │   ├── 9symml.bdnet
    │   ├── alu2.bdnet
    │   └── apex6.bdnet
├── src
    ├── net.cpp
    ├── net.h
    ├── cellLibrary.h
    ├── io.h
    ├── mosek.h
    ├── cellLibrary.cpp
    ├── posynomial.h
    ├── gateSizing.cpp
    ├── cell.h
    ├── gateSizer.h
    ├── posynomial.cpp
    ├── mosek.cpp
    ├── cell.cpp
    ├── io.cpp
    └── gateSizer.cpp
└── README.md


/statement/boyd.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lrakai/gate-sizing/HEAD/statement/boyd.png


--------------------------------------------------------------------------------
/statement/p1-circuit.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/lrakai/gate-sizing/HEAD/statement/p1-circuit.pdf


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CXXFLAGS =	-O0 -g -Wall -fmessage-length=0
 2 | 
 3 | SRCDIR = src
 4 | OBJDIR = obj
 5 | 
 6 | CPPS = $(wildcard $(SRCDIR)/*.cpp)
 7 | OBJS = $(addprefix $(OBJDIR)/,$(notdir $(CPPS:.cpp=.o)))
 8 | 
 9 | 
10 | TARGET   = gateSizing
11 | 
12 | 
13 | $(OBJDIR)/%.o: $(SRCDIR)/%.cpp
14 | 	$(CXX) -c $(CXXFLAGS) $< -o $@
15 | 
16 | $(TARGET):	$(OBJS)
17 | 	$(CXX) -o $@ $^
18 | 
19 | $(OBJS): | $(OBJDIR)
20 | 
21 | $(OBJDIR):
22 | 	mkdir -p $(OBJDIR)
23 | 
24 | all:	$(TARGET)
25 | 
26 | clean:
27 | 	rm -f $(OBJS) $(TARGET)
28 | 


--------------------------------------------------------------------------------
/benchmarks/scriptSynth.bash:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | blifDir=$HOME/tools/mvsis/mvsis-1.3/examples/ex/comb/mcnc91/mlex
 4 | genlibDir=$HOME/tools/sis/sis-1.3.6/sis/sis_lib
 5 | genlibScript=script.myMcnc
 6 | 
 7 | for bench in `ls ${blifDir}/*\.blif`; do
 8 | 	bench=`echo ${bench} | sed 's%.*/\(.*\)\.blif%\1%g'`
 9 | 	benchDir=comb	
10 | 	
11 | 	echo "read_blif ${blifDir}/${bench}.blif
12 | 	      source ${genlibDir}/${genlibScript}
13 | 	      write_bdnet ${benchDir}/${bench}.bdnet
14 | 	      quit" | sis >> synth.log
15 | done
16 | 


--------------------------------------------------------------------------------
/src/net.cpp:
--------------------------------------------------------------------------------
 1 | #include "net.h"
 2 | #include <iostream>
 3 | #include "cell.h"
 4 | 
 5 | gateSizing::net::~net()
 6 | {
 7 | }
 8 | 
 9 | void gateSizing::net::print() const
10 | {	
11 | 	std::cout << "Net name: " << m_name << std::endl;
12 | 	std::cout << "Driver: " << m_driver->identifier() << ':' << m_driver->cellTypeString() << std::endl;
13 | 	std::cout << "Loads: ";
14 | 	for(std::vector<gateSizing::cell*>::const_iterator vIt = m_loads.begin(); vIt != m_loads.end(); vIt++)
15 | 		std::cout << (*vIt)->identifier() << ':' << (*vIt)->cellTypeString() << ' ';
16 | 	std::cout << std::endl;
17 | }


--------------------------------------------------------------------------------
/benchmarks/comb/b1.bdnet:
--------------------------------------------------------------------------------
 1 | MODEL "b1";
 2 | 
 3 | INPUT
 4 | 	"a"	:	"a"
 5 | 	"b"	:	"b"
 6 | 	"c"	:	"c";
 7 | 
 8 | OUTPUT
 9 | 	"d"	:	"c"
10 | 	"e"	:	"[259]"
11 | 	"f"	:	"[2]"
12 | 	"g"	:	"[3]";
13 | 
14 | INSTANCE "inv":"physical"
15 | 	"a"	:	"a";
16 | 	"O"	:	"[274]";
17 | 
18 | INSTANCE "inv":"physical"
19 | 	"a"	:	"b";
20 | 	"O"	:	"[275]";
21 | 
22 | INSTANCE "oai22":"physical"
23 | 	"a"	:	"b";
24 | 	"b"	:	"[274]";
25 | 	"c"	:	"a";
26 | 	"d"	:	"[275]";
27 | 	"O"	:	"[259]";
28 | 
29 | INSTANCE "inv":"physical"
30 | 	"a"	:	"c";
31 | 	"O"	:	"[3]";
32 | 
33 | INSTANCE "aoi22":"physical"
34 | 	"a"	:	"[3]";
35 | 	"b"	:	"b";
36 | 	"c"	:	"[274]";
37 | 	"d"	:	"c";
38 | 	"O"	:	"[254]";
39 | 
40 | INSTANCE "nor2":"physical"
41 | 	"a"	:	"[254]";
42 | 	"b"	:	"[259]";
43 | 	"O"	:	"[2]";
44 | 
45 | ENDMODEL;
46 | 


--------------------------------------------------------------------------------
/src/net.h:
--------------------------------------------------------------------------------
 1 | // class net retains driver, loads, and name information about nets in the design
 2 | 
 3 | #ifndef NET_H_
 4 | #define NET_H_
 5 | 
 6 | #include <vector>
 7 | #include <string>
 8 | 
 9 | namespace gateSizing {
10 | 
11 | class cell;
12 | 
13 | class net
14 | {
15 | public:
16 | 	net()
17 | 	:m_driver(NULL)
18 | 	{	
19 | 		m_loads.reserve(10);	
20 | 	}
21 | 
22 | 	net(std::string& n, cell* d)
23 | 	:m_name(n), m_driver(d)
24 | 	{	
25 | 		m_loads.reserve(10);	
26 | 	}
27 | 	
28 | 	virtual ~net();
29 | 	
30 | 	inline void assignDriver(cell* d)
31 | 	{	
32 | 		m_driver = d;
33 | 	}
34 | 	
35 | 	inline void addLoad(cell* l)
36 | 	{	
37 | 		m_loads.push_back(l);
38 | 	}
39 | 	
40 | 	inline cell* driver() const
41 | 	{	
42 | 		return m_driver;
43 | 	}
44 | 	
45 | 	inline const std::vector<cell*>& loads() const
46 | 	{	
47 | 		return m_loads;
48 | 	}
49 | 	
50 | 	void print() const;
51 | 	
52 | 	inline const std::string name() const
53 | 	{	
54 | 		return m_name;
55 | 	}
56 | 	
57 | private:
58 | 	std::string m_name;
59 | 	cell* m_driver;
60 | 	std::vector<cell*> m_loads;
61 | };
62 | 
63 | }
64 | 
65 | #endif /*NET_H_*/
66 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # gate-sizing
 2 | Optimal gate sizing of digital circuits using geometric programming.
 3 | 
 4 | A C++ program that reads circuit netlists and formulates a geometric program for optimizing gate sizes in terms of power, delay, and area.
 5 | Posynomial and monomial classes are used for the constructing geometric programs and may be useful in other problem domains.
 6 | In the default configuration it sweeps a range of constraint bounds to generate a trade-off curves as shown in [Sample Results](#sample-results).
 7 | 
 8 | This code was featured in the [2012 ICCAD Cadathlon competition](http://www.sigda.org/programs/cadathlon/problems2012).
 9 | 
10 | # Dependencies
11 | Depends upon `gnuplot` for plots, and [Mosek](https://www.mosek.com/)'s exponential optimization solver `mskexpopt` for solving the geometric programs.
12 | 
13 | # Usage
14 | `./gateSizing benchmarks/circuit.bdnet`
15 | 
16 | # Sample Results
17 | ![Sample results](statement/boyd.png)
18 | 
19 | # Acknowledgements
20 | Based upon the gate sizing geometric programming formulation in Boyd's [A Tutorial on Geometric Programming](http://stanford.edu/~boyd/papers/gp_tutorial.html). 
21 | 


--------------------------------------------------------------------------------
/src/cellLibrary.h:
--------------------------------------------------------------------------------
 1 | // class cellLibary stores parameters related to each cellType including
 2 | // area (a), intrinsic capacitance (alpha), per unit capacitance (beta), driving 
 3 | // resistance factor (gamma), transition energy (e), transition frequency (f)
 4 | 
 5 | #ifndef CELLLIBRARY_H_
 6 | #define CELLLIBRARY_H_
 7 | 
 8 | #include <vector>
 9 | #include "cell.h"
10 | 
11 | namespace gateSizing {
12 | 
13 | class cellLibrary
14 | {	
15 | public:
16 | 	cellLibrary()
17 | 	{	
18 | 		populateElements();
19 | 	}
20 | 	
21 | 	// libraryElement contains all the parameters for a cell
22 | 	struct libraryElement
23 | 	{	
24 | 		libraryElement(double a, double alpha, double beta, double gamma, double e, double f)
25 | 		:a(a), alpha(alpha), beta(beta), gamma(gamma), e(e), f(f)
26 | 		{}
27 | 		
28 | 		double a, alpha, beta, gamma, e, f;
29 | 	};
30 | 	
31 | 	const libraryElement& operator[](const cellTypes& c) const
32 | 	{	
33 | 		return m_elements[c];
34 | 	}
35 | 	
36 | private:	
37 | 	// populate elements with hard-coded values for each cell type
38 | 	void populateElements();
39 | 	std::vector<libraryElement> m_elements;
40 | };
41 | 
42 | }
43 | 
44 | #endif /*CELLLIBRARY_H_*/
45 | 


--------------------------------------------------------------------------------
/src/io.h:
--------------------------------------------------------------------------------
 1 | // Functions used in the process of communicating via files
 2 | 
 3 | #ifndef IO_H_
 4 | #define IO_H_
 5 | 
 6 | #include <string>
 7 | #include <map>
 8 | #include "cell.h"
 9 | 
10 | namespace gateSizing {
11 | 	class gateSizer;
12 | }
13 | class vector;
14 | 
15 | namespace IO {
16 | 
17 | 	// read in the file specified by bdnetFile and populate the given gateSizer net and cell information
18 | 	void constructNetlist(gateSizing::gateSizer& gs, const std::string& bdnetFile);
19 | 	// populate the map with hard-coded (string, cellType) key-value pairs
20 | 	void prepareCellTypeMap(std::map<const std::string, gateSizing::cellTypes>& cellTypeMap);
21 | 	void extractPinTypeAndNetName(const std::string& line, std::string& pinType, std::string& netName);
22 | 	void extractInstanceType(const std::string& line, std::string& instanceType);
23 | 	// populate net driver/load and cell output/input
24 | 	void fillInNetAndCell(gateSizing::net* n, gateSizing::cell* c, bool isOutput);
25 | 	
26 | 	inline void removeQuotes(std::string& str)
27 | 	{	
28 | 		str = str.substr(1, str.find_last_of('\"') - 1);
29 | 	}
30 | 	
31 | 	void plotResults(std::string problemName, const std::vector<double>& areaFactors);
32 | 
33 | }
34 | #endif /*IO_H_*/
35 | 


--------------------------------------------------------------------------------
/src/mosek.h:
--------------------------------------------------------------------------------
 1 | // class to abstract away interfacing with mosek 
 2 | 
 3 | #ifndef MOSEK_H_
 4 | #define MOSEK_H_
 5 | 
 6 | #include <vector>
 7 | #include <map>
 8 | #include <string>
 9 | 
10 | namespace gateSizing {
11 | 
12 | class mosek
13 | {
14 | public:
15 | 	mosek()
16 | 	:m_objective(-1), m_currentVar(0)
17 | 	{}
18 | 
19 | 	struct sparseTerm
20 | 	{	
21 | 		sparseTerm(unsigned int t, unsigned int v, int e)
22 | 		:term(t), variable(v), exponent(e)
23 | 		{}
24 | 	
25 | 		unsigned int term;
26 | 		unsigned int variable;
27 | 		int exponent;
28 | 	};
29 | 	
30 | 	inline void addTerm(unsigned int t, unsigned int v, int e)
31 | 	{	
32 | 		if(m_id2Var.find(v) == m_id2Var.end()) // not found
33 | 			m_id2Var[v] = m_currentVar++;
34 | 		m_constraintMatrix.push_back(sparseTerm(t, m_id2Var[v], e));
35 | 	}
36 | 
37 | 	inline void addCoefficient(double c)
38 | 	{	
39 | 		m_coefficients.push_back(c);
40 | 	}
41 | 	
42 | 	inline void addAssociation(double c)
43 | 	{	
44 | 		m_associations.push_back(c);
45 | 	}
46 | 	
47 | 	void solve(const std::string& problemName);
48 | 	void writeProblem(std::string problemName) const;
49 | 	void readSolution(std::string problemName);
50 | 	
51 | 	double value(unsigned int id)
52 | 	{	
53 | 		return m_primalVariables[m_id2Var[id]];
54 | 	}
55 | 	double objective() const
56 | 	{	
57 | 		return m_objective;
58 | 	}
59 | 	
60 | private:
61 | 	std::vector<double> m_coefficients;
62 | 	std::vector<unsigned int> m_associations;
63 | 	std::vector<sparseTerm> m_constraintMatrix;
64 | 	std::vector<double> m_primalVariables;
65 | 	// mosek variables must start from 0 and be contiguous this map
66 | 	// goes between the external identifiers and internal variables
67 | 	std::map<unsigned int, unsigned int> m_id2Var;
68 | 	double m_objective;
69 | 	unsigned int m_currentVar;
70 | };
71 | 
72 | }
73 | 
74 | #endif /*MOSEK_H_*/
75 | 


--------------------------------------------------------------------------------
/src/cellLibrary.cpp:
--------------------------------------------------------------------------------
 1 | #include "cellLibrary.h"
 2 | 
 3 | void gateSizing::cellLibrary::populateElements()
 4 | {	
 5 | 	m_elements.resize(17, gateSizing::cellLibrary::libraryElement(-1, -1, -1, -1, -1, -1));
 6 | 	m_elements[gateSizing::PRIMARYIN] = gateSizing::cellLibrary::libraryElement(0, 10, 0, 0, 0, 0);
 7 | 	m_elements[gateSizing::PRIMARYOUT] = gateSizing::cellLibrary::libraryElement(0, 10, 0, 0, 0, 0);
 8 | 	m_elements[gateSizing::INV] = gateSizing::cellLibrary::libraryElement(1, 1, 1, 1, 1, 1);
 9 | 	m_elements[gateSizing::NAND2] = gateSizing::cellLibrary::libraryElement(2, 1, 1, 1, 2, 0.7);
10 | 	m_elements[gateSizing::NAND3] = gateSizing::cellLibrary::libraryElement(3, 1, 1, 1, 3, 0.55);
11 | 	m_elements[gateSizing::NAND4] = gateSizing::cellLibrary::libraryElement(4, 1, 1, 1, 4, 0.4);
12 | 	m_elements[gateSizing::NOR2] = gateSizing::cellLibrary::libraryElement(2, 1, 1, 1, 2, 0.7);
13 | 	m_elements[gateSizing::NOR3] = gateSizing::cellLibrary::libraryElement(3, 1, 1, 1, 3, 0.55);
14 | 	m_elements[gateSizing::NOR4] = gateSizing::cellLibrary::libraryElement(4, 1, 1, 1, 4, 0.4);
15 | 	m_elements[gateSizing::AND2] = gateSizing::cellLibrary::libraryElement(2, 1, 1, 1, 2, 0.7);
16 | 	m_elements[gateSizing::OR2] = gateSizing::cellLibrary::libraryElement(2, 1, 1, 1, 2, 0.7);
17 | 	m_elements[gateSizing::XOR] = gateSizing::cellLibrary::libraryElement(8, 1, 1, 1, 8, 0.5);
18 | 	m_elements[gateSizing::XNOR] = gateSizing::cellLibrary::libraryElement(8, 1, 1, 1, 8, 0.5);
19 | 	m_elements[gateSizing::AOI21] = gateSizing::cellLibrary::libraryElement(6, 1, 1, 1, 6, 0.6);
20 | 	m_elements[gateSizing::AOI22] = gateSizing::cellLibrary::libraryElement(8, 1, 1, 1, 8, 0.55);
21 | 	m_elements[gateSizing::OAI21] = gateSizing::cellLibrary::libraryElement(6, 1, 1, 1, 6, 0.6);
22 | 	m_elements[gateSizing::OAI22] = gateSizing::cellLibrary::libraryElement(8, 1, 1, 1, 8, 0.55);
23 | }


--------------------------------------------------------------------------------
/src/posynomial.h:
--------------------------------------------------------------------------------
 1 | // class monomial is a coefficient and a (cell id, exponent) map
 2 | // class posynomial is a vector of monomials, 
 3 | 
 4 | #ifndef POSYNOMIAL_H_
 5 | #define POSYNOMIAL_H_
 6 | 
 7 | #include <vector>
 8 | #include <map>
 9 | 
10 | namespace gateSizing {
11 | 
12 | class posynomial;
13 | 
14 | class monomial
15 | {
16 | public:
17 | 	monomial()
18 | 	:m_coefficient(0)
19 | 	{}
20 | 
21 | 	monomial(double c)
22 | 	:m_coefficient(c)
23 | 	{}
24 | 
25 | 	monomial(double c, unsigned int index, int e)
26 | 	:m_coefficient(c)
27 | 	{
28 | 		m_exponents[index] = e;
29 | 	}
30 | 	
31 | 	bool sameVariables(const monomial& m);
32 | 	
33 | 	inline double coefficient() const
34 | 	{	
35 | 		return m_coefficient;
36 | 	}
37 | 	
38 | 	inline void incrementCoefficient(const double c)
39 | 	{	
40 | 		m_coefficient += c;		
41 | 	}
42 | 
43 | 	posynomial operator+(const monomial& m);
44 | 	monomial& operator*=(const monomial& m);
45 | 	
46 | 	inline const std::map<unsigned int, int>& exponents() const
47 | 	{	
48 | 		return m_exponents;
49 | 	}
50 | 	
51 | 	void print() const;
52 | 	
53 | private:
54 | 	double m_coefficient;
55 | 	std::map<unsigned int, int> m_exponents;
56 | };
57 | 
58 | class posynomial
59 | {
60 | public:
61 | 	posynomial()
62 | 	{	
63 | 		m_monomials.reserve(10);
64 | 	}
65 | 	
66 | 	inline void addMonomial(const monomial& m)
67 | 	{	
68 | 		m_monomials.push_back(m);
69 | 	}
70 | 
71 | 	inline void addMonomial(monomial& m)
72 | 	{	
73 | 		m_monomials.push_back(m);
74 | 	}
75 | 
76 | 	inline const std::vector<monomial>& monomials() const
77 | 	{	
78 | 		return m_monomials;
79 | 	}
80 | 	
81 | 	posynomial& operator+=(const monomial& m);
82 | 	posynomial& operator*=(const monomial& m);
83 | 	posynomial& operator+=(const posynomial& p);
84 | 	
85 | 	inline bool isEmpty() const
86 | 	{	
87 | 		return m_monomials.size()==0;
88 | 	}
89 | 	
90 | 	void print() const;
91 | 	
92 | private:
93 | 	std::vector<monomial> m_monomials;
94 | };
95 | 
96 | }
97 | 
98 | #endif /*POSYNOMIAL_H_*/
99 | 


--------------------------------------------------------------------------------
/src/gateSizing.cpp:
--------------------------------------------------------------------------------
 1 | // Main function to test the gateSizer class
 2 | // Basic command line argument checking is performed
 3 | 
 4 | #include <iostream>
 5 | #include <string>
 6 | #include <cstdlib>
 7 | #include <fstream>
 8 | #include <vector>
 9 | #include "gateSizer.h"
10 | #include "io.h"
11 | 
12 | int reportUsage(const char** argv)
13 | {	
14 | 	std::cerr << "  Usage: " << argv[0] << " problemName" << std::endl;
15 | 	std::cerr << "Example: " << argv[0] << " benchmarks/comb/b1" << std::endl;
16 | 	return EXIT_FAILURE;
17 | }
18 | 
19 | int main(int argc, const char** argv)
20 | {	
21 | 	if(argc != 2)
22 | 		return reportUsage(argv);
23 | 
24 | 	const std::string problemName(argv[1]);
25 | 	// test if file can be opened
26 | 	std::ifstream bdnetStream((problemName + ".bdnet").c_str());
27 | 	if(bdnetStream)
28 | 	{	
29 | 		bdnetStream.close();
30 | 		
31 | 		// an areaFactor sets Amax = areaFactor * Amin
32 | 		// where Amin is obtained when all gates have unit scaling
33 | 		std::vector<double> areaFactors;
34 | 		const double areaFactorIncrement = 0.5;
35 | 		const double areaFactorMax = 3.; 
36 | 		for(double areaFactor = 1.5; areaFactor < areaFactorMax; areaFactor += areaFactorIncrement)
37 | 			areaFactors.push_back(areaFactor);
38 | 
39 | 		// a powerFactor sets Pmax = powerFactor * Pmin
40 | 		std::vector<double> powerFactors;
41 | 		const double powerFactorIncrement = 0.1;
42 | 		const double powerFactorMax = 3.5;
43 | 		for(double powerFactor = 1.0; powerFactor < powerFactorMax; powerFactor += powerFactorIncrement)
44 | 			powerFactors.push_back(powerFactor);
45 | 		
46 | 		for(unsigned int a = 0; a < areaFactors.size(); a++)
47 | 		{	
48 | 			for(unsigned int p = 0; p < powerFactors.size(); p++)
49 | 			{	
50 | 				gateSizing::gateSizer sizingProblem(problemName, powerFactors[p], areaFactors[a]);
51 | 				sizingProblem.reportResults(problemName, p, powerFactors[p], areaFactors[a]);
52 | 			}
53 | 		}
54 | 		IO::plotResults(problemName, areaFactors);
55 | 		return EXIT_SUCCESS;
56 | 	}
57 | 	else
58 | 		return reportUsage(argv);
59 | }
60 | 


--------------------------------------------------------------------------------
/src/cell.h:
--------------------------------------------------------------------------------
 1 | // class cell stores various information relating to cells/instances in the design 
 2 | // including inputs, output, and scale factor for the gate sizing problem formulation
 3 | 
 4 | #ifndef CELL_H_
 5 | #define CELL_H_
 6 | 
 7 | #include <vector>
 8 | #include "posynomial.h"
 9 | 
10 | namespace gateSizing {
11 | 
12 | class net;
13 | class cellLibrary;
14 | 
15 | enum cellTypes { PRIMARYIN, PRIMARYOUT, INV, NAND2, NAND3, NAND4, NOR2, NOR3,  
16 | 	             NOR4, AND2, OR2, XOR, XNOR, AOI21, AOI22, OAI21, OAI22 };
17 | 
18 | class cell
19 | {
20 | public:
21 | 	cell(const cellTypes cellType, const unsigned int identifier);
22 | 	virtual ~cell();
23 | 	
24 | 	inline void assignOutput(net* outputNet)
25 | 	{	
26 | 		m_output = outputNet;
27 | 	}
28 | 
29 | 	inline void addInput(net* inputNet)
30 | 	{	
31 | 		m_inputs.push_back(inputNet);
32 | 	}
33 | 
34 | 	inline void assignScaleFactor(double s)
35 | 	{	
36 | 		m_scaleFactor = s;
37 | 	}
38 | 
39 | 	void populateDescendants();
40 | 	void populateAncestors();
41 | 	void populateDelay(const cellLibrary& cellLib);
42 | 	
43 | 	void print() const;
44 | 	const char* cellTypeString() const;
45 | 	inline unsigned int identifier() const
46 | 	{ 
47 | 		return m_id;
48 | 	}
49 | 
50 | 	inline enum cellTypes type() const
51 | 	{ 
52 | 		return m_type;
53 | 	}
54 | 
55 | 	inline const posynomial& delay() const
56 | 	{	
57 | 		return m_delay;
58 | 	}
59 | 	
60 | 	inline const std::vector<unsigned int>& ancestors() const
61 | 	{	
62 | 		return m_ancestors;
63 | 	}
64 | 
65 | 	inline const std::vector<cell*>& descendants() const
66 | 	{	
67 | 		return m_descendants;
68 | 	}
69 | 
70 | 	inline double scaleFactor() const
71 | 	{	
72 | 		return m_scaleFactor;
73 | 	}
74 | 	
75 | private:
76 | 	const enum cellTypes m_type;
77 | 	const unsigned int m_id;
78 | 	double m_scaleFactor;
79 | 	posynomial m_delay;
80 | 	net* m_output;
81 | 	std::vector<net*> m_inputs;
82 | 	// first level upstream neighbor cell ids
83 | 	std::vector<unsigned int> m_ancestors;
84 | 	// first level downstream neighbor cell ids
85 | 	std::vector<cell*> m_descendants;
86 | };
87 | 
88 | }
89 | 
90 | #endif /*CELL_H_*/
91 | 


--------------------------------------------------------------------------------
/src/gateSizer.h:
--------------------------------------------------------------------------------
 1 | // class gateSizer is the main class for solving a gate sizing problem
 2 | 
 3 | #ifndef GATESIZER_H_
 4 | #define GATESIZER_H_
 5 | 
 6 | #include <vector>
 7 | #include <string>
 8 | #include <set>
 9 | #include "net.h"
10 | #include "cell.h"
11 | #include "cellLibrary.h"
12 | #include "mosek.h"
13 | 
14 | namespace gateSizing {
15 | 
16 | class posynomial;
17 | class monomial;
18 | 
19 | class gateSizer
20 | {
21 | public:
22 | 	// problem is read in, formulation is written, formulation is solved, 
23 | 	// solution is read in the constructor 
24 | 	// powerFactor and areaFactor are numbers >= 1.0 and scale their
25 | 	// respective limit away from the minimum
26 | 	// i.e. Pmax = powerFactor * Pmin; 
27 | 	gateSizer(const std::string& problemName, double powerFactor = 2.0, double areaFactor = 2.0);
28 | 	virtual ~gateSizer();
29 | 	
30 | 	cell* addCell(cellTypes cellType);
31 | 	net* addNet(std::string& name, cell* driver);
32 | 	
33 | 	double evaluatePower() const;
34 | 	double evaluateArea() const;
35 | 	void reportResults(std::string resultFile, bool append, double powerFactor = 2.0, double areaFactor = 2.0) const;
36 | 	void plotResults(std::string problemName, const std::vector<double>& areaFactors);
37 | 	void printNetList() const;
38 | 	
39 | private:
40 | 	void populateDescendants();
41 | 	void populateAncestors();
42 | 	void populateDelays();
43 | 	void populateFormulation(double powerFactor, double areaFactor);
44 | 	void populateScaleFactors();
45 | 	
46 | 	// add the given monomial to the formulation
47 | 	void writeMonomialTerms(const monomial& p, unsigned int& term, unsigned int constraint);
48 | 	// add the given posynomial to the formulation
49 | 	void writePosynomialTerms(const posynomial& p, unsigned int& term, unsigned int constraint);
50 | 	// determine if the given cell is a descendant of a primaryInput or an internal cell
51 | 	// the identifier of the cell is added to the appropriate set
52 | 	// if the cell is a primaryInput or primaryOutput it does nothing
53 | 	void internalOrPIDescendant(const cell* c, std::set<unsigned int>& internals, std::set<unsigned int>& inputDescendants);
54 | 	// fill the ancestor set with ancestors of c that are not primaryInputs
55 | 	void nonPIAncestors(const cell* c, std::set<unsigned int>& ancestors);
56 | 	// of the cells whose identifiers are in ancestors, remove all
57 | 	// but the ones that exclusively drive primaryOutputs
58 | 	void exclusivePODescendants(std::set<unsigned int>& ancestors);
59 | 
60 | 	// all cells (primaryInputs, primaryOutputs, and internal gates)
61 | 	std::vector<cell*> m_cells;
62 | 	std::vector<net*> m_nets;
63 | 	// primary inputs and outputs are stored for convenience 
64 | 	// (they are duplicated in the m_cells member) 
65 | 	std::vector<cell*> m_primaryInputs;
66 | 	std::vector<cell*> m_primaryOutputs;
67 | 	// cellLibrary stores parameters for each cellType
68 | 	cellLibrary cellLib;
69 | 	mosek formulation;
70 | };
71 | 
72 | }
73 | 
74 | #endif /*GATESIZER_H_*/
75 | 


--------------------------------------------------------------------------------
/src/posynomial.cpp:
--------------------------------------------------------------------------------
  1 | #include "posynomial.h"
  2 | #include <vector>
  3 | #include <map>
  4 | #include <iostream>
  5 | 
  6 | bool gateSizing::monomial::sameVariables(const gateSizing::monomial& m)
  7 | {	
  8 | 	bool sameVariables = true;
  9 | 	if(m.m_exponents.size() != m_exponents.size())
 10 | 	{	
 11 | 		sameVariables = false;
 12 | 	}
 13 | 	else
 14 | 	{	
 15 | 		for(std::map<unsigned int, int>::const_iterator mIt = m.m_exponents.begin(); mIt != m.m_exponents.end(); mIt++)
 16 | 		{	
 17 | 			std::map<unsigned int, int>::const_iterator eIt = m_exponents.find(((*mIt).first));
 18 | 			if(eIt == m_exponents.end() || (*eIt).second != (*mIt).second)
 19 | 			{ 	
 20 | 				sameVariables = false;
 21 | 				break;
 22 | 			}
 23 | 		}		
 24 | 	}	
 25 | 	return sameVariables;
 26 | }
 27 | 
 28 | gateSizing::posynomial gateSizing::monomial::operator+(const gateSizing::monomial& m)
 29 | {	
 30 | 	gateSizing::posynomial p;
 31 | 	// check if same terms exist in both cases
 32 | 	bool isSame = sameVariables(m);
 33 | 	
 34 | 	if(isSame)
 35 | 	{	
 36 | 		m_coefficient += m.m_coefficient;	
 37 | 		p.addMonomial(*this);
 38 | 	}
 39 | 	else
 40 | 	{	
 41 | 		p.addMonomial(*this);
 42 | 		p.addMonomial(m);
 43 | 	}
 44 | 	return p;
 45 | }
 46 | 
 47 | gateSizing::monomial& gateSizing::monomial::operator*=(const gateSizing::monomial& m)
 48 | {	
 49 | 	m_coefficient *= m.m_coefficient;
 50 | 	for(std::map<unsigned int, int>::const_iterator mIt = m.m_exponents.begin(); mIt != m.m_exponents.end(); mIt++)
 51 | 	{	
 52 | 		if(m_exponents.find(((*mIt).first)) == m_exponents.end())
 53 | 		{ 	
 54 | 			m_exponents[(*mIt).first] = (*mIt).second;
 55 | 		}
 56 | 		else
 57 | 		{	
 58 | 			m_exponents[(*mIt).first] += (*mIt).second;
 59 | 		}
 60 | 	}
 61 | 	return *this;
 62 | }
 63 | 
 64 | void gateSizing::monomial::print() const
 65 | {	
 66 | 	std::cout << m_coefficient;
 67 | 	if(m_exponents.size())
 68 | 	{	
 69 | 		for(std::map<unsigned int, int>::const_iterator mIt = m_exponents.begin(); mIt != m_exponents.end(); mIt++)
 70 | 		{	
 71 | 			std::cout << "*(x"<< (*mIt).first << ")^" << (*mIt).second;
 72 | 		}
 73 | 	}
 74 | }
 75 | 
 76 | gateSizing::posynomial& gateSizing::posynomial::operator+=(const monomial& m)
 77 | {	
 78 | 	bool isSame = false;
 79 | 	for(std::vector<gateSizing::monomial>::iterator vIt = m_monomials.begin(); vIt != m_monomials.end(); vIt++)
 80 | 	{	
 81 | 		isSame = (*vIt).sameVariables(m);
 82 | 		if(isSame)
 83 | 		{	
 84 | 			(*vIt).incrementCoefficient(m.coefficient());
 85 | 			break;
 86 | 		}
 87 | 	}
 88 | 	if(!isSame)
 89 | 	{	
 90 | 		addMonomial(m);
 91 | 	}
 92 | 	return *this;
 93 | }
 94 | 
 95 | gateSizing::posynomial& gateSizing::posynomial::operator*=(const gateSizing::monomial& m)
 96 | {	for(std::vector<gateSizing::monomial>::iterator vIt = m_monomials.begin(); vIt != m_monomials.end(); vIt++)
 97 | 	{	
 98 | 		(*vIt) *= m;		
 99 | 	}
100 | 	return *this;
101 | }
102 | 
103 | gateSizing::posynomial& gateSizing::posynomial::operator+=(const gateSizing::posynomial& p)
104 | {	
105 | 	for(std::vector<gateSizing::monomial>::const_iterator vIt = p.m_monomials.begin(); vIt != p.m_monomials.end(); vIt++)
106 | 	{	
107 | 		*this += (*vIt);		
108 | 	}
109 | 	return *this;
110 | }
111 | 
112 | void gateSizing::posynomial::print() const
113 | {	
114 | 	if(m_monomials.size())
115 | 	{	
116 | 		std::vector<gateSizing::monomial>::const_iterator end = m_monomials.end();
117 | 		--end;
118 | 		for(std::vector<gateSizing::monomial>::const_iterator vIt = m_monomials.begin(); vIt != end; vIt++)
119 | 		{	
120 | 			(*vIt).print();
121 | 			std::cout << " + ";
122 | 		}
123 | 		(*end).print();
124 | 		std::cout << std::endl;
125 | 	}
126 | }


--------------------------------------------------------------------------------
/src/mosek.cpp:
--------------------------------------------------------------------------------
  1 | #include "mosek.h"
  2 | #include <string>
  3 | #include <cstdlib>
  4 | #include <cmath>
  5 | #include <limits>
  6 | #include <fstream>
  7 | #include <iostream>
  8 | #include <sstream>
  9 | 
 10 | void gateSizing::mosek::solve(const std::string& problemName)
 11 | {	
 12 | 	writeProblem(problemName);
 13 | 	std::string command = "mskexpopt ";
 14 | 	command += problemName + ".eo";
 15 | 	int returnValue = system(command.c_str());
 16 | 	if(returnValue)
 17 | 	{	
 18 | 		std::cerr << "Call to mskexpopt returned an error. (" << returnValue << ")" << std::endl;
 19 | 		exit(EXIT_FAILURE);
 20 | 	}
 21 | 	readSolution(problemName);
 22 | }
 23 | 
 24 | void gateSizing::mosek::writeProblem(std::string problemName) const
 25 | {	
 26 | 	problemName+=".eo";
 27 | 	std::ofstream problemFile(problemName.c_str());
 28 | 	if(!problemFile)
 29 | 	{	
 30 | 		std::cerr << problemName << " at " << __LINE__ << " could not be opened for output.\n";
 31 | 		exit(EXIT_FAILURE);
 32 | 	}
 33 | 	
 34 | 	problemFile.precision(std::numeric_limits<double>::digits10);
 35 | 	problemFile << m_associations[m_associations.size() - 1] + 1 << " * numConstraints" << std::endl;
 36 | 	problemFile << m_id2Var.size() << " * numVariables" << std::endl;
 37 | 	problemFile << m_coefficients.size() << " * numTerms" << std::endl;
 38 | 	problemFile << "* Coefficients of terms" << std::endl;
 39 | 	for(std::vector<double>::const_iterator vIt = m_coefficients.begin(); vIt != m_coefficients.end(); vIt++)
 40 | 		problemFile << *vIt << std::endl;
 41 | 	problemFile << "* Constraints each term belongs to" << std::endl;
 42 | 	for(std::vector<unsigned int>::const_iterator vIt = m_associations.begin(); vIt != m_associations.end(); vIt++)
 43 | 		problemFile << *vIt << std::endl;
 44 | 	problemFile << "* Section defining a_kj\n* Format: term var exp" << std::endl;
 45 | 	for(std::vector<sparseTerm>::const_iterator vIt = m_constraintMatrix.begin(); vIt != m_constraintMatrix.end(); vIt++)
 46 | 		problemFile << (*vIt).term << ' ' << (*vIt).variable << ' ' << (*vIt).exponent << std::endl;
 47 | 	
 48 | 	problemFile.close();
 49 | }
 50 | 
 51 | void gateSizing::mosek::readSolution(std::string problemName)
 52 | {	std::string line, str1;
 53 | 	std::istringstream strline;
 54 | 
 55 | 	if(problemName.find_first_of('.') != std::string::npos)
 56 | 		problemName = problemName.substr(0, problemName.find_first_of('.'));
 57 | 	problemName = problemName + ".sol";
 58 | 	std::ifstream solutionFile(problemName.c_str());
 59 | 	if(!solutionFile) 
 60 | 	{	
 61 | 		std::cerr << problemName << " at " << __LINE__ << " could not be opened for input.\n";
 62 | 		exit(EXIT_FAILURE);
 63 | 	}
 64 | 
 65 | 	while (getline(solutionFile, line)) 
 66 | 	{	
 67 | 		if(line.find("INFEASIBLE") != std::string::npos) 
 68 | 		{	
 69 | 			std::cerr << "GP is infeasible.  Terminating..." << std::endl;
 70 | 			exit(EXIT_FAILURE);
 71 | 		} 
 72 | 		else if(line.find("OBJECTIVE") != std::string::npos) 
 73 | 		{	
 74 | 			strline.str(line);
 75 | 			strline >> str1 >> str1 >> m_objective;
 76 | 			strline.clear();
 77 | 			break;
 78 | 		}
 79 | 	}
 80 | 
 81 | 	while (getline(solutionFile, line)) 
 82 | 	{	
 83 | 		if (line.find("PRIMAL VARIABLES") != std::string::npos) 
 84 | 		{	
 85 | 			getline(solutionFile, line);
 86 | 			break;
 87 | 		}
 88 | 	}
 89 | 	
 90 | 	const unsigned int numVariables = m_id2Var.size();
 91 | 	m_primalVariables.resize(numVariables);
 92 | 	for (unsigned int variable = 0; variable < numVariables; variable++) 
 93 | 	{	
 94 | 		double value;
 95 | 		getline(solutionFile, line);
 96 | 		strline.str(line);
 97 | 		strline >> str1 >> value;
 98 | 		m_primalVariables[variable] = exp(value);
 99 | 	}
100 | 
101 | 	solutionFile.close();
102 | }	


--------------------------------------------------------------------------------
/src/cell.cpp:
--------------------------------------------------------------------------------
  1 | #include "cell.h"
  2 | #include <vector>
  3 | #include <iostream>
  4 | #include "net.h"
  5 | #include "posynomial.h"
  6 | #include "cellLibrary.h"
  7 | 
  8 | gateSizing::cell::cell(const gateSizing::cellTypes cellType, const unsigned int identifier)
  9 | :m_type(cellType), m_id(identifier), m_scaleFactor(1.), m_output(NULL)
 10 | {	
 11 | 	m_inputs.reserve(10);
 12 | }
 13 | 
 14 | gateSizing::cell::~cell()
 15 | {
 16 | }
 17 | 
 18 | void gateSizing::cell::populateDescendants()
 19 | {	
 20 | 	if(m_output)
 21 | 		for(std::vector<gateSizing::cell*>::const_iterator vIt = m_output->loads().begin(); vIt != m_output->loads().end(); ++vIt)
 22 | 			m_descendants.push_back((*vIt));
 23 | }
 24 | 
 25 | void gateSizing::cell::populateAncestors()
 26 | {	
 27 | 	for(std::vector<gateSizing::net*>::iterator vIt = m_inputs.begin(); vIt != m_inputs.end(); ++vIt)
 28 | 		m_ancestors.push_back((*vIt)->driver()->identifier());
 29 | }
 30 | 
 31 | // cell delay is the output resistance * sum of load capacitances
 32 | void gateSizing::cell::populateDelay(const gateSizing::cellLibrary& cellLib)
 33 | {	
 34 | 	if(m_output && m_inputs.size()) // skip primary inputs and  outputs
 35 | 	{	
 36 | 		gateSizing::monomial outputResistance(cellLib[m_type].gamma, m_id, -1);
 37 | 		for(std::vector<gateSizing::cell*>::iterator vIt = m_descendants.begin(); vIt != m_descendants.end(); ++vIt)
 38 | 		{
 39 | 			gateSizing::monomial intrinsicCap(cellLib[(*vIt)->m_type].alpha);
 40 | 			if((*vIt)->m_type != gateSizing::PRIMARYOUT)
 41 | 			{	
 42 | 				gateSizing::monomial perUnitCap(cellLib[(*vIt)->m_type].beta, (*vIt)->m_id, 1);
 43 | 				m_delay += perUnitCap + intrinsicCap;
 44 | 			}
 45 | 			else // primary outputs have only intrinsic capacitance
 46 | 				m_delay += intrinsicCap;
 47 | 		}
 48 | 		m_delay *= outputResistance;
 49 | 	}
 50 | }
 51 | 
 52 | void gateSizing::cell::print() const
 53 | {	
 54 | 	std::cout << "Cell type: " << cellTypeString() << " id: " << m_id << std::endl;
 55 | 	if(m_inputs.size())
 56 | 	{	
 57 | 		std::cout << "Inputs: ";
 58 | 		for(std::vector<gateSizing::net*>::const_iterator vIt = m_inputs.begin(); vIt != m_inputs.end(); vIt++)
 59 | 			std::cout << (*vIt)->name() << ' ';
 60 | 		std::cout << std::endl;
 61 | 	}
 62 | 	if(m_output)
 63 | 		std::cout << "Output: " << m_output->name() << std::endl;
 64 | 	
 65 | 	if(m_ancestors.size())
 66 | 	{	
 67 | 		std::cout << "Ancestors: ";
 68 | 		for(std::vector<unsigned int>::const_iterator vIt = m_ancestors.begin(); vIt != m_ancestors.end(); ++vIt)
 69 | 			std::cout << *vIt << ' ';
 70 | 		std::cout << std::endl;
 71 | 	}
 72 | 	if(m_descendants.size())
 73 | 	{	
 74 | 		std::cout << "Descendants: ";
 75 | 		for(std::vector<cell*>::const_iterator vIt = m_descendants.begin(); vIt != m_descendants.end(); ++vIt)
 76 | 			std::cout << (*vIt)->m_id << ' ';
 77 | 		std::cout << std::endl;
 78 | 	}
 79 | 	if(!m_delay.isEmpty())
 80 | 	{	
 81 | 		std::cout << "Delay = ";
 82 | 		m_delay.print();
 83 | 	}
 84 | }
 85 | 
 86 | const char* gateSizing::cell::cellTypeString() const
 87 | {	
 88 | 	switch(m_type)
 89 | 	{	
 90 | 		case gateSizing::PRIMARYIN: return "primaryInput";
 91 | 		case gateSizing::PRIMARYOUT: return "primaryOutput";
 92 | 		case gateSizing::INV: return "inv";
 93 | 		case gateSizing::NAND2: return "nand2";
 94 | 		case gateSizing::NAND3: return "nand3";
 95 | 		case gateSizing::NAND4: return "nand4";
 96 | 		case gateSizing::NOR2: return "nor2";
 97 | 		case gateSizing::NOR3: return "nor3";
 98 | 		case gateSizing::NOR4: return "nor4";
 99 | 		case gateSizing::AND2: return "and2";
100 | 		case gateSizing::OR2: return "or2";
101 | 		case gateSizing::XOR: return "xor";
102 | 		case gateSizing::XNOR: return "xnor";
103 | 		case gateSizing::AOI21: return "aoi21";
104 | 		case gateSizing::AOI22: return "aoi22";
105 | 		case gateSizing::OAI21: return "oai21";
106 | 		case gateSizing::OAI22: return "oai22";
107 | 	}
108 | 	return "invalidType";
109 | }


--------------------------------------------------------------------------------
/src/io.cpp:
--------------------------------------------------------------------------------
  1 | #include "io.h"
  2 | #include <map>
  3 | #include <sstream>
  4 | #include <fstream>
  5 | #include <string>
  6 | #include <vector>
  7 | #include <cstdlib>
  8 | #include "net.h"
  9 | #include "cell.h"
 10 | #include "gateSizer.h"
 11 | 
 12 | // Parse the bdnet file filling in cell and net structures as it progresses
 13 | // Requires bdnetFile to be the name of a valid bdnet input file and
 14 | //          assumes the netlist is well-formed (connected, valid cell types, etc.)
 15 | void IO::constructNetlist(gateSizing::gateSizer& gs, const std::string& bdnetFile)
 16 | {	
 17 | 	std::map<const std::string, gateSizing::net*> netMap;
 18 | 	std::map<const std::string, gateSizing::cellTypes> cellTypeMap;
 19 | 	std::string line, instanceType, pinType, netName;
 20 | 	
 21 | 	IO::prepareCellTypeMap(cellTypeMap);
 22 | 	
 23 | 	std::ifstream bdnetStream(bdnetFile.c_str());
 24 | 	while (getline(bdnetStream, line)) 
 25 | 	{	
 26 | 		if (line.find("INPUT") != std::string::npos) 
 27 | 		{	
 28 | 			while (getline(bdnetStream, line)) 
 29 | 			{	
 30 | 				if (line.find("\"") == std::string::npos)
 31 | 					break;
 32 | 				IO::extractPinTypeAndNetName(line, pinType, netName);
 33 | 				gateSizing::cell* c = gs.addCell(gateSizing::PRIMARYIN);
 34 | 				gateSizing::net* n = gs.addNet(netName, c);
 35 | 				netMap[netName] = n;
 36 | 				IO::fillInNetAndCell(n,c,true);
 37 | 			}
 38 | 		}
 39 | 		if (line.find("OUTPUT") != std::string::npos) 
 40 | 		{	
 41 | 			while (getline(bdnetStream, line)) 
 42 | 			{	
 43 | 				if (line.find("\"") == std::string::npos)
 44 | 					break;
 45 | 				IO::extractPinTypeAndNetName(line, pinType, netName);
 46 | 				gateSizing::cell* c = gs.addCell(gateSizing::PRIMARYOUT);
 47 | 				gateSizing::net* n;
 48 | 				if(netMap.find(netName) == netMap.end())
 49 | 				{	
 50 | 					n = gs.addNet(netName, NULL);
 51 | 					netMap[netName] = n;
 52 | 				}
 53 | 				else // net already exists (primary input is a primary output) 
 54 | 				{	
 55 | 					n = netMap[netName];
 56 | 				}
 57 | 				IO::fillInNetAndCell(n,c,false);
 58 | 			}
 59 | 		}
 60 | 		if (line.find("INSTANCE") != std::string::npos) 
 61 | 		{	
 62 | 			IO::extractInstanceType(line, instanceType);
 63 | 			gateSizing::cell* c = gs.addCell(cellTypeMap[instanceType]);
 64 | 			while (getline(bdnetStream, line)) 
 65 | 			{	
 66 | 				if (line.find("\"") == std::string::npos)
 67 | 					break;
 68 | 				IO::extractPinTypeAndNetName(line, pinType, netName);
 69 | 				bool isOutput = false;
 70 | 				if(pinType == "O")
 71 | 					isOutput = true;
 72 | 				if(netMap.find(netName) == netMap.end())
 73 | 				{	
 74 | 					gateSizing::net* n = gs.addNet(netName, NULL);
 75 | 					netMap[netName] = n;
 76 | 					IO::fillInNetAndCell(n,c,isOutput);
 77 | 				}
 78 | 				else // net already exists (primary input is a primary output) 
 79 | 				{	
 80 | 					gateSizing::net* n = netMap[netName];
 81 | 					IO::fillInNetAndCell(n,c,isOutput);
 82 | 				}
 83 | 			}
 84 | 		}
 85 | 	}
 86 | 
 87 | 	bdnetStream.close();
 88 | }
 89 | 
 90 | void IO::prepareCellTypeMap(std::map<const std::string, gateSizing::cellTypes>& cellTypeMap)
 91 | {	
 92 | 	cellTypeMap["inv"] = gateSizing::INV;
 93 | 	cellTypeMap["nand2"] = gateSizing::NAND2;
 94 | 	cellTypeMap["nand3"] = gateSizing::NAND3;
 95 | 	cellTypeMap["nand4"] = gateSizing::NAND4;
 96 | 	cellTypeMap["nor2"] = gateSizing::NOR2;
 97 | 	cellTypeMap["nor3"] = gateSizing::NOR3;
 98 | 	cellTypeMap["nor4"] = gateSizing::NOR4;
 99 | 	cellTypeMap["and2"] = gateSizing::AND2;
100 | 	cellTypeMap["or2"] = gateSizing::OR2;
101 | 	cellTypeMap["xor"] = gateSizing::XOR;
102 | 	cellTypeMap["xnor"] = gateSizing::XNOR;
103 | 	cellTypeMap["aoi21"] = gateSizing::AOI21;
104 | 	cellTypeMap["aoi22"] = gateSizing::AOI22;
105 | 	cellTypeMap["oai21"] = gateSizing::OAI21;
106 | 	cellTypeMap["oai22"] = gateSizing::OAI22;
107 | }
108 | 
109 | void IO::extractPinTypeAndNetName(const std::string& line, std::string& pinType, std::string& netName)
110 | {	
111 | 	std::istringstream isstr(line);
112 | 	isstr >> pinType >> netName >> netName;
113 | 	removeQuotes(pinType);
114 | 	removeQuotes(netName);
115 | }
116 | 
117 | void IO::extractInstanceType(const std::string& line, std::string& instanceType)
118 | {	
119 | 	std::istringstream isstr(line);
120 | 	isstr >> instanceType >> instanceType;
121 | 	instanceType = instanceType.substr(1, instanceType.find_first_of(':')-2);
122 | }
123 | 
124 | void IO::fillInNetAndCell(gateSizing::net* n, gateSizing::cell* c, bool isOutput)
125 | {	
126 | 	if(isOutput)
127 | 	{	
128 | 		n->assignDriver(c);
129 | 		c->assignOutput(n);
130 | 	}
131 | 	else
132 | 	{	
133 | 		n->addLoad(c);
134 | 		c->addInput(n);
135 | 	}
136 | }
137 | 
138 | void IO::plotResults(std::string problemName, const std::vector<double>& areaFactors)
139 | {	
140 | 	std::ofstream plotStream((problemName + ".plt").c_str(), std::ofstream::out);
141 | 	plotStream << "set terminal png enhanced size 1280, 768" << std::endl;
142 | 	plotStream << "set output '" << problemName << ".png'" << std::endl;
143 | 	plotStream << "set lmargin 12" << std::endl;
144 | 	plotStream << "set size 1,1" << std::endl;
145 | 	plotStream << "set origin 0,0" << std::endl;
146 | 	plotStream << "set multiplot" << std::endl;
147 | 	plotStream << "set size 1,0.334" << std::endl;
148 | 	plotStream << "set origin 0,0.666" << std::endl;
149 | 	plotStream << "set key left center" << std::endl;
150 | 	plotStream << "set title 'Delay Plot'" << std::endl;
151 | 	plotStream << "set ylabel \"Delay (ns)\"" << std::endl;
152 | 	plotStream << "set xlabel \"Pmax\"" << std::endl;
153 | 	plotStream << "plot ";
154 | 	for(unsigned int a = 0; a < areaFactors.size(); a++)
155 | 	{	
156 | 		double areaFactor = areaFactors[a];
157 | 		std::ostringstream oss;
158 | 		oss << areaFactor;
159 | 		std::string resultName = problemName + "af" + oss.str() + ".res";
160 | 		plotStream << "\"" << resultName << "\" using 2:3 with lines title \"areaFactor " << areaFactor << "\"";
161 | 		if(a != areaFactors.size() - 1)
162 | 			plotStream << ", \\";
163 | 		plotStream << std::endl;
164 | 	}
165 | 	plotStream << "set size 1,0.333" << std::endl;
166 | 	plotStream << "set origin 0,0.333" << std::endl;
167 | 	plotStream << "set key left center" << std::endl;
168 | 	plotStream << "set title 'Power Plot'" << std::endl;
169 | 	plotStream << "set ylabel \"Power (uW)\"" << std::endl;
170 | 	plotStream << "set xlabel \"Pmax\"" << std::endl;
171 | 	plotStream << "plot ";
172 | 	for(unsigned int a = 0; a < areaFactors.size(); a++)
173 | 	{	
174 | 		double areaFactor = areaFactors[a];
175 | 		std::ostringstream oss;
176 | 		oss << areaFactor;
177 | 		std::string resultName = problemName + "af" + oss.str() + ".res";
178 | 		plotStream << "\"" << resultName << "\" using 2:4 with lines title \"areaFactor " << areaFactor << "\"";
179 | 		if(a != areaFactors.size() - 1)
180 | 			plotStream << ", \\";
181 | 		plotStream << std::endl;
182 | 	}
183 | 	plotStream << "set size 1,0.333" << std::endl;
184 | 	plotStream << "set origin 0,0" << std::endl;
185 | 	plotStream << "set key left center" << std::endl;
186 | 	plotStream << "set title 'Area Plot'" << std::endl;
187 | 	plotStream << "set ylabel \"Area (nm*nm)\"" << std::endl;
188 | 	plotStream << "set xlabel \"Pmax\"" << std::endl;
189 | 	plotStream << "plot ";
190 | 	for(unsigned int a = 0; a < areaFactors.size(); a++)
191 | 	{	
192 | 		double areaFactor = areaFactors[a];
193 | 		std::ostringstream oss;
194 | 		oss << areaFactor;
195 | 		std::string resultName = problemName + "af" + oss.str() + ".res";
196 | 		plotStream << "\"" << resultName << "\" using 2:5 with lines title \"areaFactor " << areaFactor << "\"";
197 | 		if(a != areaFactors.size() - 1)
198 | 			plotStream << ", \\";
199 | 		plotStream << std::endl;
200 | 	}
201 | 	plotStream << "unset multiplot" << std::endl;
202 | 	
203 | 	plotStream.close();
204 | 	
205 | 	std::string command;
206 | 	command = "gnuplot " + problemName + ".plt; display " + problemName + ".png &";
207 | 	system(command.c_str());
208 | }


--------------------------------------------------------------------------------
/benchmarks/comb/b9.bdnet:
--------------------------------------------------------------------------------
  1 | MODEL "b9";
  2 | 
  3 | INPUT
  4 | 	"a"	:	"a"
  5 | 	"b"	:	"b"
  6 | 	"c"	:	"c"
  7 | 	"d"	:	"d"
  8 | 	"e"	:	"e"
  9 | 	"f"	:	"f"
 10 | 	"g"	:	"g"
 11 | 	"h"	:	"h"
 12 | 	"i"	:	"i"
 13 | 	"j"	:	"j"
 14 | 	"k"	:	"k"
 15 | 	"l"	:	"l"
 16 | 	"m"	:	"m"
 17 | 	"n"	:	"n"
 18 | 	"o"	:	"o"
 19 | 	"p"	:	"p"
 20 | 	"q"	:	"q"
 21 | 	"r"	:	"r"
 22 | 	"s"	:	"s"
 23 | 	"t"	:	"t"
 24 | 	"u"	:	"u"
 25 | 	"v"	:	"v"
 26 | 	"w"	:	"w"
 27 | 	"x"	:	"x"
 28 | 	"y"	:	"y"
 29 | 	"z"	:	"z"
 30 | 	"a0"	:	"a0"
 31 | 	"b0"	:	"b0"
 32 | 	"c0"	:	"c0"
 33 | 	"d0"	:	"d0"
 34 | 	"e0"	:	"e0"
 35 | 	"f0"	:	"f0"
 36 | 	"g0"	:	"g0"
 37 | 	"h0"	:	"h0"
 38 | 	"i0"	:	"i0"
 39 | 	"j0"	:	"j0"
 40 | 	"k0"	:	"k0"
 41 | 	"l0"	:	"l0"
 42 | 	"m0"	:	"m0"
 43 | 	"n0"	:	"n0"
 44 | 	"o0"	:	"o0";
 45 | 
 46 | OUTPUT
 47 | 	"p0"	:	"[352]"
 48 | 	"q0"	:	"[351]"
 49 | 	"r0"	:	"[350]"
 50 | 	"s0"	:	"[349]"
 51 | 	"t0"	:	"[348]"
 52 | 	"u0"	:	"[354]"
 53 | 	"v0"	:	"[778]"
 54 | 	"w0"	:	"[753]"
 55 | 	"x0"	:	"[754]"
 56 | 	"y0"	:	"[763]"
 57 | 	"z0"	:	"[347]"
 58 | 	"a1"	:	"[346]"
 59 | 	"b1"	:	"[353]"
 60 | 	"c1"	:	"[13]"
 61 | 	"d1"	:	"[779]"
 62 | 	"e1"	:	"[768]"
 63 | 	"f1"	:	"[16]"
 64 | 	"g1"	:	"[17]"
 65 | 	"h1"	:	"[962]"
 66 | 	"i1"	:	"[346]"
 67 | 	"j1"	:	"[774]";
 68 | 
 69 | INSTANCE "inv":"physical"
 70 | 	"a"	:	"k0";
 71 | 	"O"	:	"[736]";
 72 | 
 73 | INSTANCE "inv":"physical"
 74 | 	"a"	:	"c0";
 75 | 	"O"	:	"[541]";
 76 | 
 77 | INSTANCE "nand2":"physical"
 78 | 	"a"	:	"[541]";
 79 | 	"b"	:	"j0";
 80 | 	"O"	:	"[811]";
 81 | 
 82 | INSTANCE "nand2":"physical"
 83 | 	"a"	:	"[736]";
 84 | 	"b"	:	"[811]";
 85 | 	"O"	:	"[543]";
 86 | 
 87 | INSTANCE "nor3":"physical"
 88 | 	"a"	:	"[543]";
 89 | 	"b"	:	"j0";
 90 | 	"c"	:	"l0";
 91 | 	"O"	:	"[339]";
 92 | 
 93 | INSTANCE "inv":"physical"
 94 | 	"a"	:	"b0";
 95 | 	"O"	:	"[540]";
 96 | 
 97 | INSTANCE "nor2":"physical"
 98 | 	"a"	:	"[339]";
 99 | 	"b"	:	"[540]";
100 | 	"O"	:	"[296]";
101 | 
102 | INSTANCE "inv":"physical"
103 | 	"a"	:	"l0";
104 | 	"O"	:	"[544]";
105 | 
106 | INSTANCE "oai21":"physical"
107 | 	"a"	:	"[540]";
108 | 	"b"	:	"[541]";
109 | 	"c"	:	"[544]";
110 | 	"O"	:	"[354]";
111 | 
112 | INSTANCE "oai21":"physical"
113 | 	"a"	:	"j0";
114 | 	"b"	:	"l0";
115 | 	"c"	:	"[354]";
116 | 	"O"	:	"[551]";
117 | 
118 | INSTANCE "nand2":"physical"
119 | 	"a"	:	"n0";
120 | 	"b"	:	"o0";
121 | 	"O"	:	"[549]";
122 | 
123 | INSTANCE "or2":"physical"
124 | 	"a"	:	"e";
125 | 	"b"	:	"[549]";
126 | 	"O"	:	"[550]";
127 | 
128 | INSTANCE "oai21":"physical"
129 | 	"a"	:	"[540]";
130 | 	"b"	:	"[551]";
131 | 	"c"	:	"[550]";
132 | 	"O"	:	"[891]";
133 | 
134 | INSTANCE "oai21":"physical"
135 | 	"a"	:	"k";
136 | 	"b"	:	"[296]";
137 | 	"c"	:	"[891]";
138 | 	"O"	:	"[353]";
139 | 
140 | INSTANCE "oai21":"physical"
141 | 	"a"	:	"p";
142 | 	"b"	:	"[353]";
143 | 	"c"	:	"q";
144 | 	"O"	:	"[352]";
145 | 
146 | INSTANCE "nand2":"physical"
147 | 	"a"	:	"[543]";
148 | 	"b"	:	"b0";
149 | 	"O"	:	"[553]";
150 | 
151 | INSTANCE "nor2":"physical"
152 | 	"a"	:	"e0";
153 | 	"b"	:	"g0";
154 | 	"O"	:	"[24]";
155 | 
156 | INSTANCE "nand2":"physical"
157 | 	"a"	:	"[553]";
158 | 	"b"	:	"[24]";
159 | 	"O"	:	"[814]";
160 | 
161 | INSTANCE "nand2":"physical"
162 | 	"a"	:	"[814]";
163 | 	"b"	:	"e";
164 | 	"O"	:	"[351]";
165 | 
166 | INSTANCE "inv":"physical"
167 | 	"a"	:	"i";
168 | 	"O"	:	"[554]";
169 | 
170 | INSTANCE "inv":"physical"
171 | 	"a"	:	"e";
172 | 	"O"	:	"[546]";
173 | 
174 | INSTANCE "oai21":"physical"
175 | 	"a"	:	"b0";
176 | 	"b"	:	"[546]";
177 | 	"c"	:	"c";
178 | 	"O"	:	"[821]";
179 | 
180 | INSTANCE "aoi22":"physical"
181 | 	"a"	:	"[554]";
182 | 	"b"	:	"[821]";
183 | 	"c"	:	"[811]";
184 | 	"d"	:	"e";
185 | 	"O"	:	"[486]";
186 | 
187 | INSTANCE "nor2":"physical"
188 | 	"a"	:	"c";
189 | 	"b"	:	"d0";
190 | 	"O"	:	"[331]";
191 | 
192 | INSTANCE "nor2":"physical"
193 | 	"a"	:	"[331]";
194 | 	"b"	:	"[549]";
195 | 	"O"	:	"[483]";
196 | 
197 | INSTANCE "nand2":"physical"
198 | 	"a"	:	"[486]";
199 | 	"b"	:	"[483]";
200 | 	"O"	:	"[350]";
201 | 
202 | INSTANCE "nand2":"physical"
203 | 	"a"	:	"c0";
204 | 	"b"	:	"j0";
205 | 	"O"	:	"[805]";
206 | 
207 | INSTANCE "nand2":"physical"
208 | 	"a"	:	"[805]";
209 | 	"b"	:	"b0";
210 | 	"O"	:	"[877]";
211 | 
212 | INSTANCE "nand2":"physical"
213 | 	"a"	:	"[354]";
214 | 	"b"	:	"[877]";
215 | 	"O"	:	"[560]";
216 | 
217 | INSTANCE "inv":"physical"
218 | 	"a"	:	"[560]";
219 | 	"O"	:	"[819]";
220 | 
221 | INSTANCE "nand2":"physical"
222 | 	"a"	:	"v";
223 | 	"b"	:	"[819]";
224 | 	"O"	:	"[349]";
225 | 
226 | INSTANCE "or2":"physical"
227 | 	"a"	:	"v";
228 | 	"b"	:	"[560]";
229 | 	"O"	:	"[348]";
230 | 
231 | INSTANCE "inv":"physical"
232 | 	"a"	:	"[354]";
233 | 	"O"	:	"[778]";
234 | 
235 | INSTANCE "inv":"physical"
236 | 	"a"	:	"r";
237 | 	"O"	:	"[650]";
238 | 
239 | INSTANCE "inv":"physical"
240 | 	"a"	:	"a";
241 | 	"O"	:	"[565]";
242 | 
243 | INSTANCE "oai21":"physical"
244 | 	"a"	:	"z";
245 | 	"b"	:	"[565]";
246 | 	"c"	:	"m0";
247 | 	"O"	:	"[825]";
248 | 
249 | INSTANCE "oai21":"physical"
250 | 	"a"	:	"p";
251 | 	"b"	:	"[650]";
252 | 	"c"	:	"[825]";
253 | 	"O"	:	"[566]";
254 | 
255 | INSTANCE "nor3":"physical"
256 | 	"a"	:	"[566]";
257 | 	"b"	:	"f0";
258 | 	"c"	:	"h0";
259 | 	"O"	:	"[320]";
260 | 
261 | INSTANCE "inv":"physical"
262 | 	"a"	:	"z";
263 | 	"O"	:	"[669]";
264 | 
265 | INSTANCE "inv":"physical"
266 | 	"a"	:	"m0";
267 | 	"O"	:	"[564]";
268 | 
269 | INSTANCE "aoi21":"physical"
270 | 	"a"	:	"[669]";
271 | 	"b"	:	"a";
272 | 	"c"	:	"[564]";
273 | 	"O"	:	"[456]";
274 | 
275 | INSTANCE "aoi21":"physical"
276 | 	"a"	:	"[669]";
277 | 	"b"	:	"[456]";
278 | 	"c"	:	"o";
279 | 	"O"	:	"[321]";
280 | 
281 | INSTANCE "oai21":"physical"
282 | 	"a"	:	"[320]";
283 | 	"b"	:	"[321]";
284 | 	"c"	:	"d";
285 | 	"O"	:	"[752]";
286 | 
287 | INSTANCE "inv":"physical"
288 | 	"a"	:	"[752]";
289 | 	"O"	:	"[753]";
290 | 
291 | INSTANCE "inv":"physical"
292 | 	"a"	:	"[549]";
293 | 	"O"	:	"[754]";
294 | 
295 | INSTANCE "nand4":"physical"
296 | 	"a"	:	"l";
297 | 	"b"	:	"a0";
298 | 	"c"	:	"b0";
299 | 	"d"	:	"i0";
300 | 	"O"	:	"[762]";
301 | 
302 | INSTANCE "inv":"physical"
303 | 	"a"	:	"[762]";
304 | 	"O"	:	"[763]";
305 | 
306 | INSTANCE "nand3":"physical"
307 | 	"a"	:	"l0";
308 | 	"b"	:	"b0";
309 | 	"c"	:	"g";
310 | 	"O"	:	"[867]";
311 | 
312 | INSTANCE "inv":"physical"
313 | 	"a"	:	"[553]";
314 | 	"O"	:	"[809]";
315 | 
316 | INSTANCE "nand4":"physical"
317 | 	"a"	:	"[546]";
318 | 	"b"	:	"h";
319 | 	"c"	:	"[549]";
320 | 	"d"	:	"[809]";
321 | 	"O"	:	"[863]";
322 | 
323 | INSTANCE "inv":"physical"
324 | 	"a"	:	"[550]";
325 | 	"O"	:	"[792]";
326 | 
327 | INSTANCE "nand3":"physical"
328 | 	"a"	:	"[814]";
329 | 	"b"	:	"[792]";
330 | 	"c"	:	"f";
331 | 	"O"	:	"[865]";
332 | 
333 | INSTANCE "nand3":"physical"
334 | 	"a"	:	"[867]";
335 | 	"b"	:	"[863]";
336 | 	"c"	:	"[865]";
337 | 	"O"	:	"[347]";
338 | 
339 | INSTANCE "nand2":"physical"
340 | 	"a"	:	"[754]";
341 | 	"b"	:	"d0";
342 | 	"O"	:	"[582]";
343 | 
344 | INSTANCE "aoi21":"physical"
345 | 	"a"	:	"[582]";
346 | 	"b"	:	"c0";
347 | 	"c"	:	"[554]";
348 | 	"O"	:	"[299]";
349 | 
350 | INSTANCE "oai22":"physical"
351 | 	"a"	:	"b0";
352 | 	"b"	:	"[299]";
353 | 	"c"	:	"j0";
354 | 	"d"	:	"[959]";
355 | 	"O"	:	"[837]";
356 | 
357 | INSTANCE "nor2":"physical"
358 | 	"a"	:	"j";
359 | 	"b"	:	"e0";
360 | 	"O"	:	"[27]";
361 | 
362 | INSTANCE "nand2":"physical"
363 | 	"a"	:	"[837]";
364 | 	"b"	:	"[27]";
365 | 	"O"	:	"[773]";
366 | 
367 | INSTANCE "aoi21":"physical"
368 | 	"a"	:	"b0";
369 | 	"b"	:	"e";
370 | 	"c"	:	"c0";
371 | 	"O"	:	"[295]";
372 | 
373 | INSTANCE "or2":"physical"
374 | 	"a"	:	"j";
375 | 	"b"	:	"e0";
376 | 	"O"	:	"[581]";
377 | 
378 | INSTANCE "nor3":"physical"
379 | 	"a"	:	"[295]";
380 | 	"b"	:	"[959]";
381 | 	"c"	:	"[581]";
382 | 	"O"	:	"[309]";
383 | 
384 | INSTANCE "inv":"physical"
385 | 	"a"	:	"[962]";
386 | 	"O"	:	"[346]";
387 | 
388 | INSTANCE "nand2":"physical"
389 | 	"a"	:	"[543]";
390 | 	"b"	:	"j0";
391 | 	"O"	:	"[845]";
392 | 
393 | INSTANCE "aoi21":"physical"
394 | 	"a"	:	"[845]";
395 | 	"b"	:	"c0";
396 | 	"c"	:	"[540]";
397 | 	"O"	:	"[301]";
398 | 
399 | INSTANCE "or2":"physical"
400 | 	"a"	:	"e0";
401 | 	"b"	:	"g0";
402 | 	"O"	:	"[552]";
403 | 
404 | INSTANCE "oai21":"physical"
405 | 	"a"	:	"[301]";
406 | 	"b"	:	"[552]";
407 | 	"c"	:	"[792]";
408 | 	"O"	:	"[588]";
409 | 
410 | INSTANCE "nor2":"physical"
411 | 	"a"	:	"s";
412 | 	"b"	:	"t";
413 | 	"O"	:	"[391]";
414 | 
415 | INSTANCE "nand2":"physical"
416 | 	"a"	:	"[544]";
417 | 	"b"	:	"[805]";
418 | 	"O"	:	"[847]";
419 | 
420 | INSTANCE "nand4":"physical"
421 | 	"a"	:	"u";
422 | 	"b"	:	"[391]";
423 | 	"c"	:	"[847]";
424 | 	"d"	:	"b0";
425 | 	"O"	:	"[780]";
426 | 
427 | INSTANCE "oai21":"physical"
428 | 	"a"	:	"n";
429 | 	"b"	:	"[588]";
430 | 	"c"	:	"[780]";
431 | 	"O"	:	"[13]";
432 | 
433 | INSTANCE "inv":"physical"
434 | 	"a"	:	"[13]";
435 | 	"O"	:	"[779]";
436 | 
437 | INSTANCE "nand4":"physical"
438 | 	"a"	:	"a0";
439 | 	"b"	:	"m";
440 | 	"c"	:	"b0";
441 | 	"d"	:	"i0";
442 | 	"O"	:	"[767]";
443 | 
444 | INSTANCE "inv":"physical"
445 | 	"a"	:	"[767]";
446 | 	"O"	:	"[768]";
447 | 
448 | INSTANCE "nand2":"physical"
449 | 	"a"	:	"b";
450 | 	"b"	:	"w";
451 | 	"O"	:	"[595]";
452 | 
453 | INSTANCE "nor2":"physical"
454 | 	"a"	:	"x";
455 | 	"b"	:	"[595]";
456 | 	"O"	:	"[16]";
457 | 
458 | INSTANCE "nand2":"physical"
459 | 	"a"	:	"b";
460 | 	"b"	:	"w";
461 | 	"O"	:	"[596]";
462 | 
463 | INSTANCE "inv":"physical"
464 | 	"a"	:	"x";
465 | 	"O"	:	"[592]";
466 | 
467 | INSTANCE "nor3":"physical"
468 | 	"a"	:	"[596]";
469 | 	"b"	:	"y";
470 | 	"c"	:	"[592]";
471 | 	"O"	:	"[17]";
472 | 
473 | INSTANCE "inv":"physical"
474 | 	"a"	:	"[773]";
475 | 	"O"	:	"[774]";
476 | 
477 | INSTANCE "nor2":"physical"
478 | 	"a"	:	"[554]";
479 | 	"b"	:	"[582]";
480 | 	"O"	:	"[959]";
481 | 
482 | INSTANCE "nor2":"physical"
483 | 	"a"	:	"[774]";
484 | 	"b"	:	"[309]";
485 | 	"O"	:	"[962]";
486 | 
487 | ENDMODEL;
488 | 


--------------------------------------------------------------------------------
/benchmarks/comb/9symml.bdnet:
--------------------------------------------------------------------------------
  1 | MODEL "lif/9symml";
  2 | 
  3 | INPUT
  4 | 	"1"	:	"1"
  5 | 	"2"	:	"2"
  6 | 	"3"	:	"3"
  7 | 	"4"	:	"4"
  8 | 	"5"	:	"5"
  9 | 	"6"	:	"6"
 10 | 	"7"	:	"7"
 11 | 	"8"	:	"8"
 12 | 	"9"	:	"9";
 13 | 
 14 | OUTPUT
 15 | 	"52"	:	"[383]";
 16 | 
 17 | INSTANCE "inv":"physical"
 18 | 	"a"	:	"9";
 19 | 	"O"	:	"[721]";
 20 | 
 21 | INSTANCE "inv":"physical"
 22 | 	"a"	:	"8";
 23 | 	"O"	:	"[720]";
 24 | 
 25 | INSTANCE "oai22":"physical"
 26 | 	"a"	:	"8";
 27 | 	"b"	:	"[721]";
 28 | 	"c"	:	"7";
 29 | 	"d"	:	"[720]";
 30 | 	"O"	:	"[723]";
 31 | 
 32 | INSTANCE "inv":"physical"
 33 | 	"a"	:	"7";
 34 | 	"O"	:	"[722]";
 35 | 
 36 | INSTANCE "oai22":"physical"
 37 | 	"a"	:	"8";
 38 | 	"b"	:	"[722]";
 39 | 	"c"	:	"7";
 40 | 	"d"	:	"[720]";
 41 | 	"O"	:	"[728]";
 42 | 
 43 | INSTANCE "inv":"physical"
 44 | 	"a"	:	"[728]";
 45 | 	"O"	:	"[970]";
 46 | 
 47 | INSTANCE "inv":"physical"
 48 | 	"a"	:	"3";
 49 | 	"O"	:	"[734]";
 50 | 
 51 | INSTANCE "inv":"physical"
 52 | 	"a"	:	"5";
 53 | 	"O"	:	"[732]";
 54 | 
 55 | INSTANCE "inv":"physical"
 56 | 	"a"	:	"4";
 57 | 	"O"	:	"[724]";
 58 | 
 59 | INSTANCE "oai22":"physical"
 60 | 	"a"	:	"6";
 61 | 	"b"	:	"[732]";
 62 | 	"c"	:	"5";
 63 | 	"d"	:	"[724]";
 64 | 	"O"	:	"[739]";
 65 | 
 66 | INSTANCE "aoi21":"physical"
 67 | 	"a"	:	"[734]";
 68 | 	"b"	:	"9";
 69 | 	"c"	:	"[739]";
 70 | 	"O"	:	"[297]";
 71 | 
 72 | INSTANCE "oai22":"physical"
 73 | 	"a"	:	"5";
 74 | 	"b"	:	"[724]";
 75 | 	"c"	:	"4";
 76 | 	"d"	:	"[732]";
 77 | 	"O"	:	"[737]";
 78 | 
 79 | INSTANCE "nand3":"physical"
 80 | 	"a"	:	"[737]";
 81 | 	"b"	:	"[734]";
 82 | 	"c"	:	"9";
 83 | 	"O"	:	"[1238]";
 84 | 
 85 | INSTANCE "oai21":"physical"
 86 | 	"a"	:	"[970]";
 87 | 	"b"	:	"[297]";
 88 | 	"c"	:	"[1238]";
 89 | 	"O"	:	"[1116]";
 90 | 
 91 | INSTANCE "oai22":"physical"
 92 | 	"a"	:	"4";
 93 | 	"b"	:	"[734]";
 94 | 	"c"	:	"3";
 95 | 	"d"	:	"[724]";
 96 | 	"O"	:	"[741]";
 97 | 
 98 | INSTANCE "inv":"physical"
 99 | 	"a"	:	"1";
100 | 	"O"	:	"[729]";
101 | 
102 | INSTANCE "oai22":"physical"
103 | 	"a"	:	"4";
104 | 	"b"	:	"[729]";
105 | 	"c"	:	"1";
106 | 	"d"	:	"[724]";
107 | 	"O"	:	"[730]";
108 | 
109 | INSTANCE "inv":"physical"
110 | 	"a"	:	"[730]";
111 | 	"O"	:	"[1009]";
112 | 
113 | INSTANCE "aoi22":"physical"
114 | 	"a"	:	"[741]";
115 | 	"b"	:	"[1009]";
116 | 	"c"	:	"[730]";
117 | 	"d"	:	"9";
118 | 	"O"	:	"[629]";
119 | 
120 | INSTANCE "oai21":"physical"
121 | 	"a"	:	"9";
122 | 	"b"	:	"[741]";
123 | 	"c"	:	"[629]";
124 | 	"O"	:	"[1120]";
125 | 
126 | INSTANCE "inv":"physical"
127 | 	"a"	:	"[737]";
128 | 	"O"	:	"[958]";
129 | 
130 | INSTANCE "nand2":"physical"
131 | 	"a"	:	"[739]";
132 | 	"b"	:	"[958]";
133 | 	"O"	:	"[740]";
134 | 
135 | INSTANCE "inv":"physical"
136 | 	"a"	:	"[740]";
137 | 	"O"	:	"[1066]";
138 | 
139 | INSTANCE "aoi22":"physical"
140 | 	"a"	:	"[1116]";
141 | 	"b"	:	"1";
142 | 	"c"	:	"[1120]";
143 | 	"d"	:	"[1066]";
144 | 	"O"	:	"[620]";
145 | 
146 | INSTANCE "nor2":"physical"
147 | 	"a"	:	"[728]";
148 | 	"b"	:	"[730]";
149 | 	"O"	:	"[672]";
150 | 
151 | INSTANCE "nand4":"physical"
152 | 	"a"	:	"[672]";
153 | 	"b"	:	"[722]";
154 | 	"c"	:	"4";
155 | 	"d"	:	"6";
156 | 	"O"	:	"[1230]";
157 | 
158 | INSTANCE "nand3":"physical"
159 | 	"a"	:	"[1398]";
160 | 	"b"	:	"[730]";
161 | 	"c"	:	"3";
162 | 	"O"	:	"[1232]";
163 | 
164 | INSTANCE "nand3":"physical"
165 | 	"a"	:	"[620]";
166 | 	"b"	:	"[1230]";
167 | 	"c"	:	"[1232]";
168 | 	"O"	:	"[744]";
169 | 
170 | INSTANCE "nor2":"physical"
171 | 	"a"	:	"[728]";
172 | 	"b"	:	"[744]";
173 | 	"O"	:	"[611]";
174 | 
175 | INSTANCE "aoi21":"physical"
176 | 	"a"	:	"[734]";
177 | 	"b"	:	"2";
178 | 	"c"	:	"[730]";
179 | 	"O"	:	"[300]";
180 | 
181 | INSTANCE "nand2":"physical"
182 | 	"a"	:	"[729]";
183 | 	"b"	:	"[741]";
184 | 	"O"	:	"[746]";
185 | 
186 | INSTANCE "oai21":"physical"
187 | 	"a"	:	"[300]";
188 | 	"b"	:	"[723]";
189 | 	"c"	:	"[746]";
190 | 	"O"	:	"[1122]";
191 | 
192 | INSTANCE "aoi22":"physical"
193 | 	"a"	:	"[723]";
194 | 	"b"	:	"[611]";
195 | 	"c"	:	"[720]";
196 | 	"d"	:	"[1122]";
197 | 	"O"	:	"[29]";
198 | 
199 | INSTANCE "nor3":"physical"
200 | 	"a"	:	"[29]";
201 | 	"b"	:	"[732]";
202 | 	"c"	:	"[739]";
203 | 	"O"	:	"[303]";
204 | 
205 | INSTANCE "nand2":"physical"
206 | 	"a"	:	"[729]";
207 | 	"b"	:	"3";
208 | 	"O"	:	"[750]";
209 | 
210 | INSTANCE "nor4":"physical"
211 | 	"a"	:	"5";
212 | 	"b"	:	"[750]";
213 | 	"c"	:	"[970]";
214 | 	"d"	:	"[721]";
215 | 	"O"	:	"[301]";
216 | 
217 | INSTANCE "nand2":"physical"
218 | 	"a"	:	"[732]";
219 | 	"b"	:	"2";
220 | 	"O"	:	"[754]";
221 | 
222 | INSTANCE "inv":"physical"
223 | 	"a"	:	"2";
224 | 	"O"	:	"[747]";
225 | 
226 | INSTANCE "nand3":"physical"
227 | 	"a"	:	"7";
228 | 	"b"	:	"[747]";
229 | 	"c"	:	"[734]";
230 | 	"O"	:	"[1268]";
231 | 
232 | INSTANCE "oai21":"physical"
233 | 	"a"	:	"7";
234 | 	"b"	:	"[754]";
235 | 	"c"	:	"[1268]";
236 | 	"O"	:	"[756]";
237 | 
238 | INSTANCE "nand4":"physical"
239 | 	"a"	:	"6";
240 | 	"b"	:	"1";
241 | 	"c"	:	"[721]";
242 | 	"d"	:	"[756]";
243 | 	"O"	:	"[1128]";
244 | 
245 | INSTANCE "inv":"physical"
246 | 	"a"	:	"[1128]";
247 | 	"O"	:	"[1129]";
248 | 
249 | INSTANCE "nor3":"physical"
250 | 	"a"	:	"[303]";
251 | 	"b"	:	"[301]";
252 | 	"c"	:	"[1129]";
253 | 	"O"	:	"[400]";
254 | 
255 | INSTANCE "inv":"physical"
256 | 	"a"	:	"[741]";
257 | 	"O"	:	"[1000]";
258 | 
259 | INSTANCE "nand2":"physical"
260 | 	"a"	:	"[970]";
261 | 	"b"	:	"[1401]";
262 | 	"O"	:	"[762]";
263 | 
264 | INSTANCE "nand3":"physical"
265 | 	"a"	:	"[723]";
266 | 	"b"	:	"[970]";
267 | 	"c"	:	"3";
268 | 	"O"	:	"[1146]";
269 | 
270 | INSTANCE "oai21":"physical"
271 | 	"a"	:	"[1000]";
272 | 	"b"	:	"[762]";
273 | 	"c"	:	"[1146]";
274 | 	"O"	:	"[1086]";
275 | 
276 | INSTANCE "nand2":"physical"
277 | 	"a"	:	"[721]";
278 | 	"b"	:	"7";
279 | 	"O"	:	"[764]";
280 | 
281 | INSTANCE "nand2":"physical"
282 | 	"a"	:	"8";
283 | 	"b"	:	"9";
284 | 	"O"	:	"[765]";
285 | 
286 | INSTANCE "oai21":"physical"
287 | 	"a"	:	"[744]";
288 | 	"b"	:	"[765]";
289 | 	"c"	:	"[762]";
290 | 	"O"	:	"[766]";
291 | 
292 | INSTANCE "inv":"physical"
293 | 	"a"	:	"[766]";
294 | 	"O"	:	"[1072]";
295 | 
296 | INSTANCE "oai22":"physical"
297 | 	"a"	:	"[958]";
298 | 	"b"	:	"[764]";
299 | 	"c"	:	"1";
300 | 	"d"	:	"[1072]";
301 | 	"O"	:	"[1088]";
302 | 
303 | INSTANCE "inv":"physical"
304 | 	"a"	:	"6";
305 | 	"O"	:	"[725]";
306 | 
307 | INSTANCE "nand2":"physical"
308 | 	"a"	:	"[725]";
309 | 	"b"	:	"3";
310 | 	"O"	:	"[763]";
311 | 
312 | INSTANCE "inv":"physical"
313 | 	"a"	:	"[763]";
314 | 	"O"	:	"[1057]";
315 | 
316 | INSTANCE "aoi22":"physical"
317 | 	"a"	:	"[739]";
318 | 	"b"	:	"[1086]";
319 | 	"c"	:	"[1088]";
320 | 	"d"	:	"[1057]";
321 | 	"O"	:	"[395]";
322 | 
323 | INSTANCE "nor2":"physical"
324 | 	"a"	:	"[739]";
325 | 	"b"	:	"[756]";
326 | 	"O"	:	"[325]";
327 | 
328 | INSTANCE "aoi21":"physical"
329 | 	"a"	:	"[728]";
330 | 	"b"	:	"[739]";
331 | 	"c"	:	"[325]";
332 | 	"O"	:	"[287]";
333 | 
334 | INSTANCE "nand3":"physical"
335 | 	"a"	:	"[1401]";
336 | 	"b"	:	"[729]";
337 | 	"c"	:	"3";
338 | 	"O"	:	"[1166]";
339 | 
340 | INSTANCE "oai21":"physical"
341 | 	"a"	:	"[287]";
342 | 	"b"	:	"[764]";
343 | 	"c"	:	"[1166]";
344 | 	"O"	:	"[770]";
345 | 
346 | INSTANCE "aoi21":"physical"
347 | 	"a"	:	"[741]";
348 | 	"b"	:	"[723]";
349 | 	"c"	:	"[770]";
350 | 	"O"	:	"[285]";
351 | 
352 | INSTANCE "inv":"physical"
353 | 	"a"	:	"[285]";
354 | 	"O"	:	"[1094]";
355 | 
356 | INSTANCE "aoi22":"physical"
357 | 	"a"	:	"7";
358 | 	"b"	:	"[1066]";
359 | 	"c"	:	"5";
360 | 	"d"	:	"[1401]";
361 | 	"O"	:	"[283]";
362 | 
363 | INSTANCE "nand2":"physical"
364 | 	"a"	:	"[722]";
365 | 	"b"	:	"6";
366 | 	"O"	:	"[773]";
367 | 
368 | INSTANCE "oai21":"physical"
369 | 	"a"	:	"[766]";
370 | 	"b"	:	"[773]";
371 | 	"c"	:	"[763]";
372 | 	"O"	:	"[1096]";
373 | 
374 | INSTANCE "nor4":"physical"
375 | 	"a"	:	"6";
376 | 	"b"	:	"[722]";
377 | 	"c"	:	"[739]";
378 | 	"d"	:	"[756]";
379 | 	"O"	:	"[317]";
380 | 
381 | INSTANCE "aoi21":"physical"
382 | 	"a"	:	"[723]";
383 | 	"b"	:	"[1096]";
384 | 	"c"	:	"[317]";
385 | 	"O"	:	"[533]";
386 | 
387 | INSTANCE "inv":"physical"
388 | 	"a"	:	"[533]";
389 | 	"O"	:	"[1341]";
390 | 
391 | INSTANCE "aoi21":"physical"
392 | 	"a"	:	"[756]";
393 | 	"b"	:	"[29]";
394 | 	"c"	:	"[1341]";
395 | 	"O"	:	"[284]";
396 | 
397 | INSTANCE "oai22":"physical"
398 | 	"a"	:	"[283]";
399 | 	"b"	:	"[746]";
400 | 	"c"	:	"[1009]";
401 | 	"d"	:	"[284]";
402 | 	"O"	:	"[775]";
403 | 
404 | INSTANCE "aoi21":"physical"
405 | 	"a"	:	"[1094]";
406 | 	"b"	:	"[1398]";
407 | 	"c"	:	"[775]";
408 | 	"O"	:	"[391]";
409 | 
410 | INSTANCE "nand2":"physical"
411 | 	"a"	:	"[741]";
412 | 	"b"	:	"[970]";
413 | 	"O"	:	"[1214]";
414 | 
415 | INSTANCE "nor2":"physical"
416 | 	"a"	:	"6";
417 | 	"b"	:	"[756]";
418 | 	"O"	:	"[431]";
419 | 
420 | INSTANCE "nor3":"physical"
421 | 	"a"	:	"[744]";
422 | 	"b"	:	"3";
423 | 	"c"	:	"[725]";
424 | 	"O"	:	"[348]";
425 | 
426 | INSTANCE "aoi21":"physical"
427 | 	"a"	:	"[763]";
428 | 	"b"	:	"[431]";
429 | 	"c"	:	"[348]";
430 | 	"O"	:	"[421]";
431 | 
432 | INSTANCE "nand2":"physical"
433 | 	"a"	:	"[1214]";
434 | 	"b"	:	"[421]";
435 | 	"O"	:	"[1114]";
436 | 
437 | INSTANCE "nor3":"physical"
438 | 	"a"	:	"7";
439 | 	"b"	:	"[729]";
440 | 	"c"	:	"[734]";
441 | 	"O"	:	"[345]";
442 | 
443 | INSTANCE "aoi21":"physical"
444 | 	"a"	:	"[720]";
445 | 	"b"	:	"[1066]";
446 | 	"c"	:	"[345]";
447 | 	"O"	:	"[293]";
448 | 
449 | INSTANCE "nor2":"physical"
450 | 	"a"	:	"[1398]";
451 | 	"b"	:	"[728]";
452 | 	"O"	:	"[294]";
453 | 
454 | INSTANCE "oai22":"physical"
455 | 	"a"	:	"[293]";
456 | 	"b"	:	"[723]";
457 | 	"c"	:	"[294]";
458 | 	"d"	:	"[746]";
459 | 	"O"	:	"[798]";
460 | 
461 | INSTANCE "aoi21":"physical"
462 | 	"a"	:	"[723]";
463 | 	"b"	:	"[1114]";
464 | 	"c"	:	"[798]";
465 | 	"O"	:	"[408]";
466 | 
467 | INSTANCE "nor2":"physical"
468 | 	"a"	:	"4";
469 | 	"b"	:	"[741]";
470 | 	"O"	:	"[459]";
471 | 
472 | INSTANCE "nand2":"physical"
473 | 	"a"	:	"[725]";
474 | 	"b"	:	"1";
475 | 	"O"	:	"[791]";
476 | 
477 | INSTANCE "oai22":"physical"
478 | 	"a"	:	"[766]";
479 | 	"b"	:	"[791]";
480 | 	"c"	:	"3";
481 | 	"d"	:	"[970]";
482 | 	"O"	:	"[1106]";
483 | 
484 | INSTANCE "aoi22":"physical"
485 | 	"a"	:	"[766]";
486 | 	"b"	:	"[459]";
487 | 	"c"	:	"[737]";
488 | 	"d"	:	"[1106]";
489 | 	"O"	:	"[411]";
490 | 
491 | INSTANCE "nand4":"physical"
492 | 	"a"	:	"[721]";
493 | 	"b"	:	"3";
494 | 	"c"	:	"[739]";
495 | 	"d"	:	"[764]";
496 | 	"O"	:	"[1188]";
497 | 
498 | INSTANCE "nand4":"physical"
499 | 	"a"	:	"[734]";
500 | 	"b"	:	"[732]";
501 | 	"c"	:	"[730]";
502 | 	"d"	:	"9";
503 | 	"O"	:	"[1190]";
504 | 
505 | INSTANCE "nand4":"physical"
506 | 	"a"	:	"[408]";
507 | 	"b"	:	"[411]";
508 | 	"c"	:	"[1188]";
509 | 	"d"	:	"[1190]";
510 | 	"O"	:	"[1104]";
511 | 
512 | INSTANCE "nor3":"physical"
513 | 	"a"	:	"[763]";
514 | 	"b"	:	"[958]";
515 | 	"c"	:	"[729]";
516 | 	"O"	:	"[329]";
517 | 
518 | INSTANCE "nor4":"physical"
519 | 	"a"	:	"4";
520 | 	"b"	:	"[721]";
521 | 	"c"	:	"[723]";
522 | 	"d"	:	"[730]";
523 | 	"O"	:	"[327]";
524 | 
525 | INSTANCE "nor4":"physical"
526 | 	"a"	:	"[725]";
527 | 	"b"	:	"[732]";
528 | 	"c"	:	"9";
529 | 	"d"	:	"[970]";
530 | 	"O"	:	"[328]";
531 | 
532 | INSTANCE "nor3":"physical"
533 | 	"a"	:	"[329]";
534 | 	"b"	:	"[327]";
535 | 	"c"	:	"[328]";
536 | 	"O"	:	"[481]";
537 | 
538 | INSTANCE "oai21":"physical"
539 | 	"a"	:	"1";
540 | 	"b"	:	"[725]";
541 | 	"c"	:	"[958]";
542 | 	"O"	:	"[1108]";
543 | 
544 | INSTANCE "oai21":"physical"
545 | 	"a"	:	"[970]";
546 | 	"b"	:	"[721]";
547 | 	"c"	:	"[762]";
548 | 	"O"	:	"[1102]";
549 | 
550 | INSTANCE "aoi21":"physical"
551 | 	"a"	:	"[1108]";
552 | 	"b"	:	"[1102]";
553 | 	"c"	:	"[744]";
554 | 	"O"	:	"[476]";
555 | 
556 | INSTANCE "aoi21":"physical"
557 | 	"a"	:	"[481]";
558 | 	"b"	:	"[476]";
559 | 	"c"	:	"2";
560 | 	"O"	:	"[309]";
561 | 
562 | INSTANCE "aoi21":"physical"
563 | 	"a"	:	"[1104]";
564 | 	"b"	:	"2";
565 | 	"c"	:	"[309]";
566 | 	"O"	:	"[386]";
567 | 
568 | INSTANCE "nand4":"physical"
569 | 	"a"	:	"[400]";
570 | 	"b"	:	"[395]";
571 | 	"c"	:	"[391]";
572 | 	"d"	:	"[386]";
573 | 	"O"	:	"[383]";
574 | 
575 | INSTANCE "nor2":"physical"
576 | 	"a"	:	"5";
577 | 	"b"	:	"[725]";
578 | 	"O"	:	"[1398]";
579 | 
580 | INSTANCE "nor2":"physical"
581 | 	"a"	:	"9";
582 | 	"b"	:	"[720]";
583 | 	"O"	:	"[1401]";
584 | 
585 | ENDMODEL;
586 | 


--------------------------------------------------------------------------------
/src/gateSizer.cpp:
--------------------------------------------------------------------------------
  1 | #include "gateSizer.h"
  2 | #include <set>
  3 | #include <iostream>
  4 | #include <fstream>
  5 | #include <sstream>
  6 | #include "io.h"
  7 | #include "cell.h"
  8 | #include "net.h"
  9 | #include "posynomial.h"
 10 | 
 11 | 
 12 | gateSizing::gateSizer::gateSizer(const std::string& problemName, double powerFactor, double areaFactor)
 13 | {	
 14 | 	IO::constructNetlist(*this, problemName + ".bdnet");
 15 | 	populateDescendants();
 16 | 	populateDelays();
 17 | 	populateAncestors();
 18 | 	populateFormulation(powerFactor, areaFactor);
 19 | 	formulation.solve(problemName);
 20 | 	populateScaleFactors();
 21 | }
 22 | 
 23 | gateSizing::gateSizer::~gateSizer()
 24 | {	
 25 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); ++vIt)
 26 | 		delete *vIt;
 27 | 	for(std::vector<gateSizing::net*>::iterator vIt = m_nets.begin(); vIt != m_nets.end(); ++vIt)
 28 | 		delete *vIt;
 29 | }
 30 | 
 31 | gateSizing::cell* gateSizing::gateSizer::addCell(gateSizing::cellTypes cellType)
 32 | {	
 33 | 	unsigned int identifier = m_cells.size();
 34 | 	m_cells.push_back(new gateSizing::cell(cellType, identifier));
 35 | 	gateSizing::cell* c = m_cells[identifier];
 36 | 	if(cellType == gateSizing::PRIMARYIN)
 37 | 		m_primaryInputs.push_back(c);
 38 | 	if(cellType == gateSizing::PRIMARYOUT)
 39 | 		m_primaryOutputs.push_back(c);
 40 | 	return c;
 41 | }
 42 | 
 43 | gateSizing::net* gateSizing::gateSizer::addNet(std::string& name, gateSizing::cell* driver)
 44 | {	
 45 | 	m_nets.push_back(new gateSizing::net(name, driver));
 46 | 	return m_nets[m_nets.size()-1];
 47 | }
 48 | 
 49 | double gateSizing::gateSizer::evaluatePower() const
 50 | {	
 51 | 	double power = 0.;
 52 | 	for(std::vector<gateSizing::cell*>::const_iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
 53 | 		power += (*vIt)->scaleFactor() * cellLib[(*vIt)->type()].e * cellLib[(*vIt)->type()].f;
 54 | 	return power;
 55 | }
 56 | 
 57 | double gateSizing::gateSizer::evaluateArea() const
 58 | {	
 59 | 	double area = 0.;
 60 | 	for(std::vector<gateSizing::cell*>::const_iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
 61 | 		area += (*vIt)->scaleFactor() * cellLib[(*vIt)->type()].a;
 62 | 	return area;
 63 | }
 64 | 
 65 | void gateSizing::gateSizer::reportResults(std::string problemName, bool append, double powerFactor, double areaFactor) const
 66 | {	
 67 | 	double delay = formulation.objective();
 68 | 	double power = evaluatePower();
 69 | 	double area = evaluateArea();
 70 | 	
 71 | 	std::cout << "areaFactor: " << areaFactor << "\tpowerFactor: " << powerFactor << "\tDelay: " << delay << 
 72 | 	             "ns\tPower: " << power << "uW\tArea: " << area << "nm^2" << std::endl;
 73 | 	
 74 | 	std::ostringstream oss;
 75 | 	oss << areaFactor;
 76 | 	problemName += "af" + oss.str() + ".res";
 77 | 	std::ofstream resultStream;
 78 | 	if(append)
 79 | 		resultStream.open(problemName.c_str(), std::ofstream::app);
 80 | 	else
 81 | 		resultStream.open(problemName.c_str(), std::ofstream::out);
 82 | 	resultStream << areaFactor << '\t' << powerFactor << '\t' << delay << '\t' << power << '\t' << area << std::endl;
 83 | 	resultStream.close();
 84 | }
 85 | 
 86 | void gateSizing::gateSizer::printNetList() const
 87 | {	std::cout << "Printing nets" << std::endl;
 88 | 	for(std::vector<gateSizing::net*>::const_iterator vIt = m_nets.begin(); vIt != m_nets.end(); vIt++)
 89 | 		(*vIt)->print();
 90 | 	
 91 | 	std::cout << "Printing cells" << std::endl;
 92 | 	for(std::vector<gateSizing::cell*>::const_iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
 93 | 		(*vIt)->print();
 94 | }
 95 | 
 96 | // private functions
 97 | 
 98 | void gateSizing::gateSizer::populateDescendants()
 99 | {	
100 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); ++vIt)
101 | 		(*vIt)->populateDescendants();
102 | }
103 | 
104 | void gateSizing::gateSizer::populateAncestors()
105 | {	
106 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); ++vIt)
107 | 		(*vIt)->populateAncestors();
108 | }
109 | 
110 | void gateSizing::gateSizer::populateDelays()
111 | {	
112 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); ++vIt)
113 | 		(*vIt)->populateDelay(cellLib);
114 | }
115 | 
116 | // The variables for the formulation are the scaleFactors x_i,
117 | // the path delay to a cell T_i, and additional variables to 
118 | // remove the max{T_j1,...,T_jk} for each cell called V_i.
119 | // One last variable is added for the objective D (max of all) 
120 | // As an example of how to remove a max operator, consider
121 | // the formulation 
122 | // minimize z
123 | // s.t. max{y1, y2} <= z
124 | // It can be equivalently reformulated as
125 | // minimize z 
126 | // s.t. w <= z
127 | // y1 <= w
128 | // y2 <= w
129 | // The variables are indexed as follows
130 | // [0..numCells-1] are the corresponding x_i variable
131 | // [numCells..2*numCells-1] are the corresponding T_i variable
132 | // [2*numCells..3*numCells-1] are the corresponding V_i variable
133 | // 3*numCells is the objective variable D
134 | // 
135 | // The input powerFactor is used to assign Pmax = powerFactor * Pmin
136 | // where Pmin is the power with all gates at minimum allowed size
137 | // the input areaFactor is used to assign Amax = areaFactor * Amin
138 | // where Amin is the area when all gates are minimum size
139 | void gateSizing::gateSizer::populateFormulation(double powerFactor, double areaFactor)
140 | {	
141 | 	const unsigned int numCells = m_cells.size();
142 | 	const unsigned int D = 3*numCells;
143 | 	unsigned int constraint = 0; // objective is constraint 0
144 | 	unsigned int term = 0;
145 | 	
146 | 	// objective
147 | 	formulation.addTerm(term++, D, 1);
148 | 	formulation.addCoefficient(1.);
149 | 	formulation.addAssociation(constraint++);
150 | 	
151 | 	// delay constraints
152 | 	// all inputs are primaryInputs
153 | 	std::set<unsigned int> inputDescendants;
154 | 	// not all inputs are primaryInputs
155 | 	std::set<unsigned int> internals;
156 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
157 | 		internalOrPIDescendant(*vIt, internals, inputDescendants);
158 | 	
159 | 	// inputDescendants D_i <= T_i
160 | 	for(std::set<unsigned int>::iterator sIt = inputDescendants.begin(); sIt != inputDescendants.end(); sIt++)
161 | 	{	
162 | 		gateSizing::posynomial p = m_cells[*sIt]->delay(); // D_i
163 | 		gateSizing::monomial m(1., numCells+(*sIt), -1); // T_i^-1
164 | 		p *= m; // D_i * T_i^-1
165 | 		writePosynomialTerms(p, term, constraint);
166 | 		constraint++;
167 | 	}
168 | 	
169 | 	// internals D_i + V_i <= T_i 
170 | 	for(std::set<unsigned int>::iterator sIt = internals.begin(); sIt != internals.end(); sIt++)
171 | 	{	
172 | 		gateSizing::posynomial p = m_cells[*sIt]->delay(); // D_i
173 | 		gateSizing::monomial m(1., numCells+(*sIt), -1); // T_i^-1
174 | 		gateSizing::monomial v(1., 2*numCells+(*sIt), 1); // V_i
175 | 		p += v; // D_i + V_i
176 | 		p *= m; // (D_i + V_i) * T_i^-1
177 | 		writePosynomialTerms(p, term, constraint);
178 | 		constraint++;
179 | 	}
180 | 	
181 | 	// internals T_ancestor <= V_i 
182 | 	for(std::set<unsigned int>::iterator sIt = internals.begin(); sIt != internals.end(); sIt++)
183 | 	{	
184 | 		std::set<unsigned int> internalAncestors;
185 | 		nonPIAncestors(m_cells[*sIt], internalAncestors);
186 | 		for(std::set<unsigned int>::iterator aIt = internalAncestors.begin(); aIt != internalAncestors.end(); aIt++)
187 | 		{	formulation.addTerm(term, numCells+(*aIt), 1); // T_ancestor
188 | 			formulation.addTerm(term++, 2*numCells+(*sIt), -1); // V_i^-1
189 | 			formulation.addCoefficient(1.);
190 | 			formulation.addAssociation(constraint++);
191 | 		}
192 | 	}
193 | 	
194 | 	// delay constraints for primaryOutputs (T_i <= D)
195 | 	// ids of non-primaryInput ancestors of primaryOutputs 
196 | 	std::set<unsigned int> outputAncestors;
197 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_primaryOutputs.begin(); vIt != m_primaryOutputs.end(); vIt++)
198 | 		nonPIAncestors((*vIt), outputAncestors);
199 | 	// find cells that output only to primaryOutputs
200 | 	exclusivePODescendants(outputAncestors);
201 | 	// T_i <= D
202 | 	for(std::set<unsigned int>::iterator sIt = outputAncestors.begin(); sIt != outputAncestors.end(); sIt++)
203 | 	{	
204 | 		formulation.addTerm(term, numCells+(*sIt), 1); // T_i
205 | 		formulation.addTerm(term++, D, -1); // D^-1
206 | 		formulation.addCoefficient(1.);
207 | 		formulation.addAssociation(constraint++);
208 | 	}
209 | 	
210 | 	// Power constraint P <= P_max
211 | 	const double Pmin = evaluatePower(); // minimum power initially
212 | 	const double Pmax = powerFactor * Pmin;
213 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
214 | 	{	
215 | 		gateSizing::cellTypes type = (*vIt)->type();
216 | 		if(type != gateSizing::PRIMARYIN && type != gateSizing::PRIMARYOUT)
217 | 		{	
218 | 			formulation.addTerm(term++, (*vIt)->identifier(), 1);
219 | 			formulation.addCoefficient(cellLib[type].f * cellLib[type].e / Pmax);
220 | 			formulation.addAssociation(constraint);
221 | 		}
222 | 	}
223 | 	constraint++;
224 | 	
225 | 	// Area constraint A <= A_max
226 | 	const double Amin = evaluateArea(); // minimum area initially
227 | 	const double Amax = areaFactor * Amin;
228 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
229 | 	{	
230 | 		gateSizing::cellTypes type = (*vIt)->type();
231 | 		if(type != gateSizing::PRIMARYIN && type != gateSizing::PRIMARYOUT)
232 | 		{	
233 | 			formulation.addTerm(term++, (*vIt)->identifier(), 1);
234 | 			formulation.addCoefficient(cellLib[type].a / Amax);
235 | 			formulation.addAssociation(constraint);
236 | 		}
237 | 	}
238 | 	constraint++;
239 | 	
240 | 	// scaleFactor constraint 1 <= x_i
241 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
242 | 	{	
243 | 		gateSizing::cellTypes type = (*vIt)->type();
244 | 		if(type != gateSizing::PRIMARYIN && type != gateSizing::PRIMARYOUT)
245 | 		{	
246 | 			formulation.addTerm(term++, (*vIt)->identifier(), -1);
247 | 			formulation.addCoefficient(1.);
248 | 			formulation.addAssociation(constraint++);
249 | 		}
250 | 	}
251 | }
252 | 
253 | void gateSizing::gateSizer::populateScaleFactors()
254 | {	
255 | 	for(std::vector<gateSizing::cell*>::iterator vIt = m_cells.begin(); vIt != m_cells.end(); vIt++)
256 | 	{	
257 | 		if((*vIt)->type() != gateSizing::PRIMARYIN && (*vIt)->type() != gateSizing::PRIMARYOUT)
258 | 		{	
259 | 			(*vIt)->assignScaleFactor(formulation.value((*vIt)->identifier()));
260 | 		}
261 | 	}
262 | }
263 | 
264 | void gateSizing::gateSizer::writeMonomialTerms(const monomial& m, unsigned int& term, unsigned int constraint)
265 | {	
266 | 	const std::map<unsigned int, int>& map = m.exponents();
267 | 	for(std::map<unsigned int, int>::const_iterator mIt = map.begin(); mIt != map.end(); mIt++)
268 | 		formulation.addTerm(term, (*mIt).first, (*mIt).second); // T_i
269 | 	formulation.addCoefficient(m.coefficient());
270 | 	formulation.addAssociation(constraint);
271 | 	term++;
272 | }
273 | 
274 | void gateSizing::gateSizer::writePosynomialTerms(const posynomial& p, unsigned int& term, unsigned int constraint)
275 | {	
276 | 	for(std::vector<gateSizing::monomial>::const_iterator vIt = p.monomials().begin(); vIt != p.monomials().end(); vIt++)
277 | 		writeMonomialTerms(*vIt, term, constraint);
278 | }
279 | 
280 | void gateSizing::gateSizer::internalOrPIDescendant(const gateSizing::cell* c, std::set<unsigned int>& internals, std::set<unsigned int>& inputDescendants)
281 | {	
282 | 	if(c->type() != gateSizing::PRIMARYIN && c->type() != gateSizing::PRIMARYOUT)
283 | 	{	
284 | 		std::set<unsigned int> internalAncestors;
285 | 		nonPIAncestors(c, internalAncestors);
286 | 		if(internalAncestors.size())
287 | 			internals.insert(c->identifier());
288 | 		else
289 | 			inputDescendants.insert(c->identifier());
290 | 	}	
291 | }
292 | 
293 | void gateSizing::gateSizer::nonPIAncestors(const gateSizing::cell* c, std::set<unsigned int>& ancestors)
294 | {	
295 | 	for(std::vector<unsigned int>::const_iterator vIt = c->ancestors().begin(); vIt != c->ancestors().end(); vIt++)
296 | 		if(m_cells[(*vIt)]->type() != gateSizing::PRIMARYIN)
297 | 			ancestors.insert(*vIt);
298 | }
299 | 
300 | void gateSizing::gateSizer::exclusivePODescendants(std::set<unsigned int>& ancestors)
301 | {	
302 | 	std::set<unsigned int> exclusivePOs;
303 | 	for(std::set<unsigned int>::iterator sIt = ancestors.begin(); sIt != ancestors.end(); sIt++)
304 | 	{	
305 | 		std::vector<gateSizing::cell*> d = m_cells[*sIt]->descendants();
306 | 		bool allPOs = true;
307 | 		for(std::vector<gateSizing::cell*>::iterator vIt = d.begin(); vIt != d.end(); vIt++)
308 | 			if((*vIt)->type() != gateSizing::PRIMARYOUT)
309 | 			{	
310 | 				allPOs = false;
311 | 				break;
312 | 			}
313 | 		if(allPOs)
314 | 			exclusivePOs.insert(*sIt);
315 | 	}
316 | 	ancestors = exclusivePOs;
317 | }


--------------------------------------------------------------------------------
/benchmarks/comb/alu2.bdnet:
--------------------------------------------------------------------------------
   1 | MODEL "alu4_cl";
   2 | 
   3 | INPUT
   4 | 	"a"	:	"a"
   5 | 	"b"	:	"b"
   6 | 	"c"	:	"c"
   7 | 	"d"	:	"d"
   8 | 	"e"	:	"e"
   9 | 	"f"	:	"f"
  10 | 	"g"	:	"g"
  11 | 	"h"	:	"h"
  12 | 	"i"	:	"i"
  13 | 	"j"	:	"j";
  14 | 
  15 | OUTPUT
  16 | 	"k"	:	"[454]"
  17 | 	"l"	:	"[452]"
  18 | 	"m"	:	"[453]"
  19 | 	"n"	:	"[1357]"
  20 | 	"o"	:	"[451]"
  21 | 	"p"	:	"[5]";
  22 | 
  23 | INSTANCE "inv":"physical"
  24 | 	"a"	:	"f";
  25 | 	"O"	:	"[1070]";
  26 | 
  27 | INSTANCE "inv":"physical"
  28 | 	"a"	:	"j";
  29 | 	"O"	:	"[1060]";
  30 | 
  31 | INSTANCE "nand2":"physical"
  32 | 	"a"	:	"[1070]";
  33 | 	"b"	:	"[1060]";
  34 | 	"O"	:	"[1079]";
  35 | 
  36 | INSTANCE "inv":"physical"
  37 | 	"a"	:	"c";
  38 | 	"O"	:	"[1072]";
  39 | 
  40 | INSTANCE "inv":"physical"
  41 | 	"a"	:	"h";
  42 | 	"O"	:	"[1061]";
  43 | 
  44 | INSTANCE "nand2":"physical"
  45 | 	"a"	:	"[1061]";
  46 | 	"b"	:	"g";
  47 | 	"O"	:	"[1066]";
  48 | 
  49 | INSTANCE "nand2":"physical"
  50 | 	"a"	:	"e";
  51 | 	"b"	:	"f";
  52 | 	"O"	:	"[1087]";
  53 | 
  54 | INSTANCE "inv":"physical"
  55 | 	"a"	:	"g";
  56 | 	"O"	:	"[1059]";
  57 | 
  58 | INSTANCE "nand2":"physical"
  59 | 	"a"	:	"[1059]";
  60 | 	"b"	:	"[1061]";
  61 | 	"O"	:	"[1062]";
  62 | 
  63 | INSTANCE "oai22":"physical"
  64 | 	"a"	:	"j";
  65 | 	"b"	:	"[1062]";
  66 | 	"c"	:	"[1059]";
  67 | 	"d"	:	"[1060]";
  68 | 	"O"	:	"[1063]";
  69 | 
  70 | INSTANCE "inv":"physical"
  71 | 	"a"	:	"[1063]";
  72 | 	"O"	:	"[1572]";
  73 | 
  74 | INSTANCE "nand2":"physical"
  75 | 	"a"	:	"g";
  76 | 	"b"	:	"[1572]";
  77 | 	"O"	:	"[1064]";
  78 | 
  79 | INSTANCE "nand2":"physical"
  80 | 	"a"	:	"[1070]";
  81 | 	"b"	:	"e";
  82 | 	"O"	:	"[1088]";
  83 | 
  84 | INSTANCE "nor3":"physical"
  85 | 	"a"	:	"[1064]";
  86 | 	"b"	:	"[1061]";
  87 | 	"c"	:	"[1088]";
  88 | 	"O"	:	"[446]";
  89 | 
  90 | INSTANCE "inv":"physical"
  91 | 	"a"	:	"[1066]";
  92 | 	"O"	:	"[1605]";
  93 | 
  94 | INSTANCE "inv":"physical"
  95 | 	"a"	:	"e";
  96 | 	"O"	:	"[1069]";
  97 | 
  98 | INSTANCE "nand2":"physical"
  99 | 	"a"	:	"[1069]";
 100 | 	"b"	:	"f";
 101 | 	"O"	:	"[1071]";
 102 | 
 103 | INSTANCE "nor3":"physical"
 104 | 	"a"	:	"[1605]";
 105 | 	"b"	:	"[1060]";
 106 | 	"c"	:	"[1071]";
 107 | 	"O"	:	"[447]";
 108 | 
 109 | INSTANCE "nor2":"physical"
 110 | 	"a"	:	"[446]";
 111 | 	"b"	:	"[447]";
 112 | 	"O"	:	"[974]";
 113 | 
 114 | INSTANCE "oai21":"physical"
 115 | 	"a"	:	"[1066]";
 116 | 	"b"	:	"[1087]";
 117 | 	"c"	:	"[974]";
 118 | 	"O"	:	"[1092]";
 119 | 
 120 | INSTANCE "inv":"physical"
 121 | 	"a"	:	"[1088]";
 122 | 	"O"	:	"[1533]";
 123 | 
 124 | INSTANCE "nand2":"physical"
 125 | 	"a"	:	"a";
 126 | 	"b"	:	"[1533]";
 127 | 	"O"	:	"[1093]";
 128 | 
 129 | INSTANCE "inv":"physical"
 130 | 	"a"	:	"[1087]";
 131 | 	"O"	:	"[1477]";
 132 | 
 133 | INSTANCE "nand2":"physical"
 134 | 	"a"	:	"[1069]";
 135 | 	"b"	:	"[1070]";
 136 | 	"O"	:	"[1083]";
 137 | 
 138 | INSTANCE "inv":"physical"
 139 | 	"a"	:	"[1083]";
 140 | 	"O"	:	"[1506]";
 141 | 
 142 | INSTANCE "nand2":"physical"
 143 | 	"a"	:	"a";
 144 | 	"b"	:	"c";
 145 | 	"O"	:	"[1073]";
 146 | 
 147 | INSTANCE "nand2":"physical"
 148 | 	"a"	:	"[1073]";
 149 | 	"b"	:	"c";
 150 | 	"O"	:	"[1074]";
 151 | 
 152 | INSTANCE "nor4":"physical"
 153 | 	"a"	:	"[1477]";
 154 | 	"b"	:	"[1506]";
 155 | 	"c"	:	"[1572]";
 156 | 	"d"	:	"[1074]";
 157 | 	"O"	:	"[442]";
 158 | 
 159 | INSTANCE "nand2":"physical"
 160 | 	"a"	:	"j";
 161 | 	"b"	:	"h";
 162 | 	"O"	:	"[1096]";
 163 | 
 164 | INSTANCE "or2":"physical"
 165 | 	"a"	:	"[1073]";
 166 | 	"b"	:	"[1096]";
 167 | 	"O"	:	"[1097]";
 168 | 
 169 | INSTANCE "nand2":"physical"
 170 | 	"a"	:	"[1088]";
 171 | 	"b"	:	"[1572]";
 172 | 	"O"	:	"[1098]";
 173 | 
 174 | INSTANCE "nor2":"physical"
 175 | 	"a"	:	"[1097]";
 176 | 	"b"	:	"[1098]";
 177 | 	"O"	:	"[443]";
 178 | 
 179 | INSTANCE "nor2":"physical"
 180 | 	"a"	:	"[442]";
 181 | 	"b"	:	"[443]";
 182 | 	"O"	:	"[312]";
 183 | 
 184 | INSTANCE "oai22":"physical"
 185 | 	"a"	:	"[1572]";
 186 | 	"b"	:	"[1093]";
 187 | 	"c"	:	"[312]";
 188 | 	"d"	:	"[1092]";
 189 | 	"O"	:	"[1099]";
 190 | 
 191 | INSTANCE "aoi21":"physical"
 192 | 	"a"	:	"[1072]";
 193 | 	"b"	:	"[1092]";
 194 | 	"c"	:	"[1099]";
 195 | 	"O"	:	"[947]";
 196 | 
 197 | INSTANCE "oai22":"physical"
 198 | 	"a"	:	"g";
 199 | 	"b"	:	"[1079]";
 200 | 	"c"	:	"j";
 201 | 	"d"	:	"[1572]";
 202 | 	"O"	:	"[1080]";
 203 | 
 204 | INSTANCE "inv":"physical"
 205 | 	"a"	:	"a";
 206 | 	"O"	:	"[1065]";
 207 | 
 208 | INSTANCE "nand3":"physical"
 209 | 	"a"	:	"[1080]";
 210 | 	"b"	:	"[1065]";
 211 | 	"c"	:	"[1069]";
 212 | 	"O"	:	"[2069]";
 213 | 
 214 | INSTANCE "nor2":"physical"
 215 | 	"a"	:	"[1073]";
 216 | 	"b"	:	"[1083]";
 217 | 	"O"	:	"[1006]";
 218 | 
 219 | INSTANCE "nand2":"physical"
 220 | 	"a"	:	"[1073]";
 221 | 	"b"	:	"a";
 222 | 	"O"	:	"[1075]";
 223 | 
 224 | INSTANCE "nor3":"physical"
 225 | 	"a"	:	"[1075]";
 226 | 	"b"	:	"[1060]";
 227 | 	"c"	:	"[1071]";
 228 | 	"O"	:	"[436]";
 229 | 
 230 | INSTANCE "aoi21":"physical"
 231 | 	"a"	:	"[1605]";
 232 | 	"b"	:	"[1006]";
 233 | 	"c"	:	"[436]";
 234 | 	"O"	:	"[951]";
 235 | 
 236 | INSTANCE "nand3":"physical"
 237 | 	"a"	:	"[947]";
 238 | 	"b"	:	"[2069]";
 239 | 	"c"	:	"[951]";
 240 | 	"O"	:	"[1101]";
 241 | 
 242 | INSTANCE "inv":"physical"
 243 | 	"a"	:	"[1101]";
 244 | 	"O"	:	"[1378]";
 245 | 
 246 | INSTANCE "nand2":"physical"
 247 | 	"a"	:	"[1074]";
 248 | 	"b"	:	"[1075]";
 249 | 	"O"	:	"[1076]";
 250 | 
 251 | INSTANCE "inv":"physical"
 252 | 	"a"	:	"[1076]";
 253 | 	"O"	:	"[1700]";
 254 | 
 255 | INSTANCE "nor2":"physical"
 256 | 	"a"	:	"[1378]";
 257 | 	"b"	:	"[1700]";
 258 | 	"O"	:	"[842]";
 259 | 
 260 | INSTANCE "or2":"physical"
 261 | 	"a"	:	"[1477]";
 262 | 	"b"	:	"[1092]";
 263 | 	"O"	:	"[1134]";
 264 | 
 265 | INSTANCE "oai22":"physical"
 266 | 	"a"	:	"[1074]";
 267 | 	"b"	:	"[1134]";
 268 | 	"c"	:	"[1533]";
 269 | 	"d"	:	"[1073]";
 270 | 	"O"	:	"[1809]";
 271 | 
 272 | INSTANCE "aoi22":"physical"
 273 | 	"a"	:	"[1079]";
 274 | 	"b"	:	"[842]";
 275 | 	"c"	:	"[1809]";
 276 | 	"d"	:	"h";
 277 | 	"O"	:	"[301]";
 278 | 
 279 | INSTANCE "nand2":"physical"
 280 | 	"a"	:	"[1059]";
 281 | 	"b"	:	"[1533]";
 282 | 	"O"	:	"[1114]";
 283 | 
 284 | INSTANCE "nor2":"physical"
 285 | 	"a"	:	"[1074]";
 286 | 	"b"	:	"[1114]";
 287 | 	"O"	:	"[424]";
 288 | 
 289 | INSTANCE "nand2":"physical"
 290 | 	"a"	:	"j";
 291 | 	"b"	:	"[1605]";
 292 | 	"O"	:	"[1117]";
 293 | 
 294 | INSTANCE "inv":"physical"
 295 | 	"a"	:	"[1117]";
 296 | 	"O"	:	"[1692]";
 297 | 
 298 | INSTANCE "nand2":"physical"
 299 | 	"a"	:	"[1533]";
 300 | 	"b"	:	"[1692]";
 301 | 	"O"	:	"[1119]";
 302 | 
 303 | INSTANCE "or2":"physical"
 304 | 	"a"	:	"[1071]";
 305 | 	"b"	:	"[1096]";
 306 | 	"O"	:	"[1115]";
 307 | 
 308 | INSTANCE "nand2":"physical"
 309 | 	"a"	:	"[1101]";
 310 | 	"b"	:	"a";
 311 | 	"O"	:	"[1118]";
 312 | 
 313 | INSTANCE "oai22":"physical"
 314 | 	"a"	:	"[1087]";
 315 | 	"b"	:	"[1118]";
 316 | 	"c"	:	"[1083]";
 317 | 	"d"	:	"[1101]";
 318 | 	"O"	:	"[1847]";
 319 | 
 320 | INSTANCE "nor2":"physical"
 321 | 	"a"	:	"[1073]";
 322 | 	"b"	:	"[1119]";
 323 | 	"O"	:	"[430]";
 324 | 
 325 | INSTANCE "aoi21":"physical"
 326 | 	"a"	:	"[1847]";
 327 | 	"b"	:	"[1692]";
 328 | 	"c"	:	"[430]";
 329 | 	"O"	:	"[888]";
 330 | 
 331 | INSTANCE "nand2":"physical"
 332 | 	"a"	:	"[1115]";
 333 | 	"b"	:	"[888]";
 334 | 	"O"	:	"[1121]";
 335 | 
 336 | INSTANCE "nor3":"physical"
 337 | 	"a"	:	"[1115]";
 338 | 	"b"	:	"g";
 339 | 	"c"	:	"[1073]";
 340 | 	"O"	:	"[427]";
 341 | 
 342 | INSTANCE "inv":"physical"
 343 | 	"a"	:	"[427]";
 344 | 	"O"	:	"[2049]";
 345 | 
 346 | INSTANCE "oai21":"physical"
 347 | 	"a"	:	"[1119]";
 348 | 	"b"	:	"[1121]";
 349 | 	"c"	:	"[2049]";
 350 | 	"O"	:	"[1122]";
 351 | 
 352 | INSTANCE "nand2":"physical"
 353 | 	"a"	:	"[1101]";
 354 | 	"b"	:	"[1087]";
 355 | 	"O"	:	"[1123]";
 356 | 
 357 | INSTANCE "nand2":"physical"
 358 | 	"a"	:	"[1572]";
 359 | 	"b"	:	"[1477]";
 360 | 	"O"	:	"[1102]";
 361 | 
 362 | INSTANCE "nand2":"physical"
 363 | 	"a"	:	"[1063]";
 364 | 	"b"	:	"[1605]";
 365 | 	"O"	:	"[1103]";
 366 | 
 367 | INSTANCE "oai22":"physical"
 368 | 	"a"	:	"[1096]";
 369 | 	"b"	:	"[1102]";
 370 | 	"c"	:	"[1071]";
 371 | 	"d"	:	"[1103]";
 372 | 	"O"	:	"[1104]";
 373 | 
 374 | INSTANCE "nand2":"physical"
 375 | 	"a"	:	"[1063]";
 376 | 	"b"	:	"h";
 377 | 	"O"	:	"[1106]";
 378 | 
 379 | INSTANCE "nand3":"physical"
 380 | 	"a"	:	"[1572]";
 381 | 	"b"	:	"j";
 382 | 	"c"	:	"[1506]";
 383 | 	"O"	:	"[2045]";
 384 | 
 385 | INSTANCE "oai21":"physical"
 386 | 	"a"	:	"[1477]";
 387 | 	"b"	:	"[1106]";
 388 | 	"c"	:	"[2045]";
 389 | 	"O"	:	"[1107]";
 390 | 
 391 | INSTANCE "nor4":"physical"
 392 | 	"a"	:	"[1122]";
 393 | 	"b"	:	"[1123]";
 394 | 	"c"	:	"[1104]";
 395 | 	"d"	:	"[1107]";
 396 | 	"O"	:	"[422]";
 397 | 
 398 | INSTANCE "nor2":"physical"
 399 | 	"a"	:	"[1063]";
 400 | 	"b"	:	"[1075]";
 401 | 	"O"	:	"[423]";
 402 | 
 403 | INSTANCE "nor3":"physical"
 404 | 	"a"	:	"[424]";
 405 | 	"b"	:	"[422]";
 406 | 	"c"	:	"[423]";
 407 | 	"O"	:	"[311]";
 408 | 
 409 | INSTANCE "nand2":"physical"
 410 | 	"a"	:	"[1061]";
 411 | 	"b"	:	"j";
 412 | 	"O"	:	"[1127]";
 413 | 
 414 | INSTANCE "or2":"physical"
 415 | 	"a"	:	"[1605]";
 416 | 	"b"	:	"[1127]";
 417 | 	"O"	:	"[1128]";
 418 | 
 419 | INSTANCE "oai22":"physical"
 420 | 	"a"	:	"[311]";
 421 | 	"b"	:	"[1060]";
 422 | 	"c"	:	"[1065]";
 423 | 	"d"	:	"[1128]";
 424 | 	"O"	:	"[1129]";
 425 | 
 426 | INSTANCE "aoi21":"physical"
 427 | 	"a"	:	"[1107]";
 428 | 	"b"	:	"a";
 429 | 	"c"	:	"[1104]";
 430 | 	"O"	:	"[309]";
 431 | 
 432 | INSTANCE "nor2":"physical"
 433 | 	"a"	:	"[309]";
 434 | 	"b"	:	"[1101]";
 435 | 	"O"	:	"[417]";
 436 | 
 437 | INSTANCE "inv":"physical"
 438 | 	"a"	:	"[1103]";
 439 | 	"O"	:	"[1623]";
 440 | 
 441 | INSTANCE "nand2":"physical"
 442 | 	"a"	:	"[1533]";
 443 | 	"b"	:	"[1623]";
 444 | 	"O"	:	"[1109]";
 445 | 
 446 | INSTANCE "oai21":"physical"
 447 | 	"a"	:	"[1378]";
 448 | 	"b"	:	"[1109]";
 449 | 	"c"	:	"[1075]";
 450 | 	"O"	:	"[1110]";
 451 | 
 452 | INSTANCE "nor3":"physical"
 453 | 	"a"	:	"[1110]";
 454 | 	"b"	:	"[1103]";
 455 | 	"c"	:	"[1104]";
 456 | 	"O"	:	"[415]";
 457 | 
 458 | INSTANCE "nor2":"physical"
 459 | 	"a"	:	"[1477]";
 460 | 	"b"	:	"[1101]";
 461 | 	"O"	:	"[310]";
 462 | 
 463 | INSTANCE "nor3":"physical"
 464 | 	"a"	:	"[310]";
 465 | 	"b"	:	"a";
 466 | 	"c"	:	"[1106]";
 467 | 	"O"	:	"[416]";
 468 | 
 469 | INSTANCE "nor4":"physical"
 470 | 	"a"	:	"[1129]";
 471 | 	"b"	:	"[417]";
 472 | 	"c"	:	"[415]";
 473 | 	"d"	:	"[416]";
 474 | 	"O"	:	"f0";
 475 | 
 476 | INSTANCE "inv":"physical"
 477 | 	"a"	:	"i";
 478 | 	"O"	:	"[1131]";
 479 | 
 480 | INSTANCE "nand3":"physical"
 481 | 	"a"	:	"f0";
 482 | 	"b"	:	"[1131]";
 483 | 	"c"	:	"j";
 484 | 	"O"	:	"[1999]";
 485 | 
 486 | INSTANCE "oai21":"physical"
 487 | 	"a"	:	"j";
 488 | 	"b"	:	"[301]";
 489 | 	"c"	:	"[1999]";
 490 | 	"O"	:	"[1135]";
 491 | 
 492 | INSTANCE "nand2":"physical"
 493 | 	"a"	:	"[1572]";
 494 | 	"b"	:	"[1605]";
 495 | 	"O"	:	"[1067]";
 496 | 
 497 | INSTANCE "nand2":"physical"
 498 | 	"a"	:	"[1067]";
 499 | 	"b"	:	"a";
 500 | 	"O"	:	"[1068]";
 501 | 
 502 | INSTANCE "nor2":"physical"
 503 | 	"a"	:	"[1064]";
 504 | 	"b"	:	"[1068]";
 505 | 	"O"	:	"[398]";
 506 | 
 507 | INSTANCE "nor3":"physical"
 508 | 	"a"	:	"[1067]";
 509 | 	"b"	:	"[1071]";
 510 | 	"c"	:	"[1076]";
 511 | 	"O"	:	"[399]";
 512 | 
 513 | INSTANCE "nor3":"physical"
 514 | 	"a"	:	"[1135]";
 515 | 	"b"	:	"[398]";
 516 | 	"c"	:	"[399]";
 517 | 	"O"	:	"[800]";
 518 | 
 519 | INSTANCE "oai22":"physical"
 520 | 	"a"	:	"[1064]";
 521 | 	"b"	:	"[1083]";
 522 | 	"c"	:	"[1572]";
 523 | 	"d"	:	"[1114]";
 524 | 	"O"	:	"[1137]";
 525 | 
 526 | INSTANCE "nor2":"physical"
 527 | 	"a"	:	"[1378]";
 528 | 	"b"	:	"[1137]";
 529 | 	"O"	:	"[412]";
 530 | 
 531 | INSTANCE "oai22":"physical"
 532 | 	"a"	:	"[1063]";
 533 | 	"b"	:	"[1075]";
 534 | 	"c"	:	"c";
 535 | 	"d"	:	"[1067]";
 536 | 	"O"	:	"[1138]";
 537 | 
 538 | INSTANCE "nor2":"physical"
 539 | 	"a"	:	"[412]";
 540 | 	"b"	:	"[1138]";
 541 | 	"O"	:	"[303]";
 542 | 
 543 | INSTANCE "nand2":"physical"
 544 | 	"a"	:	"[1137]";
 545 | 	"b"	:	"[1378]";
 546 | 	"O"	:	"[2005]";
 547 | 
 548 | INSTANCE "oai21":"physical"
 549 | 	"a"	:	"[303]";
 550 | 	"b"	:	"[1079]";
 551 | 	"c"	:	"[2005]";
 552 | 	"O"	:	"[1139]";
 553 | 
 554 | INSTANCE "inv":"physical"
 555 | 	"a"	:	"[1128]";
 556 | 	"O"	:	"[1740]";
 557 | 
 558 | INSTANCE "nand2":"physical"
 559 | 	"a"	:	"[1477]";
 560 | 	"b"	:	"[1740]";
 561 | 	"O"	:	"[1804]";
 562 | 
 563 | INSTANCE "oai21":"physical"
 564 | 	"a"	:	"f0";
 565 | 	"b"	:	"[1131]";
 566 | 	"c"	:	"[1804]";
 567 | 	"O"	:	"[1140]";
 568 | 
 569 | INSTANCE "nor2":"physical"
 570 | 	"a"	:	"[1139]";
 571 | 	"b"	:	"[1140]";
 572 | 	"O"	:	"[793]";
 573 | 
 574 | INSTANCE "nand2":"physical"
 575 | 	"a"	:	"[800]";
 576 | 	"b"	:	"[793]";
 577 | 	"O"	:	"[454]";
 578 | 
 579 | INSTANCE "nand3":"physical"
 580 | 	"a"	:	"[1080]";
 581 | 	"b"	:	"h";
 582 | 	"c"	:	"[1506]";
 583 | 	"O"	:	"[1883]";
 584 | 
 585 | INSTANCE "inv":"physical"
 586 | 	"a"	:	"[1883]";
 587 | 	"O"	:	"[1884]";
 588 | 
 589 | INSTANCE "nand2":"physical"
 590 | 	"a"	:	"[1067]";
 591 | 	"b"	:	"b";
 592 | 	"O"	:	"[1144]";
 593 | 
 594 | INSTANCE "nand2":"physical"
 595 | 	"a"	:	"b";
 596 | 	"b"	:	"d";
 597 | 	"O"	:	"[1146]";
 598 | 
 599 | INSTANCE "oai21":"physical"
 600 | 	"a"	:	"b";
 601 | 	"b"	:	"d";
 602 | 	"c"	:	"[1146]";
 603 | 	"O"	:	"[453]";
 604 | 
 605 | INSTANCE "inv":"physical"
 606 | 	"a"	:	"[1071]";
 607 | 	"O"	:	"[1446]";
 608 | 
 609 | INSTANCE "nand2":"physical"
 610 | 	"a"	:	"[453]";
 611 | 	"b"	:	"[1446]";
 612 | 	"O"	:	"[1147]";
 613 | 
 614 | INSTANCE "oai22":"physical"
 615 | 	"a"	:	"[1064]";
 616 | 	"b"	:	"[1144]";
 617 | 	"c"	:	"[1067]";
 618 | 	"d"	:	"[1147]";
 619 | 	"O"	:	"[1148]";
 620 | 
 621 | INSTANCE "inv":"physical"
 622 | 	"a"	:	"d";
 623 | 	"O"	:	"[1145]";
 624 | 
 625 | INSTANCE "nand2":"physical"
 626 | 	"a"	:	"[1145]";
 627 | 	"b"	:	"[453]";
 628 | 	"O"	:	"[1742]";
 629 | 
 630 | INSTANCE "nand3":"physical"
 631 | 	"a"	:	"[1742]";
 632 | 	"b"	:	"[1063]";
 633 | 	"c"	:	"[1533]";
 634 | 	"O"	:	"[1977]";
 635 | 
 636 | INSTANCE "nor3":"physical"
 637 | 	"a"	:	"[1092]";
 638 | 	"b"	:	"[1533]";
 639 | 	"c"	:	"[1146]";
 640 | 	"O"	:	"[768]";
 641 | 
 642 | INSTANCE "inv":"physical"
 643 | 	"a"	:	"[1106]";
 644 | 	"O"	:	"[1706]";
 645 | 
 646 | INSTANCE "nor2":"physical"
 647 | 	"a"	:	"[1706]";
 648 | 	"b"	:	"[1096]";
 649 | 	"O"	:	"[763]";
 650 | 
 651 | INSTANCE "inv":"physical"
 652 | 	"a"	:	"[1074]";
 653 | 	"O"	:	"[1649]";
 654 | 
 655 | INSTANCE "inv":"physical"
 656 | 	"a"	:	"[453]";
 657 | 	"O"	:	"[1351]";
 658 | 
 659 | INSTANCE "aoi22":"physical"
 660 | 	"a"	:	"[453]";
 661 | 	"b"	:	"[1649]";
 662 | 	"c"	:	"[1074]";
 663 | 	"d"	:	"[1351]";
 664 | 	"O"	:	"[318]";
 665 | 
 666 | INSTANCE "nor3":"physical"
 667 | 	"a"	:	"[318]";
 668 | 	"b"	:	"[1071]";
 669 | 	"c"	:	"[1117]";
 670 | 	"O"	:	"[387]";
 671 | 
 672 | INSTANCE "aoi21":"physical"
 673 | 	"a"	:	"[768]";
 674 | 	"b"	:	"[763]";
 675 | 	"c"	:	"[387]";
 676 | 	"O"	:	"[729]";
 677 | 
 678 | INSTANCE "nand2":"physical"
 679 | 	"a"	:	"[1145]";
 680 | 	"b"	:	"[1092]";
 681 | 	"O"	:	"[1983]";
 682 | 
 683 | INSTANCE "nor2":"physical"
 684 | 	"a"	:	"b";
 685 | 	"b"	:	"e";
 686 | 	"O"	:	"[744]";
 687 | 
 688 | INSTANCE "oai22":"physical"
 689 | 	"a"	:	"[1065]";
 690 | 	"b"	:	"[1106]";
 691 | 	"c"	:	"[1066]";
 692 | 	"d"	:	"[1146]";
 693 | 	"O"	:	"[1839]";
 694 | 
 695 | INSTANCE "aoi22":"physical"
 696 | 	"a"	:	"[1080]";
 697 | 	"b"	:	"[744]";
 698 | 	"c"	:	"[1839]";
 699 | 	"d"	:	"[1506]";
 700 | 	"O"	:	"[724]";
 701 | 
 702 | INSTANCE "nand4":"physical"
 703 | 	"a"	:	"[1977]";
 704 | 	"b"	:	"[729]";
 705 | 	"c"	:	"[1983]";
 706 | 	"d"	:	"[724]";
 707 | 	"O"	:	"[1160]";
 708 | 
 709 | INSTANCE "nand3":"physical"
 710 | 	"a"	:	"[1079]";
 711 | 	"b"	:	"[1160]";
 712 | 	"c"	:	"[1351]";
 713 | 	"O"	:	"[1895]";
 714 | 
 715 | INSTANCE "oai22":"physical"
 716 | 	"a"	:	"[1080]";
 717 | 	"b"	:	"[1146]";
 718 | 	"c"	:	"[1071]";
 719 | 	"d"	:	"[1145]";
 720 | 	"O"	:	"[1815]";
 721 | 
 722 | INSTANCE "nand2":"physical"
 723 | 	"a"	:	"[1815]";
 724 | 	"b"	:	"h";
 725 | 	"O"	:	"[1897]";
 726 | 
 727 | INSTANCE "aoi21":"physical"
 728 | 	"a"	:	"[1895]";
 729 | 	"b"	:	"[1897]";
 730 | 	"c"	:	"j";
 731 | 	"O"	:	"[340]";
 732 | 
 733 | INSTANCE "inv":"physical"
 734 | 	"a"	:	"[1137]";
 735 | 	"O"	:	"[1698]";
 736 | 
 737 | INSTANCE "inv":"physical"
 738 | 	"a"	:	"[2311]";
 739 | 	"O"	:	"[1162]";
 740 | 
 741 | INSTANCE "oai22":"physical"
 742 | 	"a"	:	"d";
 743 | 	"b"	:	"[1067]";
 744 | 	"c"	:	"[1063]";
 745 | 	"d"	:	"[1162]";
 746 | 	"O"	:	"[1163]";
 747 | 
 748 | INSTANCE "aoi21":"physical"
 749 | 	"a"	:	"[1160]";
 750 | 	"b"	:	"[1698]";
 751 | 	"c"	:	"[1163]";
 752 | 	"O"	:	"[306]";
 753 | 
 754 | INSTANCE "nor2":"physical"
 755 | 	"a"	:	"[306]";
 756 | 	"b"	:	"[1079]";
 757 | 	"O"	:	"[341]";
 758 | 
 759 | INSTANCE "nor4":"physical"
 760 | 	"a"	:	"[1884]";
 761 | 	"b"	:	"[1148]";
 762 | 	"c"	:	"[340]";
 763 | 	"d"	:	"[341]";
 764 | 	"O"	:	"[534]";
 765 | 
 766 | INSTANCE "nor2":"physical"
 767 | 	"a"	:	"a";
 768 | 	"b"	:	"b";
 769 | 	"O"	:	"[626]";
 770 | 
 771 | INSTANCE "nand3":"physical"
 772 | 	"a"	:	"[1477]";
 773 | 	"b"	:	"[1160]";
 774 | 	"c"	:	"b";
 775 | 	"O"	:	"[1969]";
 776 | 
 777 | INSTANCE "oai21":"physical"
 778 | 	"a"	:	"[1083]";
 779 | 	"b"	:	"[1160]";
 780 | 	"c"	:	"[1969]";
 781 | 	"O"	:	"[1845]";
 782 | 
 783 | INSTANCE "inv":"physical"
 784 | 	"a"	:	"[1115]";
 785 | 	"O"	:	"[1552]";
 786 | 
 787 | INSTANCE "aoi21":"physical"
 788 | 	"a"	:	"[1845]";
 789 | 	"b"	:	"[1692]";
 790 | 	"c"	:	"[2308]";
 791 | 	"O"	:	"[674]";
 792 | 
 793 | INSTANCE "oai21":"physical"
 794 | 	"a"	:	"[1119]";
 795 | 	"b"	:	"[1146]";
 796 | 	"c"	:	"[674]";
 797 | 	"O"	:	"[1169]";
 798 | 
 799 | INSTANCE "nor2":"physical"
 800 | 	"a"	:	"[1121]";
 801 | 	"b"	:	"[1169]";
 802 | 	"O"	:	"[622]";
 803 | 
 804 | INSTANCE "aoi22":"physical"
 805 | 	"a"	:	"[1706]";
 806 | 	"b"	:	"[626]";
 807 | 	"c"	:	"[1623]";
 808 | 	"d"	:	"[622]";
 809 | 	"O"	:	"[17]";
 810 | 
 811 | INSTANCE "nor2":"physical"
 812 | 	"a"	:	"[17]";
 813 | 	"b"	:	"[1087]";
 814 | 	"O"	:	"[359]";
 815 | 
 816 | INSTANCE "nand2":"physical"
 817 | 	"a"	:	"[1162]";
 818 | 	"b"	:	"[1572]";
 819 | 	"O"	:	"[1188]";
 820 | 
 821 | INSTANCE "nor2":"physical"
 822 | 	"a"	:	"[1097]";
 823 | 	"b"	:	"[1188]";
 824 | 	"O"	:	"[366]";
 825 | 
 826 | INSTANCE "nor2":"physical"
 827 | 	"a"	:	"[366]";
 828 | 	"b"	:	"[1104]";
 829 | 	"O"	:	"[315]";
 830 | 
 831 | INSTANCE "inv":"physical"
 832 | 	"a"	:	"[1160]";
 833 | 	"O"	:	"[1418]";
 834 | 
 835 | INSTANCE "nand2":"physical"
 836 | 	"a"	:	"[1118]";
 837 | 	"b"	:	"[1418]";
 838 | 	"O"	:	"[1945]";
 839 | 
 840 | INSTANCE "oai21":"physical"
 841 | 	"a"	:	"[1418]";
 842 | 	"b"	:	"[1118]";
 843 | 	"c"	:	"[1945]";
 844 | 	"O"	:	"[1175]";
 845 | 
 846 | INSTANCE "nand2":"physical"
 847 | 	"a"	:	"[1175]";
 848 | 	"b"	:	"[1378]";
 849 | 	"O"	:	"[1187]";
 850 | 
 851 | INSTANCE "nand3":"physical"
 852 | 	"a"	:	"[1175]";
 853 | 	"b"	:	"a";
 854 | 	"c"	:	"b";
 855 | 	"O"	:	"[1193]";
 856 | 
 857 | INSTANCE "nand2":"physical"
 858 | 	"a"	:	"[1063]";
 859 | 	"b"	:	"[1109]";
 860 | 	"O"	:	"[1194]";
 861 | 
 862 | INSTANCE "nor3":"physical"
 863 | 	"a"	:	"[1169]";
 864 | 	"b"	:	"[1378]";
 865 | 	"c"	:	"[1418]";
 866 | 	"O"	:	"[580]";
 867 | 
 868 | INSTANCE "nand2":"physical"
 869 | 	"a"	:	"[1121]";
 870 | 	"b"	:	"a";
 871 | 	"O"	:	"[1183]";
 872 | 
 873 | INSTANCE "nand3":"physical"
 874 | 	"a"	:	"[580]";
 875 | 	"b"	:	"[1106]";
 876 | 	"c"	:	"[1183]";
 877 | 	"O"	:	"[1937]";
 878 | 
 879 | INSTANCE "oai21":"physical"
 880 | 	"a"	:	"[1193]";
 881 | 	"b"	:	"[1194]";
 882 | 	"c"	:	"[1937]";
 883 | 	"O"	:	"[1195]";
 884 | 
 885 | INSTANCE "aoi21":"physical"
 886 | 	"a"	:	"[1097]";
 887 | 	"b"	:	"[2311]";
 888 | 	"c"	:	"[1195]";
 889 | 	"O"	:	"[316]";
 890 | 
 891 | INSTANCE "oai22":"physical"
 892 | 	"a"	:	"[315]";
 893 | 	"b"	:	"[1187]";
 894 | 	"c"	:	"[316]";
 895 | 	"d"	:	"[1060]";
 896 | 	"O"	:	"[1196]";
 897 | 
 898 | INSTANCE "nor2":"physical"
 899 | 	"a"	:	"[359]";
 900 | 	"b"	:	"[1196]";
 901 | 	"O"	:	"[547]";
 902 | 
 903 | INSTANCE "nand2":"physical"
 904 | 	"a"	:	"[1572]";
 905 | 	"b"	:	"[1552]";
 906 | 	"O"	:	"[1166]";
 907 | 
 908 | INSTANCE "nor2":"physical"
 909 | 	"a"	:	"g";
 910 | 	"b"	:	"[1146]";
 911 | 	"O"	:	"[670]";
 912 | 
 913 | INSTANCE "nand2":"physical"
 914 | 	"a"	:	"[1552]";
 915 | 	"b"	:	"[670]";
 916 | 	"O"	:	"[1959]";
 917 | 
 918 | INSTANCE "oai21":"physical"
 919 | 	"a"	:	"[1119]";
 920 | 	"b"	:	"[1169]";
 921 | 	"c"	:	"[1959]";
 922 | 	"O"	:	"[1171]";
 923 | 
 924 | INSTANCE "inv":"physical"
 925 | 	"a"	:	"[1171]";
 926 | 	"O"	:	"[1473]";
 927 | 
 928 | INSTANCE "inv":"physical"
 929 | 	"a"	:	"[1169]";
 930 | 	"O"	:	"[1436]";
 931 | 
 932 | INSTANCE "aoi22":"physical"
 933 | 	"a"	:	"[1169]";
 934 | 	"b"	:	"[1473]";
 935 | 	"c"	:	"[1171]";
 936 | 	"d"	:	"[1436]";
 937 | 	"O"	:	"[7]";
 938 | 
 939 | INSTANCE "nor3":"physical"
 940 | 	"a"	:	"[1166]";
 941 | 	"b"	:	"[7]";
 942 | 	"c"	:	"[1122]";
 943 | 	"O"	:	"[353]";
 944 | 
 945 | INSTANCE "oai22":"physical"
 946 | 	"a"	:	"[1418]";
 947 | 	"b"	:	"[1171]";
 948 | 	"c"	:	"[1473]";
 949 | 	"d"	:	"[1160]";
 950 | 	"O"	:	"[1655]";
 951 | 
 952 | INSTANCE "nand2":"physical"
 953 | 	"a"	:	"[1655]";
 954 | 	"b"	:	"[1378]";
 955 | 	"O"	:	"[1173]";
 956 | 
 957 | INSTANCE "nor2":"physical"
 958 | 	"a"	:	"[1109]";
 959 | 	"b"	:	"[1173]";
 960 | 	"O"	:	"[354]";
 961 | 
 962 | INSTANCE "nor2":"physical"
 963 | 	"a"	:	"[353]";
 964 | 	"b"	:	"[354]";
 965 | 	"O"	:	"[553]";
 966 | 
 967 | INSTANCE "nand2":"physical"
 968 | 	"a"	:	"[1175]";
 969 | 	"b"	:	"b";
 970 | 	"O"	:	"[1925]";
 971 | 
 972 | INSTANCE "oai21":"physical"
 973 | 	"a"	:	"b";
 974 | 	"b"	:	"[1175]";
 975 | 	"c"	:	"[1925]";
 976 | 	"O"	:	"[1831]";
 977 | 
 978 | INSTANCE "nor3":"physical"
 979 | 	"a"	:	"[1122]";
 980 | 	"b"	:	"[1477]";
 981 | 	"c"	:	"[1506]";
 982 | 	"O"	:	"[616]";
 983 | 
 984 | INSTANCE "nand3":"physical"
 985 | 	"a"	:	"[616]";
 986 | 	"b"	:	"[1655]";
 987 | 	"c"	:	"[17]";
 988 | 	"O"	:	"[1927]";
 989 | 
 990 | INSTANCE "inv":"physical"
 991 | 	"a"	:	"b";
 992 | 	"O"	:	"[1143]";
 993 | 
 994 | INSTANCE "oai22":"physical"
 995 | 	"a"	:	"[1143]";
 996 | 	"b"	:	"[1169]";
 997 | 	"c"	:	"b";
 998 | 	"d"	:	"[1436]";
 999 | 	"O"	:	"[1633]";
1000 | 
1001 | INSTANCE "inv":"physical"
1002 | 	"a"	:	"[1104]";
1003 | 	"O"	:	"[1637]";
1004 | 
1005 | INSTANCE "nand4":"physical"
1006 | 	"a"	:	"[1633]";
1007 | 	"b"	:	"[1637]";
1008 | 	"c"	:	"[1109]";
1009 | 	"d"	:	"[1183]";
1010 | 	"O"	:	"[1929]";
1011 | 
1012 | INSTANCE "aoi21":"physical"
1013 | 	"a"	:	"[1927]";
1014 | 	"b"	:	"[1929]";
1015 | 	"c"	:	"[1127]";
1016 | 	"O"	:	"[356]";
1017 | 
1018 | INSTANCE "aoi21":"physical"
1019 | 	"a"	:	"[1107]";
1020 | 	"b"	:	"[1831]";
1021 | 	"c"	:	"[356]";
1022 | 	"O"	:	"[550]";
1023 | 
1024 | INSTANCE "nand3":"physical"
1025 | 	"a"	:	"[547]";
1026 | 	"b"	:	"[553]";
1027 | 	"c"	:	"[550]";
1028 | 	"O"	:	"[1198]";
1029 | 
1030 | INSTANCE "or2":"physical"
1031 | 	"a"	:	"i";
1032 | 	"b"	:	"f0";
1033 | 	"O"	:	"[1199]";
1034 | 
1035 | INSTANCE "nor2":"physical"
1036 | 	"a"	:	"[1198]";
1037 | 	"b"	:	"[1199]";
1038 | 	"O"	:	"[342]";
1039 | 
1040 | INSTANCE "aoi21":"physical"
1041 | 	"a"	:	"[1198]";
1042 | 	"b"	:	"[1199]";
1043 | 	"c"	:	"[342]";
1044 | 	"O"	:	"[524]";
1045 | 
1046 | INSTANCE "nand2":"physical"
1047 | 	"a"	:	"[1137]";
1048 | 	"b"	:	"[1418]";
1049 | 	"O"	:	"[1893]";
1050 | 
1051 | INSTANCE "nand4":"physical"
1052 | 	"a"	:	"[534]";
1053 | 	"b"	:	"[524]";
1054 | 	"c"	:	"[1804]";
1055 | 	"d"	:	"[1893]";
1056 | 	"O"	:	"[452]";
1057 | 
1058 | INSTANCE "inv":"physical"
1059 | 	"a"	:	"[1146]";
1060 | 	"O"	:	"[1357]";
1061 | 
1062 | INSTANCE "inv":"physical"
1063 | 	"a"	:	"[1198]";
1064 | 	"O"	:	"[1408]";
1065 | 
1066 | INSTANCE "oai22":"physical"
1067 | 	"a"	:	"[1097]";
1068 | 	"b"	:	"[1162]";
1069 | 	"c"	:	"[1408]";
1070 | 	"d"	:	"[1199]";
1071 | 	"O"	:	"[1212]";
1072 | 
1073 | INSTANCE "oai22":"physical"
1074 | 	"a"	:	"[17]";
1075 | 	"b"	:	"[1087]";
1076 | 	"c"	:	"[1418]";
1077 | 	"d"	:	"[1473]";
1078 | 	"O"	:	"[1213]";
1079 | 
1080 | INSTANCE "nor2":"physical"
1081 | 	"a"	:	"[1212]";
1082 | 	"b"	:	"[1213]";
1083 | 	"O"	:	"[463]";
1084 | 
1085 | INSTANCE "inv":"physical"
1086 | 	"a"	:	"[1175]";
1087 | 	"O"	:	"[1500]";
1088 | 
1089 | INSTANCE "nor2":"physical"
1090 | 	"a"	:	"[1418]";
1091 | 	"b"	:	"[1500]";
1092 | 	"O"	:	"[518]";
1093 | 
1094 | INSTANCE "aoi22":"physical"
1095 | 	"a"	:	"[1166]";
1096 | 	"b"	:	"[518]";
1097 | 	"c"	:	"[1572]";
1098 | 	"d"	:	"[1357]";
1099 | 	"O"	:	"[510]";
1100 | 
1101 | INSTANCE "oai21":"physical"
1102 | 	"a"	:	"[1143]";
1103 | 	"b"	:	"[1198]";
1104 | 	"c"	:	"[510]";
1105 | 	"O"	:	"[1821]";
1106 | 
1107 | INSTANCE "nor2":"physical"
1108 | 	"a"	:	"[1477]";
1109 | 	"b"	:	"[1096]";
1110 | 	"O"	:	"[506]";
1111 | 
1112 | INSTANCE "inv":"physical"
1113 | 	"a"	:	"[1166]";
1114 | 	"O"	:	"[1720]";
1115 | 
1116 | INSTANCE "aoi22":"physical"
1117 | 	"a"	:	"[1122]";
1118 | 	"b"	:	"[1720]";
1119 | 	"c"	:	"a";
1120 | 	"d"	:	"[1506]";
1121 | 	"O"	:	"[15]";
1122 | 
1123 | INSTANCE "nor3":"physical"
1124 | 	"a"	:	"[1183]";
1125 | 	"b"	:	"[1436]";
1126 | 	"c"	:	"[15]";
1127 | 	"O"	:	"[323]";
1128 | 
1129 | INSTANCE "aoi21":"physical"
1130 | 	"a"	:	"[1821]";
1131 | 	"b"	:	"[506]";
1132 | 	"c"	:	"[323]";
1133 | 	"O"	:	"[469]";
1134 | 
1135 | INSTANCE "nor2":"physical"
1136 | 	"a"	:	"f";
1137 | 	"b"	:	"[1198]";
1138 | 	"O"	:	"[492]";
1139 | 
1140 | INSTANCE "nand3":"physical"
1141 | 	"a"	:	"[1572]";
1142 | 	"b"	:	"j";
1143 | 	"c"	:	"[1477]";
1144 | 	"O"	:	"[1865]";
1145 | 
1146 | INSTANCE "oai21":"physical"
1147 | 	"a"	:	"[1071]";
1148 | 	"b"	:	"[1103]";
1149 | 	"c"	:	"[1865]";
1150 | 	"O"	:	"[1819]";
1151 | 
1152 | INSTANCE "inv":"physical"
1153 | 	"a"	:	"[1187]";
1154 | 	"O"	:	"[1779]";
1155 | 
1156 | INSTANCE "aoi22":"physical"
1157 | 	"a"	:	"[1623]";
1158 | 	"b"	:	"[492]";
1159 | 	"c"	:	"[1819]";
1160 | 	"d"	:	"[1779]";
1161 | 	"O"	:	"[466]";
1162 | 
1163 | INSTANCE "nand3":"physical"
1164 | 	"a"	:	"[463]";
1165 | 	"b"	:	"[469]";
1166 | 	"c"	:	"[466]";
1167 | 	"O"	:	"[451]";
1168 | 
1169 | INSTANCE "nor2":"physical"
1170 | 	"a"	:	"[1351]";
1171 | 	"b"	:	"[1076]";
1172 | 	"O"	:	"[5]";
1173 | 
1174 | INSTANCE "aoi21":"physical"
1175 | 	"a"	:	"[1143]";
1176 | 	"b"	:	"[1418]";
1177 | 	"c"	:	"[1115]";
1178 | 	"O"	:	"[2308]";
1179 | 
1180 | INSTANCE "nor2":"physical"
1181 | 	"a"	:	"[453]";
1182 | 	"b"	:	"[1114]";
1183 | 	"O"	:	"[2311]";
1184 | 
1185 | ENDMODEL;
1186 | 


--------------------------------------------------------------------------------
/benchmarks/comb/apex6.bdnet:
--------------------------------------------------------------------------------
   1 | MODEL "apex6";
   2 | 
   3 | INPUT
   4 | 	"PSRW"	:	"PSRW"
   5 | 	"VFIN"	:	"VFIN"
   6 | 	"PFIN"	:	"PFIN"
   7 | 	"INFIN"	:	"INFIN"
   8 | 	"VYBB0"	:	"VYBB0"
   9 | 	"VYBB1"	:	"VYBB1"
  10 | 	"VZZZE"	:	"VZZZE"
  11 | 	"PYBB0"	:	"PYBB0"
  12 | 	"PYBB1"	:	"PYBB1"
  13 | 	"PYBB2"	:	"PYBB2"
  14 | 	"PYBB3"	:	"PYBB3"
  15 | 	"PYBB4"	:	"PYBB4"
  16 | 	"PYBB5"	:	"PYBB5"
  17 | 	"PYBB6"	:	"PYBB6"
  18 | 	"PYBB7"	:	"PYBB7"
  19 | 	"PYBB8"	:	"PYBB8"
  20 | 	"PZZZE"	:	"PZZZE"
  21 | 	"INYBB0"	:	"INYBB0"
  22 | 	"INYBB1"	:	"INYBB1"
  23 | 	"INYBB2"	:	"INYBB2"
  24 | 	"INYBB3"	:	"INYBB3"
  25 | 	"INYBB4"	:	"INYBB4"
  26 | 	"INYBB5"	:	"INYBB5"
  27 | 	"INYBB6"	:	"INYBB6"
  28 | 	"INYBB7"	:	"INYBB7"
  29 | 	"INYBB8"	:	"INYBB8"
  30 | 	"INZZZE"	:	"INZZZE"
  31 | 	"MMERR"	:	"MMERR"
  32 | 	"ESRSUM"	:	"ESRSUM"
  33 | 	"CBT0"	:	"CBT0"
  34 | 	"CBT1"	:	"CBT1"
  35 | 	"CBT2"	:	"CBT2"
  36 | 	"SLAD0"	:	"SLAD0"
  37 | 	"SLAD1"	:	"SLAD1"
  38 | 	"SLAD2"	:	"SLAD2"
  39 | 	"SLAD3"	:	"SLAD3"
  40 | 	"PSYNC"	:	"PSYNC"
  41 | 	"RPTEN"	:	"RPTEN"
  42 | 	"ICLR"	:	"ICLR"
  43 | 	"STW_N"	:	"STW_N"
  44 | 	"P1ZZZ0"	:	"P1ZZZ0"
  45 | 	"P1ZZZ1"	:	"P1ZZZ1"
  46 | 	"P1ZZZ2"	:	"P1ZZZ2"
  47 | 	"P1ZZZ3"	:	"P1ZZZ3"
  48 | 	"P1ZZZ4"	:	"P1ZZZ4"
  49 | 	"P1ZZZ5"	:	"P1ZZZ5"
  50 | 	"P1ZZZ6"	:	"P1ZZZ6"
  51 | 	"P1ZZZ7"	:	"P1ZZZ7"
  52 | 	"P2ZZZ0"	:	"P2ZZZ0"
  53 | 	"P2ZZZ1"	:	"P2ZZZ1"
  54 | 	"P2ZZZ2"	:	"P2ZZZ2"
  55 | 	"P2ZZZ3"	:	"P2ZZZ3"
  56 | 	"P2ZZZ4"	:	"P2ZZZ4"
  57 | 	"P2ZZZ5"	:	"P2ZZZ5"
  58 | 	"P2ZZZ6"	:	"P2ZZZ6"
  59 | 	"P2ZZZ7"	:	"P2ZZZ7"
  60 | 	"I1ZZZ0"	:	"I1ZZZ0"
  61 | 	"I1ZZZ1"	:	"I1ZZZ1"
  62 | 	"I1ZZZ2"	:	"I1ZZZ2"
  63 | 	"I1ZZZ3"	:	"I1ZZZ3"
  64 | 	"I1ZZZ4"	:	"I1ZZZ4"
  65 | 	"I1ZZZ5"	:	"I1ZZZ5"
  66 | 	"I1ZZZ6"	:	"I1ZZZ6"
  67 | 	"I1ZZZ7"	:	"I1ZZZ7"
  68 | 	"I2ZZZ0"	:	"I2ZZZ0"
  69 | 	"I2ZZZ1"	:	"I2ZZZ1"
  70 | 	"I2ZZZ2"	:	"I2ZZZ2"
  71 | 	"I2ZZZ3"	:	"I2ZZZ3"
  72 | 	"I2ZZZ4"	:	"I2ZZZ4"
  73 | 	"I2ZZZ5"	:	"I2ZZZ5"
  74 | 	"I2ZZZ6"	:	"I2ZZZ6"
  75 | 	"I2ZZZ7"	:	"I2ZZZ7"
  76 | 	"TXMESS_N"	:	"TXMESS_N"
  77 | 	"RYZ"	:	"RYZ"
  78 | 	"COMPPAR"	:	"COMPPAR"
  79 | 	"RPTWIN"	:	"RPTWIN"
  80 | 	"XZFR0"	:	"XZFR0"
  81 | 	"XZFR1"	:	"XZFR1"
  82 | 	"XZFS"	:	"XZFS"
  83 | 	"RXZ0"	:	"RXZ0"
  84 | 	"RXZ1"	:	"RXZ1"
  85 | 	"OFS2"	:	"OFS2"
  86 | 	"OFS1"	:	"OFS1"
  87 | 	"A"	:	"A"
  88 | 	"B"	:	"B"
  89 | 	"C"	:	"C"
  90 | 	"QPR0"	:	"QPR0"
  91 | 	"QPR1"	:	"QPR1"
  92 | 	"QPR2"	:	"QPR2"
  93 | 	"QPR3"	:	"QPR3"
  94 | 	"QPR4"	:	"QPR4"
  95 | 	"AXZ0"	:	"AXZ0"
  96 | 	"AXZ1"	:	"AXZ1"
  97 | 	"V1ZZZ0"	:	"V1ZZZ0"
  98 | 	"V1ZZZ1"	:	"V1ZZZ1"
  99 | 	"V1ZZZ2"	:	"V1ZZZ2"
 100 | 	"V1ZZZ3"	:	"V1ZZZ3"
 101 | 	"V1ZZZ4"	:	"V1ZZZ4"
 102 | 	"V1ZZZ5"	:	"V1ZZZ5"
 103 | 	"V1ZZZ6"	:	"V1ZZZ6"
 104 | 	"V1ZZZ7"	:	"V1ZZZ7"
 105 | 	"V2ZZZ0"	:	"V2ZZZ0"
 106 | 	"V2ZZZ1"	:	"V2ZZZ1"
 107 | 	"V2ZZZ2"	:	"V2ZZZ2"
 108 | 	"V2ZZZ3"	:	"V2ZZZ3"
 109 | 	"V2ZZZ4"	:	"V2ZZZ4"
 110 | 	"V2ZZZ5"	:	"V2ZZZ5"
 111 | 	"V2ZZZ6"	:	"V2ZZZ6"
 112 | 	"V2ZZZ7"	:	"V2ZZZ7"
 113 | 	"TXWRD0"	:	"TXWRD0"
 114 | 	"TXWRD1"	:	"TXWRD1"
 115 | 	"TXWRD2"	:	"TXWRD2"
 116 | 	"TXWRD3"	:	"TXWRD3"
 117 | 	"TXWRD4"	:	"TXWRD4"
 118 | 	"TXWRD5"	:	"TXWRD5"
 119 | 	"TXWRD6"	:	"TXWRD6"
 120 | 	"TXWRD7"	:	"TXWRD7"
 121 | 	"TXWRD8"	:	"TXWRD8"
 122 | 	"TXWRD9"	:	"TXWRD9"
 123 | 	"TXWRD10"	:	"TXWRD10"
 124 | 	"TXWRD11"	:	"TXWRD11"
 125 | 	"TXWRD12"	:	"TXWRD12"
 126 | 	"TXWRD13"	:	"TXWRD13"
 127 | 	"TXWRD14"	:	"TXWRD14"
 128 | 	"TXWRD15"	:	"TXWRD15"
 129 | 	"XZ320"	:	"XZ320"
 130 | 	"XZ321"	:	"XZ321"
 131 | 	"XZ322"	:	"XZ322"
 132 | 	"XZ323"	:	"XZ323"
 133 | 	"XZ324"	:	"XZ324"
 134 | 	"XZ160_N"	:	"XZ160_N"
 135 | 	"XZ161"	:	"XZ161"
 136 | 	"XZ162"	:	"XZ162"
 137 | 	"XZ163"	:	"XZ163"
 138 | 	"ENWIN"	:	"ENWIN";
 139 | 
 140 | OUTPUT
 141 | 	"SBUFF"	:	"[830]"
 142 | 	"STW_F"	:	"[828]"
 143 | 	"TD_P"	:	"[826]"
 144 | 	"FSESR_P"	:	"[825]"
 145 | 	"P1ZZZ0_P"	:	"[824]"
 146 | 	"P1ZZZ1_P"	:	"[823]"
 147 | 	"P1ZZZ2_P"	:	"[822]"
 148 | 	"P1ZZZ3_P"	:	"[821]"
 149 | 	"P1ZZZ4_P"	:	"[820]"
 150 | 	"P1ZZZ5_P"	:	"[819]"
 151 | 	"P1ZZZ6_P"	:	"[818]"
 152 | 	"P1ZZZ7_P"	:	"[817]"
 153 | 	"P2ZZZ0_P"	:	"[816]"
 154 | 	"P2ZZZ1_P"	:	"[815]"
 155 | 	"P2ZZZ2_P"	:	"[814]"
 156 | 	"P2ZZZ3_P"	:	"[813]"
 157 | 	"P2ZZZ4_P"	:	"[812]"
 158 | 	"P2ZZZ5_P"	:	"[811]"
 159 | 	"P2ZZZ6_P"	:	"[810]"
 160 | 	"P2ZZZ7_P"	:	"[809]"
 161 | 	"I1ZZZ0_P"	:	"[808]"
 162 | 	"I1ZZZ1_P"	:	"[807]"
 163 | 	"I1ZZZ2_P"	:	"[806]"
 164 | 	"I1ZZZ3_P"	:	"[805]"
 165 | 	"I1ZZZ4_P"	:	"[804]"
 166 | 	"I1ZZZ5_P"	:	"[803]"
 167 | 	"I1ZZZ6_P"	:	"[802]"
 168 | 	"I1ZZZ7_P"	:	"[801]"
 169 | 	"I2ZZZ0_P"	:	"[800]"
 170 | 	"I2ZZZ1_P"	:	"[799]"
 171 | 	"I2ZZZ2_P"	:	"[798]"
 172 | 	"I2ZZZ3_P"	:	"[797]"
 173 | 	"I2ZZZ4_P"	:	"[796]"
 174 | 	"I2ZZZ5_P"	:	"[795]"
 175 | 	"I2ZZZ6_P"	:	"[794]"
 176 | 	"I2ZZZ7_P"	:	"[793]"
 177 | 	"TXMESS_F"	:	"[829]"
 178 | 	"RYZ_P"	:	"[792]"
 179 | 	"COMPPAR_P"	:	"[827]"
 180 | 	"RPTWIN_P"	:	"[39]"
 181 | 	"XZFR0_P"	:	"[791]"
 182 | 	"XZFR1_P"	:	"[790]"
 183 | 	"XZFS_P"	:	"[42]"
 184 | 	"RXZ0_P"	:	"[789]"
 185 | 	"RXZ1_P"	:	"[788]"
 186 | 	"OFS2_P"	:	"[4740]"
 187 | 	"OFS1_P"	:	"[3058]"
 188 | 	"A_P"	:	"[787]"
 189 | 	"B_P"	:	"[786]"
 190 | 	"C_P"	:	"[49]"
 191 | 	"QPR0_P"	:	"[785]"
 192 | 	"QPR1_P"	:	"[784]"
 193 | 	"QPR2_P"	:	"[783]"
 194 | 	"QPR3_P"	:	"[782]"
 195 | 	"QPR4_P"	:	"[781]"
 196 | 	"AXZ0_P"	:	"[55]"
 197 | 	"AXZ1_P"	:	"[56]"
 198 | 	"V1ZZZ0_P"	:	"[780]"
 199 | 	"V1ZZZ1_P"	:	"[779]"
 200 | 	"V1ZZZ2_P"	:	"[778]"
 201 | 	"V1ZZZ3_P"	:	"[777]"
 202 | 	"V1ZZZ4_P"	:	"[776]"
 203 | 	"V1ZZZ5_P"	:	"[775]"
 204 | 	"V1ZZZ6_P"	:	"[774]"
 205 | 	"V1ZZZ7_P"	:	"[773]"
 206 | 	"V2ZZZ0_P"	:	"[772]"
 207 | 	"V2ZZZ1_P"	:	"[771]"
 208 | 	"V2ZZZ2_P"	:	"[770]"
 209 | 	"V2ZZZ3_P"	:	"[769]"
 210 | 	"V2ZZZ4_P"	:	"[768]"
 211 | 	"V2ZZZ5_P"	:	"[767]"
 212 | 	"V2ZZZ6_P"	:	"[766]"
 213 | 	"V2ZZZ7_P"	:	"[765]"
 214 | 	"TXWRD0_P"	:	"[5015]"
 215 | 	"TXWRD1_P"	:	"[5019]"
 216 | 	"TXWRD2_P"	:	"[5023]"
 217 | 	"TXWRD3_P"	:	"[5027]"
 218 | 	"TXWRD4_P"	:	"[5031]"
 219 | 	"TXWRD5_P"	:	"[5035]"
 220 | 	"TXWRD6_P"	:	"[5039]"
 221 | 	"TXWRD7_P"	:	"[5043]"
 222 | 	"TXWRD8_P"	:	"[5047]"
 223 | 	"TXWRD9_P"	:	"[5051]"
 224 | 	"TXWRD10_P"	:	"[5055]"
 225 | 	"TXWRD11_P"	:	"[5059]"
 226 | 	"TXWRD12_P"	:	"[5063]"
 227 | 	"TXWRD13_P"	:	"[5067]"
 228 | 	"TXWRD14_P"	:	"[5071]"
 229 | 	"TXWRD15_P"	:	"[749]"
 230 | 	"XZ320_P"	:	"[5000]"
 231 | 	"XZ321_P"	:	"[748]"
 232 | 	"XZ322_P"	:	"[747]"
 233 | 	"XZ323_P"	:	"[746]"
 234 | 	"XZ324_P"	:	"[745]"
 235 | 	"XZ160_F"	:	"[744]"
 236 | 	"XZ161_P"	:	"[743]"
 237 | 	"XZ162_P"	:	"[742]"
 238 | 	"XZ163_P"	:	"[741]"
 239 | 	"ENWIN_P"	:	"[98]";
 240 | 
 241 | INSTANCE "inv":"physical"
 242 | 	"a"	:	"RPTWIN";
 243 | 	"O"	:	"[2016]";
 244 | 
 245 | INSTANCE "nand2":"physical"
 246 | 	"a"	:	"[2016]";
 247 | 	"b"	:	"TXMESS_N";
 248 | 	"O"	:	"[830]";
 249 | 
 250 | INSTANCE "inv":"physical"
 251 | 	"a"	:	"RYZ";
 252 | 	"O"	:	"[2614]";
 253 | 
 254 | INSTANCE "inv":"physical"
 255 | 	"a"	:	"A";
 256 | 	"O"	:	"[2017]";
 257 | 
 258 | INSTANCE "inv":"physical"
 259 | 	"a"	:	"AXZ0";
 260 | 	"O"	:	"[2018]";
 261 | 
 262 | INSTANCE "inv":"physical"
 263 | 	"a"	:	"PFIN";
 264 | 	"O"	:	"[2021]";
 265 | 
 266 | INSTANCE "inv":"physical"
 267 | 	"a"	:	"INFIN";
 268 | 	"O"	:	"[2022]";
 269 | 
 270 | INSTANCE "nand3":"physical"
 271 | 	"a"	:	"[2614]";
 272 | 	"b"	:	"[2021]";
 273 | 	"c"	:	"[2022]";
 274 | 	"O"	:	"[2024]";
 275 | 
 276 | INSTANCE "inv":"physical"
 277 | 	"a"	:	"VFIN";
 278 | 	"O"	:	"[2025]";
 279 | 
 280 | INSTANCE "nand2":"physical"
 281 | 	"a"	:	"[2025]";
 282 | 	"b"	:	"TXMESS_N";
 283 | 	"O"	:	"[2026]";
 284 | 
 285 | INSTANCE "oai21":"physical"
 286 | 	"a"	:	"[2024]";
 287 | 	"b"	:	"[2026]";
 288 | 	"c"	:	"[2614]";
 289 | 	"O"	:	"[829]";
 290 | 
 291 | INSTANCE "inv":"physical"
 292 | 	"a"	:	"AXZ1";
 293 | 	"O"	:	"[2020]";
 294 | 
 295 | INSTANCE "nor4":"physical"
 296 | 	"a"	:	"[2017]";
 297 | 	"b"	:	"[2018]";
 298 | 	"c"	:	"[829]";
 299 | 	"d"	:	"[2020]";
 300 | 	"O"	:	"[737]";
 301 | 
 302 | INSTANCE "nor2":"physical"
 303 | 	"a"	:	"VFIN";
 304 | 	"b"	:	"[2024]";
 305 | 	"O"	:	"[1994]";
 306 | 
 307 | INSTANCE "oai21":"physical"
 308 | 	"a"	:	"STW_N";
 309 | 	"b"	:	"[737]";
 310 | 	"c"	:	"[1994]";
 311 | 	"O"	:	"[4291]";
 312 | 
 313 | INSTANCE "nand2":"physical"
 314 | 	"a"	:	"[2614]";
 315 | 	"b"	:	"[4291]";
 316 | 	"O"	:	"[828]";
 317 | 
 318 | INSTANCE "inv":"physical"
 319 | 	"a"	:	"COMPPAR";
 320 | 	"O"	:	"[2050]";
 321 | 
 322 | INSTANCE "inv":"physical"
 323 | 	"a"	:	"B";
 324 | 	"O"	:	"[2044]";
 325 | 
 326 | INSTANCE "inv":"physical"
 327 | 	"a"	:	"C";
 328 | 	"O"	:	"[2045]";
 329 | 
 330 | INSTANCE "nand2":"physical"
 331 | 	"a"	:	"[2044]";
 332 | 	"b"	:	"[2045]";
 333 | 	"O"	:	"[2046]";
 334 | 
 335 | INSTANCE "inv":"physical"
 336 | 	"a"	:	"SLAD0";
 337 | 	"O"	:	"[2032]";
 338 | 
 339 | INSTANCE "inv":"physical"
 340 | 	"a"	:	"QPR1";
 341 | 	"O"	:	"[2034]";
 342 | 
 343 | INSTANCE "nand2":"physical"
 344 | 	"a"	:	"QPR0";
 345 | 	"b"	:	"[4864]";
 346 | 	"O"	:	"[2037]";
 347 | 
 348 | INSTANCE "inv":"physical"
 349 | 	"a"	:	"QPR0";
 350 | 	"O"	:	"[2033]";
 351 | 
 352 | INSTANCE "aoi22":"physical"
 353 | 	"a"	:	"[2033]";
 354 | 	"b"	:	"SLAD3";
 355 | 	"c"	:	"QPR0";
 356 | 	"d"	:	"SLAD2";
 357 | 	"O"	:	"[420]";
 358 | 
 359 | INSTANCE "inv":"physical"
 360 | 	"a"	:	"QPR2";
 361 | 	"O"	:	"[2035]";
 362 | 
 363 | INSTANCE "nand2":"physical"
 364 | 	"a"	:	"[2035]";
 365 | 	"b"	:	"QPR1";
 366 | 	"O"	:	"[2040]";
 367 | 
 368 | INSTANCE "nand3":"physical"
 369 | 	"a"	:	"[4864]";
 370 | 	"b"	:	"[2037]";
 371 | 	"c"	:	"SLAD1";
 372 | 	"O"	:	"[4283]";
 373 | 
 374 | INSTANCE "oai21":"physical"
 375 | 	"a"	:	"[420]";
 376 | 	"b"	:	"[2040]";
 377 | 	"c"	:	"[4283]";
 378 | 	"O"	:	"[2043]";
 379 | 
 380 | INSTANCE "nor4":"physical"
 381 | 	"a"	:	"QPR3";
 382 | 	"b"	:	"QPR4";
 383 | 	"c"	:	"[4726]";
 384 | 	"d"	:	"[2046]";
 385 | 	"O"	:	"[716]";
 386 | 
 387 | INSTANCE "aoi21":"physical"
 388 | 	"a"	:	"[2046]";
 389 | 	"b"	:	"TXWRD0";
 390 | 	"c"	:	"[716]";
 391 | 	"O"	:	"MIS11154";
 392 | 
 393 | INSTANCE "nor3":"physical"
 394 | 	"a"	:	"MIS11154";
 395 | 	"b"	:	"TXMESS_N";
 396 | 	"c"	:	"COMPPAR";
 397 | 	"O"	:	"[714]";
 398 | 
 399 | INSTANCE "aoi21":"physical"
 400 | 	"a"	:	"MIS11154";
 401 | 	"b"	:	"COMPPAR";
 402 | 	"c"	:	"[714]";
 403 | 	"O"	:	"[392]";
 404 | 
 405 | INSTANCE "nor3":"physical"
 406 | 	"a"	:	"COMPPAR";
 407 | 	"b"	:	"MMERR";
 408 | 	"c"	:	"TXMESS_N";
 409 | 	"O"	:	"[722]";
 410 | 
 411 | INSTANCE "aoi21":"physical"
 412 | 	"a"	:	"COMPPAR";
 413 | 	"b"	:	"MMERR";
 414 | 	"c"	:	"[722]";
 415 | 	"O"	:	"[393]";
 416 | 
 417 | INSTANCE "inv":"physical"
 418 | 	"a"	:	"[4833]";
 419 | 	"O"	:	"[2052]";
 420 | 
 421 | INSTANCE "inv":"physical"
 422 | 	"a"	:	"[4853]";
 423 | 	"O"	:	"[827]";
 424 | 
 425 | INSTANCE "nor3":"physical"
 426 | 	"a"	:	"[827]";
 427 | 	"b"	:	"RYZ";
 428 | 	"c"	:	"[2050]";
 429 | 	"O"	:	"[708]";
 430 | 
 431 | INSTANCE "aoi21":"physical"
 432 | 	"a"	:	"[2050]";
 433 | 	"b"	:	"[827]";
 434 | 	"c"	:	"[708]";
 435 | 	"O"	:	"[388]";
 436 | 
 437 | INSTANCE "inv":"physical"
 438 | 	"a"	:	"ESRSUM";
 439 | 	"O"	:	"[2055]";
 440 | 
 441 | INSTANCE "inv":"physical"
 442 | 	"a"	:	"RXZ0";
 443 | 	"O"	:	"[2060]";
 444 | 
 445 | INSTANCE "inv":"physical"
 446 | 	"a"	:	"QPR3";
 447 | 	"O"	:	"[2029]";
 448 | 
 449 | INSTANCE "inv":"physical"
 450 | 	"a"	:	"[4836]";
 451 | 	"O"	:	"[2065]";
 452 | 
 453 | INSTANCE "nor4":"physical"
 454 | 	"a"	:	"QPR4";
 455 | 	"b"	:	"[830]";
 456 | 	"c"	:	"[4726]";
 457 | 	"d"	:	"[2065]";
 458 | 	"O"	:	"[706]";
 459 | 
 460 | INSTANCE "nor2":"physical"
 461 | 	"a"	:	"[4737]";
 462 | 	"b"	:	"[706]";
 463 | 	"O"	:	"[1868]";
 464 | 
 465 | INSTANCE "oai21":"physical"
 466 | 	"a"	:	"RPTWIN";
 467 | 	"b"	:	"[388]";
 468 | 	"c"	:	"[1868]";
 469 | 	"O"	:	"[826]";
 470 | 
 471 | INSTANCE "inv":"physical"
 472 | 	"a"	:	"ICLR";
 473 | 	"O"	:	"[2461]";
 474 | 
 475 | INSTANCE "inv":"physical"
 476 | 	"a"	:	"XZFR1";
 477 | 	"O"	:	"[2071]";
 478 | 
 479 | INSTANCE "inv":"physical"
 480 | 	"a"	:	"[4745]";
 481 | 	"O"	:	"[825]";
 482 | 
 483 | INSTANCE "nand3":"physical"
 484 | 	"a"	:	"[2614]";
 485 | 	"b"	:	"PYBB0";
 486 | 	"c"	:	"PZZZE";
 487 | 	"O"	:	"[2076]";
 488 | 
 489 | INSTANCE "nand2":"physical"
 490 | 	"a"	:	"PYBB0";
 491 | 	"b"	:	"[4839]";
 492 | 	"O"	:	"[2078]";
 493 | 
 494 | INSTANCE "inv":"physical"
 495 | 	"a"	:	"[4551]";
 496 | 	"O"	:	"[824]";
 497 | 
 498 | INSTANCE "inv":"physical"
 499 | 	"a"	:	"[4561]";
 500 | 	"O"	:	"[823]";
 501 | 
 502 | INSTANCE "inv":"physical"
 503 | 	"a"	:	"[4571]";
 504 | 	"O"	:	"[822]";
 505 | 
 506 | INSTANCE "inv":"physical"
 507 | 	"a"	:	"[4581]";
 508 | 	"O"	:	"[821]";
 509 | 
 510 | INSTANCE "inv":"physical"
 511 | 	"a"	:	"[4591]";
 512 | 	"O"	:	"[820]";
 513 | 
 514 | INSTANCE "inv":"physical"
 515 | 	"a"	:	"[4601]";
 516 | 	"O"	:	"[819]";
 517 | 
 518 | INSTANCE "inv":"physical"
 519 | 	"a"	:	"[4611]";
 520 | 	"O"	:	"[818]";
 521 | 
 522 | INSTANCE "inv":"physical"
 523 | 	"a"	:	"[4621]";
 524 | 	"O"	:	"[817]";
 525 | 
 526 | INSTANCE "inv":"physical"
 527 | 	"a"	:	"[4556]";
 528 | 	"O"	:	"[816]";
 529 | 
 530 | INSTANCE "inv":"physical"
 531 | 	"a"	:	"[4566]";
 532 | 	"O"	:	"[815]";
 533 | 
 534 | INSTANCE "inv":"physical"
 535 | 	"a"	:	"[4576]";
 536 | 	"O"	:	"[814]";
 537 | 
 538 | INSTANCE "inv":"physical"
 539 | 	"a"	:	"[4586]";
 540 | 	"O"	:	"[813]";
 541 | 
 542 | INSTANCE "inv":"physical"
 543 | 	"a"	:	"[4596]";
 544 | 	"O"	:	"[812]";
 545 | 
 546 | INSTANCE "inv":"physical"
 547 | 	"a"	:	"[4606]";
 548 | 	"O"	:	"[811]";
 549 | 
 550 | INSTANCE "inv":"physical"
 551 | 	"a"	:	"[4616]";
 552 | 	"O"	:	"[810]";
 553 | 
 554 | INSTANCE "inv":"physical"
 555 | 	"a"	:	"[4626]";
 556 | 	"O"	:	"[809]";
 557 | 
 558 | INSTANCE "nand3":"physical"
 559 | 	"a"	:	"[2614]";
 560 | 	"b"	:	"INYBB0";
 561 | 	"c"	:	"INZZZE";
 562 | 	"O"	:	"[2107]";
 563 | 
 564 | INSTANCE "nand2":"physical"
 565 | 	"a"	:	"INYBB0";
 566 | 	"b"	:	"[4845]";
 567 | 	"O"	:	"[2109]";
 568 | 
 569 | INSTANCE "inv":"physical"
 570 | 	"a"	:	"[4631]";
 571 | 	"O"	:	"[808]";
 572 | 
 573 | INSTANCE "inv":"physical"
 574 | 	"a"	:	"[4641]";
 575 | 	"O"	:	"[807]";
 576 | 
 577 | INSTANCE "inv":"physical"
 578 | 	"a"	:	"[4651]";
 579 | 	"O"	:	"[806]";
 580 | 
 581 | INSTANCE "inv":"physical"
 582 | 	"a"	:	"[4661]";
 583 | 	"O"	:	"[805]";
 584 | 
 585 | INSTANCE "inv":"physical"
 586 | 	"a"	:	"[4671]";
 587 | 	"O"	:	"[804]";
 588 | 
 589 | INSTANCE "inv":"physical"
 590 | 	"a"	:	"[4681]";
 591 | 	"O"	:	"[803]";
 592 | 
 593 | INSTANCE "inv":"physical"
 594 | 	"a"	:	"[4691]";
 595 | 	"O"	:	"[802]";
 596 | 
 597 | INSTANCE "inv":"physical"
 598 | 	"a"	:	"[4701]";
 599 | 	"O"	:	"[801]";
 600 | 
 601 | INSTANCE "inv":"physical"
 602 | 	"a"	:	"[4636]";
 603 | 	"O"	:	"[800]";
 604 | 
 605 | INSTANCE "inv":"physical"
 606 | 	"a"	:	"[4646]";
 607 | 	"O"	:	"[799]";
 608 | 
 609 | INSTANCE "inv":"physical"
 610 | 	"a"	:	"[4656]";
 611 | 	"O"	:	"[798]";
 612 | 
 613 | INSTANCE "inv":"physical"
 614 | 	"a"	:	"[4666]";
 615 | 	"O"	:	"[797]";
 616 | 
 617 | INSTANCE "inv":"physical"
 618 | 	"a"	:	"[4676]";
 619 | 	"O"	:	"[796]";
 620 | 
 621 | INSTANCE "inv":"physical"
 622 | 	"a"	:	"[4686]";
 623 | 	"O"	:	"[795]";
 624 | 
 625 | INSTANCE "inv":"physical"
 626 | 	"a"	:	"[4696]";
 627 | 	"O"	:	"[794]";
 628 | 
 629 | INSTANCE "inv":"physical"
 630 | 	"a"	:	"[4706]";
 631 | 	"O"	:	"[793]";
 632 | 
 633 | INSTANCE "inv":"physical"
 634 | 	"a"	:	"TXMESS_N";
 635 | 	"O"	:	"[2015]";
 636 | 
 637 | INSTANCE "nand4":"physical"
 638 | 	"a"	:	"[2015]";
 639 | 	"b"	:	"A";
 640 | 	"c"	:	"AXZ0";
 641 | 	"d"	:	"AXZ1";
 642 | 	"O"	:	"[4101]";
 643 | 
 644 | INSTANCE "nand2":"physical"
 645 | 	"a"	:	"[2461]";
 646 | 	"b"	:	"[4101]";
 647 | 	"O"	:	"[792]";
 648 | 
 649 | INSTANCE "nor3":"physical"
 650 | 	"a"	:	"XZ160_N";
 651 | 	"b"	:	"SLAD1";
 652 | 	"c"	:	"[2032]";
 653 | 	"O"	:	"[631]";
 654 | 
 655 | INSTANCE "aoi21":"physical"
 656 | 	"a"	:	"XZ160_N";
 657 | 	"b"	:	"[4729]";
 658 | 	"c"	:	"[631]";
 659 | 	"O"	:	"[423]";
 660 | 
 661 | INSTANCE "inv":"physical"
 662 | 	"a"	:	"XZ160_N";
 663 | 	"O"	:	"[2136]";
 664 | 
 665 | INSTANCE "oai22":"physical"
 666 | 	"a"	:	"XZ160_N";
 667 | 	"b"	:	"[2032]";
 668 | 	"c"	:	"SLAD0";
 669 | 	"d"	:	"[2136]";
 670 | 	"O"	:	"[3703]";
 671 | 
 672 | INSTANCE "nand3":"physical"
 673 | 	"a"	:	"[3703]";
 674 | 	"b"	:	"SLAD1";
 675 | 	"c"	:	"XZ161";
 676 | 	"O"	:	"[4081]";
 677 | 
 678 | INSTANCE "oai21":"physical"
 679 | 	"a"	:	"XZ161";
 680 | 	"b"	:	"[423]";
 681 | 	"c"	:	"[4081]";
 682 | 	"O"	:	"[3701]";
 683 | 
 684 | INSTANCE "inv":"physical"
 685 | 	"a"	:	"SLAD2";
 686 | 	"O"	:	"[2039]";
 687 | 
 688 | INSTANCE "inv":"physical"
 689 | 	"a"	:	"XZ162";
 690 | 	"O"	:	"[2142]";
 691 | 
 692 | INSTANCE "aoi22":"physical"
 693 | 	"a"	:	"[2039]";
 694 | 	"b"	:	"[2142]";
 695 | 	"c"	:	"SLAD2";
 696 | 	"d"	:	"XZ162";
 697 | 	"O"	:	"[428]";
 698 | 
 699 | INSTANCE "inv":"physical"
 700 | 	"a"	:	"SLAD3";
 701 | 	"O"	:	"[2038]";
 702 | 
 703 | INSTANCE "inv":"physical"
 704 | 	"a"	:	"XZ163";
 705 | 	"O"	:	"[2143]";
 706 | 
 707 | INSTANCE "aoi22":"physical"
 708 | 	"a"	:	"[2038]";
 709 | 	"b"	:	"[2143]";
 710 | 	"c"	:	"SLAD3";
 711 | 	"d"	:	"XZ163";
 712 | 	"O"	:	"[427]";
 713 | 
 714 | INSTANCE "inv":"physical"
 715 | 	"a"	:	"ENWIN";
 716 | 	"O"	:	"[2145]";
 717 | 
 718 | INSTANCE "nand4":"physical"
 719 | 	"a"	:	"XZ321";
 720 | 	"b"	:	"XZ322";
 721 | 	"c"	:	"XZ323";
 722 | 	"d"	:	"XZ324";
 723 | 	"O"	:	"[2152]";
 724 | 
 725 | INSTANCE "nor4":"physical"
 726 | 	"a"	:	"[428]";
 727 | 	"b"	:	"[427]";
 728 | 	"c"	:	"[2145]";
 729 | 	"d"	:	"[2152]";
 730 | 	"O"	:	"[108]";
 731 | 
 732 | INSTANCE "nand3":"physical"
 733 | 	"a"	:	"[3701]";
 734 | 	"b"	:	"XZ320";
 735 | 	"c"	:	"[108]";
 736 | 	"O"	:	"[3435]";
 737 | 
 738 | INSTANCE "nand2":"physical"
 739 | 	"a"	:	"RXZ1";
 740 | 	"b"	:	"RXZ0";
 741 | 	"O"	:	"[3655]";
 742 | 
 743 | INSTANCE "nor2":"physical"
 744 | 	"a"	:	"SLAD2";
 745 | 	"b"	:	"SLAD3";
 746 | 	"O"	:	"[109]";
 747 | 
 748 | INSTANCE "nand3":"physical"
 749 | 	"a"	:	"[109]";
 750 | 	"b"	:	"PSYNC";
 751 | 	"c"	:	"XZFS";
 752 | 	"O"	:	"[2160]";
 753 | 
 754 | INSTANCE "inv":"physical"
 755 | 	"a"	:	"[2160]";
 756 | 	"O"	:	"[3431]";
 757 | 
 758 | INSTANCE "aoi22":"physical"
 759 | 	"a"	:	"[3655]";
 760 | 	"b"	:	"RPTWIN";
 761 | 	"c"	:	"[4729]";
 762 | 	"d"	:	"[3431]";
 763 | 	"O"	:	"[1572]";
 764 | 
 765 | INSTANCE "aoi21":"physical"
 766 | 	"a"	:	"[3435]";
 767 | 	"b"	:	"[1572]";
 768 | 	"c"	:	"RYZ";
 769 | 	"O"	:	"[39]";
 770 | 
 771 | INSTANCE "inv":"physical"
 772 | 	"a"	:	"[4732]";
 773 | 	"O"	:	"[2162]";
 774 | 
 775 | INSTANCE "inv":"physical"
 776 | 	"a"	:	"[5000]";
 777 | 	"O"	:	"[2170]";
 778 | 
 779 | INSTANCE "nor2":"physical"
 780 | 	"a"	:	"XZ163";
 781 | 	"b"	:	"[2152]";
 782 | 	"O"	:	"[1561]";
 783 | 
 784 | INSTANCE "inv":"physical"
 785 | 	"a"	:	"XZ161";
 786 | 	"O"	:	"[2137]";
 787 | 
 788 | INSTANCE "nand4":"physical"
 789 | 	"a"	:	"[1561]";
 790 | 	"b"	:	"[2142]";
 791 | 	"c"	:	"[2137]";
 792 | 	"d"	:	"XZ160_N";
 793 | 	"O"	:	"[2168]";
 794 | 
 795 | INSTANCE "nand2":"physical"
 796 | 	"a"	:	"[2168]";
 797 | 	"b"	:	"[4732]";
 798 | 	"O"	:	"[4075]";
 799 | 
 800 | INSTANCE "nand2":"physical"
 801 | 	"a"	:	"[2170]";
 802 | 	"b"	:	"[4075]";
 803 | 	"O"	:	"[3657]";
 804 | 
 805 | INSTANCE "nand2":"physical"
 806 | 	"a"	:	"XZ320";
 807 | 	"b"	:	"[4732]";
 808 | 	"O"	:	"[2163]";
 809 | 
 810 | INSTANCE "nor3":"physical"
 811 | 	"a"	:	"[2163]";
 812 | 	"b"	:	"XZFR0";
 813 | 	"c"	:	"[2168]";
 814 | 	"O"	:	"[620]";
 815 | 
 816 | INSTANCE "aoi21":"physical"
 817 | 	"a"	:	"[3657]";
 818 | 	"b"	:	"XZFR0";
 819 | 	"c"	:	"[620]";
 820 | 	"O"	:	"[40]";
 821 | 
 822 | INSTANCE "inv":"physical"
 823 | 	"a"	:	"[40]";
 824 | 	"O"	:	"[791]";
 825 | 
 826 | INSTANCE "inv":"physical"
 827 | 	"a"	:	"XZFR0";
 828 | 	"O"	:	"[2164]";
 829 | 
 830 | INSTANCE "nor2":"physical"
 831 | 	"a"	:	"XZFR1";
 832 | 	"b"	:	"[2164]";
 833 | 	"O"	:	"[1540]";
 834 | 
 835 | INSTANCE "aoi22":"physical"
 836 | 	"a"	:	"[40]";
 837 | 	"b"	:	"[1540]";
 838 | 	"c"	:	"[2164]";
 839 | 	"d"	:	"XZFR1";
 840 | 	"O"	:	"[400]";
 841 | 
 842 | INSTANCE "oai22":"physical"
 843 | 	"a"	:	"[400]";
 844 | 	"b"	:	"[2162]";
 845 | 	"c"	:	"[40]";
 846 | 	"d"	:	"[2071]";
 847 | 	"O"	:	"[790]";
 848 | 
 849 | INSTANCE "nand2":"physical"
 850 | 	"a"	:	"[2461]";
 851 | 	"b"	:	"PSYNC";
 852 | 	"O"	:	"[2174]";
 853 | 
 854 | INSTANCE "nand2":"physical"
 855 | 	"a"	:	"[2461]";
 856 | 	"b"	:	"XZFS";
 857 | 	"O"	:	"[4061]";
 858 | 
 859 | INSTANCE "nand2":"physical"
 860 | 	"a"	:	"OFS2";
 861 | 	"b"	:	"OFS1";
 862 | 	"O"	:	"[3717]";
 863 | 
 864 | INSTANCE "nand2":"physical"
 865 | 	"a"	:	"[3717]";
 866 | 	"b"	:	"PSRW";
 867 | 	"O"	:	"[2173]";
 868 | 
 869 | INSTANCE "aoi21":"physical"
 870 | 	"a"	:	"[2174]";
 871 | 	"b"	:	"[4061]";
 872 | 	"c"	:	"[2173]";
 873 | 	"O"	:	"[42]";
 874 | 
 875 | INSTANCE "nand3":"physical"
 876 | 	"a"	:	"[109]";
 877 | 	"b"	:	"[4729]";
 878 | 	"c"	:	"XZFS";
 879 | 	"O"	:	"[2176]";
 880 | 
 881 | INSTANCE "inv":"physical"
 882 | 	"a"	:	"[3435]";
 883 | 	"O"	:	"[3436]";
 884 | 
 885 | INSTANCE "nor2":"physical"
 886 | 	"a"	:	"ICLR";
 887 | 	"b"	:	"[3436]";
 888 | 	"O"	:	"[1508]";
 889 | 
 890 | INSTANCE "oai21":"physical"
 891 | 	"a"	:	"[2160]";
 892 | 	"b"	:	"[2176]";
 893 | 	"c"	:	"[1508]";
 894 | 	"O"	:	"[2178]";
 895 | 
 896 | INSTANCE "nand2":"physical"
 897 | 	"a"	:	"[2016]";
 898 | 	"b"	:	"RXZ0";
 899 | 	"O"	:	"[2179]";
 900 | 
 901 | INSTANCE "nor2":"physical"
 902 | 	"a"	:	"RPTWIN";
 903 | 	"b"	:	"[3436]";
 904 | 	"O"	:	"[418]";
 905 | 
 906 | INSTANCE "oai22":"physical"
 907 | 	"a"	:	"ICLR";
 908 | 	"b"	:	"[418]";
 909 | 	"c"	:	"[2174]";
 910 | 	"d"	:	"[2176]";
 911 | 	"O"	:	"[2180]";
 912 | 
 913 | INSTANCE "inv":"physical"
 914 | 	"a"	:	"[2180]";
 915 | 	"O"	:	"[3249]";
 916 | 
 917 | INSTANCE "oai22":"physical"
 918 | 	"a"	:	"[2178]";
 919 | 	"b"	:	"[2179]";
 920 | 	"c"	:	"RXZ0";
 921 | 	"d"	:	"[3249]";
 922 | 	"O"	:	"[789]";
 923 | 
 924 | INSTANCE "or2":"physical"
 925 | 	"a"	:	"RXZ1";
 926 | 	"b"	:	"[789]";
 927 | 	"O"	:	"[2181]";
 928 | 
 929 | INSTANCE "inv":"physical"
 930 | 	"a"	:	"[2178]";
 931 | 	"O"	:	"[3255]";
 932 | 
 933 | INSTANCE "aoi21":"physical"
 934 | 	"a"	:	"[3255]";
 935 | 	"b"	:	"[3249]";
 936 | 	"c"	:	"[789]";
 937 | 	"O"	:	"[402]";
 938 | 
 939 | INSTANCE "inv":"physical"
 940 | 	"a"	:	"RXZ1";
 941 | 	"O"	:	"[2059]";
 942 | 
 943 | INSTANCE "oai22":"physical"
 944 | 	"a"	:	"[3249]";
 945 | 	"b"	:	"[2181]";
 946 | 	"c"	:	"[402]";
 947 | 	"d"	:	"[2059]";
 948 | 	"O"	:	"[788]";
 949 | 
 950 | INSTANCE "inv":"physical"
 951 | 	"a"	:	"[2174]";
 952 | 	"O"	:	"[3058]";
 953 | 
 954 | INSTANCE "inv":"physical"
 955 | 	"a"	:	"CBT2";
 956 | 	"O"	:	"[2182]";
 957 | 
 958 | INSTANCE "nor3":"physical"
 959 | 	"a"	:	"QPR4";
 960 | 	"b"	:	"QPR3";
 961 | 	"c"	:	"[2182]";
 962 | 	"O"	:	"[603]";
 963 | 
 964 | INSTANCE "inv":"physical"
 965 | 	"a"	:	"QPR4";
 966 | 	"O"	:	"[2030]";
 967 | 
 968 | INSTANCE "aoi21":"physical"
 969 | 	"a"	:	"[2030]";
 970 | 	"b"	:	"B";
 971 | 	"c"	:	"[2029]";
 972 | 	"O"	:	"[604]";
 973 | 
 974 | INSTANCE "nor3":"physical"
 975 | 	"a"	:	"[2037]";
 976 | 	"b"	:	"[603]";
 977 | 	"c"	:	"[604]";
 978 | 	"O"	:	"[425]";
 979 | 
 980 | INSTANCE "oai21":"physical"
 981 | 	"a"	:	"A";
 982 | 	"b"	:	"[425]";
 983 | 	"c"	:	"[2015]";
 984 | 	"O"	:	"[2185]";
 985 | 
 986 | INSTANCE "oai21":"physical"
 987 | 	"a"	:	"RYZ";
 988 | 	"b"	:	"[2185]";
 989 | 	"c"	:	"[2052]";
 990 | 	"O"	:	"[787]";
 991 | 
 992 | INSTANCE "nor2":"physical"
 993 | 	"a"	:	"CBT0";
 994 | 	"b"	:	"CBT1";
 995 | 	"O"	:	"[1456]";
 996 | 
 997 | INSTANCE "aoi21":"physical"
 998 | 	"a"	:	"CBT2";
 999 | 	"b"	:	"[1456]";
1000 | 	"c"	:	"QPR4";
1001 | 	"O"	:	"[596]";
1002 | 
1003 | INSTANCE "or2":"physical"
1004 | 	"a"	:	"TXMESS_N";
1005 | 	"b"	:	"[2037]";
1006 | 	"O"	:	"[2186]";
1007 | 
1008 | INSTANCE "nor3":"physical"
1009 | 	"a"	:	"QPR3";
1010 | 	"b"	:	"[596]";
1011 | 	"c"	:	"[2186]";
1012 | 	"O"	:	"MIS9174";
1013 | 
1014 | INSTANCE "or2":"physical"
1015 | 	"a"	:	"MIS9174";
1016 | 	"b"	:	"[2186]";
1017 | 	"O"	:	"[2190]";
1018 | 
1019 | INSTANCE "nor2":"physical"
1020 | 	"a"	:	"QPR4";
1021 | 	"b"	:	"[2190]";
1022 | 	"O"	:	"[404]";
1023 | 
1024 | INSTANCE "nand2":"physical"
1025 | 	"a"	:	"[2614]";
1026 | 	"b"	:	"B";
1027 | 	"O"	:	"[2191]";
1028 | 
1029 | INSTANCE "nor3":"physical"
1030 | 	"a"	:	"[2190]";
1031 | 	"b"	:	"B";
1032 | 	"c"	:	"[2182]";
1033 | 	"O"	:	"[594]";
1034 | 
1035 | INSTANCE "aoi21":"physical"
1036 | 	"a"	:	"[2182]";
1037 | 	"b"	:	"B";
1038 | 	"c"	:	"[594]";
1039 | 	"O"	:	"[403]";
1040 | 
1041 | INSTANCE "oai22":"physical"
1042 | 	"a"	:	"[404]";
1043 | 	"b"	:	"[2191]";
1044 | 	"c"	:	"[403]";
1045 | 	"d"	:	"[2065]";
1046 | 	"O"	:	"[786]";
1047 | 
1048 | INSTANCE "nor2":"physical"
1049 | 	"a"	:	"MIS9174";
1050 | 	"b"	:	"[2045]";
1051 | 	"O"	:	"[591]";
1052 | 
1053 | INSTANCE "aoi21":"physical"
1054 | 	"a"	:	"[2045]";
1055 | 	"b"	:	"MIS9174";
1056 | 	"c"	:	"[591]";
1057 | 	"O"	:	"[405]";
1058 | 
1059 | INSTANCE "nor2":"physical"
1060 | 	"a"	:	"RYZ";
1061 | 	"b"	:	"[405]";
1062 | 	"O"	:	"[49]";
1063 | 
1064 | INSTANCE "nand2":"physical"
1065 | 	"a"	:	"[829]";
1066 | 	"b"	:	"QPR0";
1067 | 	"O"	:	"[2193]";
1068 | 
1069 | INSTANCE "oai22":"physical"
1070 | 	"a"	:	"[2024]";
1071 | 	"b"	:	"[2193]";
1072 | 	"c"	:	"QPR0";
1073 | 	"d"	:	"[829]";
1074 | 	"O"	:	"[785]";
1075 | 
1076 | INSTANCE "or2":"physical"
1077 | 	"a"	:	"QPR1";
1078 | 	"b"	:	"[829]";
1079 | 	"O"	:	"[2194]";
1080 | 
1081 | INSTANCE "inv":"physical"
1082 | 	"a"	:	"[2024]";
1083 | 	"O"	:	"[3391]";
1084 | 
1085 | INSTANCE "aoi21":"physical"
1086 | 	"a"	:	"[829]";
1087 | 	"b"	:	"[3391]";
1088 | 	"c"	:	"[785]";
1089 | 	"O"	:	"[406]";
1090 | 
1091 | INSTANCE "oai22":"physical"
1092 | 	"a"	:	"[785]";
1093 | 	"b"	:	"[2194]";
1094 | 	"c"	:	"[406]";
1095 | 	"d"	:	"[2034]";
1096 | 	"O"	:	"[784]";
1097 | 
1098 | INSTANCE "nand2":"physical"
1099 | 	"a"	:	"[784]";
1100 | 	"b"	:	"QPR2";
1101 | 	"O"	:	"[4013]";
1102 | 
1103 | INSTANCE "nor4":"physical"
1104 | 	"a"	:	"QPR2";
1105 | 	"b"	:	"[2034]";
1106 | 	"c"	:	"[784]";
1107 | 	"d"	:	"[829]";
1108 | 	"O"	:	"[581]";
1109 | 
1110 | INSTANCE "aoi21":"physical"
1111 | 	"a"	:	"[2614]";
1112 | 	"b"	:	"[4864]";
1113 | 	"c"	:	"[581]";
1114 | 	"O"	:	"[1386]";
1115 | 
1116 | INSTANCE "nand2":"physical"
1117 | 	"a"	:	"[4013]";
1118 | 	"b"	:	"[1386]";
1119 | 	"O"	:	"[783]";
1120 | 
1121 | INSTANCE "inv":"physical"
1122 | 	"a"	:	"[4867]";
1123 | 	"O"	:	"[2198]";
1124 | 
1125 | INSTANCE "nor2":"physical"
1126 | 	"a"	:	"RYZ";
1127 | 	"b"	:	"QPR2";
1128 | 	"O"	:	"[579]";
1129 | 
1130 | INSTANCE "oai21":"physical"
1131 | 	"a"	:	"[579]";
1132 | 	"b"	:	"[783]";
1133 | 	"c"	:	"[2065]";
1134 | 	"O"	:	"[4005]";
1135 | 
1136 | INSTANCE "oai21":"physical"
1137 | 	"a"	:	"[2065]";
1138 | 	"b"	:	"[2198]";
1139 | 	"c"	:	"[4005]";
1140 | 	"O"	:	"[782]";
1141 | 
1142 | INSTANCE "nor2":"physical"
1143 | 	"a"	:	"[782]";
1144 | 	"b"	:	"[829]";
1145 | 	"O"	:	"[1367]";
1146 | 
1147 | INSTANCE "nand3":"physical"
1148 | 	"a"	:	"[1367]";
1149 | 	"b"	:	"[2030]";
1150 | 	"c"	:	"QPR3";
1151 | 	"O"	:	"[3999]";
1152 | 
1153 | INSTANCE "oai21":"physical"
1154 | 	"a"	:	"[4836]";
1155 | 	"b"	:	"[782]";
1156 | 	"c"	:	"QPR4";
1157 | 	"O"	:	"[4001]";
1158 | 
1159 | INSTANCE "nand2":"physical"
1160 | 	"a"	:	"[3999]";
1161 | 	"b"	:	"[4001]";
1162 | 	"O"	:	"[781]";
1163 | 
1164 | INSTANCE "nor2":"physical"
1165 | 	"a"	:	"AXZ0";
1166 | 	"b"	:	"[2185]";
1167 | 	"O"	:	"[573]";
1168 | 
1169 | INSTANCE "aoi21":"physical"
1170 | 	"a"	:	"[2185]";
1171 | 	"b"	:	"AXZ0";
1172 | 	"c"	:	"[573]";
1173 | 	"O"	:	"[409]";
1174 | 
1175 | INSTANCE "nor2":"physical"
1176 | 	"a"	:	"RYZ";
1177 | 	"b"	:	"[409]";
1178 | 	"O"	:	"[55]";
1179 | 
1180 | INSTANCE "nor2":"physical"
1181 | 	"a"	:	"[2018]";
1182 | 	"b"	:	"[2185]";
1183 | 	"O"	:	"[116]";
1184 | 
1185 | INSTANCE "xnor":"physical"
1186 | 	"a"	:	"AXZ1";
1187 | 	"b"	:	"[116]";
1188 | 	"O"	:	"[410]";
1189 | 
1190 | INSTANCE "nor2":"physical"
1191 | 	"a"	:	"RYZ";
1192 | 	"b"	:	"[410]";
1193 | 	"O"	:	"[56]";
1194 | 
1195 | INSTANCE "inv":"physical"
1196 | 	"a"	:	"V1ZZZ1";
1197 | 	"O"	:	"[2202]";
1198 | 
1199 | INSTANCE "nand3":"physical"
1200 | 	"a"	:	"[2614]";
1201 | 	"b"	:	"VYBB0";
1202 | 	"c"	:	"VZZZE";
1203 | 	"O"	:	"[2206]";
1204 | 
1205 | INSTANCE "nand2":"physical"
1206 | 	"a"	:	"[2614]";
1207 | 	"b"	:	"[2206]";
1208 | 	"O"	:	"[2207]";
1209 | 
1210 | INSTANCE "inv":"physical"
1211 | 	"a"	:	"[2207]";
1212 | 	"O"	:	"[3290]";
1213 | 
1214 | INSTANCE "nand2":"physical"
1215 | 	"a"	:	"VYBB0";
1216 | 	"b"	:	"[3290]";
1217 | 	"O"	:	"[2208]";
1218 | 
1219 | INSTANCE "inv":"physical"
1220 | 	"a"	:	"V1ZZZ0";
1221 | 	"O"	:	"[2209]";
1222 | 
1223 | INSTANCE "nand2":"physical"
1224 | 	"a"	:	"[2614]";
1225 | 	"b"	:	"[2208]";
1226 | 	"O"	:	"[2210]";
1227 | 
1228 | INSTANCE "oai22":"physical"
1229 | 	"a"	:	"[2202]";
1230 | 	"b"	:	"[2208]";
1231 | 	"c"	:	"[2209]";
1232 | 	"d"	:	"[2210]";
1233 | 	"O"	:	"[780]";
1234 | 
1235 | INSTANCE "inv":"physical"
1236 | 	"a"	:	"V1ZZZ2";
1237 | 	"O"	:	"[2211]";
1238 | 
1239 | INSTANCE "oai22":"physical"
1240 | 	"a"	:	"[2208]";
1241 | 	"b"	:	"[2211]";
1242 | 	"c"	:	"[2202]";
1243 | 	"d"	:	"[2210]";
1244 | 	"O"	:	"[779]";
1245 | 
1246 | INSTANCE "inv":"physical"
1247 | 	"a"	:	"V1ZZZ3";
1248 | 	"O"	:	"[2212]";
1249 | 
1250 | INSTANCE "oai22":"physical"
1251 | 	"a"	:	"[2208]";
1252 | 	"b"	:	"[2212]";
1253 | 	"c"	:	"[2210]";
1254 | 	"d"	:	"[2211]";
1255 | 	"O"	:	"[778]";
1256 | 
1257 | INSTANCE "inv":"physical"
1258 | 	"a"	:	"V1ZZZ4";
1259 | 	"O"	:	"[2213]";
1260 | 
1261 | INSTANCE "oai22":"physical"
1262 | 	"a"	:	"[2208]";
1263 | 	"b"	:	"[2213]";
1264 | 	"c"	:	"[2210]";
1265 | 	"d"	:	"[2212]";
1266 | 	"O"	:	"[777]";
1267 | 
1268 | INSTANCE "inv":"physical"
1269 | 	"a"	:	"V1ZZZ5";
1270 | 	"O"	:	"[2214]";
1271 | 
1272 | INSTANCE "oai22":"physical"
1273 | 	"a"	:	"[2208]";
1274 | 	"b"	:	"[2214]";
1275 | 	"c"	:	"[2210]";
1276 | 	"d"	:	"[2213]";
1277 | 	"O"	:	"[776]";
1278 | 
1279 | INSTANCE "inv":"physical"
1280 | 	"a"	:	"V1ZZZ6";
1281 | 	"O"	:	"[2215]";
1282 | 
1283 | INSTANCE "oai22":"physical"
1284 | 	"a"	:	"[2208]";
1285 | 	"b"	:	"[2215]";
1286 | 	"c"	:	"[2210]";
1287 | 	"d"	:	"[2214]";
1288 | 	"O"	:	"[775]";
1289 | 
1290 | INSTANCE "inv":"physical"
1291 | 	"a"	:	"V1ZZZ7";
1292 | 	"O"	:	"[2216]";
1293 | 
1294 | INSTANCE "oai22":"physical"
1295 | 	"a"	:	"[2208]";
1296 | 	"b"	:	"[2216]";
1297 | 	"c"	:	"[2210]";
1298 | 	"d"	:	"[2215]";
1299 | 	"O"	:	"[774]";
1300 | 
1301 | INSTANCE "inv":"physical"
1302 | 	"a"	:	"VYBB1";
1303 | 	"O"	:	"[2217]";
1304 | 
1305 | INSTANCE "oai22":"physical"
1306 | 	"a"	:	"[2208]";
1307 | 	"b"	:	"[2217]";
1308 | 	"c"	:	"[2210]";
1309 | 	"d"	:	"[2216]";
1310 | 	"O"	:	"[773]";
1311 | 
1312 | INSTANCE "inv":"physical"
1313 | 	"a"	:	"V2ZZZ1";
1314 | 	"O"	:	"[2218]";
1315 | 
1316 | INSTANCE "inv":"physical"
1317 | 	"a"	:	"V2ZZZ0";
1318 | 	"O"	:	"[2219]";
1319 | 
1320 | INSTANCE "oai22":"physical"
1321 | 	"a"	:	"[2206]";
1322 | 	"b"	:	"[2218]";
1323 | 	"c"	:	"[2207]";
1324 | 	"d"	:	"[2219]";
1325 | 	"O"	:	"[772]";
1326 | 
1327 | INSTANCE "inv":"physical"
1328 | 	"a"	:	"V2ZZZ2";
1329 | 	"O"	:	"[2220]";
1330 | 
1331 | INSTANCE "oai22":"physical"
1332 | 	"a"	:	"[2206]";
1333 | 	"b"	:	"[2220]";
1334 | 	"c"	:	"[2207]";
1335 | 	"d"	:	"[2218]";
1336 | 	"O"	:	"[771]";
1337 | 
1338 | INSTANCE "inv":"physical"
1339 | 	"a"	:	"V2ZZZ3";
1340 | 	"O"	:	"[2221]";
1341 | 
1342 | INSTANCE "oai22":"physical"
1343 | 	"a"	:	"[2206]";
1344 | 	"b"	:	"[2221]";
1345 | 	"c"	:	"[2207]";
1346 | 	"d"	:	"[2220]";
1347 | 	"O"	:	"[770]";
1348 | 
1349 | INSTANCE "inv":"physical"
1350 | 	"a"	:	"V2ZZZ4";
1351 | 	"O"	:	"[2222]";
1352 | 
1353 | INSTANCE "oai22":"physical"
1354 | 	"a"	:	"[2206]";
1355 | 	"b"	:	"[2222]";
1356 | 	"c"	:	"[2207]";
1357 | 	"d"	:	"[2221]";
1358 | 	"O"	:	"[769]";
1359 | 
1360 | INSTANCE "inv":"physical"
1361 | 	"a"	:	"V2ZZZ5";
1362 | 	"O"	:	"[2223]";
1363 | 
1364 | INSTANCE "oai22":"physical"
1365 | 	"a"	:	"[2206]";
1366 | 	"b"	:	"[2223]";
1367 | 	"c"	:	"[2207]";
1368 | 	"d"	:	"[2222]";
1369 | 	"O"	:	"[768]";
1370 | 
1371 | INSTANCE "inv":"physical"
1372 | 	"a"	:	"V2ZZZ6";
1373 | 	"O"	:	"[2224]";
1374 | 
1375 | INSTANCE "oai22":"physical"
1376 | 	"a"	:	"[2206]";
1377 | 	"b"	:	"[2224]";
1378 | 	"c"	:	"[2207]";
1379 | 	"d"	:	"[2223]";
1380 | 	"O"	:	"[767]";
1381 | 
1382 | INSTANCE "inv":"physical"
1383 | 	"a"	:	"V2ZZZ7";
1384 | 	"O"	:	"[2225]";
1385 | 
1386 | INSTANCE "oai22":"physical"
1387 | 	"a"	:	"[2206]";
1388 | 	"b"	:	"[2225]";
1389 | 	"c"	:	"[2207]";
1390 | 	"d"	:	"[2224]";
1391 | 	"O"	:	"[766]";
1392 | 
1393 | INSTANCE "oai22":"physical"
1394 | 	"a"	:	"[2206]";
1395 | 	"b"	:	"[2217]";
1396 | 	"c"	:	"[2207]";
1397 | 	"d"	:	"[2225]";
1398 | 	"O"	:	"[765]";
1399 | 
1400 | INSTANCE "nand3":"physical"
1401 | 	"a"	:	"[2046]";
1402 | 	"b"	:	"[2025]";
1403 | 	"c"	:	"[2015]";
1404 | 	"O"	:	"[2227]";
1405 | 
1406 | INSTANCE "inv":"physical"
1407 | 	"a"	:	"[2227]";
1408 | 	"O"	:	"[3468]";
1409 | 
1410 | INSTANCE "inv":"physical"
1411 | 	"a"	:	"[5074]";
1412 | 	"O"	:	"[749]";
1413 | 
1414 | INSTANCE "inv":"physical"
1415 | 	"a"	:	"XZ321";
1416 | 	"O"	:	"[2146]";
1417 | 
1418 | INSTANCE "oai22":"physical"
1419 | 	"a"	:	"XZ321";
1420 | 	"b"	:	"[2163]";
1421 | 	"c"	:	"[2146]";
1422 | 	"d"	:	"[2170]";
1423 | 	"O"	:	"[748]";
1424 | 
1425 | INSTANCE "inv":"physical"
1426 | 	"a"	:	"[5003]";
1427 | 	"O"	:	"[2297]";
1428 | 
1429 | INSTANCE "oai21":"physical"
1430 | 	"a"	:	"XZ321";
1431 | 	"b"	:	"[2162]";
1432 | 	"c"	:	"[2170]";
1433 | 	"O"	:	"[3681]";
1434 | 
1435 | INSTANCE "nand2":"physical"
1436 | 	"a"	:	"[3681]";
1437 | 	"b"	:	"XZ322";
1438 | 	"O"	:	"[3761]";
1439 | 
1440 | INSTANCE "oai21":"physical"
1441 | 	"a"	:	"[2163]";
1442 | 	"b"	:	"[2297]";
1443 | 	"c"	:	"[3761]";
1444 | 	"O"	:	"[747]";
1445 | 
1446 | INSTANCE "inv":"physical"
1447 | 	"a"	:	"XZ323";
1448 | 	"O"	:	"[2149]";
1449 | 
1450 | INSTANCE "nand2":"physical"
1451 | 	"a"	:	"[2149]";
1452 | 	"b"	:	"XZ322";
1453 | 	"O"	:	"[2298]";
1454 | 
1455 | INSTANCE "oai22":"physical"
1456 | 	"a"	:	"[747]";
1457 | 	"b"	:	"[2298]";
1458 | 	"c"	:	"XZ322";
1459 | 	"d"	:	"[2149]";
1460 | 	"O"	:	"[3683]";
1461 | 
1462 | INSTANCE "aoi22":"physical"
1463 | 	"a"	:	"[3683]";
1464 | 	"b"	:	"[4732]";
1465 | 	"c"	:	"[747]";
1466 | 	"d"	:	"XZ323";
1467 | 	"O"	:	"[92]";
1468 | 
1469 | INSTANCE "inv":"physical"
1470 | 	"a"	:	"[92]";
1471 | 	"O"	:	"[746]";
1472 | 
1473 | INSTANCE "aoi21":"physical"
1474 | 	"a"	:	"[92]";
1475 | 	"b"	:	"XZ323";
1476 | 	"c"	:	"XZ324";
1477 | 	"O"	:	"[413]";
1478 | 
1479 | INSTANCE "nand2":"physical"
1480 | 	"a"	:	"[2152]";
1481 | 	"b"	:	"[4732]";
1482 | 	"O"	:	"[2299]";
1483 | 
1484 | INSTANCE "oai22":"physical"
1485 | 	"a"	:	"[413]";
1486 | 	"b"	:	"[2299]";
1487 | 	"c"	:	"[92]";
1488 | 	"d"	:	"[2152]";
1489 | 	"O"	:	"[745]";
1490 | 
1491 | INSTANCE "nand2":"physical"
1492 | 	"a"	:	"[2152]";
1493 | 	"b"	:	"[4732]";
1494 | 	"O"	:	"[3743]";
1495 | 
1496 | INSTANCE "nand2":"physical"
1497 | 	"a"	:	"[2170]";
1498 | 	"b"	:	"[3743]";
1499 | 	"O"	:	"[3687]";
1500 | 
1501 | INSTANCE "nor3":"physical"
1502 | 	"a"	:	"[2163]";
1503 | 	"b"	:	"XZ160_N";
1504 | 	"c"	:	"[2152]";
1505 | 	"O"	:	"[442]";
1506 | 
1507 | INSTANCE "aoi21":"physical"
1508 | 	"a"	:	"[3687]";
1509 | 	"b"	:	"XZ160_N";
1510 | 	"c"	:	"[442]";
1511 | 	"O"	:	"[94]";
1512 | 
1513 | INSTANCE "inv":"physical"
1514 | 	"a"	:	"[94]";
1515 | 	"O"	:	"[744]";
1516 | 
1517 | INSTANCE "or2":"physical"
1518 | 	"a"	:	"XZ160_N";
1519 | 	"b"	:	"[94]";
1520 | 	"O"	:	"[2301]";
1521 | 
1522 | INSTANCE "nand3":"physical"
1523 | 	"a"	:	"[2301]";
1524 | 	"b"	:	"XZ161";
1525 | 	"c"	:	"[4732]";
1526 | 	"O"	:	"[3735]";
1527 | 
1528 | INSTANCE "oai21":"physical"
1529 | 	"a"	:	"XZ161";
1530 | 	"b"	:	"[2301]";
1531 | 	"c"	:	"[3735]";
1532 | 	"O"	:	"[743]";
1533 | 
1534 | INSTANCE "aoi21":"physical"
1535 | 	"a"	:	"[2137]";
1536 | 	"b"	:	"[4732]";
1537 | 	"c"	:	"[743]";
1538 | 	"O"	:	"[415]";
1539 | 
1540 | INSTANCE "nor2":"physical"
1541 | 	"a"	:	"[94]";
1542 | 	"b"	:	"[743]";
1543 | 	"O"	:	"[863]";
1544 | 
1545 | INSTANCE "nand3":"physical"
1546 | 	"a"	:	"[863]";
1547 | 	"b"	:	"[2142]";
1548 | 	"c"	:	"XZ161";
1549 | 	"O"	:	"[3729]";
1550 | 
1551 | INSTANCE "oai21":"physical"
1552 | 	"a"	:	"[415]";
1553 | 	"b"	:	"[2142]";
1554 | 	"c"	:	"[3729]";
1555 | 	"O"	:	"[742]";
1556 | 
1557 | INSTANCE "aoi21":"physical"
1558 | 	"a"	:	"[2142]";
1559 | 	"b"	:	"[4732]";
1560 | 	"c"	:	"[742]";
1561 | 	"O"	:	"[416]";
1562 | 
1563 | INSTANCE "oai21":"physical"
1564 | 	"a"	:	"[416]";
1565 | 	"b"	:	"[2143]";
1566 | 	"c"	:	"[5008]";
1567 | 	"O"	:	"[741]";
1568 | 
1569 | INSTANCE "aoi22":"physical"
1570 | 	"a"	:	"XZFS";
1571 | 	"b"	:	"[3058]";
1572 | 	"c"	:	"[2461]";
1573 | 	"d"	:	"ENWIN";
1574 | 	"O"	:	"[417]";
1575 | 
1576 | INSTANCE "nor2":"physical"
1577 | 	"a"	:	"[417]";
1578 | 	"b"	:	"[2173]";
1579 | 	"O"	:	"[98]";
1580 | 
1581 | INSTANCE "nor3":"physical"
1582 | 	"a"	:	"[3468]";
1583 | 	"b"	:	"VFIN";
1584 | 	"c"	:	"[2024]";
1585 | 	"O"	:	"[4536]";
1586 | 
1587 | INSTANCE "nor2":"physical"
1588 | 	"a"	:	"[2024]";
1589 | 	"b"	:	"[2025]";
1590 | 	"O"	:	"[4539]";
1591 | 
1592 | INSTANCE "nor3":"physical"
1593 | 	"a"	:	"RYZ";
1594 | 	"b"	:	"INFIN";
1595 | 	"c"	:	"[2021]";
1596 | 	"O"	:	"[4543]";
1597 | 
1598 | INSTANCE "nor2":"physical"
1599 | 	"a"	:	"RYZ";
1600 | 	"b"	:	"[2022]";
1601 | 	"O"	:	"[4546]";
1602 | 
1603 | INSTANCE "inv":"physical"
1604 | 	"a"	:	"[2078]";
1605 | 	"O"	:	"[4548]";
1606 | 
1607 | INSTANCE "aoi22":"physical"
1608 | 	"a"	:	"PYBB1";
1609 | 	"b"	:	"[4548]";
1610 | 	"c"	:	"P1ZZZ0";
1611 | 	"d"	:	"[4842]";
1612 | 	"O"	:	"[4551]";
1613 | 
1614 | INSTANCE "inv":"physical"
1615 | 	"a"	:	"[2076]";
1616 | 	"O"	:	"[4553]";
1617 | 
1618 | INSTANCE "aoi22":"physical"
1619 | 	"a"	:	"PYBB1";
1620 | 	"b"	:	"[4553]";
1621 | 	"c"	:	"[4839]";
1622 | 	"d"	:	"P2ZZZ0";
1623 | 	"O"	:	"[4556]";
1624 | 
1625 | INSTANCE "aoi22":"physical"
1626 | 	"a"	:	"[4548]";
1627 | 	"b"	:	"PYBB2";
1628 | 	"c"	:	"[4842]";
1629 | 	"d"	:	"P1ZZZ1";
1630 | 	"O"	:	"[4561]";
1631 | 
1632 | INSTANCE "aoi22":"physical"
1633 | 	"a"	:	"[4553]";
1634 | 	"b"	:	"PYBB2";
1635 | 	"c"	:	"[4839]";
1636 | 	"d"	:	"P2ZZZ1";
1637 | 	"O"	:	"[4566]";
1638 | 
1639 | INSTANCE "aoi22":"physical"
1640 | 	"a"	:	"[4548]";
1641 | 	"b"	:	"PYBB3";
1642 | 	"c"	:	"[4842]";
1643 | 	"d"	:	"P1ZZZ2";
1644 | 	"O"	:	"[4571]";
1645 | 
1646 | INSTANCE "aoi22":"physical"
1647 | 	"a"	:	"[4553]";
1648 | 	"b"	:	"PYBB3";
1649 | 	"c"	:	"[4839]";
1650 | 	"d"	:	"P2ZZZ2";
1651 | 	"O"	:	"[4576]";
1652 | 
1653 | INSTANCE "aoi22":"physical"
1654 | 	"a"	:	"[4548]";
1655 | 	"b"	:	"PYBB4";
1656 | 	"c"	:	"[4842]";
1657 | 	"d"	:	"P1ZZZ3";
1658 | 	"O"	:	"[4581]";
1659 | 
1660 | INSTANCE "aoi22":"physical"
1661 | 	"a"	:	"[4553]";
1662 | 	"b"	:	"PYBB4";
1663 | 	"c"	:	"[4839]";
1664 | 	"d"	:	"P2ZZZ3";
1665 | 	"O"	:	"[4586]";
1666 | 
1667 | INSTANCE "aoi22":"physical"
1668 | 	"a"	:	"[4548]";
1669 | 	"b"	:	"PYBB5";
1670 | 	"c"	:	"[4842]";
1671 | 	"d"	:	"P1ZZZ4";
1672 | 	"O"	:	"[4591]";
1673 | 
1674 | INSTANCE "aoi22":"physical"
1675 | 	"a"	:	"[4553]";
1676 | 	"b"	:	"PYBB5";
1677 | 	"c"	:	"[4839]";
1678 | 	"d"	:	"P2ZZZ4";
1679 | 	"O"	:	"[4596]";
1680 | 
1681 | INSTANCE "aoi22":"physical"
1682 | 	"a"	:	"[4548]";
1683 | 	"b"	:	"PYBB6";
1684 | 	"c"	:	"[4842]";
1685 | 	"d"	:	"P1ZZZ5";
1686 | 	"O"	:	"[4601]";
1687 | 
1688 | INSTANCE "aoi22":"physical"
1689 | 	"a"	:	"[4553]";
1690 | 	"b"	:	"PYBB6";
1691 | 	"c"	:	"[4839]";
1692 | 	"d"	:	"P2ZZZ5";
1693 | 	"O"	:	"[4606]";
1694 | 
1695 | INSTANCE "aoi22":"physical"
1696 | 	"a"	:	"[4548]";
1697 | 	"b"	:	"PYBB7";
1698 | 	"c"	:	"[4842]";
1699 | 	"d"	:	"P1ZZZ6";
1700 | 	"O"	:	"[4611]";
1701 | 
1702 | INSTANCE "aoi22":"physical"
1703 | 	"a"	:	"[4553]";
1704 | 	"b"	:	"PYBB7";
1705 | 	"c"	:	"[4839]";
1706 | 	"d"	:	"P2ZZZ6";
1707 | 	"O"	:	"[4616]";
1708 | 
1709 | INSTANCE "aoi22":"physical"
1710 | 	"a"	:	"[4548]";
1711 | 	"b"	:	"PYBB8";
1712 | 	"c"	:	"[4842]";
1713 | 	"d"	:	"P1ZZZ7";
1714 | 	"O"	:	"[4621]";
1715 | 
1716 | INSTANCE "aoi22":"physical"
1717 | 	"a"	:	"[4553]";
1718 | 	"b"	:	"PYBB8";
1719 | 	"c"	:	"[4839]";
1720 | 	"d"	:	"P2ZZZ7";
1721 | 	"O"	:	"[4626]";
1722 | 
1723 | INSTANCE "inv":"physical"
1724 | 	"a"	:	"[2109]";
1725 | 	"O"	:	"[4628]";
1726 | 
1727 | INSTANCE "aoi22":"physical"
1728 | 	"a"	:	"INYBB1";
1729 | 	"b"	:	"[4628]";
1730 | 	"c"	:	"I1ZZZ0";
1731 | 	"d"	:	"[4848]";
1732 | 	"O"	:	"[4631]";
1733 | 
1734 | INSTANCE "inv":"physical"
1735 | 	"a"	:	"[2107]";
1736 | 	"O"	:	"[4633]";
1737 | 
1738 | INSTANCE "aoi22":"physical"
1739 | 	"a"	:	"INYBB1";
1740 | 	"b"	:	"[4633]";
1741 | 	"c"	:	"[4845]";
1742 | 	"d"	:	"I2ZZZ0";
1743 | 	"O"	:	"[4636]";
1744 | 
1745 | INSTANCE "aoi22":"physical"
1746 | 	"a"	:	"[4628]";
1747 | 	"b"	:	"INYBB2";
1748 | 	"c"	:	"[4848]";
1749 | 	"d"	:	"I1ZZZ1";
1750 | 	"O"	:	"[4641]";
1751 | 
1752 | INSTANCE "aoi22":"physical"
1753 | 	"a"	:	"[4633]";
1754 | 	"b"	:	"INYBB2";
1755 | 	"c"	:	"[4845]";
1756 | 	"d"	:	"I2ZZZ1";
1757 | 	"O"	:	"[4646]";
1758 | 
1759 | INSTANCE "aoi22":"physical"
1760 | 	"a"	:	"[4628]";
1761 | 	"b"	:	"INYBB3";
1762 | 	"c"	:	"[4848]";
1763 | 	"d"	:	"I1ZZZ2";
1764 | 	"O"	:	"[4651]";
1765 | 
1766 | INSTANCE "aoi22":"physical"
1767 | 	"a"	:	"[4633]";
1768 | 	"b"	:	"INYBB3";
1769 | 	"c"	:	"[4845]";
1770 | 	"d"	:	"I2ZZZ2";
1771 | 	"O"	:	"[4656]";
1772 | 
1773 | INSTANCE "aoi22":"physical"
1774 | 	"a"	:	"[4628]";
1775 | 	"b"	:	"INYBB4";
1776 | 	"c"	:	"[4848]";
1777 | 	"d"	:	"I1ZZZ3";
1778 | 	"O"	:	"[4661]";
1779 | 
1780 | INSTANCE "aoi22":"physical"
1781 | 	"a"	:	"[4633]";
1782 | 	"b"	:	"INYBB4";
1783 | 	"c"	:	"[4845]";
1784 | 	"d"	:	"I2ZZZ3";
1785 | 	"O"	:	"[4666]";
1786 | 
1787 | INSTANCE "aoi22":"physical"
1788 | 	"a"	:	"[4628]";
1789 | 	"b"	:	"INYBB5";
1790 | 	"c"	:	"[4848]";
1791 | 	"d"	:	"I1ZZZ4";
1792 | 	"O"	:	"[4671]";
1793 | 
1794 | INSTANCE "aoi22":"physical"
1795 | 	"a"	:	"[4633]";
1796 | 	"b"	:	"INYBB5";
1797 | 	"c"	:	"[4845]";
1798 | 	"d"	:	"I2ZZZ4";
1799 | 	"O"	:	"[4676]";
1800 | 
1801 | INSTANCE "aoi22":"physical"
1802 | 	"a"	:	"[4628]";
1803 | 	"b"	:	"INYBB6";
1804 | 	"c"	:	"[4848]";
1805 | 	"d"	:	"I1ZZZ5";
1806 | 	"O"	:	"[4681]";
1807 | 
1808 | INSTANCE "aoi22":"physical"
1809 | 	"a"	:	"[4633]";
1810 | 	"b"	:	"INYBB6";
1811 | 	"c"	:	"[4845]";
1812 | 	"d"	:	"I2ZZZ5";
1813 | 	"O"	:	"[4686]";
1814 | 
1815 | INSTANCE "aoi22":"physical"
1816 | 	"a"	:	"[4628]";
1817 | 	"b"	:	"INYBB7";
1818 | 	"c"	:	"[4848]";
1819 | 	"d"	:	"I1ZZZ6";
1820 | 	"O"	:	"[4691]";
1821 | 
1822 | INSTANCE "aoi22":"physical"
1823 | 	"a"	:	"[4633]";
1824 | 	"b"	:	"INYBB7";
1825 | 	"c"	:	"[4845]";
1826 | 	"d"	:	"I2ZZZ6";
1827 | 	"O"	:	"[4696]";
1828 | 
1829 | INSTANCE "aoi22":"physical"
1830 | 	"a"	:	"[4628]";
1831 | 	"b"	:	"INYBB8";
1832 | 	"c"	:	"[4848]";
1833 | 	"d"	:	"I1ZZZ7";
1834 | 	"O"	:	"[4701]";
1835 | 
1836 | INSTANCE "aoi22":"physical"
1837 | 	"a"	:	"[4633]";
1838 | 	"b"	:	"INYBB8";
1839 | 	"c"	:	"[4845]";
1840 | 	"d"	:	"I2ZZZ7";
1841 | 	"O"	:	"[4706]";
1842 | 
1843 | INSTANCE "oai21":"physical"
1844 | 	"a"	:	"COMPPAR";
1845 | 	"b"	:	"[2055]";
1846 | 	"c"	:	"[2018]";
1847 | 	"O"	:	"[4710]";
1848 | 
1849 | INSTANCE "aoi22":"physical"
1850 | 	"a"	:	"[2015]";
1851 | 	"b"	:	"[4710]";
1852 | 	"c"	:	"[2055]";
1853 | 	"d"	:	"COMPPAR";
1854 | 	"O"	:	"[4715]";
1855 | 
1856 | INSTANCE "nor2":"physical"
1857 | 	"a"	:	"ESRSUM";
1858 | 	"b"	:	"[2060]";
1859 | 	"O"	:	"[4718]";
1860 | 
1861 | INSTANCE "nor3":"physical"
1862 | 	"a"	:	"[2059]";
1863 | 	"b"	:	"RXZ0";
1864 | 	"c"	:	"[2055]";
1865 | 	"O"	:	"[4722]";
1866 | 
1867 | INSTANCE "inv":"physical"
1868 | 	"a"	:	"[2037]";
1869 | 	"O"	:	"[4724]";
1870 | 
1871 | INSTANCE "aoi21":"physical"
1872 | 	"a"	:	"SLAD0";
1873 | 	"b"	:	"[4724]";
1874 | 	"c"	:	"[2043]";
1875 | 	"O"	:	"[4726]";
1876 | 
1877 | INSTANCE "nor2":"physical"
1878 | 	"a"	:	"SLAD0";
1879 | 	"b"	:	"SLAD1";
1880 | 	"O"	:	"[4729]";
1881 | 
1882 | INSTANCE "nor2":"physical"
1883 | 	"a"	:	"PSYNC";
1884 | 	"b"	:	"ICLR";
1885 | 	"O"	:	"[4732]";
1886 | 
1887 | INSTANCE "inv":"physical"
1888 | 	"a"	:	"RPTEN";
1889 | 	"O"	:	"[4734]";
1890 | 
1891 | INSTANCE "nor4":"physical"
1892 | 	"a"	:	"RYZ";
1893 | 	"b"	:	"[4734]";
1894 | 	"c"	:	"[4857]";
1895 | 	"d"	:	"[2016]";
1896 | 	"O"	:	"[4737]";
1897 | 
1898 | INSTANCE "inv":"physical"
1899 | 	"a"	:	"OFS1";
1900 | 	"O"	:	"[4739]";
1901 | 
1902 | INSTANCE "nor2":"physical"
1903 | 	"a"	:	"ICLR";
1904 | 	"b"	:	"[4739]";
1905 | 	"O"	:	"[4740]";
1906 | 
1907 | INSTANCE "aoi22":"physical"
1908 | 	"a"	:	"OFS2";
1909 | 	"b"	:	"[4740]";
1910 | 	"c"	:	"[2461]";
1911 | 	"d"	:	"XZFR1";
1912 | 	"O"	:	"[4745]";
1913 | 
1914 | INSTANCE "aoi22":"physical"
1915 | 	"a"	:	"P1ZZZ0";
1916 | 	"b"	:	"[4543]";
1917 | 	"c"	:	"I1ZZZ0";
1918 | 	"d"	:	"[4546]";
1919 | 	"O"	:	"[4750]";
1920 | 
1921 | INSTANCE "aoi22":"physical"
1922 | 	"a"	:	"P1ZZZ1";
1923 | 	"b"	:	"[4543]";
1924 | 	"c"	:	"I1ZZZ1";
1925 | 	"d"	:	"[4546]";
1926 | 	"O"	:	"[4755]";
1927 | 
1928 | INSTANCE "aoi22":"physical"
1929 | 	"a"	:	"P1ZZZ2";
1930 | 	"b"	:	"[4543]";
1931 | 	"c"	:	"I1ZZZ2";
1932 | 	"d"	:	"[4546]";
1933 | 	"O"	:	"[4760]";
1934 | 
1935 | INSTANCE "aoi22":"physical"
1936 | 	"a"	:	"P1ZZZ3";
1937 | 	"b"	:	"[4543]";
1938 | 	"c"	:	"I1ZZZ3";
1939 | 	"d"	:	"[4546]";
1940 | 	"O"	:	"[4765]";
1941 | 
1942 | INSTANCE "aoi22":"physical"
1943 | 	"a"	:	"P1ZZZ4";
1944 | 	"b"	:	"[4543]";
1945 | 	"c"	:	"I1ZZZ4";
1946 | 	"d"	:	"[4546]";
1947 | 	"O"	:	"[4770]";
1948 | 
1949 | INSTANCE "aoi22":"physical"
1950 | 	"a"	:	"P1ZZZ5";
1951 | 	"b"	:	"[4543]";
1952 | 	"c"	:	"I1ZZZ5";
1953 | 	"d"	:	"[4546]";
1954 | 	"O"	:	"[4775]";
1955 | 
1956 | INSTANCE "aoi22":"physical"
1957 | 	"a"	:	"P1ZZZ6";
1958 | 	"b"	:	"[4543]";
1959 | 	"c"	:	"I1ZZZ6";
1960 | 	"d"	:	"[4546]";
1961 | 	"O"	:	"[4780]";
1962 | 
1963 | INSTANCE "aoi22":"physical"
1964 | 	"a"	:	"P1ZZZ7";
1965 | 	"b"	:	"[4543]";
1966 | 	"c"	:	"I1ZZZ7";
1967 | 	"d"	:	"[4546]";
1968 | 	"O"	:	"[4785]";
1969 | 
1970 | INSTANCE "aoi22":"physical"
1971 | 	"a"	:	"P2ZZZ0";
1972 | 	"b"	:	"[4543]";
1973 | 	"c"	:	"I2ZZZ0";
1974 | 	"d"	:	"[4546]";
1975 | 	"O"	:	"[4790]";
1976 | 
1977 | INSTANCE "aoi22":"physical"
1978 | 	"a"	:	"P2ZZZ1";
1979 | 	"b"	:	"[4543]";
1980 | 	"c"	:	"I2ZZZ1";
1981 | 	"d"	:	"[4546]";
1982 | 	"O"	:	"[4795]";
1983 | 
1984 | INSTANCE "aoi22":"physical"
1985 | 	"a"	:	"P2ZZZ2";
1986 | 	"b"	:	"[4543]";
1987 | 	"c"	:	"I2ZZZ2";
1988 | 	"d"	:	"[4546]";
1989 | 	"O"	:	"[4800]";
1990 | 
1991 | INSTANCE "aoi22":"physical"
1992 | 	"a"	:	"P2ZZZ3";
1993 | 	"b"	:	"[4543]";
1994 | 	"c"	:	"I2ZZZ3";
1995 | 	"d"	:	"[4546]";
1996 | 	"O"	:	"[4805]";
1997 | 
1998 | INSTANCE "aoi22":"physical"
1999 | 	"a"	:	"P2ZZZ4";
2000 | 	"b"	:	"[4543]";
2001 | 	"c"	:	"I2ZZZ4";
2002 | 	"d"	:	"[4546]";
2003 | 	"O"	:	"[4810]";
2004 | 
2005 | INSTANCE "aoi22":"physical"
2006 | 	"a"	:	"P2ZZZ5";
2007 | 	"b"	:	"[4543]";
2008 | 	"c"	:	"I2ZZZ5";
2009 | 	"d"	:	"[4546]";
2010 | 	"O"	:	"[4815]";
2011 | 
2012 | INSTANCE "aoi22":"physical"
2013 | 	"a"	:	"P2ZZZ6";
2014 | 	"b"	:	"[4543]";
2015 | 	"c"	:	"I2ZZZ6";
2016 | 	"d"	:	"[4546]";
2017 | 	"O"	:	"[4820]";
2018 | 
2019 | INSTANCE "aoi22":"physical"
2020 | 	"a"	:	"P2ZZZ7";
2021 | 	"b"	:	"[4543]";
2022 | 	"c"	:	"I2ZZZ7";
2023 | 	"d"	:	"[4546]";
2024 | 	"O"	:	"[4825]";
2025 | 
2026 | INSTANCE "oai22":"physical"
2027 | 	"a"	:	"[4861]";
2028 | 	"b"	:	"[392]";
2029 | 	"c"	:	"[2015]";
2030 | 	"d"	:	"[2050]";
2031 | 	"O"	:	"[4830]";
2032 | 
2033 | INSTANCE "nor2":"physical"
2034 | 	"a"	:	"RYZ";
2035 | 	"b"	:	"[2017]";
2036 | 	"O"	:	"[4833]";
2037 | 
2038 | INSTANCE "nor2":"physical"
2039 | 	"a"	:	"RYZ";
2040 | 	"b"	:	"QPR3";
2041 | 	"O"	:	"[4836]";
2042 | 
2043 | INSTANCE "nor2":"physical"
2044 | 	"a"	:	"RYZ";
2045 | 	"b"	:	"[4553]";
2046 | 	"O"	:	"[4839]";
2047 | 
2048 | INSTANCE "nor2":"physical"
2049 | 	"a"	:	"RYZ";
2050 | 	"b"	:	"[4548]";
2051 | 	"O"	:	"[4842]";
2052 | 
2053 | INSTANCE "nor2":"physical"
2054 | 	"a"	:	"RYZ";
2055 | 	"b"	:	"[4633]";
2056 | 	"O"	:	"[4845]";
2057 | 
2058 | INSTANCE "nor2":"physical"
2059 | 	"a"	:	"RYZ";
2060 | 	"b"	:	"[4628]";
2061 | 	"O"	:	"[4848]";
2062 | 
2063 | INSTANCE "aoi22":"physical"
2064 | 	"a"	:	"[2614]";
2065 | 	"b"	:	"[4830]";
2066 | 	"c"	:	"[4872]";
2067 | 	"d"	:	"[4833]";
2068 | 	"O"	:	"[4853]";
2069 | 
2070 | INSTANCE "aoi21":"physical"
2071 | 	"a"	:	"[2059]";
2072 | 	"b"	:	"[4718]";
2073 | 	"c"	:	"[4722]";
2074 | 	"O"	:	"[4857]";
2075 | 
2076 | INSTANCE "aoi21":"physical"
2077 | 	"a"	:	"[2018]";
2078 | 	"b"	:	"[2020]";
2079 | 	"c"	:	"[2017]";
2080 | 	"O"	:	"[4861]";
2081 | 
2082 | INSTANCE "nor2":"physical"
2083 | 	"a"	:	"QPR1";
2084 | 	"b"	:	"[2035]";
2085 | 	"O"	:	"[4864]";
2086 | 
2087 | INSTANCE "nor2":"physical"
2088 | 	"a"	:	"[783]";
2089 | 	"b"	:	"[2035]";
2090 | 	"O"	:	"[4867]";
2091 | 
2092 | INSTANCE "oai22":"physical"
2093 | 	"a"	:	"[393]";
2094 | 	"b"	:	"[2018]";
2095 | 	"c"	:	"[4715]";
2096 | 	"d"	:	"[2020]";
2097 | 	"O"	:	"[4872]";
2098 | 
2099 | INSTANCE "aoi22":"physical"
2100 | 	"a"	:	"TXWRD1";
2101 | 	"b"	:	"[5011]";
2102 | 	"c"	:	"V1ZZZ0";
2103 | 	"d"	:	"[4539]";
2104 | 	"O"	:	"[4877]";
2105 | 
2106 | INSTANCE "aoi22":"physical"
2107 | 	"a"	:	"[5011]";
2108 | 	"b"	:	"TXWRD2";
2109 | 	"c"	:	"V1ZZZ1";
2110 | 	"d"	:	"[4539]";
2111 | 	"O"	:	"[4882]";
2112 | 
2113 | INSTANCE "aoi22":"physical"
2114 | 	"a"	:	"[5011]";
2115 | 	"b"	:	"TXWRD3";
2116 | 	"c"	:	"V1ZZZ2";
2117 | 	"d"	:	"[4539]";
2118 | 	"O"	:	"[4887]";
2119 | 
2120 | INSTANCE "aoi22":"physical"
2121 | 	"a"	:	"[5011]";
2122 | 	"b"	:	"TXWRD4";
2123 | 	"c"	:	"V1ZZZ3";
2124 | 	"d"	:	"[4539]";
2125 | 	"O"	:	"[4892]";
2126 | 
2127 | INSTANCE "aoi22":"physical"
2128 | 	"a"	:	"[5011]";
2129 | 	"b"	:	"TXWRD5";
2130 | 	"c"	:	"V1ZZZ4";
2131 | 	"d"	:	"[4539]";
2132 | 	"O"	:	"[4897]";
2133 | 
2134 | INSTANCE "aoi22":"physical"
2135 | 	"a"	:	"[5011]";
2136 | 	"b"	:	"TXWRD6";
2137 | 	"c"	:	"V1ZZZ5";
2138 | 	"d"	:	"[4539]";
2139 | 	"O"	:	"[4902]";
2140 | 
2141 | INSTANCE "aoi22":"physical"
2142 | 	"a"	:	"[5011]";
2143 | 	"b"	:	"TXWRD7";
2144 | 	"c"	:	"V1ZZZ6";
2145 | 	"d"	:	"[4539]";
2146 | 	"O"	:	"[4907]";
2147 | 
2148 | INSTANCE "aoi22":"physical"
2149 | 	"a"	:	"[5011]";
2150 | 	"b"	:	"TXWRD8";
2151 | 	"c"	:	"V1ZZZ7";
2152 | 	"d"	:	"[4539]";
2153 | 	"O"	:	"[4912]";
2154 | 
2155 | INSTANCE "aoi22":"physical"
2156 | 	"a"	:	"[5011]";
2157 | 	"b"	:	"TXWRD9";
2158 | 	"c"	:	"V2ZZZ0";
2159 | 	"d"	:	"[4539]";
2160 | 	"O"	:	"[4917]";
2161 | 
2162 | INSTANCE "aoi22":"physical"
2163 | 	"a"	:	"[5011]";
2164 | 	"b"	:	"TXWRD10";
2165 | 	"c"	:	"V2ZZZ1";
2166 | 	"d"	:	"[4539]";
2167 | 	"O"	:	"[4922]";
2168 | 
2169 | INSTANCE "aoi22":"physical"
2170 | 	"a"	:	"[5011]";
2171 | 	"b"	:	"TXWRD11";
2172 | 	"c"	:	"V2ZZZ2";
2173 | 	"d"	:	"[4539]";
2174 | 	"O"	:	"[4927]";
2175 | 
2176 | INSTANCE "aoi22":"physical"
2177 | 	"a"	:	"[5011]";
2178 | 	"b"	:	"TXWRD12";
2179 | 	"c"	:	"V2ZZZ3";
2180 | 	"d"	:	"[4539]";
2181 | 	"O"	:	"[4932]";
2182 | 
2183 | INSTANCE "aoi22":"physical"
2184 | 	"a"	:	"[5011]";
2185 | 	"b"	:	"TXWRD13";
2186 | 	"c"	:	"V2ZZZ4";
2187 | 	"d"	:	"[4539]";
2188 | 	"O"	:	"[4937]";
2189 | 
2190 | INSTANCE "aoi22":"physical"
2191 | 	"a"	:	"[5011]";
2192 | 	"b"	:	"TXWRD14";
2193 | 	"c"	:	"V2ZZZ5";
2194 | 	"d"	:	"[4539]";
2195 | 	"O"	:	"[4942]";
2196 | 
2197 | INSTANCE "aoi22":"physical"
2198 | 	"a"	:	"[5011]";
2199 | 	"b"	:	"TXWRD15";
2200 | 	"c"	:	"V2ZZZ6";
2201 | 	"d"	:	"[4539]";
2202 | 	"O"	:	"[4947]";
2203 | 
2204 | INSTANCE "aoi22":"physical"
2205 | 	"a"	:	"V2ZZZ7";
2206 | 	"b"	:	"[4539]";
2207 | 	"c"	:	"[4536]";
2208 | 	"d"	:	"TXWRD15";
2209 | 	"O"	:	"[4952]";
2210 | 
2211 | INSTANCE "nand2":"physical"
2212 | 	"a"	:	"TXWRD0";
2213 | 	"b"	:	"[4536]";
2214 | 	"O"	:	"[4955]";
2215 | 
2216 | INSTANCE "nand2":"physical"
2217 | 	"a"	:	"[4536]";
2218 | 	"b"	:	"TXWRD1";
2219 | 	"O"	:	"[4958]";
2220 | 
2221 | INSTANCE "nand2":"physical"
2222 | 	"a"	:	"[4536]";
2223 | 	"b"	:	"TXWRD2";
2224 | 	"O"	:	"[4961]";
2225 | 
2226 | INSTANCE "nand2":"physical"
2227 | 	"a"	:	"[4536]";
2228 | 	"b"	:	"TXWRD3";
2229 | 	"O"	:	"[4964]";
2230 | 
2231 | INSTANCE "nand2":"physical"
2232 | 	"a"	:	"[4536]";
2233 | 	"b"	:	"TXWRD4";
2234 | 	"O"	:	"[4967]";
2235 | 
2236 | INSTANCE "nand2":"physical"
2237 | 	"a"	:	"[4536]";
2238 | 	"b"	:	"TXWRD5";
2239 | 	"O"	:	"[4970]";
2240 | 
2241 | INSTANCE "nand2":"physical"
2242 | 	"a"	:	"[4536]";
2243 | 	"b"	:	"TXWRD6";
2244 | 	"O"	:	"[4973]";
2245 | 
2246 | INSTANCE "nand2":"physical"
2247 | 	"a"	:	"[4536]";
2248 | 	"b"	:	"TXWRD7";
2249 | 	"O"	:	"[4976]";
2250 | 
2251 | INSTANCE "nand2":"physical"
2252 | 	"a"	:	"[4536]";
2253 | 	"b"	:	"TXWRD8";
2254 | 	"O"	:	"[4979]";
2255 | 
2256 | INSTANCE "nand2":"physical"
2257 | 	"a"	:	"[4536]";
2258 | 	"b"	:	"TXWRD9";
2259 | 	"O"	:	"[4982]";
2260 | 
2261 | INSTANCE "nand2":"physical"
2262 | 	"a"	:	"[4536]";
2263 | 	"b"	:	"TXWRD10";
2264 | 	"O"	:	"[4985]";
2265 | 
2266 | INSTANCE "nand2":"physical"
2267 | 	"a"	:	"[4536]";
2268 | 	"b"	:	"TXWRD11";
2269 | 	"O"	:	"[4988]";
2270 | 
2271 | INSTANCE "nand2":"physical"
2272 | 	"a"	:	"[4536]";
2273 | 	"b"	:	"TXWRD12";
2274 | 	"O"	:	"[4991]";
2275 | 
2276 | INSTANCE "nand2":"physical"
2277 | 	"a"	:	"[4536]";
2278 | 	"b"	:	"TXWRD13";
2279 | 	"O"	:	"[4994]";
2280 | 
2281 | INSTANCE "nand2":"physical"
2282 | 	"a"	:	"[4536]";
2283 | 	"b"	:	"TXWRD14";
2284 | 	"O"	:	"[4997]";
2285 | 
2286 | INSTANCE "nor2":"physical"
2287 | 	"a"	:	"XZ320";
2288 | 	"b"	:	"[2162]";
2289 | 	"O"	:	"[5000]";
2290 | 
2291 | INSTANCE "nor2":"physical"
2292 | 	"a"	:	"XZ322";
2293 | 	"b"	:	"[2146]";
2294 | 	"O"	:	"[5003]";
2295 | 
2296 | INSTANCE "inv":"physical"
2297 | 	"a"	:	"[742]";
2298 | 	"O"	:	"[5007]";
2299 | 
2300 | INSTANCE "nand4":"physical"
2301 | 	"a"	:	"[2143]";
2302 | 	"b"	:	"XZ162";
2303 | 	"c"	:	"[744]";
2304 | 	"d"	:	"[5007]";
2305 | 	"O"	:	"[5008]";
2306 | 
2307 | INSTANCE "nor2":"physical"
2308 | 	"a"	:	"[2024]";
2309 | 	"b"	:	"[2227]";
2310 | 	"O"	:	"[5011]";
2311 | 
2312 | INSTANCE "nand3":"physical"
2313 | 	"a"	:	"[4750]";
2314 | 	"b"	:	"[4955]";
2315 | 	"c"	:	"[4877]";
2316 | 	"O"	:	"[5015]";
2317 | 
2318 | INSTANCE "nand3":"physical"
2319 | 	"a"	:	"[4755]";
2320 | 	"b"	:	"[4958]";
2321 | 	"c"	:	"[4882]";
2322 | 	"O"	:	"[5019]";
2323 | 
2324 | INSTANCE "nand3":"physical"
2325 | 	"a"	:	"[4760]";
2326 | 	"b"	:	"[4961]";
2327 | 	"c"	:	"[4887]";
2328 | 	"O"	:	"[5023]";
2329 | 
2330 | INSTANCE "nand3":"physical"
2331 | 	"a"	:	"[4765]";
2332 | 	"b"	:	"[4964]";
2333 | 	"c"	:	"[4892]";
2334 | 	"O"	:	"[5027]";
2335 | 
2336 | INSTANCE "nand3":"physical"
2337 | 	"a"	:	"[4770]";
2338 | 	"b"	:	"[4967]";
2339 | 	"c"	:	"[4897]";
2340 | 	"O"	:	"[5031]";
2341 | 
2342 | INSTANCE "nand3":"physical"
2343 | 	"a"	:	"[4775]";
2344 | 	"b"	:	"[4970]";
2345 | 	"c"	:	"[4902]";
2346 | 	"O"	:	"[5035]";
2347 | 
2348 | INSTANCE "nand3":"physical"
2349 | 	"a"	:	"[4780]";
2350 | 	"b"	:	"[4973]";
2351 | 	"c"	:	"[4907]";
2352 | 	"O"	:	"[5039]";
2353 | 
2354 | INSTANCE "nand3":"physical"
2355 | 	"a"	:	"[4785]";
2356 | 	"b"	:	"[4976]";
2357 | 	"c"	:	"[4912]";
2358 | 	"O"	:	"[5043]";
2359 | 
2360 | INSTANCE "nand3":"physical"
2361 | 	"a"	:	"[4790]";
2362 | 	"b"	:	"[4979]";
2363 | 	"c"	:	"[4917]";
2364 | 	"O"	:	"[5047]";
2365 | 
2366 | INSTANCE "nand3":"physical"
2367 | 	"a"	:	"[4795]";
2368 | 	"b"	:	"[4982]";
2369 | 	"c"	:	"[4922]";
2370 | 	"O"	:	"[5051]";
2371 | 
2372 | INSTANCE "nand3":"physical"
2373 | 	"a"	:	"[4800]";
2374 | 	"b"	:	"[4985]";
2375 | 	"c"	:	"[4927]";
2376 | 	"O"	:	"[5055]";
2377 | 
2378 | INSTANCE "nand3":"physical"
2379 | 	"a"	:	"[4805]";
2380 | 	"b"	:	"[4988]";
2381 | 	"c"	:	"[4932]";
2382 | 	"O"	:	"[5059]";
2383 | 
2384 | INSTANCE "nand3":"physical"
2385 | 	"a"	:	"[4810]";
2386 | 	"b"	:	"[4991]";
2387 | 	"c"	:	"[4937]";
2388 | 	"O"	:	"[5063]";
2389 | 
2390 | INSTANCE "nand3":"physical"
2391 | 	"a"	:	"[4815]";
2392 | 	"b"	:	"[4994]";
2393 | 	"c"	:	"[4942]";
2394 | 	"O"	:	"[5067]";
2395 | 
2396 | INSTANCE "nand3":"physical"
2397 | 	"a"	:	"[4820]";
2398 | 	"b"	:	"[4997]";
2399 | 	"c"	:	"[4947]";
2400 | 	"O"	:	"[5071]";
2401 | 
2402 | INSTANCE "and2":"physical"
2403 | 	"a"	:	"[4952]";
2404 | 	"b"	:	"[4825]";
2405 | 	"O"	:	"[5074]";
2406 | 
2407 | ENDMODEL;
2408 | 


--------------------------------------------------------------------------------