<pre><font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: PDKs root directory: /media/philipp/Daten/skywater/pdk-ls</font>
<font color="#00AAAA">[INFO]: PDK: sky130A</font>
<font color="#00AAAA">[INFO]: Setting PDKPATH to /media/philipp/Daten/skywater/pdk-ls/sky130A</font>
<font color="#00AAAA">[INFO]: Standard Cell Library: sky130_fd_sc_ls</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#AA5500">[WARNING]: Removing exisiting run /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Current run directory is /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Preparing LEF Files</font>
<font color="#00AAAA">[INFO]: Extracting the number of available metal layers from /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef</font>
<font color="#00AAAA">[INFO]: The number of available metal layers is 6</font>
<font color="#00AAAA">[INFO]: The available metal layers are li1 met1 met2 met3 met4 met5</font>
<font color="#00AAAA">[INFO]: Merging LEF Files...</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: MACROs matched found: 399</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">NAND3X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND3X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX8.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX8.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX4.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX4.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">HAX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">HAX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">MUX2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">MUX2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">BUFX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">BUFX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NAND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">XNOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">XNOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INV.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INV.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#00AAAA">[INFO]: Merging the following extra LEFs: /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX8.lef /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX4.lef /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/HAX1.lef /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX2.lef /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX1.lef /project/openlane/user_proj_example/../../cells/lef/INV.lef</font>
<font color="#00AAAA">[INFO]: Trimming Liberty...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Storing configs into config.tcl ...</font>
<font color="#00AAAA">[INFO]: Preparation complete</font>
<font color="#00AAAA">[INFO]: Running Synthesis...</font>
<font color="#00AAAA">[INFO]: current step index: 1</font>

<font color="#AAAAAA"> /----------------------------------------------------------------------------\</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  yosys -- Yosys Open SYnthesis Suite                                       |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Copyright (C) 2012 - 2020  Claire Wolf &lt;claire@symbioticeda.com&gt;          |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Permission to use, copy, modify, and/or distribute this software for any  |</font>
<font color="#AAAAAA"> |  purpose with or without fee is hereby granted, provided that the above    |</font>
<font color="#AAAAAA"> |  copyright notice and this permission notice appear in all copies.         |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES  |</font>
<font color="#AAAAAA"> |  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF          |</font>
<font color="#AAAAAA"> |  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   |</font>
<font color="#AAAAAA"> |  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    |</font>
<font color="#AAAAAA"> |  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN     |</font>
<font color="#AAAAAA"> |  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   |</font>
<font color="#AAAAAA"> |  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.            |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> \----------------------------------------------------------------------------/</font>

<font color="#AAAAAA"> Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>

<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `cd&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `eval&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `exec&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `read&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `trace&apos; -&gt; skip.</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/tmp/sky130_fd_sc_ls__tt_025C_1v80.no_pg.lib as a blackbox</font>

<font color="#AAAAAA">1. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 386 cell types from liberty file.</font>

<font color="#AAAAAA">2. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 19 cell types from liberty file.</font>

<font color="#AAAAAA">3. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v&apos; to AST representation.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:10.1-17.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:19.1-26.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:28.1-36.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:38.1-47.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\BUFX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:49.1-55.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX2&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX4&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\CLKBUF1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\HAX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:73.1-81.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\HAX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INV&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:83.1-89.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INV&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:91.1-97.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:99.1-105.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX4&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:107.1-113.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX4&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX8&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:115.1-121.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX8&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\MUX2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:123.1-131.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\MUX2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:133.1-140.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND3X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:142.1-150.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:152.1-159.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:171.1-179.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:181.1-190.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:192.1-199.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\XNOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:210.1-217.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XNOR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XOR2X1&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">4. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v&apos; to AST representation.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">5. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">6. Generating Graphviz representation of design.</font>
<font color="#AAAAAA">ERROR: Nothing there to show.</font>
<font color="#AA0000">[ERROR]: during executing: &quot;yosys -c /openLANE_flow/scripts/synth.tcl -l /project/openlane/user_proj_example/runs/user_proj_example/logs/synthesis/1-yosys.log |&amp; tee &gt;&amp;@stdout&quot;</font>
<font color="#AA0000">[ERROR]: Exit code: 1</font>
<font color="#AA0000">[ERROR]: Last 10 lines:</font>
<font color="#AA0000">child process exited abnormally</font>

<font color="#AA0000">[ERROR]: Please check yosys  log file</font>
<font color="#AA0000">[ERROR]: Dumping to /project/openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow failed for user_proj_example/13-06_17-48 in 0h0m17s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.gds.log</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">No antenna report found.</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#AA0000">[ERROR]: Flow Failed.</font>

<font color="#AAAAAA">    while executing</font>
<font color="#AAAAAA">&quot;try_catch [get_yosys_bin]  -c $::env(SYNTH_SCRIPT)  -l [index_file $::env(yosys_log_file_tag).log 0]  |&amp; tee $::env(TERMINAL_OUTPUT)&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_yosys&quot; line 34)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_yosys&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_synthesis&quot; line 9)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_synthesis&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_non_interactive_mode&quot; line 14)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_non_interactive_mode {*}$argv&quot;</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;if { [info exists flags_map(-interactive)] || [info exists flags_map(-it)] } {</font>
	<font color="#AAAAAA">puts_info &quot;Running interactively&quot;</font>
	<font color="#AAAAAA">if { [info exists arg_values(-file)...&quot;</font>
<font color="#AAAAAA">    (file &quot;/openLANE_flow/flow.tcl&quot; line 223)</font>
<font color="#AAAAAA">make[1]: *** [Makefile:43: user_proj_example] Fehler 1</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird verlassen</font>
<font color="#AAAAAA">make: *** [Makefile:71: user_proj_example] Fehler 2</font>
<font color="#AAAAAA">Deployment done.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ vi user_proj_example/runs/user_proj_example/error.log</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ cd ..</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ ls</font>
<font color="#AAAAAA">caravel  cells</font>	<font color="#AAAAAA">def  docs  env.sh  gds</font>	<font color="#AAAAAA">info.yaml  lef</font>	<font color="#AAAAAA">LICENSE  mag  maglef  Makefile</font>	<font color="#AAAAAA">openlane  README.md  scripts  signoff  spi  verilog</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ vi openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ vi openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ vi openlane/user_proj_example/runs/user_proj_example/logs/synthesis/1-yosys.log</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ ls</font>
<font color="#AAAAAA">caravel  cells</font>	<font color="#AAAAAA">def  docs  env.sh  gds</font>	<font color="#AAAAAA">info.yaml  lef</font>	<font color="#AAAAAA">LICENSE  mag  maglef  Makefile</font>	<font color="#AAAAAA">openlane  README.md  scripts  signoff  spi  verilog</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ cd verilog/</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog$ ls</font>
<font color="#AAAAAA">dv  gl</font>	<font color="#AAAAAA">rtl</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog$ cd rtl/</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ ls</font>
<font color="#AAAAAA">uprj_netlists.v  user_proj_cells.v  user_project_wrapper.v  user_proj_example.v</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi *</font>
<font color="#AAAAAA">4 Dateien zum Editieren</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ l</font>
<font color="#AAAAAA">l: Befehl nicht gefunden.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/generator.pl </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/</font>
<font color="#AAAAAA">cells.pl           deploy2caravel.sh  drcexpander.pl     generator.pl       magic.layers.out   placement.pl       removeDRCcells.pl  testgen.pl         viewer.pl          </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/testgen.pl </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/cells.pl </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/cells.pl </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ grep ifdef *</font>
<font color="#AAAAAA">uprj_netlists.v:`ifdef GL</font>
<font color="#AAAAAA">user_project_wrapper.v:`ifdef USE_POWER_PINS</font>
<font color="#AAAAAA">user_project_wrapper.v:    `ifdef USE_POWER_PINS</font>
<font color="#AAAAAA">user_proj_example.v:`ifdef USE_POWER_PINS</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi user_project_wrapper.v </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi ../../scripts/cells.pl </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ ls -al</font>
<font color="#AAAAAA">insgesamt 24</font>
<font color="#AAAAAA">drwxrwxr-x 2 philipp philipp 4096 Jun 13 20:11 .</font>
<font color="#AAAAAA">drwxrwxr-x 5 philipp philipp 4096 Mai 13 21:22 ..</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 1069 Mai 13 21:22 uprj_netlists.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3955 Jun 13 19:48 user_proj_cells.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3635 Mai 13 21:22 user_project_wrapper.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 1191 Jun 13 19:48 user_proj_example.v</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi *</font>
<font color="#AAAAAA">4 Dateien zum Editieren</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ ls -al</font>
<font color="#AAAAAA">insgesamt 24</font>
<font color="#AAAAAA">drwxrwxr-x 2 philipp philipp 4096 Jun 13 20:15 .</font>
<font color="#AAAAAA">drwxrwxr-x 5 philipp philipp 4096 Mai 13 21:22 ..</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 1069 Mai 13 21:22 uprj_netlists.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3955 Jun 13 19:48 user_proj_cells.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3635 Mai 13 21:22 user_project_wrapper.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 1191 Jun 13 19:48 user_proj_example.v</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ echo $CARAVEL</font>
<font color="#AAAAAA">/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ perl $CARAVEL/scripts/generator.pl &gt;$CARAVEL/verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ perl $CARAVEL/scripts/generator.pl &gt;$CARAVEL/verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/AND2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/AND2X2.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/AOI21X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/AOI22X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/BUFX2.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/BUFX4.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/CLKBUF1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/HAX1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/INV.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/INVX1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/INVX2.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/INVX4.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/INVX8.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/MUX2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/NAND2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/NAND3X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/NOR2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/NOR3X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/OAI21X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/OAI22X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/OR2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/OR2X2.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/XNOR2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 71.</font>
<font color="#AAAAAA">Checking for /cells/mag/XOR2X1.mag</font>
<font color="#AAAAAA">Use of uninitialized value in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/generator.pl line 72.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ echo $CARAVEL</font>
<font color="#AAAAAA">/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi *^C</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ perl $CARAVEL/scripts/generator.pl &gt;$CARAVEL/verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ vi user_proj_example.v </font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ ls -la</font>
<font color="#AAAAAA">insgesamt 28</font>
<font color="#AAAAAA">drwxrwxr-x 2 philipp philipp 4096 Jun 13 20:17 .</font>
<font color="#AAAAAA">drwxrwxr-x 5 philipp philipp 4096 Mai 13 21:22 ..</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 1069 Mai 13 21:22 uprj_netlists.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3955 Jun 13 19:48 user_proj_cells.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 3635 Mai 13 21:22 user_project_wrapper.v</font>
<font color="#AAAAAA">-rw-rw-r-- 1 philipp philipp 4794 Jun 13 20:17 user_proj_example.v</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog/rtl$ cd ..</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/verilog$ cd ..</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ ls</font>
<font color="#AAAAAA">caravel  cells</font>	<font color="#AAAAAA">def  docs  env.sh  gds</font>	<font color="#AAAAAA">info.yaml  lef</font>	<font color="#AAAAAA">LICENSE  mag  maglef  Makefile</font>	<font color="#AAAAAA">openlane  README.md  scripts  signoff  spi  verilog</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project$ cd scripts/</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ ls</font>
<font color="#AAAAAA">cells.pl  deploy2caravel.sh  drcexpander.pl  generator.pl  magic.layers.out  placement.pl  removeDRCcells.pl  testgen.pl  viewer.pl</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ bash deploy2caravel.sh </font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lib“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef/orig“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/gds“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/mag“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">Cleaning up old files</font>
<font color="#AAAAAA">Copying files that were created by StdCellLib</font>
<font color="#AAAAAA">Removing cells with DRC issues left</font>
<font color="#AAAAAA">Checking AND2X1</font>
<font color="#AAAAAA">Checking AND2X2</font>
<font color="#AAAAAA">Checking AOI21X1</font>
<font color="#AAAAAA">Checking AOI22X1</font>
<font color="#AAAAAA">Checking BUFX2</font>
<font color="#AAAAAA">Checking BUFX4</font>
<font color="#AAAAAA">Removing cell with 2 DRC issues:</font>
<font color="#AAAAAA">Checking CLKBUF1</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking corr_XOR2X1</font>
<font color="#AAAAAA">Error: Could not find DRC: /home/philipp/libresilicon/StdCellLib/corr_XOR2X1.drc No such file or directory</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking HAX1</font>
<font color="#AAAAAA">Checking INV</font>
<font color="#AAAAAA">Checking INVX1</font>
<font color="#AAAAAA">Checking INVX2</font>
<font color="#AAAAAA">Checking INVX4</font>
<font color="#AAAAAA">Checking INVX8</font>
<font color="#AAAAAA">Checking LATCH</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking MUX2X1</font>
<font color="#AAAAAA">Checking NAND2X1</font>
<font color="#AAAAAA">Checking NAND3X1</font>
<font color="#AAAAAA">Checking NOR2X1</font>
<font color="#AAAAAA">Checking NOR3X1</font>
<font color="#AAAAAA">Removing cell with 60 DRC issues:</font>
<font color="#AAAAAA">Checking OAI21X1</font>
<font color="#AAAAAA">Checking OAI22X1</font>
<font color="#AAAAAA">Checking OR2X1</font>
<font color="#AAAAAA">Checking OR2X2</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking XNOR2X1</font>
<font color="#AAAAAA">Checking XOR2X1</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Now cleaning up the files for Sky130</font>
<font color="#AAAAAA">AND2X1.lef</font>
<font color="#AAAAAA">AND2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X1.lef for cell AND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AND2X2.lef</font>
<font color="#AAAAAA">AND2X2.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X2.lef for cell AND2X2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI21X1.lef</font>
<font color="#AAAAAA">AOI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI21X1.lef for cell AOI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI22X1.lef</font>
<font color="#AAAAAA">AOI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI22X1.lef for cell AOI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">BUFX2.lef</font>
<font color="#AAAAAA">BUFX2.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output BUFX2.lef for cell BUFX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">HAX1.lef</font>
<font color="#AAAAAA">HAX1.lef -&gt; 15.84 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output HAX1.lef for cell HAX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INV.lef</font>
<font color="#AAAAAA">INV.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INV.lef for cell INV:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX1.lef</font>
<font color="#AAAAAA">INVX1.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX1.lef for cell INVX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX2.lef</font>
<font color="#AAAAAA">INVX2.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX2.lef for cell INVX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX4.lef</font>
<font color="#AAAAAA">INVX4.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 69 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX4.lef for cell INVX4:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX8.lef</font>
<font color="#AAAAAA">INVX8.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 83 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX8.lef for cell INVX8:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">MUX2X1.lef</font>
<font color="#AAAAAA">MUX2X1.lef -&gt; 8.64 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output MUX2X1.lef for cell MUX2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND2X1.lef</font>
<font color="#AAAAAA">NAND2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND2X1.lef for cell NAND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND3X1.lef</font>
<font color="#AAAAAA">NAND3X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND3X1.lef for cell NAND3X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NOR2X1.lef</font>
<font color="#AAAAAA">NOR2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NOR2X1.lef for cell NOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI21X1.lef</font>
<font color="#AAAAAA">OAI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI21X1.lef for cell OAI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI22X1.lef</font>
<font color="#AAAAAA">OAI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI22X1.lef for cell OAI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OR2X1.lef</font>
<font color="#AAAAAA">OR2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Generating LEF output OR2X1.lef for cell OR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">XNOR2X1.lef</font>
<font color="#AAAAAA">XNOR2X1.lef -&gt; 10.08 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 80 lines.</font>
<font color="#AAAAAA">Generating LEF output XNOR2X1.lef for cell XNOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">    INFO: Reading base liberty: /home/philipp/libresilicon/StdCellLib/Catalog/libresilicon.libtemplate</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: BUFX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: HAX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INV.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX4.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX8.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: MUX2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND3X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: XNOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(BUFX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(HAX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INV)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX4)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX8)</font>
<font color="#AAAAAA">    INFO: Add group: cell(MUX2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND3X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NOR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(XNOR2X1)</font>
<font color="#AAAAAA">    INFO: Number of cells in base: 19, number of cells in output: 19</font>
<font color="#AAAAAA">    INFO: Write liberty: libresilicon.lib</font>
<font color="#AAAAAA">Now generating the demo wafer, the macro placement and the test-bench</font>
<font color="#AAAAAA">Now building the Caravel user-project</font>
<font color="#AAAAAA">cd openlane &amp;&amp; make user_proj_example</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird betreten</font>
<font color="#AAAAAA">###############################################</font>
<font color="#00AAAA">[INFO]: </font>
	<font color="#00AAAA">___   ____   ___  ____   _       ____  ____     ___</font>
	<font color="#00AAAA">/   \ |    \ /  _]|    \ | |     /    ||    \   /  _]</font>
	<font color="#00AAAA">|     ||  o  )  [_ |  _  || |    |  o  ||  _  | /  [_</font>
	<font color="#00AAAA">|  O  ||   _/    _]|  |  || |___ |     ||  |  ||    _]</font>
	<font color="#00AAAA">|     ||  | |   [_ |  |  ||     ||  _  ||  |  ||   [_</font>
	<font color="#00AAAA">\___/ |__| |_____||__|__||_____||__|__||__|__||_____|</font>


<font color="#00AAAA">[INFO]: Version: v0.15</font>
<font color="#00AAAA">[INFO]: Running non-interactively</font>
<font color="#00AAAA">[INFO]: Using design configuration at /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: PDKs root directory: /media/philipp/Daten/skywater/pdk-ls</font>
<font color="#00AAAA">[INFO]: PDK: sky130A</font>
<font color="#00AAAA">[INFO]: Setting PDKPATH to /media/philipp/Daten/skywater/pdk-ls/sky130A</font>
<font color="#00AAAA">[INFO]: Standard Cell Library: sky130_fd_sc_ls</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#AA5500">[WARNING]: Removing exisiting run /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Current run directory is /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Preparing LEF Files</font>
<font color="#00AAAA">[INFO]: Extracting the number of available metal layers from /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef</font>
<font color="#00AAAA">[INFO]: The number of available metal layers is 6</font>
<font color="#00AAAA">[INFO]: The available metal layers are li1 met1 met2 met3 met4 met5</font>
<font color="#00AAAA">[INFO]: Merging LEF Files...</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: MACROs matched found: 399</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">NAND3X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND3X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX8.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX8.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX4.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX4.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">HAX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">HAX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">MUX2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">MUX2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">BUFX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">BUFX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NAND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">XNOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">XNOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INV.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INV.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#00AAAA">[INFO]: Merging the following extra LEFs: /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX8.lef /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX4.lef /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/HAX1.lef /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX2.lef /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX1.lef /project/openlane/user_proj_example/../../cells/lef/INV.lef</font>
<font color="#00AAAA">[INFO]: Trimming Liberty...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Storing configs into config.tcl ...</font>
<font color="#00AAAA">[INFO]: Preparation complete</font>
<font color="#00AAAA">[INFO]: Running Synthesis...</font>
<font color="#00AAAA">[INFO]: current step index: 1</font>

<font color="#AAAAAA"> /----------------------------------------------------------------------------\</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  yosys -- Yosys Open SYnthesis Suite                                       |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Copyright (C) 2012 - 2020  Claire Wolf &lt;claire@symbioticeda.com&gt;          |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Permission to use, copy, modify, and/or distribute this software for any  |</font>
<font color="#AAAAAA"> |  purpose with or without fee is hereby granted, provided that the above    |</font>
<font color="#AAAAAA"> |  copyright notice and this permission notice appear in all copies.         |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES  |</font>
<font color="#AAAAAA"> |  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF          |</font>
<font color="#AAAAAA"> |  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   |</font>
<font color="#AAAAAA"> |  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    |</font>
<font color="#AAAAAA"> |  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN     |</font>
<font color="#AAAAAA"> |  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   |</font>
<font color="#AAAAAA"> |  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.            |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> \----------------------------------------------------------------------------/</font>

<font color="#AAAAAA"> Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>

<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `cd&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `eval&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `exec&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `read&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `trace&apos; -&gt; skip.</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/tmp/sky130_fd_sc_ls__tt_025C_1v80.no_pg.lib as a blackbox</font>

<font color="#AAAAAA">1. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 386 cell types from liberty file.</font>

<font color="#AAAAAA">2. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 19 cell types from liberty file.</font>

<font color="#AAAAAA">3. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v</font>
<font color="#AAAAAA">/project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:278: ERROR: syntax error, unexpected $end</font>
<font color="#AA0000">[ERROR]: during executing: &quot;yosys -c /openLANE_flow/scripts/synth.tcl -l /project/openlane/user_proj_example/runs/user_proj_example/logs/synthesis/1-yosys.log |&amp; tee &gt;&amp;@stdout&quot;</font>
<font color="#AA0000">[ERROR]: Exit code: 1</font>
<font color="#AA0000">[ERROR]: Last 10 lines:</font>
<font color="#AA0000">child process exited abnormally</font>

<font color="#AA0000">[ERROR]: Please check yosys  log file</font>
<font color="#AA0000">[ERROR]: Dumping to /project/openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow failed for user_proj_example/13-06_18-19 in 0h0m17s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.gds.log</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">No antenna report found.</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#AA0000">[ERROR]: Flow Failed.</font>

<font color="#AAAAAA">    while executing</font>
<font color="#AAAAAA">&quot;try_catch [get_yosys_bin]  -c $::env(SYNTH_SCRIPT)  -l [index_file $::env(yosys_log_file_tag).log 0]  |&amp; tee $::env(TERMINAL_OUTPUT)&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_yosys&quot; line 34)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_yosys&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_synthesis&quot; line 9)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_synthesis&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_non_interactive_mode&quot; line 14)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_non_interactive_mode {*}$argv&quot;</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;if { [info exists flags_map(-interactive)] || [info exists flags_map(-it)] } {</font>
	<font color="#AAAAAA">puts_info &quot;Running interactively&quot;</font>
	<font color="#AAAAAA">if { [info exists arg_values(-file)...&quot;</font>
<font color="#AAAAAA">    (file &quot;/openLANE_flow/flow.tcl&quot; line 223)</font>
<font color="#AAAAAA">make[1]: *** [Makefile:43: user_proj_example] Fehler 1</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird verlassen</font>
<font color="#AAAAAA">make: *** [Makefile:71: user_proj_example] Fehler 2</font>
<font color="#AAAAAA">Deployment done.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ bash deploy2caravel.sh </font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lib“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef/orig“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/gds“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/mag“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">Cleaning up old files</font>
<font color="#AAAAAA">Copying files that were created by StdCellLib</font>
<font color="#AAAAAA">Removing cells with DRC issues left</font>
<font color="#AAAAAA">Checking AND2X1</font>
<font color="#AAAAAA">Checking AND2X2</font>
<font color="#AAAAAA">Checking AOI21X1</font>
<font color="#AAAAAA">Checking AOI22X1</font>
<font color="#AAAAAA">Checking BUFX2</font>
<font color="#AAAAAA">Checking BUFX4</font>
<font color="#AAAAAA">Removing cell with 2 DRC issues:</font>
<font color="#AAAAAA">Checking CLKBUF1</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking corr_XOR2X1</font>
<font color="#AAAAAA">Error: Could not find DRC: /home/philipp/libresilicon/StdCellLib/corr_XOR2X1.drc No such file or directory</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking HAX1</font>
<font color="#AAAAAA">Checking INV</font>
<font color="#AAAAAA">Checking INVX1</font>
<font color="#AAAAAA">Checking INVX2</font>
<font color="#AAAAAA">Checking INVX4</font>
<font color="#AAAAAA">Checking INVX8</font>
<font color="#AAAAAA">Checking LATCH</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking MUX2X1</font>
<font color="#AAAAAA">Checking NAND2X1</font>
<font color="#AAAAAA">Checking NAND3X1</font>
<font color="#AAAAAA">Checking NOR2X1</font>
<font color="#AAAAAA">Checking NOR3X1</font>
<font color="#AAAAAA">Removing cell with 60 DRC issues:</font>
<font color="#AAAAAA">Checking OAI21X1</font>
<font color="#AAAAAA">Checking OAI22X1</font>
<font color="#AAAAAA">Checking OR2X1</font>
<font color="#AAAAAA">Checking OR2X2</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking XNOR2X1</font>
<font color="#AAAAAA">Checking XOR2X1</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Now cleaning up the files for Sky130</font>
<font color="#AAAAAA">AND2X1.lef</font>
<font color="#AAAAAA">AND2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X1.lef for cell AND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AND2X2.lef</font>
<font color="#AAAAAA">AND2X2.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X2.lef for cell AND2X2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI21X1.lef</font>
<font color="#AAAAAA">AOI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI21X1.lef for cell AOI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI22X1.lef</font>
<font color="#AAAAAA">AOI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI22X1.lef for cell AOI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">BUFX2.lef</font>
<font color="#AAAAAA">BUFX2.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output BUFX2.lef for cell BUFX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">HAX1.lef</font>
<font color="#AAAAAA">HAX1.lef -&gt; 15.84 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output HAX1.lef for cell HAX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INV.lef</font>
<font color="#AAAAAA">INV.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INV.lef for cell INV:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX1.lef</font>
<font color="#AAAAAA">INVX1.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX1.lef for cell INVX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX2.lef</font>
<font color="#AAAAAA">INVX2.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX2.lef for cell INVX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX4.lef</font>
<font color="#AAAAAA">INVX4.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 69 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX4.lef for cell INVX4:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX8.lef</font>
<font color="#AAAAAA">INVX8.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 83 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX8.lef for cell INVX8:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">MUX2X1.lef</font>
<font color="#AAAAAA">MUX2X1.lef -&gt; 8.64 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output MUX2X1.lef for cell MUX2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND2X1.lef</font>
<font color="#AAAAAA">NAND2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND2X1.lef for cell NAND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND3X1.lef</font>
<font color="#AAAAAA">NAND3X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND3X1.lef for cell NAND3X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NOR2X1.lef</font>
<font color="#AAAAAA">NOR2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NOR2X1.lef for cell NOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI21X1.lef</font>
<font color="#AAAAAA">OAI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI21X1.lef for cell OAI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI22X1.lef</font>
<font color="#AAAAAA">OAI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI22X1.lef for cell OAI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OR2X1.lef</font>
<font color="#AAAAAA">OR2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Generating LEF output OR2X1.lef for cell OR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">XNOR2X1.lef</font>
<font color="#AAAAAA">XNOR2X1.lef -&gt; 10.08 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 80 lines.</font>
<font color="#AAAAAA">Generating LEF output XNOR2X1.lef for cell XNOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">    INFO: Reading base liberty: /home/philipp/libresilicon/StdCellLib/Catalog/libresilicon.libtemplate</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: BUFX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: HAX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INV.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX4.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX8.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: MUX2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND3X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: XNOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(BUFX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(HAX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INV)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX4)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX8)</font>
<font color="#AAAAAA">    INFO: Add group: cell(MUX2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND3X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NOR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(XNOR2X1)</font>
<font color="#AAAAAA">    INFO: Number of cells in base: 19, number of cells in output: 19</font>
<font color="#AAAAAA">    INFO: Write liberty: libresilicon.lib</font>
<font color="#AAAAAA">Now generating the demo wafer, the macro placement and the test-bench</font>
<font color="#AAAAAA">Now building the Caravel user-project</font>
<font color="#AAAAAA">cd openlane &amp;&amp; make user_proj_example</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird betreten</font>
<font color="#AAAAAA">###############################################</font>
<font color="#00AAAA">[INFO]: </font>
	<font color="#00AAAA">___   ____   ___  ____   _       ____  ____     ___</font>
	<font color="#00AAAA">/   \ |    \ /  _]|    \ | |     /    ||    \   /  _]</font>
	<font color="#00AAAA">|     ||  o  )  [_ |  _  || |    |  o  ||  _  | /  [_</font>
	<font color="#00AAAA">|  O  ||   _/    _]|  |  || |___ |     ||  |  ||    _]</font>
	<font color="#00AAAA">|     ||  | |   [_ |  |  ||     ||  _  ||  |  ||   [_</font>
	<font color="#00AAAA">\___/ |__| |_____||__|__||_____||__|__||__|__||_____|</font>


<font color="#00AAAA">[INFO]: Version: v0.15</font>
<font color="#00AAAA">[INFO]: Running non-interactively</font>
<font color="#00AAAA">[INFO]: Using design configuration at /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: PDKs root directory: /media/philipp/Daten/skywater/pdk-ls</font>
<font color="#00AAAA">[INFO]: PDK: sky130A</font>
<font color="#00AAAA">[INFO]: Setting PDKPATH to /media/philipp/Daten/skywater/pdk-ls/sky130A</font>
<font color="#00AAAA">[INFO]: Standard Cell Library: sky130_fd_sc_ls</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#AA5500">[WARNING]: Removing exisiting run /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Current run directory is /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Preparing LEF Files</font>
<font color="#00AAAA">[INFO]: Extracting the number of available metal layers from /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef</font>
<font color="#00AAAA">[INFO]: The number of available metal layers is 6</font>
<font color="#00AAAA">[INFO]: The available metal layers are li1 met1 met2 met3 met4 met5</font>
<font color="#00AAAA">[INFO]: Merging LEF Files...</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: MACROs matched found: 399</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">NAND3X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND3X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX8.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX8.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX4.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX4.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">HAX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">HAX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">MUX2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">MUX2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">BUFX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">BUFX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NAND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">XNOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">XNOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INV.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INV.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#00AAAA">[INFO]: Merging the following extra LEFs: /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX8.lef /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX4.lef /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/HAX1.lef /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX2.lef /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX1.lef /project/openlane/user_proj_example/../../cells/lef/INV.lef</font>
<font color="#00AAAA">[INFO]: Trimming Liberty...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Storing configs into config.tcl ...</font>
<font color="#00AAAA">[INFO]: Preparation complete</font>
<font color="#00AAAA">[INFO]: Running Synthesis...</font>
<font color="#00AAAA">[INFO]: current step index: 1</font>

<font color="#AAAAAA"> /----------------------------------------------------------------------------\</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  yosys -- Yosys Open SYnthesis Suite                                       |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Copyright (C) 2012 - 2020  Claire Wolf &lt;claire@symbioticeda.com&gt;          |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Permission to use, copy, modify, and/or distribute this software for any  |</font>
<font color="#AAAAAA"> |  purpose with or without fee is hereby granted, provided that the above    |</font>
<font color="#AAAAAA"> |  copyright notice and this permission notice appear in all copies.         |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES  |</font>
<font color="#AAAAAA"> |  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF          |</font>
<font color="#AAAAAA"> |  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   |</font>
<font color="#AAAAAA"> |  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    |</font>
<font color="#AAAAAA"> |  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN     |</font>
<font color="#AAAAAA"> |  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   |</font>
<font color="#AAAAAA"> |  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.            |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> \----------------------------------------------------------------------------/</font>

<font color="#AAAAAA"> Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>

<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `cd&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `eval&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `exec&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `read&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `trace&apos; -&gt; skip.</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/tmp/sky130_fd_sc_ls__tt_025C_1v80.no_pg.lib as a blackbox</font>

<font color="#AAAAAA">1. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 386 cell types from liberty file.</font>

<font color="#AAAAAA">2. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 19 cell types from liberty file.</font>

<font color="#AAAAAA">3. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v&apos; to AST representation.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:10.1-19.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:21.1-30.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:32.1-42.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:44.1-55.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\BUFX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:57.1-65.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX2&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX4&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\CLKBUF1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\HAX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:87.1-97.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\HAX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INV&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:99.1-107.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INV&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:109.1-117.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:119.1-127.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX4&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:129.1-137.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX4&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX8&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:139.1-147.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX8&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\MUX2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:149.1-159.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\MUX2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:161.1-170.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND3X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:172.1-182.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:184.1-193.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:207.1-217.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:219.1-230.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:232.1-241.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\XNOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:254.1-263.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XNOR2X1&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XOR2X1&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">4. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v&apos; to AST representation.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">5. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">6. Generating Graphviz representation of design.</font>
<font color="#AAAAAA">Writing dot description to `/project/openlane/user_proj_example/runs/user_proj_example/tmp/synthesis/hierarchy.dot&apos;.</font>
<font color="#AAAAAA">Dumping module user_proj_example to page 1.</font>

<font color="#AAAAAA">7. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">7.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">7.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">8. Executing TRIBUF pass.</font>

<font color="#AAAAAA">9. Executing SYNTH pass.</font>

<font color="#AAAAAA">9.1. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.1.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.1.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.2. Executing PROC pass (convert processes to netlists).</font>

<font color="#AAAAAA">9.2.1. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.2.2. Executing PROC_RMDEAD pass (remove dead branches from decision trees).</font>
<font color="#AAAAAA">Removed a total of 0 dead cases.</font>

<font color="#AAAAAA">9.2.3. Executing PROC_PRUNE pass (remove redundant assignments in processes).</font>
<font color="#AAAAAA">Removed 0 redundant assignments.</font>
<font color="#AAAAAA">Promoted 0 assignments to connections.</font>

<font color="#AAAAAA">9.2.4. Executing PROC_INIT pass (extract init attributes).</font>

<font color="#AAAAAA">9.2.5. Executing PROC_ARST pass (detect async resets in processes).</font>

<font color="#AAAAAA">9.2.6. Executing PROC_MUX pass (convert decision trees to multiplexers).</font>

<font color="#AAAAAA">9.2.7. Executing PROC_DLATCH pass (convert process syncs to latches).</font>

<font color="#AAAAAA">9.2.8. Executing PROC_DFF pass (convert process syncs to FFs).</font>

<font color="#AAAAAA">9.2.9. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.3. Executing FLATTEN pass (flatten design).</font>

<font color="#AAAAAA">9.4. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.6. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_ack_o is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [127] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [126] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [125] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [124] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [123] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [122] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [121] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [120] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [119] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [118] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [117] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [116] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [115] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [114] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [113] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [112] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [111] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [110] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [109] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [108] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [107] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [106] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [105] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [104] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [103] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [102] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [101] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [100] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [99] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [98] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [97] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [96] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [95] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [94] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [93] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [92] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [91] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [90] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [89] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [88] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [87] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [86] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [85] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [84] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [83] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [82] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [81] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [80] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [79] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [78] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [77] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [76] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [75] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [74] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [73] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [72] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [71] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [70] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [69] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [68] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [67] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [66] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [65] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [64] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [63] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [62] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [61] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [60] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [59] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [58] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [57] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [56] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [55] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [54] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [53] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [52] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [51] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [50] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [49] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [48] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [47] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [46] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [45] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [44] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [43] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [42] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [41] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [40] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [39] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [38] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [37] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [34] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [0] is used but has no driver.</font>
<font color="#AAAAAA">found and reported 179 problems.</font>

<font color="#AAAAAA">9.7. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.7.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.7.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.7.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.7.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.7.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.8. Executing FSM pass (extract and optimize FSM).</font>

<font color="#AAAAAA">9.8.1. Executing FSM_DETECT pass (finding FSMs in design).</font>

<font color="#AAAAAA">9.8.2. Executing FSM_EXTRACT pass (extracting FSM from design).</font>

<font color="#AAAAAA">9.8.3. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.8.5. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.6. Executing FSM_RECODE pass (re-assigning FSM state encoding).</font>

<font color="#AAAAAA">9.8.7. Executing FSM_INFO pass (dumping all available information on FSM cells).</font>

<font color="#AAAAAA">9.8.8. Executing FSM_MAP pass (mapping FSMs to basic logic).</font>

<font color="#AAAAAA">9.9. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.9.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.9.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.9.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.9.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.9.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.10. Executing WREDUCE pass (reducing word size of cells).</font>

<font color="#AAAAAA">9.11. Executing PEEPOPT pass (run peephole optimizers).</font>

<font color="#AAAAAA">9.12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.13. Executing ALUMACC pass (create $alu and $macc cells).</font>
<font color="#AAAAAA">Extracting $alu and $macc cells in module user_proj_example:</font>
<font color="#AAAAAA">  created 0 $alu and 0 $macc cells.</font>

<font color="#AAAAAA">9.14. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">9.15. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.15.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.15.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.15.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.15.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.15.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.16. Executing MEMORY pass.</font>

<font color="#AAAAAA">9.16.1. Executing OPT_MEM pass (optimize memories).</font>
<font color="#AAAAAA">Performed a total of 0 transformations.</font>

<font color="#AAAAAA">9.16.2. Executing MEMORY_DFF pass (merging $dff cells to $memrd and $memwr).</font>

<font color="#AAAAAA">9.16.3. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.4. Executing MEMORY_SHARE pass (consolidating $memrd/$memwr cells).</font>

<font color="#AAAAAA">9.16.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.6. Executing MEMORY_COLLECT pass (generating $mem cells).</font>

<font color="#AAAAAA">9.17. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.18.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>
<font color="#AAAAAA">&lt;suppressed ~87 debug messages&gt;</font>

<font color="#AAAAAA">9.18.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.18.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.18.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.19. Executing MEMORY_MAP pass (converting $mem cells to logic and flip-flops).</font>

<font color="#AAAAAA">9.20. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.20.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.20.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.20.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.6. Executing OPT_SHARE pass.</font>

<font color="#AAAAAA">9.20.7. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.20.8. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.20.9. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.10. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">9.21.1. Executing Verilog-2005 frontend: /build/bin/../share/yosys/techmap.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/build/bin/../share/yosys/techmap.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_bool_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_reduce_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_logic_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_compare_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_various&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_registers&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_ops_shr_shl_sshl_sshr&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_shiftx&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_fa&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lcu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_macc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alumacc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_u&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_trunc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_div&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_mod&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_floor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_divfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_modfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pow&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pmux&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lut&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">9.21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~67 debug messages&gt;</font>

<font color="#AAAAAA">9.22. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.22.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.22.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.22.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.22.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.22.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.23. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">9.23.1. Extracting gate netlist of module `\user_proj_example&apos; to `&lt;abc-temp-dir&gt;/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">9.24. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.24.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.24.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.24.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.24.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.24.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.25. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.25.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.25.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.26. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">9.27. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">10. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">11. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">11.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">11.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">11.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">11.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">11.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">13. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">mapping tbuf</font>

<font color="#AAAAAA">14. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">14.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_TBUF_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">14.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">15. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">16. Executing MUXCOVER pass (mapping to wider MUXes).</font>
<font color="#AAAAAA">Covering MUX trees in module user_proj_example..</font>
<font color="#AAAAAA">  Treeifying 0 MUXes:</font>
<font color="#AAAAAA">    Finished treeification: Found 0 trees.</font>
<font color="#AAAAAA">  Covering trees:</font>
<font color="#AAAAAA">  Added a total of 0 decoder MUXes.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">17. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">17.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX4_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">17.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">18. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">19. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">19.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">19.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">20. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">21.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_P_&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_N_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~4 debug messages&gt;</font>

<font color="#AAAAAA">22. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">23. Executing DFFLIBMAP pass (mapping DFF cells to sequential cells from liberty file).</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfxtp_2 (noninv, pins=3, area=28.77) is a direct match for cell type $_DFF_P_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfrtp_2 (noninv, pins=4, area=38.36) is a direct match for cell type $_DFF_PN0_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfstp_2 (noninv, pins=4, area=39.96) is a direct match for cell type $_DFF_PN1_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfbbn_2 (noninv, pins=6, area=47.95) is a direct match for cell type $_DFFSR_NNN_.</font>
<font color="#AAAAAA">  final dff cell mappings:</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_N_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfxtp_2 _DFF_P_ (.CLK( C), .D( D), .Q( Q));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN1_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfrtp_2 _DFF_PN0_ (.CLK( C), .D( D), .Q( Q), .RESET_B( R));</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfstp_2 _DFF_PN1_ (.CLK( C), .D( D), .Q( Q), .SET_B( R));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfbbn_2 _DFFSR_NNN_ (.CLK_N( C), .D( D), .Q( Q), .Q_N(~Q), .RESET_B( R), .SET_B( S));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPP_</font>

<font color="#AAAAAA">23.1. Executing DFFLEGALIZE pass (convert FFs to types supported by the target).</font>
<font color="#AAAAAA">Mapping DFF cells in module `\user_proj_example&apos;:</font>

<font color="#AAAAAA">24. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">[INFO]: ABC: WireLoad : S_4</font>

<font color="#AAAAAA">25. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">25.1. Extracting gate netlist of module `\user_proj_example&apos; to `/tmp/yosys-abc-semHpd/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">26. Executing SETUNDEF pass (replace undef values with defined constants).</font>

<font color="#AAAAAA">27. Executing HILOMAP pass (mapping to constant drivers).</font>

<font color="#AAAAAA">28. Executing SPLITNETS pass (splitting up multi-bit signals).</font>

<font color="#AAAAAA">29. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>
<font color="#AAAAAA">Removed 0 unused cells and 217 unused wires.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">30. Executing INSBUF pass (insert buffer cells for connected wires).</font>

<font color="#AAAAAA">31. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">32. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                236</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>
<font color="#AAAAAA">     sky130_fd_sc_ls__conb_1       217</font>

<font color="#AAAAAA">   Area for cell type \AND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AND2X2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \BUFX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \HAX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INV is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX4 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX8 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \MUX2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND3X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NOR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \XNOR2X1 is unknown!</font>

<font color="#AAAAAA">   Chip area for module &apos;\user_proj_example&apos;: 1040.558400</font>

<font color="#AAAAAA">33. Executing Verilog backend.</font>
<font color="#AAAAAA">Dumping module `\user_proj_example&apos;.</font>

<font color="#AAAAAA">Warnings: 179 unique messages, 179 total</font>
<font color="#AAAAAA">End of script. Logfile hash: 76decf997b, CPU: user 22.05s system 0.83s, MEM: 386.61 MB peak</font>
<font color="#AAAAAA">Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>
<font color="#AAAAAA">Time spent: 38% 4x read_liberty (8 sec), 36% 4x stat (8 sec), 21% 1x dfflibmap (4 sec), ...</font>
<font color="#00AAAA">[INFO]: Changing netlist from 0 to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v</font>
<font color="#00AAAA">[INFO]: Running Static Timing Analysis...</font>
<font color="#00AAAA">[INFO]: current step index: 2</font>
<font color="#AAAAAA">OpenSTA 2.3.0 38b40303a8 Copyright (c) 2019, Parallax Software, Inc.</font>
<font color="#AAAAAA">License GPLv3: GNU GPL version 3 &lt;http://gnu.org/licenses/gpl.html&gt;</font>

<font color="#AAAAAA">This is free software, and you are free to change and redistribute it</font>
<font color="#AAAAAA">under certain conditions; type `show_copying&apos; for details. </font>
<font color="#AAAAAA">This program comes with ABSOLUTELY NO WARRANTY; for details type `show_warranty&apos;.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 671, module AND2X1 not found.  Creating black box for AND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 676, module AND2X2 not found.  Creating black box for AND2X2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 681, module AOI21X1 not found.  Creating black box for AOI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 687, module AOI22X1 not found.  Creating black box for AOI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 694, module BUFX2 not found.  Creating black box for BUFX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 698, module HAX1 not found.  Creating black box for HAX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 704, module INV not found.  Creating black box for INV.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 708, module INVX1 not found.  Creating black box for INVX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 712, module INVX2 not found.  Creating black box for INVX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 716, module INVX4 not found.  Creating black box for INVX4.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 720, module INVX8 not found.  Creating black box for INVX8.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 724, module MUX2X1 not found.  Creating black box for MUX2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 730, module NAND2X1 not found.  Creating black box for NAND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 735, module NAND3X1 not found.  Creating black box for NAND3X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 741, module NOR2X1 not found.  Creating black box for NOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 746, module OAI21X1 not found.  Creating black box for OAI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 752, module OAI22X1 not found.  Creating black box for OAI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 759, module OR2X1 not found.  Creating black box for OR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 764, module XNOR2X1 not found.  Creating black box for XNOR2X1.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#00AAAA">[INFO]: Synthesis was successful</font>
<font color="#00AAAA">[INFO]: Running Floorplanning...</font>
<font color="#00AAAA">[INFO]: Running Initial Floorplanning...</font>
<font color="#00AAAA">[INFO]: current step index: 3</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master BUFX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master HAX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INV has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX4 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX8 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master MUX2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND3X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master XNOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[INFO IFP-0001] Added 82 rows of 601 sites.</font>
<font color="#00AAAA">[INFO]: Core area width: 288.48</font>
<font color="#00AAAA">[INFO]: Core area height: 273.36</font>
<font color="#00AAAA">[INFO]: Changing layout from 0 to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#00AAAA">[INFO]: current step index: 4</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Top-level design name: user_proj_example</font>
<font color="#AAAAAA">Block boundaries: 0 0 300000 300000</font>
<font color="#AAAAAA">Writing /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]:  Manual Macro Placement...</font>
<font color="#00AAAA">[INFO]: current step index: 5</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Placing the following macros:</font>
<font color="#AAAAAA">{&apos;AND2X1&apos;: [&apos;38400&apos;, &apos;23310&apos;, &apos;N&apos;], &apos;AND2X2&apos;: [&apos;38400&apos;, &apos;29970&apos;, &apos;N&apos;], &apos;AOI21X1&apos;: [&apos;38400&apos;, &apos;36630&apos;, &apos;N&apos;], &apos;AOI22X1&apos;: [&apos;38400&apos;, &apos;43290&apos;, &apos;N&apos;], &apos;BUFX2&apos;: [&apos;38400&apos;, &apos;49950&apos;, &apos;N&apos;], &apos;BUFX4&apos;: [&apos;38400&apos;, &apos;56610&apos;, &apos;N&apos;], &apos;CLKBUF1&apos;: [&apos;38400&apos;, &apos;63270&apos;, &apos;N&apos;], &apos;HAX1&apos;: [&apos;38400&apos;, &apos;69930&apos;, &apos;N&apos;], &apos;INV&apos;: [&apos;38400&apos;, &apos;76590&apos;, &apos;N&apos;], &apos;INVX1&apos;: [&apos;38400&apos;, &apos;83250&apos;, &apos;N&apos;], &apos;INVX2&apos;: [&apos;38400&apos;, &apos;89910&apos;, &apos;N&apos;], &apos;INVX4&apos;: [&apos;38400&apos;, &apos;96570&apos;, &apos;N&apos;], &apos;INVX8&apos;: [&apos;38400&apos;, &apos;103230&apos;, &apos;N&apos;], &apos;MUX2X1&apos;: [&apos;38400&apos;, &apos;109890&apos;, &apos;N&apos;], &apos;NAND2X1&apos;: [&apos;38400&apos;, &apos;116550&apos;, &apos;N&apos;], &apos;NAND3X1&apos;: [&apos;38400&apos;, &apos;123210&apos;, &apos;N&apos;], &apos;NOR2X1&apos;: [&apos;38400&apos;, &apos;129870&apos;, &apos;N&apos;], &apos;NOR3X1&apos;: [&apos;38400&apos;, &apos;136530&apos;, &apos;N&apos;], &apos;OAI21X1&apos;: [&apos;38400&apos;, &apos;143190&apos;, &apos;N&apos;], &apos;OAI22X1&apos;: [&apos;38400&apos;, &apos;149850&apos;, &apos;N&apos;], &apos;OR2X1&apos;: [&apos;38400&apos;, &apos;156510&apos;, &apos;N&apos;], &apos;OR2X2&apos;: [&apos;38400&apos;, &apos;163170&apos;, &apos;N&apos;], &apos;XNOR2X1&apos;: [&apos;38400&apos;, &apos;169830&apos;, &apos;N&apos;], &apos;XOR2X1&apos;: [&apos;38400&apos;, &apos;176490&apos;, &apos;N&apos;]}</font>
<font color="#AAAAAA">Design name: user_proj_example</font>
<font color="#AAAAAA">Placing AND2X1</font>
<font color="#AAAAAA">Placing AND2X2</font>
<font color="#AAAAAA">Placing AOI21X1</font>
<font color="#AAAAAA">Placing AOI22X1</font>
<font color="#AAAAAA">Placing BUFX2</font>
<font color="#AAAAAA">Placing HAX1</font>
<font color="#AAAAAA">Placing INV</font>
<font color="#AAAAAA">Placing INVX1</font>
<font color="#AAAAAA">Placing INVX2</font>
<font color="#AAAAAA">Placing INVX4</font>
<font color="#AAAAAA">Placing INVX8</font>
<font color="#AAAAAA">Placing MUX2X1</font>
<font color="#AAAAAA">Placing NAND2X1</font>
<font color="#AAAAAA">Placing NAND3X1</font>
<font color="#AAAAAA">Placing NOR2X1</font>
<font color="#AAAAAA">Placing OAI21X1</font>
<font color="#AAAAAA">Placing OAI22X1</font>
<font color="#AAAAAA">Placing OR2X1</font>
<font color="#AAAAAA">Placing XNOR2X1</font>
<font color="#AAAAAA">Traceback (most recent call last):</font>
<font color="#AAAAAA">  File &quot;/openLANE_flow/scripts/manual_macro_place.py&quot;, line 119, in &lt;module&gt;</font>
<font color="#AAAAAA">    assert not macros, (&quot;Macros not found:&quot;, macros)</font>
<font color="#AAAAAA">AssertionError: (&apos;Macros not found:&apos;, {&apos;BUFX4&apos;: [&apos;38400&apos;, &apos;56610&apos;, &apos;N&apos;], &apos;CLKBUF1&apos;: [&apos;38400&apos;, &apos;63270&apos;, &apos;N&apos;], &apos;NOR3X1&apos;: [&apos;38400&apos;, &apos;136530&apos;, &apos;N&apos;], &apos;OR2X2&apos;: [&apos;38400&apos;, &apos;163170&apos;, &apos;N&apos;], &apos;XOR2X1&apos;: [&apos;38400&apos;, &apos;176490&apos;, &apos;N&apos;]})</font>
<font color="#AA0000">[ERROR]: during executing: &quot;python3 /openLANE_flow/scripts/manual_macro_place.py -l /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef -id /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def -o /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def -c /project/openlane/user_proj_example/runs/user_proj_example/tmp/macro_placement.cfg -f |&amp; tee &gt;&amp;@stdout /project/openlane/user_proj_example/runs/user_proj_example/logs/5-macro_placement.log&quot;</font>
<font color="#AA0000">[ERROR]: Exit code: 1</font>
<font color="#AA0000">[ERROR]: Last 10 lines:</font>
<font color="#AA0000">child process exited abnormally</font>

<font color="#AA0000">[ERROR]: Please check python3  log file</font>
<font color="#AA0000">[ERROR]: Dumping to /project/openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow failed for user_proj_example/13-06_18-37 in 0h1m0s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.gds.log</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">No antenna report found.</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#AA0000">[ERROR]: Flow Failed.</font>

<font color="#AAAAAA">    while executing</font>
<font color="#AAAAAA">&quot;try_catch python3 $::env(SCRIPTS_DIR)/manual_macro_place.py -l $::env(MERGED_LEF) -id $::env(CURRENT_DEF) -o ${fbasename}.macro_placement.def -c $::en...&quot;</font>
<font color="#AAAAAA">    (procedure &quot;manual_macro_placement&quot; line 6)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;manual_macro_placement f&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_floorplan&quot; line 29)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_floorplan&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_non_interactive_mode&quot; line 15)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_non_interactive_mode {*}$argv&quot;</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;if { [info exists flags_map(-interactive)] || [info exists flags_map(-it)] } {</font>
	<font color="#AAAAAA">puts_info &quot;Running interactively&quot;</font>
	<font color="#AAAAAA">if { [info exists arg_values(-file)...&quot;</font>
<font color="#AAAAAA">    (file &quot;/openLANE_flow/flow.tcl&quot; line 223)</font>
<font color="#AAAAAA">make[1]: *** [Makefile:43: user_proj_example] Fehler 1</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird verlassen</font>
<font color="#AAAAAA">make: *** [Makefile:71: user_proj_example] Fehler 2</font>
<font color="#AAAAAA">Deployment done.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ bash deploy2caravel.sh </font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lib“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef/orig“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/gds“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/mag“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">Cleaning up old files</font>
<font color="#AAAAAA">Copying files that were created by StdCellLib</font>
<font color="#AAAAAA">Removing cells with DRC issues left</font>
<font color="#AAAAAA">Checking AND2X1</font>
<font color="#AAAAAA">Checking AND2X2</font>
<font color="#AAAAAA">Checking AOI21X1</font>
<font color="#AAAAAA">Checking AOI22X1</font>
<font color="#AAAAAA">Checking BUFX2</font>
<font color="#AAAAAA">Checking BUFX4</font>
<font color="#AAAAAA">Removing cell with 2 DRC issues:</font>
<font color="#AAAAAA">Checking CLKBUF1</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking corr_XOR2X1</font>
<font color="#AAAAAA">Error: Could not find DRC: /home/philipp/libresilicon/StdCellLib/corr_XOR2X1.drc No such file or directory</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking HAX1</font>
<font color="#AAAAAA">Checking INV</font>
<font color="#AAAAAA">Checking INVX1</font>
<font color="#AAAAAA">Checking INVX2</font>
<font color="#AAAAAA">Checking INVX4</font>
<font color="#AAAAAA">Checking INVX8</font>
<font color="#AAAAAA">Checking LATCH</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking MUX2X1</font>
<font color="#AAAAAA">Checking NAND2X1</font>
<font color="#AAAAAA">Checking NAND3X1</font>
<font color="#AAAAAA">Checking NOR2X1</font>
<font color="#AAAAAA">Checking NOR3X1</font>
<font color="#AAAAAA">Removing cell with 60 DRC issues:</font>
<font color="#AAAAAA">Checking OAI21X1</font>
<font color="#AAAAAA">Checking OAI22X1</font>
<font color="#AAAAAA">Checking OR2X1</font>
<font color="#AAAAAA">Checking OR2X2</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking XNOR2X1</font>
<font color="#AAAAAA">Checking XOR2X1</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Now cleaning up the files for Sky130</font>
<font color="#AAAAAA">AND2X1.lef</font>
<font color="#AAAAAA">AND2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X1.lef for cell AND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AND2X2.lef</font>
<font color="#AAAAAA">AND2X2.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X2.lef for cell AND2X2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI21X1.lef</font>
<font color="#AAAAAA">AOI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI21X1.lef for cell AOI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI22X1.lef</font>
<font color="#AAAAAA">AOI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI22X1.lef for cell AOI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">BUFX2.lef</font>
<font color="#AAAAAA">BUFX2.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output BUFX2.lef for cell BUFX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">HAX1.lef</font>
<font color="#AAAAAA">HAX1.lef -&gt; 15.84 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output HAX1.lef for cell HAX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INV.lef</font>
<font color="#AAAAAA">INV.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INV.lef for cell INV:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX1.lef</font>
<font color="#AAAAAA">INVX1.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX1.lef for cell INVX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX2.lef</font>
<font color="#AAAAAA">INVX2.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX2.lef for cell INVX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX4.lef</font>
<font color="#AAAAAA">INVX4.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 69 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX4.lef for cell INVX4:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX8.lef</font>
<font color="#AAAAAA">INVX8.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 83 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX8.lef for cell INVX8:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">MUX2X1.lef</font>
<font color="#AAAAAA">MUX2X1.lef -&gt; 8.64 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output MUX2X1.lef for cell MUX2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND2X1.lef</font>
<font color="#AAAAAA">NAND2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND2X1.lef for cell NAND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND3X1.lef</font>
<font color="#AAAAAA">NAND3X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND3X1.lef for cell NAND3X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NOR2X1.lef</font>
<font color="#AAAAAA">NOR2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NOR2X1.lef for cell NOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI21X1.lef</font>
<font color="#AAAAAA">OAI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI21X1.lef for cell OAI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI22X1.lef</font>
<font color="#AAAAAA">OAI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI22X1.lef for cell OAI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OR2X1.lef</font>
<font color="#AAAAAA">OR2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Generating LEF output OR2X1.lef for cell OR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">XNOR2X1.lef</font>
<font color="#AAAAAA">XNOR2X1.lef -&gt; 10.08 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 80 lines.</font>
<font color="#AAAAAA">Generating LEF output XNOR2X1.lef for cell XNOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">    INFO: Reading base liberty: /home/philipp/libresilicon/StdCellLib/Catalog/libresilicon.libtemplate</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: BUFX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: HAX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INV.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX4.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX8.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: MUX2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND3X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: XNOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(BUFX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(HAX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INV)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX4)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX8)</font>
<font color="#AAAAAA">    INFO: Add group: cell(MUX2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND3X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NOR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(XNOR2X1)</font>
<font color="#AAAAAA">    INFO: Number of cells in base: 19, number of cells in output: 19</font>
<font color="#AAAAAA">    INFO: Write liberty: libresilicon.lib</font>
<font color="#AAAAAA">Now generating the demo wafer, the macro placement and the test-bench</font>
<font color="#AAAAAA">Now building the Caravel user-project</font>
<font color="#AAAAAA">cd openlane &amp;&amp; make user_proj_example</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird betreten</font>
<font color="#AAAAAA">###############################################</font>
<font color="#00AAAA">[INFO]: </font>
	<font color="#00AAAA">___   ____   ___  ____   _       ____  ____     ___</font>
	<font color="#00AAAA">/   \ |    \ /  _]|    \ | |     /    ||    \   /  _]</font>
	<font color="#00AAAA">|     ||  o  )  [_ |  _  || |    |  o  ||  _  | /  [_</font>
	<font color="#00AAAA">|  O  ||   _/    _]|  |  || |___ |     ||  |  ||    _]</font>
	<font color="#00AAAA">|     ||  | |   [_ |  |  ||     ||  _  ||  |  ||   [_</font>
	<font color="#00AAAA">\___/ |__| |_____||__|__||_____||__|__||__|__||_____|</font>


<font color="#00AAAA">[INFO]: Version: v0.15</font>
<font color="#00AAAA">[INFO]: Running non-interactively</font>
<font color="#00AAAA">[INFO]: Using design configuration at /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: PDKs root directory: /media/philipp/Daten/skywater/pdk-ls</font>
<font color="#00AAAA">[INFO]: PDK: sky130A</font>
<font color="#00AAAA">[INFO]: Setting PDKPATH to /media/philipp/Daten/skywater/pdk-ls/sky130A</font>
<font color="#00AAAA">[INFO]: Standard Cell Library: sky130_fd_sc_ls</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#AA5500">[WARNING]: Removing exisiting run /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Current run directory is /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Preparing LEF Files</font>
<font color="#00AAAA">[INFO]: Extracting the number of available metal layers from /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef</font>
<font color="#00AAAA">[INFO]: The number of available metal layers is 6</font>
<font color="#00AAAA">[INFO]: The available metal layers are li1 met1 met2 met3 met4 met5</font>
<font color="#00AAAA">[INFO]: Merging LEF Files...</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: MACROs matched found: 399</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">NAND3X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND3X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX8.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX8.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX4.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX4.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">HAX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">HAX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">MUX2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">MUX2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">BUFX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">BUFX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NAND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">XNOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">XNOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INV.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INV.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#00AAAA">[INFO]: Merging the following extra LEFs: /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX8.lef /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX4.lef /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/HAX1.lef /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX2.lef /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX1.lef /project/openlane/user_proj_example/../../cells/lef/INV.lef</font>
<font color="#00AAAA">[INFO]: Trimming Liberty...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Storing configs into config.tcl ...</font>
<font color="#00AAAA">[INFO]: Preparation complete</font>
<font color="#00AAAA">[INFO]: Running Synthesis...</font>
<font color="#00AAAA">[INFO]: current step index: 1</font>

<font color="#AAAAAA"> /----------------------------------------------------------------------------\</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  yosys -- Yosys Open SYnthesis Suite                                       |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Copyright (C) 2012 - 2020  Claire Wolf &lt;claire@symbioticeda.com&gt;          |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Permission to use, copy, modify, and/or distribute this software for any  |</font>
<font color="#AAAAAA"> |  purpose with or without fee is hereby granted, provided that the above    |</font>
<font color="#AAAAAA"> |  copyright notice and this permission notice appear in all copies.         |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES  |</font>
<font color="#AAAAAA"> |  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF          |</font>
<font color="#AAAAAA"> |  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   |</font>
<font color="#AAAAAA"> |  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    |</font>
<font color="#AAAAAA"> |  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN     |</font>
<font color="#AAAAAA"> |  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   |</font>
<font color="#AAAAAA"> |  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.            |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> \----------------------------------------------------------------------------/</font>

<font color="#AAAAAA"> Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>

<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `cd&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `eval&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `exec&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `read&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `trace&apos; -&gt; skip.</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/tmp/sky130_fd_sc_ls__tt_025C_1v80.no_pg.lib as a blackbox</font>

<font color="#AAAAAA">1. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 386 cell types from liberty file.</font>

<font color="#AAAAAA">2. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 19 cell types from liberty file.</font>

<font color="#AAAAAA">3. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v&apos; to AST representation.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:10.1-19.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:21.1-30.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:32.1-42.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:44.1-55.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\BUFX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:57.1-65.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\HAX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:67.1-77.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\HAX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INV&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:79.1-87.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INV&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:89.1-97.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:99.1-107.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX4&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:109.1-117.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX4&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX8&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:119.1-127.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX8&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\MUX2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:129.1-139.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\MUX2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:141.1-150.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND3X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:152.1-162.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:164.1-173.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:175.1-185.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:187.1-198.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:200.1-209.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\XNOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:211.1-220.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XNOR2X1&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">4. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v&apos; to AST representation.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">5. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">6. Generating Graphviz representation of design.</font>
<font color="#AAAAAA">Writing dot description to `/project/openlane/user_proj_example/runs/user_proj_example/tmp/synthesis/hierarchy.dot&apos;.</font>
<font color="#AAAAAA">Dumping module user_proj_example to page 1.</font>

<font color="#AAAAAA">7. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">7.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">7.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">8. Executing TRIBUF pass.</font>

<font color="#AAAAAA">9. Executing SYNTH pass.</font>

<font color="#AAAAAA">9.1. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.1.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.1.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.2. Executing PROC pass (convert processes to netlists).</font>

<font color="#AAAAAA">9.2.1. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.2.2. Executing PROC_RMDEAD pass (remove dead branches from decision trees).</font>
<font color="#AAAAAA">Removed a total of 0 dead cases.</font>

<font color="#AAAAAA">9.2.3. Executing PROC_PRUNE pass (remove redundant assignments in processes).</font>
<font color="#AAAAAA">Removed 0 redundant assignments.</font>
<font color="#AAAAAA">Promoted 0 assignments to connections.</font>

<font color="#AAAAAA">9.2.4. Executing PROC_INIT pass (extract init attributes).</font>

<font color="#AAAAAA">9.2.5. Executing PROC_ARST pass (detect async resets in processes).</font>

<font color="#AAAAAA">9.2.6. Executing PROC_MUX pass (convert decision trees to multiplexers).</font>

<font color="#AAAAAA">9.2.7. Executing PROC_DLATCH pass (convert process syncs to latches).</font>

<font color="#AAAAAA">9.2.8. Executing PROC_DFF pass (convert process syncs to FFs).</font>

<font color="#AAAAAA">9.2.9. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.3. Executing FLATTEN pass (flatten design).</font>

<font color="#AAAAAA">9.4. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.6. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_ack_o is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [127] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [126] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [125] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [124] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [123] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [122] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [121] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [120] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [119] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [118] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [117] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [116] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [115] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [114] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [113] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [112] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [111] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [110] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [109] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [108] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [107] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [106] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [105] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [104] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [103] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [102] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [101] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [100] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [99] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [98] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [97] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [96] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [95] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [94] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [93] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [92] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [91] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [90] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [89] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [88] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [87] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [86] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [85] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [84] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [83] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [82] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [81] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [80] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [79] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [78] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [77] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [76] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [75] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [74] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [73] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [72] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [71] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [70] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [69] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [68] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [67] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [66] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [65] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [64] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [63] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [62] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [61] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [60] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [59] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [58] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [57] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [56] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [55] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [54] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [53] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [52] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [51] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [50] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [49] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [48] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [47] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [46] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [45] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [44] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [43] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [42] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [41] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [40] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [39] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [38] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [37] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [34] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [0] is used but has no driver.</font>
<font color="#AAAAAA">found and reported 179 problems.</font>

<font color="#AAAAAA">9.7. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.7.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.7.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.7.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.7.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.7.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.8. Executing FSM pass (extract and optimize FSM).</font>

<font color="#AAAAAA">9.8.1. Executing FSM_DETECT pass (finding FSMs in design).</font>

<font color="#AAAAAA">9.8.2. Executing FSM_EXTRACT pass (extracting FSM from design).</font>

<font color="#AAAAAA">9.8.3. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.8.5. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.6. Executing FSM_RECODE pass (re-assigning FSM state encoding).</font>

<font color="#AAAAAA">9.8.7. Executing FSM_INFO pass (dumping all available information on FSM cells).</font>

<font color="#AAAAAA">9.8.8. Executing FSM_MAP pass (mapping FSMs to basic logic).</font>

<font color="#AAAAAA">9.9. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.9.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.9.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.9.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.9.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.9.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.10. Executing WREDUCE pass (reducing word size of cells).</font>

<font color="#AAAAAA">9.11. Executing PEEPOPT pass (run peephole optimizers).</font>

<font color="#AAAAAA">9.12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.13. Executing ALUMACC pass (create $alu and $macc cells).</font>
<font color="#AAAAAA">Extracting $alu and $macc cells in module user_proj_example:</font>
<font color="#AAAAAA">  created 0 $alu and 0 $macc cells.</font>

<font color="#AAAAAA">9.14. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">9.15. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.15.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.15.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.15.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.15.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.15.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.16. Executing MEMORY pass.</font>

<font color="#AAAAAA">9.16.1. Executing OPT_MEM pass (optimize memories).</font>
<font color="#AAAAAA">Performed a total of 0 transformations.</font>

<font color="#AAAAAA">9.16.2. Executing MEMORY_DFF pass (merging $dff cells to $memrd and $memwr).</font>

<font color="#AAAAAA">9.16.3. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.4. Executing MEMORY_SHARE pass (consolidating $memrd/$memwr cells).</font>

<font color="#AAAAAA">9.16.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.6. Executing MEMORY_COLLECT pass (generating $mem cells).</font>

<font color="#AAAAAA">9.17. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.18.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>
<font color="#AAAAAA">&lt;suppressed ~87 debug messages&gt;</font>

<font color="#AAAAAA">9.18.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.18.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.18.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.19. Executing MEMORY_MAP pass (converting $mem cells to logic and flip-flops).</font>

<font color="#AAAAAA">9.20. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.20.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.20.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.20.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.6. Executing OPT_SHARE pass.</font>

<font color="#AAAAAA">9.20.7. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.20.8. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.20.9. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.10. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">9.21.1. Executing Verilog-2005 frontend: /build/bin/../share/yosys/techmap.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/build/bin/../share/yosys/techmap.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_bool_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_reduce_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_logic_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_compare_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_various&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_registers&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_ops_shr_shl_sshl_sshr&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_shiftx&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_fa&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lcu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_macc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alumacc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_u&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_trunc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_div&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_mod&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_floor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_divfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_modfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pow&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pmux&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lut&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">9.21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~67 debug messages&gt;</font>

<font color="#AAAAAA">9.22. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.22.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.22.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.22.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.22.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.22.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.23. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">9.23.1. Extracting gate netlist of module `\user_proj_example&apos; to `&lt;abc-temp-dir&gt;/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">9.24. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.24.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.24.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.24.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.24.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.24.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.25. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.25.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.25.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.26. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">9.27. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">10. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">11. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">11.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">11.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">11.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">11.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">11.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">13. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">mapping tbuf</font>

<font color="#AAAAAA">14. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">14.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_TBUF_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">14.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">15. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">16. Executing MUXCOVER pass (mapping to wider MUXes).</font>
<font color="#AAAAAA">Covering MUX trees in module user_proj_example..</font>
<font color="#AAAAAA">  Treeifying 0 MUXes:</font>
<font color="#AAAAAA">    Finished treeification: Found 0 trees.</font>
<font color="#AAAAAA">  Covering trees:</font>
<font color="#AAAAAA">  Added a total of 0 decoder MUXes.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">17. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">17.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX4_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">17.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">18. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">19. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">19.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">19.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">20. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">21.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_P_&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_N_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~4 debug messages&gt;</font>

<font color="#AAAAAA">22. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">23. Executing DFFLIBMAP pass (mapping DFF cells to sequential cells from liberty file).</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfxtp_2 (noninv, pins=3, area=28.77) is a direct match for cell type $_DFF_P_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfrtp_2 (noninv, pins=4, area=38.36) is a direct match for cell type $_DFF_PN0_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfstp_2 (noninv, pins=4, area=39.96) is a direct match for cell type $_DFF_PN1_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfbbn_2 (noninv, pins=6, area=47.95) is a direct match for cell type $_DFFSR_NNN_.</font>
<font color="#AAAAAA">  final dff cell mappings:</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_N_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfxtp_2 _DFF_P_ (.CLK( C), .D( D), .Q( Q));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN1_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfrtp_2 _DFF_PN0_ (.CLK( C), .D( D), .Q( Q), .RESET_B( R));</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfstp_2 _DFF_PN1_ (.CLK( C), .D( D), .Q( Q), .SET_B( R));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfbbn_2 _DFFSR_NNN_ (.CLK_N( C), .D( D), .Q( Q), .Q_N(~Q), .RESET_B( R), .SET_B( S));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPP_</font>

<font color="#AAAAAA">23.1. Executing DFFLEGALIZE pass (convert FFs to types supported by the target).</font>
<font color="#AAAAAA">Mapping DFF cells in module `\user_proj_example&apos;:</font>

<font color="#AAAAAA">24. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">[INFO]: ABC: WireLoad : S_4</font>

<font color="#AAAAAA">25. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">25.1. Extracting gate netlist of module `\user_proj_example&apos; to `/tmp/yosys-abc-lDi3pC/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">26. Executing SETUNDEF pass (replace undef values with defined constants).</font>

<font color="#AAAAAA">27. Executing HILOMAP pass (mapping to constant drivers).</font>

<font color="#AAAAAA">28. Executing SPLITNETS pass (splitting up multi-bit signals).</font>

<font color="#AAAAAA">29. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>
<font color="#AAAAAA">Removed 0 unused cells and 217 unused wires.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">30. Executing INSBUF pass (insert buffer cells for connected wires).</font>

<font color="#AAAAAA">31. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">32. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                236</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>
<font color="#AAAAAA">     sky130_fd_sc_ls__conb_1       217</font>

<font color="#AAAAAA">   Area for cell type \AND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AND2X2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \BUFX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \HAX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INV is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX4 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX8 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \MUX2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND3X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NOR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \XNOR2X1 is unknown!</font>

<font color="#AAAAAA">   Chip area for module &apos;\user_proj_example&apos;: 1040.558400</font>

<font color="#AAAAAA">33. Executing Verilog backend.</font>
<font color="#AAAAAA">Dumping module `\user_proj_example&apos;.</font>

<font color="#AAAAAA">Warnings: 179 unique messages, 179 total</font>
<font color="#AAAAAA">End of script. Logfile hash: ed1a35b6ad, CPU: user 21.56s system 0.86s, MEM: 386.82 MB peak</font>
<font color="#AAAAAA">Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>
<font color="#AAAAAA">Time spent: 37% 4x read_liberty (8 sec), 37% 4x stat (8 sec), 21% 1x dfflibmap (4 sec), ...</font>
<font color="#00AAAA">[INFO]: Changing netlist from 0 to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v</font>
<font color="#00AAAA">[INFO]: Running Static Timing Analysis...</font>
<font color="#00AAAA">[INFO]: current step index: 2</font>
<font color="#AAAAAA">OpenSTA 2.3.0 38b40303a8 Copyright (c) 2019, Parallax Software, Inc.</font>
<font color="#AAAAAA">License GPLv3: GNU GPL version 3 &lt;http://gnu.org/licenses/gpl.html&gt;</font>

<font color="#AAAAAA">This is free software, and you are free to change and redistribute it</font>
<font color="#AAAAAA">under certain conditions; type `show_copying&apos; for details. </font>
<font color="#AAAAAA">This program comes with ABSOLUTELY NO WARRANTY; for details type `show_warranty&apos;.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 671, module AND2X1 not found.  Creating black box for AND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 676, module AND2X2 not found.  Creating black box for AND2X2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 681, module AOI21X1 not found.  Creating black box for AOI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 687, module AOI22X1 not found.  Creating black box for AOI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 694, module BUFX2 not found.  Creating black box for BUFX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 698, module HAX1 not found.  Creating black box for HAX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 704, module INV not found.  Creating black box for INV.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 708, module INVX1 not found.  Creating black box for INVX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 712, module INVX2 not found.  Creating black box for INVX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 716, module INVX4 not found.  Creating black box for INVX4.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 720, module INVX8 not found.  Creating black box for INVX8.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 724, module MUX2X1 not found.  Creating black box for MUX2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 730, module NAND2X1 not found.  Creating black box for NAND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 735, module NAND3X1 not found.  Creating black box for NAND3X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 741, module NOR2X1 not found.  Creating black box for NOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 746, module OAI21X1 not found.  Creating black box for OAI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 752, module OAI22X1 not found.  Creating black box for OAI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 759, module OR2X1 not found.  Creating black box for OR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 764, module XNOR2X1 not found.  Creating black box for XNOR2X1.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#00AAAA">[INFO]: Synthesis was successful</font>
<font color="#00AAAA">[INFO]: Running Floorplanning...</font>
<font color="#00AAAA">[INFO]: Running Initial Floorplanning...</font>
<font color="#00AAAA">[INFO]: current step index: 3</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master BUFX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master HAX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INV has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX4 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX8 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master MUX2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND3X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master XNOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[INFO IFP-0001] Added 82 rows of 601 sites.</font>
<font color="#00AAAA">[INFO]: Core area width: 288.48</font>
<font color="#00AAAA">[INFO]: Core area height: 273.36</font>
<font color="#00AAAA">[INFO]: Changing layout from 0 to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#00AAAA">[INFO]: current step index: 4</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Top-level design name: user_proj_example</font>
<font color="#AAAAAA">Block boundaries: 0 0 300000 300000</font>
<font color="#AAAAAA">Writing /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]:  Manual Macro Placement...</font>
<font color="#00AAAA">[INFO]: current step index: 5</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Placing the following macros:</font>
<font color="#AAAAAA">{&apos;AND2X1&apos;: [&apos;38400&apos;, &apos;23310&apos;, &apos;N&apos;], &apos;AND2X2&apos;: [&apos;38400&apos;, &apos;29970&apos;, &apos;N&apos;], &apos;AOI21X1&apos;: [&apos;38400&apos;, &apos;36630&apos;, &apos;N&apos;], &apos;AOI22X1&apos;: [&apos;38400&apos;, &apos;43290&apos;, &apos;N&apos;], &apos;BUFX2&apos;: [&apos;38400&apos;, &apos;49950&apos;, &apos;N&apos;], &apos;BUFX4&apos;: [&apos;38400&apos;, &apos;56610&apos;, &apos;N&apos;], &apos;CLKBUF1&apos;: [&apos;38400&apos;, &apos;63270&apos;, &apos;N&apos;], &apos;HAX1&apos;: [&apos;38400&apos;, &apos;69930&apos;, &apos;N&apos;], &apos;INV&apos;: [&apos;38400&apos;, &apos;76590&apos;, &apos;N&apos;], &apos;INVX1&apos;: [&apos;38400&apos;, &apos;83250&apos;, &apos;N&apos;], &apos;INVX2&apos;: [&apos;38400&apos;, &apos;89910&apos;, &apos;N&apos;], &apos;INVX4&apos;: [&apos;38400&apos;, &apos;96570&apos;, &apos;N&apos;], &apos;INVX8&apos;: [&apos;38400&apos;, &apos;103230&apos;, &apos;N&apos;], &apos;MUX2X1&apos;: [&apos;38400&apos;, &apos;109890&apos;, &apos;N&apos;], &apos;NAND2X1&apos;: [&apos;38400&apos;, &apos;116550&apos;, &apos;N&apos;], &apos;NAND3X1&apos;: [&apos;38400&apos;, &apos;123210&apos;, &apos;N&apos;], &apos;NOR2X1&apos;: [&apos;38400&apos;, &apos;129870&apos;, &apos;N&apos;], &apos;NOR3X1&apos;: [&apos;38400&apos;, &apos;136530&apos;, &apos;N&apos;], &apos;OAI21X1&apos;: [&apos;38400&apos;, &apos;143190&apos;, &apos;N&apos;], &apos;OAI22X1&apos;: [&apos;38400&apos;, &apos;149850&apos;, &apos;N&apos;], &apos;OR2X1&apos;: [&apos;38400&apos;, &apos;156510&apos;, &apos;N&apos;], &apos;OR2X2&apos;: [&apos;38400&apos;, &apos;163170&apos;, &apos;N&apos;], &apos;XNOR2X1&apos;: [&apos;38400&apos;, &apos;169830&apos;, &apos;N&apos;], &apos;XOR2X1&apos;: [&apos;38400&apos;, &apos;176490&apos;, &apos;N&apos;]}</font>
<font color="#AAAAAA">Design name: user_proj_example</font>
<font color="#AAAAAA">Placing AND2X1</font>
<font color="#AAAAAA">Placing AND2X2</font>
<font color="#AAAAAA">Placing AOI21X1</font>
<font color="#AAAAAA">Placing AOI22X1</font>
<font color="#AAAAAA">Placing BUFX2</font>
<font color="#AAAAAA">Placing HAX1</font>
<font color="#AAAAAA">Placing INV</font>
<font color="#AAAAAA">Placing INVX1</font>
<font color="#AAAAAA">Placing INVX2</font>
<font color="#AAAAAA">Placing INVX4</font>
<font color="#AAAAAA">Placing INVX8</font>
<font color="#AAAAAA">Placing MUX2X1</font>
<font color="#AAAAAA">Placing NAND2X1</font>
<font color="#AAAAAA">Placing NAND3X1</font>
<font color="#AAAAAA">Placing NOR2X1</font>
<font color="#AAAAAA">Placing OAI21X1</font>
<font color="#AAAAAA">Placing OAI22X1</font>
<font color="#AAAAAA">Placing OR2X1</font>
<font color="#AAAAAA">Placing XNOR2X1</font>
<font color="#AAAAAA">Traceback (most recent call last):</font>
<font color="#AAAAAA">  File &quot;/openLANE_flow/scripts/manual_macro_place.py&quot;, line 119, in &lt;module&gt;</font>
<font color="#AAAAAA">    assert not macros, (&quot;Macros not found:&quot;, macros)</font>
<font color="#AAAAAA">AssertionError: (&apos;Macros not found:&apos;, {&apos;BUFX4&apos;: [&apos;38400&apos;, &apos;56610&apos;, &apos;N&apos;], &apos;CLKBUF1&apos;: [&apos;38400&apos;, &apos;63270&apos;, &apos;N&apos;], &apos;NOR3X1&apos;: [&apos;38400&apos;, &apos;136530&apos;, &apos;N&apos;], &apos;OR2X2&apos;: [&apos;38400&apos;, &apos;163170&apos;, &apos;N&apos;], &apos;XOR2X1&apos;: [&apos;38400&apos;, &apos;176490&apos;, &apos;N&apos;]})</font>
<font color="#AA0000">[ERROR]: during executing: &quot;python3 /openLANE_flow/scripts/manual_macro_place.py -l /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef -id /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def -o /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def -c /project/openlane/user_proj_example/runs/user_proj_example/tmp/macro_placement.cfg -f |&amp; tee &gt;&amp;@stdout /project/openlane/user_proj_example/runs/user_proj_example/logs/5-macro_placement.log&quot;</font>
<font color="#AA0000">[ERROR]: Exit code: 1</font>
<font color="#AA0000">[ERROR]: Last 10 lines:</font>
<font color="#AA0000">child process exited abnormally</font>

<font color="#AA0000">[ERROR]: Please check python3  log file</font>
<font color="#AA0000">[ERROR]: Dumping to /project/openlane/user_proj_example/runs/user_proj_example/error.log</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow failed for user_proj_example/13-06_18-40 in 0h1m0s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.gds.log</font>
<font color="#00AAAA">Source not found.</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">No antenna report found.</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#AA0000">[ERROR]: Flow Failed.</font>

<font color="#AAAAAA">    while executing</font>
<font color="#AAAAAA">&quot;try_catch python3 $::env(SCRIPTS_DIR)/manual_macro_place.py -l $::env(MERGED_LEF) -id $::env(CURRENT_DEF) -o ${fbasename}.macro_placement.def -c $::en...&quot;</font>
<font color="#AAAAAA">    (procedure &quot;manual_macro_placement&quot; line 6)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;manual_macro_placement f&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_floorplan&quot; line 29)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_floorplan&quot;</font>
<font color="#AAAAAA">    (procedure &quot;run_non_interactive_mode&quot; line 15)</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;run_non_interactive_mode {*}$argv&quot;</font>
<font color="#AAAAAA">    invoked from within</font>
<font color="#AAAAAA">&quot;if { [info exists flags_map(-interactive)] || [info exists flags_map(-it)] } {</font>
	<font color="#AAAAAA">puts_info &quot;Running interactively&quot;</font>
	<font color="#AAAAAA">if { [info exists arg_values(-file)...&quot;</font>
<font color="#AAAAAA">    (file &quot;/openLANE_flow/flow.tcl&quot; line 223)</font>
<font color="#AAAAAA">make[1]: *** [Makefile:43: user_proj_example] Fehler 1</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird verlassen</font>
<font color="#AAAAAA">make: *** [Makefile:71: user_proj_example] Fehler 2</font>
<font color="#AAAAAA">Deployment done.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ bash deploy2caravel.sh </font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lib“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/lef/orig“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/gds“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">mkdir: das Verzeichnis »/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/cells/mag“ kann nicht angelegt werden: Die Datei existiert bereits</font>
<font color="#AAAAAA">Cleaning up old files</font>
<font color="#AAAAAA">Copying files that were created by StdCellLib</font>
<font color="#AAAAAA">Removing cells with DRC issues left</font>
<font color="#AAAAAA">Checking AND2X1</font>
<font color="#AAAAAA">Checking AND2X2</font>
<font color="#AAAAAA">Checking AOI21X1</font>
<font color="#AAAAAA">Checking AOI22X1</font>
<font color="#AAAAAA">Checking BUFX2</font>
<font color="#AAAAAA">Checking BUFX4</font>
<font color="#AAAAAA">Removing cell with 2 DRC issues:</font>
<font color="#AAAAAA">Checking CLKBUF1</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking corr_XOR2X1</font>
<font color="#AAAAAA">Error: Could not find DRC: /home/philipp/libresilicon/StdCellLib/corr_XOR2X1.drc No such file or directory</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking HAX1</font>
<font color="#AAAAAA">Checking INV</font>
<font color="#AAAAAA">Checking INVX1</font>
<font color="#AAAAAA">Checking INVX2</font>
<font color="#AAAAAA">Checking INVX4</font>
<font color="#AAAAAA">Checking INVX8</font>
<font color="#AAAAAA">Checking LATCH</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Checking MUX2X1</font>
<font color="#AAAAAA">Checking NAND2X1</font>
<font color="#AAAAAA">Checking NAND3X1</font>
<font color="#AAAAAA">Checking NOR2X1</font>
<font color="#AAAAAA">Checking NOR3X1</font>
<font color="#AAAAAA">Removing cell with 60 DRC issues:</font>
<font color="#AAAAAA">Checking OAI21X1</font>
<font color="#AAAAAA">Checking OAI22X1</font>
<font color="#AAAAAA">Checking OR2X1</font>
<font color="#AAAAAA">Checking OR2X2</font>
<font color="#AAAAAA">Removing cell with 7 DRC issues:</font>
<font color="#AAAAAA">Checking XNOR2X1</font>
<font color="#AAAAAA">Checking XOR2X1</font>
<font color="#AAAAAA">Removing cell with 1 DRC issues:</font>
<font color="#AAAAAA">Now cleaning up the files for Sky130</font>
<font color="#AAAAAA">AND2X1.lef</font>
<font color="#AAAAAA">AND2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X1.lef for cell AND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AND2X2.lef</font>
<font color="#AAAAAA">AND2X2.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 70 lines.</font>
<font color="#AAAAAA">Generating LEF output AND2X2.lef for cell AND2X2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AND2X2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI21X1.lef</font>
<font color="#AAAAAA">AOI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI21X1.lef for cell AOI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">AOI22X1.lef</font>
<font color="#AAAAAA">AOI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output AOI22X1.lef for cell AOI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell AOI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">BUFX2.lef</font>
<font color="#AAAAAA">BUFX2.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output BUFX2.lef for cell BUFX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell BUFX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">HAX1.lef</font>
<font color="#AAAAAA">HAX1.lef -&gt; 15.84 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output HAX1.lef for cell HAX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell HAX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INV.lef</font>
<font color="#AAAAAA">INV.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INV.lef for cell INV:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INV</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX1.lef</font>
<font color="#AAAAAA">INVX1.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX1.lef for cell INVX1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX2.lef</font>
<font color="#AAAAAA">INVX2.lef -&gt; 2.88 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 57 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX2.lef for cell INVX2:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX2</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX4.lef</font>
<font color="#AAAAAA">INVX4.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 69 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX4.lef for cell INVX4:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX4</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">INVX8.lef</font>
<font color="#AAAAAA">INVX8.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 83 lines.</font>
<font color="#AAAAAA">Generating LEF output INVX8.lef for cell INVX8:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell INVX8</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">MUX2X1.lef</font>
<font color="#AAAAAA">MUX2X1.lef -&gt; 8.64 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 89 lines.</font>
<font color="#AAAAAA">Generating LEF output MUX2X1.lef for cell MUX2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell MUX2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND2X1.lef</font>
<font color="#AAAAAA">NAND2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND2X1.lef for cell NAND2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NAND3X1.lef</font>
<font color="#AAAAAA">NAND3X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output NAND3X1.lef for cell NAND3X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NAND3X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">NOR2X1.lef</font>
<font color="#AAAAAA">NOR2X1.lef -&gt; 4.32 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Generating LEF output NOR2X1.lef for cell NOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell NOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI21X1.lef</font>
<font color="#AAAAAA">OAI21X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 87 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI21X1.lef for cell OAI21X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI21X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OAI22X1.lef</font>
<font color="#AAAAAA">OAI22X1.lef -&gt; 7.2 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 100 lines.</font>
<font color="#AAAAAA">Generating LEF output OAI22X1.lef for cell OAI22X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OAI22X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">OR2X1.lef</font>
<font color="#AAAAAA">OR2X1.lef -&gt; 5.76 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Generating LEF output OR2X1.lef for cell OR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell OR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">XNOR2X1.lef</font>
<font color="#AAAAAA">XNOR2X1.lef -&gt; 10.08 3.33</font>

<font color="#AAAAAA">Magic 8.3 revision 158 - Compiled on Mo 26 Apr 2021 00:02:04 CEST.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Input style sky130: scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.81-0-gb184e85</font>
<font color="#AAAAAA">Reading LEF data from file XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 80 lines.</font>
<font color="#AAAAAA">Generating LEF output XNOR2X1.lef for cell XNOR2X1:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell XNOR2X1</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.010000</font>
<font color="#AAAAAA">    INFO: Reading base liberty: /home/philipp/libresilicon/StdCellLib/Catalog/libresilicon.libtemplate</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AND2X2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: AOI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: BUFX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: HAX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INV.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX2.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX4.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: INVX8.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: MUX2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NAND3X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: NOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI21X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OAI22X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: OR2X1.lib</font>
<font color="#AAAAAA">    INFO: Reading liberty: XNOR2X1.lib</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AND2X2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(AOI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(BUFX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(HAX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INV)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX2)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX4)</font>
<font color="#AAAAAA">    INFO: Add group: cell(INVX8)</font>
<font color="#AAAAAA">    INFO: Add group: cell(MUX2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NAND3X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(NOR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI21X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OAI22X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(OR2X1)</font>
<font color="#AAAAAA">    INFO: Add group: cell(XNOR2X1)</font>
<font color="#AAAAAA">    INFO: Number of cells in base: 19, number of cells in output: 19</font>
<font color="#AAAAAA">    INFO: Write liberty: libresilicon.lib</font>
<font color="#AAAAAA">Now generating the demo wafer, the macro placement and the test-bench</font>
<font color="#AAAAAA">Name &quot;main::name&quot; used only once: possible typo at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Use of uninitialized value $name in concatenation (.) or string at /media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts/placement.pl line 18.</font>
<font color="#AAAAAA">Now building the Caravel user-project</font>
<font color="#AAAAAA">cd openlane &amp;&amp; make user_proj_example</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird betreten</font>
<font color="#AAAAAA">###############################################</font>
<font color="#00AAAA">[INFO]: </font>
	<font color="#00AAAA">___   ____   ___  ____   _       ____  ____     ___</font>
	<font color="#00AAAA">/   \ |    \ /  _]|    \ | |     /    ||    \   /  _]</font>
	<font color="#00AAAA">|     ||  o  )  [_ |  _  || |    |  o  ||  _  | /  [_</font>
	<font color="#00AAAA">|  O  ||   _/    _]|  |  || |___ |     ||  |  ||    _]</font>
	<font color="#00AAAA">|     ||  | |   [_ |  |  ||     ||  _  ||  |  ||   [_</font>
	<font color="#00AAAA">\___/ |__| |_____||__|__||_____||__|__||__|__||_____|</font>


<font color="#00AAAA">[INFO]: Version: v0.15</font>
<font color="#00AAAA">[INFO]: Running non-interactively</font>
<font color="#00AAAA">[INFO]: Using design configuration at /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#00AAAA">[INFO]: PDKs root directory: /media/philipp/Daten/skywater/pdk-ls</font>
<font color="#00AAAA">[INFO]: PDK: sky130A</font>
<font color="#00AAAA">[INFO]: Setting PDKPATH to /media/philipp/Daten/skywater/pdk-ls/sky130A</font>
<font color="#00AAAA">[INFO]: Standard Cell Library: sky130_fd_sc_ls</font>
<font color="#00AAAA">[INFO]: Sourcing Configurations from /project/openlane/user_proj_example/config.tcl</font>
<font color="#AA5500">[WARNING]: Removing exisiting run /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Current run directory is /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">[INFO]: Preparing LEF Files</font>
<font color="#00AAAA">[INFO]: Extracting the number of available metal layers from /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef</font>
<font color="#00AAAA">[INFO]: The number of available metal layers is 6</font>
<font color="#00AAAA">[INFO]: The available metal layers are li1 met1 met2 met3 met4 met5</font>
<font color="#00AAAA">[INFO]: Merging LEF Files...</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">sky130_fd_sc_ls.lef: MACROs matched found: 399</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs</font>
<font color="#AAAAAA">NAND3X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND3X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX8.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX8.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX4.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX4.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OAI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OAI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">HAX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">HAX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI21X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI21X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">MUX2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">MUX2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">BUFX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">BUFX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">OR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">OR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">NAND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">NAND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X2.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X2.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AOI22X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AOI22X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">XNOR2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">XNOR2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">AND2X1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">AND2X1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INVX1.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INVX1.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">INV.lef: SITEs matched found: 0</font>
<font color="#AAAAAA">INV.lef: MACROs matched found: 1</font>
<font color="#AAAAAA">mergeLef.py : Merging LEFs complete</font>
<font color="#00AAAA">[INFO]: Merging the following extra LEFs: /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX8.lef /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX4.lef /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/HAX1.lef /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX2.lef /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef /project/openlane/user_proj_example/../../cells/lef/INVX1.lef /project/openlane/user_proj_example/../../cells/lef/INV.lef</font>
<font color="#00AAAA">[INFO]: Trimming Liberty...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Storing configs into config.tcl ...</font>
<font color="#00AAAA">[INFO]: Preparation complete</font>
<font color="#00AAAA">[INFO]: Running Synthesis...</font>
<font color="#00AAAA">[INFO]: current step index: 1</font>

<font color="#AAAAAA"> /----------------------------------------------------------------------------\</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  yosys -- Yosys Open SYnthesis Suite                                       |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Copyright (C) 2012 - 2020  Claire Wolf &lt;claire@symbioticeda.com&gt;          |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  Permission to use, copy, modify, and/or distribute this software for any  |</font>
<font color="#AAAAAA"> |  purpose with or without fee is hereby granted, provided that the above    |</font>
<font color="#AAAAAA"> |  copyright notice and this permission notice appear in all copies.         |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> |  THE SOFTWARE IS PROVIDED &quot;AS IS&quot; AND THE AUTHOR DISCLAIMS ALL WARRANTIES  |</font>
<font color="#AAAAAA"> |  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF          |</font>
<font color="#AAAAAA"> |  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   |</font>
<font color="#AAAAAA"> |  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    |</font>
<font color="#AAAAAA"> |  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN     |</font>
<font color="#AAAAAA"> |  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   |</font>
<font color="#AAAAAA"> |  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.            |</font>
<font color="#AAAAAA"> |                                                                            |</font>
<font color="#AAAAAA"> \----------------------------------------------------------------------------/</font>

<font color="#AAAAAA"> Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>

<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `cd&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `eval&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `exec&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `read&apos; -&gt; skip.</font>
<font color="#AAAAAA">[TCL: yosys -import] Command name collision: found pre-existing command `trace&apos; -&gt; skip.</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/tmp/sky130_fd_sc_ls__tt_025C_1v80.no_pg.lib as a blackbox</font>

<font color="#AAAAAA">1. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 386 cell types from liberty file.</font>

<font color="#AAAAAA">2. Executing Liberty frontend.</font>
<font color="#AAAAAA">Imported 19 cell types from liberty file.</font>

<font color="#AAAAAA">3. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v&apos; to AST representation.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:10.1-19.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AND2X2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:21.1-30.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AND2X2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:32.1-42.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\AOI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:44.1-55.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\AOI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\BUFX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:57.1-65.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\BUFX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\HAX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:67.1-77.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\HAX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INV&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:79.1-87.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INV&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:89.1-97.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX2&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:99.1-107.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX2&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX4&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:109.1-117.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX4&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\INVX8&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:119.1-127.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\INVX8&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\MUX2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:129.1-139.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\MUX2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:141.1-150.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NAND3X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:152.1-162.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NAND3X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\NOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:164.1-173.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\NOR2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI21X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:175.1-185.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI21X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OAI22X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:187.1-198.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OAI22X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\OR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:200.1-209.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\OR2X1&apos;.</font>
<font color="#AAAAAA">Replacing existing blackbox module `\XNOR2X1&apos; at /project/openlane/user_proj_example/../../verilog//rtl/user_proj_cells.v:211.1-220.10.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\XNOR2X1&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">4. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../caravel/verilog/rtl/defines.v&apos; to AST representation.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">5. Executing Verilog-2005 frontend: /project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v</font>
<font color="#AAAAAA">Parsing SystemVerilog input from `/project/openlane/user_proj_example/../../verilog/rtl/user_proj_example.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">6. Generating Graphviz representation of design.</font>
<font color="#AAAAAA">Writing dot description to `/project/openlane/user_proj_example/runs/user_proj_example/tmp/synthesis/hierarchy.dot&apos;.</font>
<font color="#AAAAAA">Dumping module user_proj_example to page 1.</font>

<font color="#AAAAAA">7. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">7.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">7.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">8. Executing TRIBUF pass.</font>

<font color="#AAAAAA">9. Executing SYNTH pass.</font>

<font color="#AAAAAA">9.1. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.1.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.1.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.2. Executing PROC pass (convert processes to netlists).</font>

<font color="#AAAAAA">9.2.1. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.2.2. Executing PROC_RMDEAD pass (remove dead branches from decision trees).</font>
<font color="#AAAAAA">Removed a total of 0 dead cases.</font>

<font color="#AAAAAA">9.2.3. Executing PROC_PRUNE pass (remove redundant assignments in processes).</font>
<font color="#AAAAAA">Removed 0 redundant assignments.</font>
<font color="#AAAAAA">Promoted 0 assignments to connections.</font>

<font color="#AAAAAA">9.2.4. Executing PROC_INIT pass (extract init attributes).</font>

<font color="#AAAAAA">9.2.5. Executing PROC_ARST pass (detect async resets in processes).</font>

<font color="#AAAAAA">9.2.6. Executing PROC_MUX pass (convert decision trees to multiplexers).</font>

<font color="#AAAAAA">9.2.7. Executing PROC_DLATCH pass (convert process syncs to latches).</font>

<font color="#AAAAAA">9.2.8. Executing PROC_DFF pass (convert process syncs to FFs).</font>

<font color="#AAAAAA">9.2.9. Executing PROC_CLEAN pass (remove empty switches from decision trees).</font>
<font color="#AAAAAA">Cleaned up 0 empty switches.</font>

<font color="#AAAAAA">9.3. Executing FLATTEN pass (flatten design).</font>

<font color="#AAAAAA">9.4. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.6. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_dat_o [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\wbs_ack_o is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [127] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [126] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [125] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [124] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [123] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [122] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [121] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [120] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [119] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [118] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [117] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [116] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [115] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [114] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [113] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [112] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [111] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [110] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [109] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [108] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [107] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [106] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [105] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [104] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [103] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [102] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [101] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [100] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [99] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [98] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [97] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [96] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [95] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [94] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [93] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [92] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [91] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [90] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [89] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [88] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [87] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [86] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [85] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [84] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [83] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [82] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [81] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [80] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [79] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [78] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [77] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [76] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [75] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [74] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [73] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [72] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [71] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [70] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [69] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [68] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [67] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [66] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [65] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [64] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [63] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [62] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [61] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [60] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [59] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [58] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [57] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [56] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [55] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [54] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [53] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [52] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [51] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [50] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [49] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [48] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [47] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [46] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [45] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [44] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [43] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [42] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [41] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [40] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [39] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [38] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [37] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [34] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [30] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [28] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [26] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [24] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [22] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [20] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [19] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [16] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [14] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [9] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [5] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [2] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\la_data_out [0] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [36] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [35] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [33] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [32] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [31] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [29] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [27] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [25] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [23] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [21] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [18] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [17] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [15] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [13] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [12] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [11] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [10] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [8] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [7] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [6] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [4] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [3] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [1] is used but has no driver.</font>
<font color="#AAAAAA">Warning: Wire user_proj_example.\io_out [0] is used but has no driver.</font>
<font color="#AAAAAA">found and reported 179 problems.</font>

<font color="#AAAAAA">9.7. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.7.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.7.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.7.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.7.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.7.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.7.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.7.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.8. Executing FSM pass (extract and optimize FSM).</font>

<font color="#AAAAAA">9.8.1. Executing FSM_DETECT pass (finding FSMs in design).</font>

<font color="#AAAAAA">9.8.2. Executing FSM_EXTRACT pass (extracting FSM from design).</font>

<font color="#AAAAAA">9.8.3. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.8.5. Executing FSM_OPT pass (simple optimizations of FSMs).</font>

<font color="#AAAAAA">9.8.6. Executing FSM_RECODE pass (re-assigning FSM state encoding).</font>

<font color="#AAAAAA">9.8.7. Executing FSM_INFO pass (dumping all available information on FSM cells).</font>

<font color="#AAAAAA">9.8.8. Executing FSM_MAP pass (mapping FSMs to basic logic).</font>

<font color="#AAAAAA">9.9. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.9.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.9.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.9.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.9.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.9.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.9.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.9.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.10. Executing WREDUCE pass (reducing word size of cells).</font>

<font color="#AAAAAA">9.11. Executing PEEPOPT pass (run peephole optimizers).</font>

<font color="#AAAAAA">9.12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.13. Executing ALUMACC pass (create $alu and $macc cells).</font>
<font color="#AAAAAA">Extracting $alu and $macc cells in module user_proj_example:</font>
<font color="#AAAAAA">  created 0 $alu and 0 $macc cells.</font>

<font color="#AAAAAA">9.14. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">9.15. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.15.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.15.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.15.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.15.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.15.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.15.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.15.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.16. Executing MEMORY pass.</font>

<font color="#AAAAAA">9.16.1. Executing OPT_MEM pass (optimize memories).</font>
<font color="#AAAAAA">Performed a total of 0 transformations.</font>

<font color="#AAAAAA">9.16.2. Executing MEMORY_DFF pass (merging $dff cells to $memrd and $memwr).</font>

<font color="#AAAAAA">9.16.3. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.4. Executing MEMORY_SHARE pass (consolidating $memrd/$memwr cells).</font>

<font color="#AAAAAA">9.16.5. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.16.6. Executing MEMORY_COLLECT pass (generating $mem cells).</font>

<font color="#AAAAAA">9.17. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.18.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>
<font color="#AAAAAA">&lt;suppressed ~87 debug messages&gt;</font>

<font color="#AAAAAA">9.18.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.18.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.18.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.18.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.19. Executing MEMORY_MAP pass (converting $mem cells to logic and flip-flops).</font>

<font color="#AAAAAA">9.20. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.20.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">9.20.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">9.20.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.20.6. Executing OPT_SHARE pass.</font>

<font color="#AAAAAA">9.20.7. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.20.8. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.20.9. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.20.10. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">9.21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">9.21.1. Executing Verilog-2005 frontend: /build/bin/../share/yosys/techmap.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/build/bin/../share/yosys/techmap.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_bool_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_reduce_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_logic_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_compare_ops&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_various&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_simplemap_registers&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_ops_shr_shl_sshl_sshr&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_shift_shiftx&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_fa&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lcu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alu&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_macc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_alumacc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_u&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_trunc&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_div&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_mod&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$__div_mod_floor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_divfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_modfloor&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pow&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_pmux&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\_90_lut&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">9.21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~67 debug messages&gt;</font>

<font color="#AAAAAA">9.22. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.22.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.22.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.22.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.22.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.22.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.23. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">9.23.1. Extracting gate netlist of module `\user_proj_example&apos; to `&lt;abc-temp-dir&gt;/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">9.24. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">9.24.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">9.24.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">9.24.3. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">9.24.4. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">9.24.5. Finished fast OPT passes.</font>

<font color="#AAAAAA">9.25. Executing HIERARCHY pass (managing design hierarchy).</font>

<font color="#AAAAAA">9.25.1. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>

<font color="#AAAAAA">9.25.2. Analyzing design hierarchy..</font>
<font color="#AAAAAA">Top module:  \user_proj_example</font>
<font color="#AAAAAA">Removed 0 unused modules.</font>

<font color="#AAAAAA">9.26. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">9.27. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">10. Executing SHARE pass (SAT-based resource sharing).</font>

<font color="#AAAAAA">11. Executing OPT pass (performing simple optimizations).</font>

<font color="#AAAAAA">11.1. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.2. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.3. Executing OPT_MUXTREE pass (detect dead branches in mux trees).</font>
<font color="#AAAAAA">Running muxtree optimizer on module \user_proj_example..</font>
<font color="#AAAAAA">  Creating internal representation of mux trees.</font>
<font color="#AAAAAA">  No muxes found in this module.</font>
<font color="#AAAAAA">Removed 0 multiplexer ports.</font>

<font color="#AAAAAA">11.4. Executing OPT_REDUCE pass (consolidate $*mux and $reduce_* inputs).</font>
<font color="#AAAAAA">  Optimizing cells in module \user_proj_example.</font>
<font color="#AAAAAA">Performed a total of 0 changes.</font>

<font color="#AAAAAA">11.5. Executing OPT_MERGE pass (detect identical cells).</font>
<font color="#AAAAAA">Finding identical cells in module `\user_proj_example&apos;.</font>
<font color="#AAAAAA">Removed a total of 0 cells.</font>

<font color="#AAAAAA">11.6. Executing OPT_DFF pass (perform DFF optimizations).</font>

<font color="#AAAAAA">11.7. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">11.8. Executing OPT_EXPR pass (perform const folding).</font>
<font color="#AAAAAA">Optimizing module user_proj_example.</font>

<font color="#AAAAAA">11.9. Finished OPT passes. (There is nothing left to do.)</font>

<font color="#AAAAAA">12. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>

<font color="#AAAAAA">13. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">mapping tbuf</font>

<font color="#AAAAAA">14. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">14.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/tribuff_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_TBUF_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">14.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">15. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">16. Executing MUXCOVER pass (mapping to wider MUXes).</font>
<font color="#AAAAAA">Covering MUX trees in module user_proj_example..</font>
<font color="#AAAAAA">  Treeifying 0 MUXes:</font>
<font color="#AAAAAA">    Finished treeification: Found 0 trees.</font>
<font color="#AAAAAA">  Covering trees:</font>
<font color="#AAAAAA">  Added a total of 0 decoder MUXes.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">17. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">17.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux4_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX4_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">17.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">18. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">19. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">19.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/mux2_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_MUX_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">19.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~3 debug messages&gt;</font>

<font color="#AAAAAA">20. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">21. Executing TECHMAP pass (map to technology primitives).</font>

<font color="#AAAAAA">21.1. Executing Verilog-2005 frontend: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v</font>
<font color="#AAAAAA">Parsing Verilog input from `/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/sky130_fd_sc_ls/latch_map.v&apos; to AST representation.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_P_&apos;.</font>
<font color="#AAAAAA">Generating RTLIL representation for module `\$_DLATCH_N_&apos;.</font>
<font color="#AAAAAA">Successfully finished Verilog frontend.</font>

<font color="#AAAAAA">21.2. Continuing TECHMAP pass.</font>
<font color="#AAAAAA">No more expansions possible.</font>
<font color="#AAAAAA">&lt;suppressed ~4 debug messages&gt;</font>

<font color="#AAAAAA">22. Executing SIMPLEMAP pass (map simple cells to gate primitives).</font>

<font color="#AAAAAA">23. Executing DFFLIBMAP pass (mapping DFF cells to sequential cells from liberty file).</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfxtp_2 (noninv, pins=3, area=28.77) is a direct match for cell type $_DFF_P_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfrtp_2 (noninv, pins=4, area=38.36) is a direct match for cell type $_DFF_PN0_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfstp_2 (noninv, pins=4, area=39.96) is a direct match for cell type $_DFF_PN1_.</font>
<font color="#AAAAAA">  cell sky130_fd_sc_ls__dfbbn_2 (noninv, pins=6, area=47.95) is a direct match for cell type $_DFFSR_NNN_.</font>
<font color="#AAAAAA">  final dff cell mappings:</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_N_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfxtp_2 _DFF_P_ (.CLK( C), .D( D), .Q( Q));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NN1_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_NP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfrtp_2 _DFF_PN0_ (.CLK( C), .D( D), .Q( Q), .RESET_B( R));</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfstp_2 _DFF_PN1_ (.CLK( C), .D( D), .Q( Q), .SET_B( R));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP0_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFF_PP1_</font>
<font color="#AAAAAA">    \sky130_fd_sc_ls__dfbbn_2 _DFFSR_NNN_ (.CLK_N( C), .D( D), .Q( Q), .Q_N(~Q), .RESET_B( R), .SET_B( S));</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_NPP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PNP_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPN_</font>
<font color="#AAAAAA">    unmapped dff cell: $_DFFSR_PPP_</font>

<font color="#AAAAAA">23.1. Executing DFFLEGALIZE pass (convert FFs to types supported by the target).</font>
<font color="#AAAAAA">Mapping DFF cells in module `\user_proj_example&apos;:</font>

<font color="#AAAAAA">24. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                 19</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>

<font color="#AAAAAA">[INFO]: ABC: WireLoad : S_4</font>

<font color="#AAAAAA">25. Executing ABC pass (technology mapping using ABC).</font>

<font color="#AAAAAA">25.1. Extracting gate netlist of module `\user_proj_example&apos; to `/tmp/yosys-abc-astuwy/input.blif&apos;..</font>
<font color="#AAAAAA">Extracted 0 gates and 0 wires to a netlist network with 0 inputs and 0 outputs.</font>
<font color="#AAAAAA">Don&apos;t call ABC as there is nothing to map.</font>
<font color="#AAAAAA">Removing temp directory.</font>

<font color="#AAAAAA">26. Executing SETUNDEF pass (replace undef values with defined constants).</font>

<font color="#AAAAAA">27. Executing HILOMAP pass (mapping to constant drivers).</font>

<font color="#AAAAAA">28. Executing SPLITNETS pass (splitting up multi-bit signals).</font>

<font color="#AAAAAA">29. Executing OPT_CLEAN pass (remove unused cells and wires).</font>
<font color="#AAAAAA">Finding unused cells or wires in module \user_proj_example..</font>
<font color="#AAAAAA">Removed 0 unused cells and 217 unused wires.</font>
<font color="#AAAAAA">&lt;suppressed ~1 debug messages&gt;</font>

<font color="#AAAAAA">30. Executing INSBUF pass (insert buffer cells for connected wires).</font>

<font color="#AAAAAA">31. Executing CHECK pass (checking for obvious problems).</font>
<font color="#AAAAAA">checking module user_proj_example..</font>
<font color="#AAAAAA">found and reported 0 problems.</font>

<font color="#AAAAAA">32. Printing statistics.</font>

<font color="#AAAAAA">=== user_proj_example ===</font>

<font color="#AAAAAA">   Number of wires:                 16</font>
<font color="#AAAAAA">   Number of wire bits:            604</font>
<font color="#AAAAAA">   Number of public wires:          16</font>
<font color="#AAAAAA">   Number of public wire bits:     604</font>
<font color="#AAAAAA">   Number of memories:               0</font>
<font color="#AAAAAA">   Number of memory bits:            0</font>
<font color="#AAAAAA">   Number of processes:              0</font>
<font color="#AAAAAA">   Number of cells:                236</font>
<font color="#AAAAAA">     AND2X1                          1</font>
<font color="#AAAAAA">     AND2X2                          1</font>
<font color="#AAAAAA">     AOI21X1                         1</font>
<font color="#AAAAAA">     AOI22X1                         1</font>
<font color="#AAAAAA">     BUFX2                           1</font>
<font color="#AAAAAA">     HAX1                            1</font>
<font color="#AAAAAA">     INV                             1</font>
<font color="#AAAAAA">     INVX1                           1</font>
<font color="#AAAAAA">     INVX2                           1</font>
<font color="#AAAAAA">     INVX4                           1</font>
<font color="#AAAAAA">     INVX8                           1</font>
<font color="#AAAAAA">     MUX2X1                          1</font>
<font color="#AAAAAA">     NAND2X1                         1</font>
<font color="#AAAAAA">     NAND3X1                         1</font>
<font color="#AAAAAA">     NOR2X1                          1</font>
<font color="#AAAAAA">     OAI21X1                         1</font>
<font color="#AAAAAA">     OAI22X1                         1</font>
<font color="#AAAAAA">     OR2X1                           1</font>
<font color="#AAAAAA">     XNOR2X1                         1</font>
<font color="#AAAAAA">     sky130_fd_sc_ls__conb_1       217</font>

<font color="#AAAAAA">   Area for cell type \AND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AND2X2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \AOI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \BUFX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \HAX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INV is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX2 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX4 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \INVX8 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \MUX2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NAND3X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \NOR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI21X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OAI22X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \OR2X1 is unknown!</font>
<font color="#AAAAAA">   Area for cell type \XNOR2X1 is unknown!</font>

<font color="#AAAAAA">   Chip area for module &apos;\user_proj_example&apos;: 1040.558400</font>

<font color="#AAAAAA">33. Executing Verilog backend.</font>
<font color="#AAAAAA">Dumping module `\user_proj_example&apos;.</font>

<font color="#AAAAAA">Warnings: 179 unique messages, 179 total</font>
<font color="#AAAAAA">End of script. Logfile hash: 6d67308f2b, CPU: user 22.03s system 0.80s, MEM: 386.66 MB peak</font>
<font color="#AAAAAA">Yosys 0.9+3621 (git sha1 84e9fa7, gcc 8.3.1 -fPIC -Os)</font>
<font color="#AAAAAA">Time spent: 37% 4x read_liberty (8 sec), 37% 4x stat (8 sec), 21% 1x dfflibmap (4 sec), ...</font>
<font color="#00AAAA">[INFO]: Changing netlist from 0 to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v</font>
<font color="#00AAAA">[INFO]: Running Static Timing Analysis...</font>
<font color="#00AAAA">[INFO]: current step index: 2</font>
<font color="#AAAAAA">OpenSTA 2.3.0 38b40303a8 Copyright (c) 2019, Parallax Software, Inc.</font>
<font color="#AAAAAA">License GPLv3: GNU GPL version 3 &lt;http://gnu.org/licenses/gpl.html&gt;</font>

<font color="#AAAAAA">This is free software, and you are free to change and redistribute it</font>
<font color="#AAAAAA">under certain conditions; type `show_copying&apos; for details. </font>
<font color="#AAAAAA">This program comes with ABSOLUTELY NO WARRANTY; for details type `show_warranty&apos;.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 671, module AND2X1 not found.  Creating black box for AND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 676, module AND2X2 not found.  Creating black box for AND2X2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 681, module AOI21X1 not found.  Creating black box for AOI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 687, module AOI22X1 not found.  Creating black box for AOI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 694, module BUFX2 not found.  Creating black box for BUFX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 698, module HAX1 not found.  Creating black box for HAX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 704, module INV not found.  Creating black box for INV.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 708, module INVX1 not found.  Creating black box for INVX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 712, module INVX2 not found.  Creating black box for INVX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 716, module INVX4 not found.  Creating black box for INVX4.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 720, module INVX8 not found.  Creating black box for INVX8.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 724, module MUX2X1 not found.  Creating black box for MUX2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 730, module NAND2X1 not found.  Creating black box for NAND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 735, module NAND3X1 not found.  Creating black box for NAND3X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 741, module NOR2X1 not found.  Creating black box for NOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 746, module OAI21X1 not found.  Creating black box for OAI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 752, module OAI22X1 not found.  Creating black box for OAI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 759, module OR2X1 not found.  Creating black box for OR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v line 764, module XNOR2X1 not found.  Creating black box for XNOR2X1.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#00AAAA">[INFO]: Synthesis was successful</font>
<font color="#00AAAA">[INFO]: Running Floorplanning...</font>
<font color="#00AAAA">[INFO]: Running Initial Floorplanning...</font>
<font color="#00AAAA">[INFO]: current step index: 3</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AND2X2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master AOI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master BUFX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master HAX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INV has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX2 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX4 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master INVX8 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master MUX2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NAND3X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master NOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI21X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OAI22X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master OR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[WARNING ORD-1000] LEF master XNOR2X1 has no liberty cell.</font>
<font color="#AAAAAA">[INFO IFP-0001] Added 82 rows of 601 sites.</font>
<font color="#00AAAA">[INFO]: Core area width: 288.48</font>
<font color="#00AAAA">[INFO]: Core area height: 273.36</font>
<font color="#00AAAA">[INFO]: Changing layout from 0 to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#00AAAA">[INFO]: current step index: 4</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def</font>
<font color="#AAAAAA">Top-level design name: user_proj_example</font>
<font color="#AAAAAA">Block boundaries: 0 0 300000 300000</font>
<font color="#AAAAAA">Writing /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/3-verilog2def_openroad.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#00AAAA">[INFO]:  Manual Macro Placement...</font>
<font color="#00AAAA">[INFO]: current step index: 5</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def</font>
<font color="#AAAAAA">Placing the following macros:</font>
<font color="#AAAAAA">{}</font>
<font color="#AAAAAA">Design name: user_proj_example</font>
<font color="#AAAAAA">Successfully placed 0 instances</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def</font>
<font color="#00AAAA">[INFO]: Running Tap/Decap Insertion...</font>
<font color="#00AAAA">[INFO]: current step index: 6</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 236 components and 1400 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def</font>
<font color="#AAAAAA">Step 1: Cut rows...</font>
<font color="#AAAAAA">[INFO TAP-0001] Macro blocks found: 0</font>
<font color="#AAAAAA">[INFO TAP-0002] #Original rows: 82</font>
<font color="#AAAAAA">[INFO TAP-0003] #Cut rows: 0</font>
<font color="#AAAAAA">Step 2: Insert endcaps...</font>
<font color="#AAAAAA">[INFO TAP-0004] #Endcaps inserted: 164</font>
<font color="#AAAAAA">Step 3: Insert tapcells...</font>
<font color="#AAAAAA">[INFO TAP-0005] #Tapcells inserted: 882</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/4-ioPlacer.macro_placement.def to /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 7</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: Power planning the following nets</font>
<font color="#00AAAA">[INFO]: Power: vccd1 vccd2 vdda1 vdda2</font>
<font color="#00AAAA">[INFO]: Ground: vssd1 vssd2 vssa1 vssa2</font>
<font color="#00AAAA">[INFO]: Generating PDN...</font>
<font color="#00AAAA">[INFO]: current step index: 8</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 604 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def</font>
<font color="#AAAAAA">[INFO] [PDNG-0016] Power Delivery Network Generator: Generating PDN</font>
<font color="#AAAAAA">[INFO] [PDNG-0016]   config: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/common_pdn.tcl</font>
<font color="#AAAAAA">[INFO] [PDNG-0008] Design Name is user_proj_example</font>
<font color="#AAAAAA">[INFO] [PDNG-0009] Reading technology data</font>
<font color="#AAAAAA">[INFO] [PDNG-0011] ****** INFO ******</font>
<font color="#AAAAAA">Type: stdcell, grid</font>
<font color="#AAAAAA">    Stdcell Rails</font>
<font color="#AAAAAA">      Layer: met1 -  width: 0.480  pitch: 3.330  offset: 0.000 </font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">      Layer: met4 -  width: 1.600  pitch: 153.600  offset: 16.320 </font>
<font color="#AAAAAA">    Connect:  {met1 met4}</font>
<font color="#AAAAAA">Type: macro, macro_1</font>
<font color="#AAAAAA">    Macro orientation: R0 R180 MX MY R90 R270 MXR90 MYR90</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">    Connect: {met4_PIN_ver met5}</font>
<font color="#AAAAAA">[INFO] [PDNG-0012] **** END INFO ****</font>
<font color="#AAAAAA">[INFO] [PDNG-0013] Inserting stdcell grid - grid</font>
<font color="#AAAAAA">[INFO] [PDNG-0015] Writing to database</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vccd1 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0022] Using voltage 0.000V for VDD network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vccd1.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (22.080um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (175.680um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (175.680um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (175.680um, 151.200um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vccd1 = 2876.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vccd1.</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vssd1 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0021] Using voltage 0.000V for ground network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vssd1.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (98.880um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (98.880um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (252.480um, 10.800um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (252.480um, 151.200um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vssd1 = 2810.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vssd1.</font>
<font color="#00AAAA">[INFO]: PDN generation was successful.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/results/floorplan/user_proj_example.floorplan.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/8-pdn.def</font>
<font color="#00AAAA">[INFO]: Generating PDN...</font>
<font color="#00AAAA">[INFO]: current step index: 9</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/8-pdn.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 606 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 2 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/8-pdn.def</font>
<font color="#AAAAAA">[INFO] [PDNG-0016] Power Delivery Network Generator: Generating PDN</font>
<font color="#AAAAAA">[INFO] [PDNG-0016]   config: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/common_pdn.tcl</font>
<font color="#AAAAAA">[INFO] [PDNG-0008] Design Name is user_proj_example</font>
<font color="#AAAAAA">[INFO] [PDNG-0009] Reading technology data</font>
<font color="#AAAAAA">[INFO] [PDNG-0011] ****** INFO ******</font>
<font color="#AAAAAA">Type: stdcell, grid</font>
<font color="#AAAAAA">    Stdcell Rails</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">      Layer: met4 -  width: 1.600  pitch: 153.600  offset: 19.620 </font>
<font color="#AAAAAA">    Connect: </font>
<font color="#AAAAAA">Type: macro, macro_1</font>
<font color="#AAAAAA">    Macro orientation: R0 R180 MX MY R90 R270 MXR90 MYR90</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">    Connect: {met4_PIN_ver met5}</font>
<font color="#AAAAAA">[INFO] [PDNG-0012] **** END INFO ****</font>
<font color="#AAAAAA">[INFO] [PDNG-0013] Inserting stdcell grid - grid</font>
<font color="#AAAAAA">[INFO] [PDNG-0015] Writing to database</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vccd2 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0022] Using voltage 0.000V for VDD network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vccd2.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (21.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (172.800um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (178.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (178.200um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vccd2 = 3.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vccd2.</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vssd2 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0021] Using voltage 0.000V for ground network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vssd2.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (97.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (102.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (253.800um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (253.800um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vssd2 = 3.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vssd2.</font>
<font color="#00AAAA">[INFO]: PDN generation was successful.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/8-pdn.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/9-pdn.def</font>
<font color="#00AAAA">[INFO]: Generating PDN...</font>
<font color="#00AAAA">[INFO]: current step index: 10</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/9-pdn.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 608 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 4 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/9-pdn.def</font>
<font color="#AAAAAA">[INFO] [PDNG-0016] Power Delivery Network Generator: Generating PDN</font>
<font color="#AAAAAA">[INFO] [PDNG-0016]   config: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/common_pdn.tcl</font>
<font color="#AAAAAA">[INFO] [PDNG-0008] Design Name is user_proj_example</font>
<font color="#AAAAAA">[INFO] [PDNG-0009] Reading technology data</font>
<font color="#AAAAAA">[INFO] [PDNG-0011] ****** INFO ******</font>
<font color="#AAAAAA">Type: stdcell, grid</font>
<font color="#AAAAAA">    Stdcell Rails</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">      Layer: met4 -  width: 1.600  pitch: 153.600  offset: 22.920 </font>
<font color="#AAAAAA">    Connect: </font>
<font color="#AAAAAA">Type: macro, macro_1</font>
<font color="#AAAAAA">    Macro orientation: R0 R180 MX MY R90 R270 MXR90 MYR90</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">    Connect: {met4_PIN_ver met5}</font>
<font color="#AAAAAA">[INFO] [PDNG-0012] **** END INFO ****</font>
<font color="#AAAAAA">[INFO] [PDNG-0013] Inserting stdcell grid - grid</font>
<font color="#AAAAAA">[INFO] [PDNG-0015] Writing to database</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vdda1 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0022] Using voltage 0.000V for VDD network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vdda1.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (27.000um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (178.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (178.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (178.200um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vdda1 = 2.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vdda1.</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vssa1 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0021] Using voltage 0.000V for ground network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vssa1.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (102.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (102.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (259.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (259.200um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vssa1 = 3.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vssa1.</font>
<font color="#00AAAA">[INFO]: PDN generation was successful.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/9-pdn.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/10-pdn.def</font>
<font color="#00AAAA">[INFO]: Generating PDN...</font>
<font color="#00AAAA">[INFO]: current step index: 11</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/10-pdn.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 610 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 6 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/10-pdn.def</font>
<font color="#AAAAAA">[INFO] [PDNG-0016] Power Delivery Network Generator: Generating PDN</font>
<font color="#AAAAAA">[INFO] [PDNG-0016]   config: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/openlane/common_pdn.tcl</font>
<font color="#AAAAAA">[INFO] [PDNG-0008] Design Name is user_proj_example</font>
<font color="#AAAAAA">[INFO] [PDNG-0009] Reading technology data</font>
<font color="#AAAAAA">[INFO] [PDNG-0011] ****** INFO ******</font>
<font color="#AAAAAA">Type: stdcell, grid</font>
<font color="#AAAAAA">    Stdcell Rails</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">      Layer: met4 -  width: 1.600  pitch: 153.600  offset: 26.220 </font>
<font color="#AAAAAA">    Connect: </font>
<font color="#AAAAAA">Type: macro, macro_1</font>
<font color="#AAAAAA">    Macro orientation: R0 R180 MX MY R90 R270 MXR90 MYR90</font>
<font color="#AAAAAA">    Straps</font>
<font color="#AAAAAA">    Connect: {met4_PIN_ver met5}</font>
<font color="#AAAAAA">[INFO] [PDNG-0012] **** END INFO ****</font>
<font color="#AAAAAA">[INFO] [PDNG-0013] Inserting stdcell grid - grid</font>
<font color="#AAAAAA">[INFO] [PDNG-0015] Writing to database</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vdda2 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0022] Using voltage 0.000V for VDD network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vdda2.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (27.000um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (183.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (183.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (183.600um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vdda2 = 3.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vdda2.</font>
<font color="#AAAAAA">[WARNING PSM-0016] Voltage pad location (vsrc) file not specified, defaulting pad location to checkerboard pattern on core area.</font>
<font color="#AAAAAA">[WARNING PSM-0017] X direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0018] Y direction bump pitch is not specified, defaulting to 140um.</font>
<font color="#AAAAAA">[WARNING PSM-0019] Voltage on net vssa2 is not explicitly set.</font>
<font color="#AAAAAA">[WARNING PSM-0021] Using voltage 0.000V for ground network.</font>
<font color="#AAAAAA">[INFO PSM-0026] Creating G matrix.</font>
<font color="#AAAAAA">[INFO PSM-0028] Extracting power stripes on net vssa2.</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (5.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (102.600um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (145.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (108.000um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 13.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (259.200um, 149.850um).</font>
<font color="#AAAAAA">[WARNING PSM-0030] Vsrc location at (285.760um, 153.320um) and size =10.000um, is not located on a power stripe. Moving to closest stripe at (259.200um, 149.850um).</font>
<font color="#AAAAAA">[INFO PSM-0031] Number of nodes on net vssa2 = 3.</font>
<font color="#AAAAAA">[INFO PSM-0037] G matrix created sucessfully.</font>
<font color="#AAAAAA">[INFO PSM-0040] Connection between all PDN nodes established in net vssa2.</font>
<font color="#00AAAA">[INFO]: PDN generation was successful.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/10-pdn.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/11-pdn.def</font>
<font color="#00AAAA">[INFO]: Running Placement...</font>
<font color="#AA5500">[WARNING]: Performing Random Global Placement...</font>
<font color="#00AAAA">[INFO]: current step index: 12</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/11-pdn.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/11-pdn.def</font>
<font color="#AAAAAA">Design name: user_proj_example</font>
<font color="#AAAAAA">Core Area Boundaries: 5760 13320 294240 286380</font>
<font color="#AAAAAA">Number of instances 1282</font>
<font color="#AAAAAA">Placed 236 instances</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/floorplan/11-pdn.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-replace.def</font>
<font color="#00AAAA">[INFO]: Skipping OpenPhySyn Timing Optimizations.</font>
<font color="#00AAAA">[INFO]: Running Resizer Design Optimizations...</font>
<font color="#00AAAA">[INFO]: Generating Exclude List...</font>
<font color="#00AAAA">[INFO]: Creating ::env(DONT_USE_CELLS)...</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/tmp/resizer.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-replace.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1282 components and 3820 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 604 nets and 277 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-replace.def</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">[INFO RSZ-0027] Inserted 367 input buffers.</font>
<font color="#AAAAAA">[INFO RSZ-0028] Inserted 237 output buffers.</font>
<font color="#AAAAAA">[INFO RSZ-0039] Resized 271 instances.</font>
<font color="#AAAAAA">Design Stats</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total instances          1886</font>
<font color="#AAAAAA">multi row instances         0</font>
<font color="#AAAAAA">fixed instances          1046</font>
<font color="#AAAAAA">nets                     1216</font>
<font color="#AAAAAA">design area           78772.3 u^2</font>
<font color="#AAAAAA">fixed area             2458.3 u^2</font>
<font color="#AAAAAA">movable area           5324.3 u^2</font>
<font color="#AAAAAA">utilization                 7 %</font>
<font color="#AAAAAA">utilization padded         15 %</font>
<font color="#AAAAAA">rows                       82</font>
<font color="#AAAAAA">row height                3.3 u</font>

<font color="#AAAAAA">Placement Analysis</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total displacement    12784.9 u</font>
<font color="#AAAAAA">average displacement      6.8 u</font>
<font color="#AAAAAA">max displacement         77.1 u</font>
<font color="#AAAAAA">original HPWL         72578.5 u</font>
<font color="#AAAAAA">legalized HPWL        77226.1 u</font>
<font color="#AAAAAA">delta HPWL                  6 %</font>

<font color="#AAAAAA">[INFO DPL-0020] Mirrored 285 instances</font>
<font color="#AAAAAA">[INFO DPL-0021] HPWL before           77226.1 u</font>
<font color="#AAAAAA">[INFO DPL-0022] HPWL after            77031.1 u</font>
<font color="#AAAAAA">[INFO DPL-0023] HPWL delta               -0.3 %</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-replace.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def</font>
<font color="#00AAAA">[INFO]: Writing Verilog...</font>
<font color="#00AAAA">[INFO]: current step index: 13</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1886 components and 7444 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1485 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def</font>
<font color="#00AAAA">[INFO]: Changing netlist from /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis.v to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v</font>
<font color="#00AAAA">[INFO]: Running Static Timing Analysis...</font>
<font color="#00AAAA">[INFO]: current step index: 14</font>
<font color="#AAAAAA">OpenSTA 2.3.0 38b40303a8 Copyright (c) 2019, Parallax Software, Inc.</font>
<font color="#AAAAAA">License GPLv3: GNU GPL version 3 &lt;http://gnu.org/licenses/gpl.html&gt;</font>

<font color="#AAAAAA">This is free software, and you are free to change and redistribute it</font>
<font color="#AAAAAA">under certain conditions; type `show_copying&apos; for details. </font>
<font color="#AAAAAA">This program comes with ABSOLUTELY NO WARRANTY; for details type `show_warranty&apos;.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 50, module AND2X1 not found.  Creating black box for AND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 53, module AND2X2 not found.  Creating black box for AND2X2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 56, module AOI21X1 not found.  Creating black box for AOI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 60, module AOI22X1 not found.  Creating black box for AOI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 65, module BUFX2 not found.  Creating black box for BUFX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 67, module HAX1 not found.  Creating black box for HAX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 71, module INV not found.  Creating black box for INV.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 73, module INVX1 not found.  Creating black box for INVX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 75, module INVX2 not found.  Creating black box for INVX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 77, module INVX4 not found.  Creating black box for INVX4.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 79, module INVX8 not found.  Creating black box for INVX8.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 81, module MUX2X1 not found.  Creating black box for MUX2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 85, module NAND2X1 not found.  Creating black box for NAND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 88, module NAND3X1 not found.  Creating black box for NAND3X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 92, module NOR2X1 not found.  Creating black box for NOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 95, module OAI21X1 not found.  Creating black box for OAI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 99, module OAI22X1 not found.  Creating black box for OAI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 104, module OR2X1 not found.  Creating black box for OR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 107, module XNOR2X1 not found.  Creating black box for XNOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 491, module sky130_fd_sc_ls__tapvpwrvgnd_1 not found.  Creating black box for PHY_164.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#00AAAA">[INFO]: Running Detailed Placement...</font>
<font color="#00AAAA">[INFO]: current step index: 15</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1886 components and 7444 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1485 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def</font>
<font color="#AAAAAA">Design Stats</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total instances          1886</font>
<font color="#AAAAAA">multi row instances         0</font>
<font color="#AAAAAA">fixed instances          1046</font>
<font color="#AAAAAA">nets                     1216</font>
<font color="#AAAAAA">design area           78772.3 u^2</font>
<font color="#AAAAAA">fixed area             2458.3 u^2</font>
<font color="#AAAAAA">movable area           5324.3 u^2</font>
<font color="#AAAAAA">utilization                 7 %</font>
<font color="#AAAAAA">utilization padded         14 %</font>
<font color="#AAAAAA">rows                       82</font>
<font color="#AAAAAA">row height                3.3 u</font>

<font color="#AAAAAA">Placement Analysis</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total displacement        0.0 u</font>
<font color="#AAAAAA">average displacement      0.0 u</font>
<font color="#AAAAAA">max displacement          0.0 u</font>
<font color="#AAAAAA">original HPWL         77031.1 u</font>
<font color="#AAAAAA">legalized HPWL        77226.1 u</font>
<font color="#AAAAAA">delta HPWL                  0 %</font>

<font color="#AAAAAA">[INFO DPL-0020] Mirrored 285 instances</font>
<font color="#AAAAAA">[INFO DPL-0021] HPWL before           77226.1 u</font>
<font color="#AAAAAA">[INFO DPL-0022] HPWL after            77031.1 u</font>
<font color="#AAAAAA">[INFO DPL-0023] HPWL delta               -0.3 %</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/12-resizer.def to /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def to /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 16</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: current step index: 17</font>
<font color="#00AAAA">[INFO]: Running Resizer Timing Optimizations...</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/tmp/resizer.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1886 components and 7444 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1485 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">[WARNING STA-0357] virtual clock  can not be propagated.</font>
<font color="#AAAAAA">[INFO RSZ-0033] No hold violations found.</font>
<font color="#AAAAAA">Design Stats</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total instances          1886</font>
<font color="#AAAAAA">multi row instances         0</font>
<font color="#AAAAAA">fixed instances          1046</font>
<font color="#AAAAAA">nets                     1216</font>
<font color="#AAAAAA">design area           78772.3 u^2</font>
<font color="#AAAAAA">fixed area             2458.3 u^2</font>
<font color="#AAAAAA">movable area           5324.3 u^2</font>
<font color="#AAAAAA">utilization                 7 %</font>
<font color="#AAAAAA">utilization padded         15 %</font>
<font color="#AAAAAA">rows                       82</font>
<font color="#AAAAAA">row height                3.3 u</font>

<font color="#AAAAAA">Placement Analysis</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total displacement        0.0 u</font>
<font color="#AAAAAA">average displacement      0.0 u</font>
<font color="#AAAAAA">max displacement          0.0 u</font>
<font color="#AAAAAA">original HPWL         77031.1 u</font>
<font color="#AAAAAA">legalized HPWL        77226.1 u</font>
<font color="#AAAAAA">delta HPWL                  0 %</font>

<font color="#AAAAAA">[INFO DPL-0020] Mirrored 285 instances</font>
<font color="#AAAAAA">[INFO DPL-0021] HPWL before           77226.1 u</font>
<font color="#AAAAAA">[INFO DPL-0022] HPWL after            77031.1 u</font>
<font color="#AAAAAA">[INFO DPL-0023] HPWL delta               -0.3 %</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/results/placement/user_proj_example.placement.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def</font>
<font color="#00AAAA">[INFO]: Writing Verilog...</font>
<font color="#00AAAA">[INFO]: current step index: 18</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1886 components and 7444 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1485 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def</font>
<font color="#00AAAA">[INFO]: Changing netlist from /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v</font>
<font color="#00AAAA">[INFO]: Running Static Timing Analysis...</font>
<font color="#00AAAA">[INFO]: current step index: 19</font>
<font color="#AAAAAA">OpenSTA 2.3.0 38b40303a8 Copyright (c) 2019, Parallax Software, Inc.</font>
<font color="#AAAAAA">License GPLv3: GNU GPL version 3 &lt;http://gnu.org/licenses/gpl.html&gt;</font>

<font color="#AAAAAA">This is free software, and you are free to change and redistribute it</font>
<font color="#AAAAAA">under certain conditions; type `show_copying&apos; for details. </font>
<font color="#AAAAAA">This program comes with ABSOLUTELY NO WARRANTY; for details type `show_warranty&apos;.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 50, module AND2X1 not found.  Creating black box for AND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 53, module AND2X2 not found.  Creating black box for AND2X2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 56, module AOI21X1 not found.  Creating black box for AOI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 60, module AOI22X1 not found.  Creating black box for AOI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 65, module BUFX2 not found.  Creating black box for BUFX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 67, module HAX1 not found.  Creating black box for HAX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 71, module INV not found.  Creating black box for INV.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 73, module INVX1 not found.  Creating black box for INVX1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 75, module INVX2 not found.  Creating black box for INVX2.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 77, module INVX4 not found.  Creating black box for INVX4.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 79, module INVX8 not found.  Creating black box for INVX8.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 81, module MUX2X1 not found.  Creating black box for MUX2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 85, module NAND2X1 not found.  Creating black box for NAND2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 88, module NAND3X1 not found.  Creating black box for NAND3X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 92, module NOR2X1 not found.  Creating black box for NOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 95, module OAI21X1 not found.  Creating black box for OAI21X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 99, module OAI22X1 not found.  Creating black box for OAI22X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 104, module OR2X1 not found.  Creating black box for OR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 107, module XNOR2X1 not found.  Creating black box for XNOR2X1.</font>
<font color="#AAAAAA">Warning: /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v line 491, module sky130_fd_sc_ls__tapvpwrvgnd_1 not found.  Creating black box for PHY_164.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#00AAAA">[INFO]: Routing...</font>
<font color="#00AAAA">[INFO]: Running Global Routing...</font>
<font color="#00AAAA">[INFO]: current step index: 20</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__tt_025C_1v80.lib line 32, default_operating_condition tt_025C_1v80 not found.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 1886 components and 7444 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1485 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def</font>
<font color="#AAAAAA">Min routing layer: 2</font>
<font color="#AAAAAA">Max routing layer: 6</font>
<font color="#AAAAAA">Global adjustment: 0.0</font>
<font color="#AAAAAA">Unidirectional routing: true</font>
<font color="#AAAAAA">Grid origin: (0, 0)</font>
<font color="#AAAAAA">[INFO GRT-0004] #DB Obstructions: 0</font>
<font color="#AAAAAA">[INFO GRT-0005] #DB Obstacles: 21579</font>
<font color="#AAAAAA">[INFO GRT-0006] #DB Macros: 0</font>
<font color="#AAAAAA">[INFO GRT-0017] Found 0 clock nets</font>
<font color="#AAAAAA">[INFO GRT-0001] Minimum degree: 2</font>
<font color="#AAAAAA">[INFO GRT-0002] Maximum degree: 2</font>
<font color="#AAAAAA">[INFO GRT-0018] Processing 15608 obstacles on layer 1</font>
<font color="#AAAAAA">[INFO GRT-0019] Processing 4121 obstacles on layer 2</font>
<font color="#AAAAAA">[INFO GRT-0022] Processing 16 obstacles on layer 5</font>
<font color="#AAAAAA">[INFO GRT-0020] Reducing resources of layer 1 by 99%</font>
<font color="#AAAAAA">[INFO] WIRELEN : 9502, WIRELEN1 : 0</font>
<font color="#AAAAAA">[INFO] NumSeg  : 835</font>
<font color="#AAAAAA">[INFO] NumShift: 0</font>
<font color="#AAAAAA">First L Route</font>
<font color="#AAAAAA">[INFO] WIRELEN : 9502, WIRELEN1 : 9502</font>
<font color="#AAAAAA">[INFO] NumSeg  : 835</font>
<font color="#AAAAAA">[INFO] NumShift: 0</font>
<font color="#AAAAAA">[Overflow Report] Total hCap    : 46135</font>
<font color="#AAAAAA">[Overflow Report] Total vCap    : 36068</font>
<font color="#AAAAAA">[Overflow Report] Total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">Second L Route</font>
<font color="#AAAAAA">[Overflow Report] Total hCap    : 46135</font>
<font color="#AAAAAA">[Overflow Report] Total vCap    : 36068</font>
<font color="#AAAAAA">[Overflow Report] Total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">First Z Route</font>
<font color="#AAAAAA">[Overflow Report] Total hCap    : 46135</font>
<font color="#AAAAAA">[Overflow Report] Total vCap    : 36068</font>
<font color="#AAAAAA">[Overflow Report] Total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">[INFO] LV routing round 0, enlarge 10 </font>
<font color="#AAAAAA">[INFO] 10 threshold, 10 expand</font>
<font color="#AAAAAA">[Overflow Report] total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">[INFO] LV routing round 1, enlarge 15 </font>
<font color="#AAAAAA">[INFO] 5 threshold, 15 expand</font>
<font color="#AAAAAA">[Overflow Report] total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">[INFO] LV routing round 2, enlarge 20 </font>
<font color="#AAAAAA">[INFO] 1 threshold, 20 expand</font>
<font color="#AAAAAA">[Overflow Report] total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">Usage checked</font>
<font color="#AAAAAA">Maze routing finished</font>
<font color="#AAAAAA">[INFO] P3 runtime: 0.000000 sec</font>
<font color="#AAAAAA">[INFO] Final 2D results: </font>
<font color="#AAAAAA">[Overflow Report] total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Num Overflow e: 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">Layer Assignment Begins</font>
<font color="#AAAAAA">Layer assignment finished</font>
<font color="#AAAAAA">[INFO] 2D + Layer Assignment Runtime: 0.010000 sec</font>
<font color="#AAAAAA">Post Processing Begins </font>
<font color="#AAAAAA">Post Processsing finished</font>
<font color="#AAAAAA"> Starting via filling</font>
<font color="#AAAAAA">[INFO] Via related to pin nodes 2661</font>
<font color="#AAAAAA">[INFO] Via related stiner nodes 0</font>
<font color="#AAAAAA">Via filling finished</font>

<font color="#AAAAAA">Final usage/overflow report: </font>
<font color="#AAAAAA">[INFO] Usage per layer: </font>
<font color="#AAAAAA">    Layer 1 usage: 0</font>
<font color="#AAAAAA">    Layer 2 usage: 3936</font>
<font color="#AAAAAA">    Layer 3 usage: 5484</font>
<font color="#AAAAAA">    Layer 4 usage: 82</font>
<font color="#AAAAAA">    Layer 5 usage: 0</font>
<font color="#AAAAAA">    Layer 6 usage: 0</font>

<font color="#AAAAAA">[INFO] Capacity per layer: </font>
<font color="#AAAAAA">    Layer 1 capacity: 0</font>
<font color="#AAAAAA">    Layer 2 capacity: 27855</font>
<font color="#AAAAAA">    Layer 3 capacity: 24920</font>
<font color="#AAAAAA">    Layer 4 capacity: 15000</font>
<font color="#AAAAAA">    Layer 5 capacity: 11148</font>
<font color="#AAAAAA">    Layer 6 capacity: 3280</font>

<font color="#AAAAAA">[INFO] Use percentage per layer: </font>
<font color="#AAAAAA">    Layer 1 use percentage: 0.0%</font>
<font color="#AAAAAA">    Layer 2 use percentage: 14.13%</font>
<font color="#AAAAAA">    Layer 3 use percentage: 22.01%</font>
<font color="#AAAAAA">    Layer 4 use percentage: 0.55%</font>
<font color="#AAAAAA">    Layer 5 use percentage: 0.00%</font>
<font color="#AAAAAA">    Layer 6 use percentage: 0.00%</font>

<font color="#AAAAAA">[INFO] Overflow per layer: </font>
<font color="#AAAAAA">    Layer 1 overflow: 0</font>
<font color="#AAAAAA">    Layer 2 overflow: 0</font>
<font color="#AAAAAA">    Layer 3 overflow: 0</font>
<font color="#AAAAAA">    Layer 4 overflow: 0</font>
<font color="#AAAAAA">    Layer 5 overflow: 0</font>
<font color="#AAAAAA">    Layer 6 overflow: 0</font>

<font color="#AAAAAA">[Overflow Report] Total Usage   : 9502</font>
<font color="#AAAAAA">[Overflow Report] Total Capacity: 82203</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">[INFO] Final usage          : 9502</font>
<font color="#AAAAAA">[INFO] Final number of vias : 3182</font>
<font color="#AAAAAA">[INFO] Final usage 3D       : 19048</font>
<font color="#AAAAAA">[INFO GRT-0018] Total wirelength: 91144 um</font>
<font color="#AAAAAA">Repairing antennas...</font>
<font color="#AAAAAA">[WARNING GRT-0025] No OR_DEFAULT vias defined</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">Notice 0: Split top of 1 T shapes.</font>
<font color="#AAAAAA">[INFO GRT-0012] #Antenna violations: 118</font>
<font color="#AAAAAA">Design Stats</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total instances          2116</font>
<font color="#AAAAAA">multi row instances         0</font>
<font color="#AAAAAA">fixed instances          1499</font>
<font color="#AAAAAA">nets                     1216</font>
<font color="#AAAAAA">design area           78772.3 u^2</font>
<font color="#AAAAAA">fixed area             4571.4 u^2</font>
<font color="#AAAAAA">movable area           3946.4 u^2</font>
<font color="#AAAAAA">utilization                 5 %</font>
<font color="#AAAAAA">utilization padded          5 %</font>
<font color="#AAAAAA">rows                       82</font>
<font color="#AAAAAA">row height                3.3 u</font>

<font color="#AAAAAA">Placement Analysis</font>
<font color="#AAAAAA">--------------------------------</font>
<font color="#AAAAAA">total displacement        0.0 u</font>
<font color="#AAAAAA">average displacement      0.0 u</font>
<font color="#AAAAAA">max displacement          0.0 u</font>
<font color="#AAAAAA">original HPWL         77263.9 u</font>
<font color="#AAAAAA">legalized HPWL        77388.7 u</font>
<font color="#AAAAAA">delta HPWL                  0 %</font>

<font color="#AAAAAA">[WARNING DPL-0005] Overlap check failed (10).</font>
<font color="#AAAAAA">[INFO GRT-0015] 230 diodes inserted</font>
<font color="#AAAAAA">Min routing layer: 2</font>
<font color="#AAAAAA">Max routing layer: 6</font>
<font color="#AAAAAA">Global adjustment: 0.0</font>
<font color="#AAAAAA">Unidirectional routing: true</font>
<font color="#AAAAAA">Grid origin: (0, 0)</font>
<font color="#AAAAAA">[INFO GRT-0004] #DB Obstructions: 0</font>
<font color="#AAAAAA">[INFO GRT-0005] #DB Obstacles: 22959</font>
<font color="#AAAAAA">[INFO GRT-0006] #DB Macros: 0</font>
<font color="#AAAAAA">[INFO GRT-0001] Minimum degree: 2</font>
<font color="#AAAAAA">[INFO GRT-0002] Maximum degree: 5</font>
<font color="#AAAAAA">[INFO GRT-0018] Processing 16298 obstacles on layer 1</font>
<font color="#AAAAAA">[INFO GRT-0019] Processing 4581 obstacles on layer 2</font>
<font color="#AAAAAA">[INFO GRT-0022] Processing 16 obstacles on layer 5</font>
<font color="#AAAAAA">[INFO GRT-0020] Reducing resources of layer 1 by 99%</font>
<font color="#AAAAAA">[INFO GRT-0009] #Nets to reroute: 377</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 15, 16</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 16, 17</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 15, 16</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 15, 16</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 15, 16</font>
<font color="#AAAAAA">[WARNING UKN-0000] Underflow in reduce</font>
<font color="#AAAAAA">[WARNING UKN-0000] cap, reducedCap: 16, 17</font>

<font color="#AAAAAA">Final usage/overflow report: </font>

<font color="#AAAAAA">[Overflow Report] Total Usage   : 8283</font>
<font color="#AAAAAA">[Overflow Report] Total Capacity: 81180</font>
<font color="#AAAAAA">[Overflow Report] Max H Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max V Overflow: 0</font>
<font color="#AAAAAA">[Overflow Report] Max Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] H   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] V   Overflow  : 0</font>
<font color="#AAAAAA">[Overflow Report] Final Overflow: 0</font>

<font color="#AAAAAA">[INFO] Final usage          : 8283</font>
<font color="#AAAAAA">[INFO] Final number of vias : 1582</font>
<font color="#AAAAAA">[INFO] Final usage 3D       : 13029</font>
<font color="#AAAAAA">[WARNING DPL-0005] Overlap check failed (10).</font>
<font color="#AAAAAA">[INFO GRT-0014] Num routed nets: 899</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ss_100C_1v60.lib line 33, default_operating_condition ss_100C_1v60 not found.</font>
<font color="#AAAAAA">Warning: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/lib/sky130_fd_sc_ls__ff_n40C_1v95.lib line 32, default_operating_condition ff_n40C_1v95 not found.</font>
<font color="#AAAAAA">create_clock [get_ports $::env(CLOCK_PORT)]  -name $::env(CLOCK_PORT)  -period $::env(CLOCK_PERIOD)</font>
<font color="#AAAAAA">set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_PCT)]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting output delay to: $output_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting output delay to: 2.0</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting input delay to: $input_delay_value&quot;</font>
<font color="#AAAAAA">[INFO]: Setting input delay to: 2.0</font>
<font color="#AAAAAA">set_max_fanout $::env(SYNTH_MAX_FANOUT) [current_design]</font>
<font color="#AAAAAA">set clk_indx [lsearch [all_inputs] [get_port $::env(CLOCK_PORT)]]</font>
<font color="#AAAAAA">#set rst_indx [lsearch [all_inputs] [get_port resetn]]</font>
<font color="#AAAAAA">set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx]</font>
<font color="#AAAAAA">#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx]</font>
<font color="#AAAAAA">set all_inputs_wo_clk_rst $all_inputs_wo_clk</font>
<font color="#AAAAAA"># correct resetn</font>
<font color="#AAAAAA">set_input_delay $input_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] $all_inputs_wo_clk_rst</font>
<font color="#AAAAAA">#set_input_delay 0.0 -clock [get_clocks $::env(CLOCK_PORT)] {resetn}</font>
<font color="#AAAAAA">set_output_delay $output_delay_value  -clock [get_clocks $::env(CLOCK_PORT)] [all_outputs]</font>
<font color="#AAAAAA"># TODO set this as parameter</font>
<font color="#AAAAAA">set_driving_cell -lib_cell $::env(SYNTH_DRIVING_CELL) -pin $::env(SYNTH_DRIVING_CELL_PIN) [all_inputs]</font>
<font color="#AAAAAA">set cap_load [expr $::env(SYNTH_CAP_LOAD) / 1000.0]</font>
<font color="#AAAAAA">puts &quot;\[INFO\]: Setting load to: $cap_load&quot;</font>
<font color="#AAAAAA">[INFO]: Setting load to: 0.02205</font>
<font color="#AAAAAA">set_load  $cap_load [all_outputs]</font>
<font color="#AAAAAA">No paths found.</font>
<font color="#AAAAAA">No paths found.</font>
<font color="#AAAAAA">No paths found.</font>
<font color="#AAAAAA">wns 0.00</font>
<font color="#AAAAAA">tns 0.00</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/placement/17-resizer_timing.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def</font>
<font color="#00AAAA">[INFO]: Changing layout from 0 to /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.guide</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.guide to /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.guide</font>
<font color="#00AAAA">[INFO]: Current Def is /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def</font>
<font color="#00AAAA">[INFO]: Current Guide is /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.guide</font>
<font color="#00AAAA">[INFO]: Running Fill Insertion...</font>
<font color="#00AAAA">[INFO]: current step index: 21</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 2116 components and 8594 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1715 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def</font>
<font color="#AAAAAA">[INFO DPL-0001] Placed 7217 filler instances.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/20-fastroute.def to /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/21-addspacers.def</font>
<font color="#00AAAA">[INFO]: Writing Verilog...</font>
<font color="#00AAAA">[INFO]: current step index: 22</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/21-addspacers.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 9333 components and 37462 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1715 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/21-addspacers.def</font>
<font color="#00AAAA">[INFO]: Changing netlist from /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_optimized.v to /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_preroute.v</font>
<font color="#00AAAA">[INFO]: Running Detailed Routing...</font>
<font color="#00AAAA">[INFO]: current step index: 23</font>

<font color="#AAAAAA">reading lef ...</font>

<font color="#AAAAAA">units:       1000</font>
<font color="#AAAAAA">#layers:     13</font>
<font color="#AAAAAA">#macros:     418</font>
<font color="#AAAAAA">#vias:       25</font>
<font color="#AAAAAA">#viarulegen: 25</font>

<font color="#AAAAAA">reading def ...</font>

<font color="#AAAAAA">design:      user_proj_example</font>
<font color="#AAAAAA">die area:    ( 0 0 ) ( 300000 300000 )</font>
<font color="#AAAAAA">trackPts:    12</font>
<font color="#AAAAAA">defvias:     3</font>
<font color="#AAAAAA">#components: 9333</font>
<font color="#AAAAAA">#terminals:  620</font>
<font color="#AAAAAA">#snets:      8</font>
<font color="#AAAAAA">#nets:       1208</font>

<font color="#AAAAAA">reading guide ...</font>

<font color="#AAAAAA">#guides:     4636</font>
<font color="#AAAAAA">Warning: met2 does not have viaDef align with layer direction, generating new viaDef via2_FR...</font>
<font color="#AAAAAA">Warning: met4 does not have viaDef align with layer direction, generating new viaDef via4_FR...</font>
<font color="#AAAAAA">done initConstraintLayerIdx</font>
<font color="#AAAAAA">List of default vias:</font>
<font color="#AAAAAA">  Layer mcon</font>
<font color="#AAAAAA">    default via: L1M1_PR_MR</font>
<font color="#AAAAAA">  Layer via</font>
<font color="#AAAAAA">    default via: M1M2_PR</font>
<font color="#AAAAAA">  Layer via2</font>
<font color="#AAAAAA">    default via: via2_FR</font>
<font color="#AAAAAA">  Layer via3</font>
<font color="#AAAAAA">    default via: M3M4_PR_M</font>
<font color="#AAAAAA">  Layer via4</font>
<font color="#AAAAAA">    default via: via4_FR</font>
<font color="#AAAAAA">Writing reference output def...</font>

<font color="#AAAAAA">libcell analysis ...</font>

<font color="#AAAAAA">instance analysis ...</font>
<font color="#AAAAAA">#unique instances = 50</font>

<font color="#AAAAAA">init region query ...</font>
<font color="#AAAAAA">  complete FR_MASTERSLICE</font>
<font color="#AAAAAA">  complete FR_VIA</font>
<font color="#AAAAAA">  complete li1</font>
<font color="#AAAAAA">  complete mcon</font>
<font color="#AAAAAA">  complete met1</font>
<font color="#AAAAAA">  complete via</font>
<font color="#AAAAAA">  complete met2</font>
<font color="#AAAAAA">  complete via2</font>
<font color="#AAAAAA">  complete met3</font>
<font color="#AAAAAA">  complete via3</font>
<font color="#AAAAAA">  complete met4</font>
<font color="#AAAAAA">  complete via4</font>
<font color="#AAAAAA">  complete met5</font>

<font color="#AAAAAA">FR_MASTERSLICE shape region query size = 0</font>
<font color="#AAAAAA">FR_VIA shape region query size = 0</font>
<font color="#AAAAAA">li1 shape region query size = 76934</font>
<font color="#AAAAAA">mcon shape region query size = 98078</font>
<font color="#AAAAAA">met1 shape region query size = 19181</font>
<font color="#AAAAAA">via shape region query size = 664</font>
<font color="#AAAAAA">met2 shape region query size = 936</font>
<font color="#AAAAAA">via2 shape region query size = 664</font>
<font color="#AAAAAA">met3 shape region query size = 332</font>
<font color="#AAAAAA">via3 shape region query size = 664</font>
<font color="#AAAAAA">met4 shape region query size = 198</font>
<font color="#AAAAAA">via4 shape region query size = 0</font>
<font color="#AAAAAA">met5 shape region query size = 0</font>


<font color="#AAAAAA">start pin access</font>
<font color="#AAAAAA">  complete 94 pins</font>
<font color="#AAAAAA">  complete 44 unique inst patterns</font>
<font color="#AAAAAA">  complete 837 groups</font>
<font color="#AAAAAA">Expt1 runtime (pin-level access point gen): 0.997188</font>
<font color="#AAAAAA">Expt2 runtime (design-level access pattern gen): 0.198724</font>
<font color="#AAAAAA">#scanned instances     = 9333</font>
<font color="#AAAAAA">#unique  instances     = 50</font>
<font color="#AAAAAA">#stdCellGenAp          = 614</font>
<font color="#AAAAAA">#stdCellValidPlanarAp  = 223</font>
<font color="#AAAAAA">#stdCellValidViaAp     = 457</font>
<font color="#AAAAAA">#stdCellPinNoAp        = 0</font>
<font color="#AAAAAA">#stdCellPinCnt         = 1485</font>
<font color="#AAAAAA">#instTermValidViaApCnt = 0</font>
<font color="#AAAAAA">#macroGenAp            = 0</font>
<font color="#AAAAAA">#macroValidPlanarAp    = 0</font>
<font color="#AAAAAA">#macroValidViaAp       = 0</font>
<font color="#AAAAAA">#macroNoAp             = 0</font>

<font color="#AAAAAA">complete pin access</font>
<font color="#AAAAAA">cpu time = 00:00:02, elapsed time = 00:00:01, memory = 27.97 (MB), peak = 30.04 (MB)</font>

<font color="#AAAAAA">post process guides ...</font>
<font color="#AAAAAA">GCELLGRID X 0 DO 41 STEP 7200 ;</font>
<font color="#AAAAAA">GCELLGRID Y 0 DO 41 STEP 7200 ;</font>
<font color="#AAAAAA">  complete FR_MASTERSLICE</font>
<font color="#AAAAAA">  complete FR_VIA</font>
<font color="#AAAAAA">  complete li1</font>
<font color="#AAAAAA">  complete mcon</font>
<font color="#AAAAAA">  complete met1</font>
<font color="#AAAAAA">  complete via</font>
<font color="#AAAAAA">  complete met2</font>
<font color="#AAAAAA">  complete via2</font>
<font color="#AAAAAA">  complete met3</font>
<font color="#AAAAAA">  complete via3</font>
<font color="#AAAAAA">  complete met4</font>
<font color="#AAAAAA">  complete via4</font>
<font color="#AAAAAA">  complete met5</font>

<font color="#AAAAAA">building cmap ... </font>

<font color="#AAAAAA">init guide query ...</font>
<font color="#AAAAAA">  complete FR_MASTERSLICE (guide)</font>
<font color="#AAAAAA">  complete FR_VIA (guide)</font>
<font color="#AAAAAA">  complete li1 (guide)</font>
<font color="#AAAAAA">  complete mcon (guide)</font>
<font color="#AAAAAA">  complete met1 (guide)</font>
<font color="#AAAAAA">  complete via (guide)</font>
<font color="#AAAAAA">  complete met2 (guide)</font>
<font color="#AAAAAA">  complete via2 (guide)</font>
<font color="#AAAAAA">  complete met3 (guide)</font>
<font color="#AAAAAA">  complete via3 (guide)</font>
<font color="#AAAAAA">  complete met4 (guide)</font>
<font color="#AAAAAA">  complete via4 (guide)</font>
<font color="#AAAAAA">  complete met5 (guide)</font>

<font color="#AAAAAA">FR_MASTERSLICE guide region query size = 0</font>
<font color="#AAAAAA">FR_VIA guide region query size = 0</font>
<font color="#AAAAAA">li1 guide region query size = 1146</font>
<font color="#AAAAAA">mcon guide region query size = 0</font>
<font color="#AAAAAA">met1 guide region query size = 1366</font>
<font color="#AAAAAA">via guide region query size = 0</font>
<font color="#AAAAAA">met2 guide region query size = 1339</font>
<font color="#AAAAAA">via2 guide region query size = 0</font>
<font color="#AAAAAA">met3 guide region query size = 0</font>
<font color="#AAAAAA">via3 guide region query size = 0</font>
<font color="#AAAAAA">met4 guide region query size = 0</font>
<font color="#AAAAAA">via4 guide region query size = 0</font>
<font color="#AAAAAA">met5 guide region query size = 0</font>

<font color="#AAAAAA">init gr pin query ...</font>


<font color="#AAAAAA">start track assignment</font>
<font color="#AAAAAA">Done with 2485 vertical wires in 1 frboxes and 1366 horizontal wires in 1 frboxes.</font>
<font color="#AAAAAA">Done with 578 vertical wires in 1 frboxes and 217 horizontal wires in 1 frboxes.</font>

<font color="#AAAAAA">complete track assignment</font>
<font color="#AAAAAA">cpu time = 00:00:01, elapsed time = 00:00:01, memory = 40.30 (MB), peak = 51.48 (MB)</font>

<font color="#AAAAAA">post processing ...</font>

<font color="#AAAAAA">start routing data preparation</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc li1 (d2d, d2u, u2d, u2u) = (0, 0, 0, 370)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc met1 (d2d, d2u, u2d, u2u) = (430, 445, 445, 460)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc met2 (d2d, d2u, u2d, u2u) = (460, 485, 485, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc met3 (d2d, d2u, u2d, u2u) = (630, 655, 655, 680)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc met4 (d2d, d2u, u2d, u2u) = (630, 1055, 1055, 3020)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minSpc met5 (d2d, d2u, u2d, u2u) = (1480, 0, 0, 0)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut li1 (d2d, d2u, u2d, u2u) = (0, 0, 0, 370)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut li1 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met1 (d2d, d2u, u2d, u2u) = (430, 445, 445, 460)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met1 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met2 (d2d, d2u, u2d, u2u) = (460, 485, 485, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met2 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met3 (d2d, d2u, u2d, u2u) = (630, 655, 655, 680)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met3 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met4 (d2d, d2u, u2d, u2u) = (630, 1055, 1055, 3020)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met4 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met5 (d2d, d2u, u2d, u2u) = (1480, 0, 0, 0)</font>
<font color="#AAAAAA">initVia2ViaMinLen_minimumcut met5 zerolen (b, b, b, b) = (1, 1, 1, 1)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc li1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (0, 0, 0, 0, 0, 0, 430, 370)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc met1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (430, 370, 445, 385, 445, 385, 460, 460)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc met2 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (460, 460, 410, 485, 410, 485, 630, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc met3 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (630, 630, 655, 625, 655, 625, 680, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc met4 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (680, 630, 1055, 1055, 1055, 1055, 3020, 3020)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minSpc met5 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (1480, 1480, 0, 0, 0, 0, 0, 0)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut li1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (0, 0, 0, 0, 0, 0, 430, 370)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut met1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (430, 370, 445, 385, 445, 385, 460, 460)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut met2 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (460, 460, 410, 485, 410, 485, 630, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut met3 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (630, 630, 655, 625, 655, 625, 680, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut met4 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (680, 630, 1055, 1055, 1055, 1055, 3020, 3020)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_minimumcut met5 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (1480, 1480, 0, 0, 0, 0, 0, 0)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc li1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (0, 0, 0, 0, 0, 0, 430, 370)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc met1 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (430, 370, 445, 385, 445, 385, 460, 460)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc met2 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (460, 460, 410, 485, 410, 485, 630, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc met3 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (630, 630, 655, 625, 655, 625, 680, 630)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc met4 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (680, 630, 1055, 1055, 1055, 1055, 3020, 3020)</font>
<font color="#AAAAAA">initVia2ViaMinLenNew_cutSpc met5 (d2d-x, d2d-y, d2u-x, d2u-y, u2d-x, u2d-y, u2u-x, u2u-y) = (1600, 1600, 0, 0, 0, 0, 0, 0)</font>
<font color="#AAAAAA">cpu time = 00:00:00, elapsed time = 00:00:00, memory = 41.36 (MB), peak = 51.48 (MB)</font>

<font color="#AAAAAA">start detail routing ...</font>
<font color="#AAAAAA">start 0th optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 84.03 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 88.41 (MB)</font>
<font color="#AAAAAA">    completing 30% with 18 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 82.33 (MB)</font>
<font color="#AAAAAA">    completing 40% with 18 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 84.70 (MB)</font>
<font color="#AAAAAA">    completing 50% with 18 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 84.79 (MB)</font>
<font color="#AAAAAA">    completing 60% with 34 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 89.45 (MB)</font>
<font color="#AAAAAA">    completing 70% with 34 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:06, memory = 94.39 (MB)</font>
<font color="#AAAAAA">    completing 80% with 44 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:07, memory = 89.90 (MB)</font>
<font color="#AAAAAA">    completing 90% with 44 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:07, memory = 90.10 (MB)</font>
<font color="#AAAAAA">    completing 100% with 51 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:08, memory = 50.19 (MB)</font>
<font color="#AAAAAA">  number of violations = 51</font>
<font color="#AAAAAA">cpu time = 00:00:15, elapsed time = 00:00:09, memory = 45.69 (MB), peak = 396.17 (MB)</font>
<font color="#AAAAAA">total wire length = 76522 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 12 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29388 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47113 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 8 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3054</font>
<font color="#AAAAAA">up-via summary (total 3054):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1356</font>
<font color="#AAAAAA">           met1    1694</font>
<font color="#AAAAAA">           met2       4</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3054</font>


<font color="#AAAAAA">start 1st optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 51 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 79.20 (MB)</font>
<font color="#AAAAAA">    completing 20% with 51 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 84.04 (MB)</font>
<font color="#AAAAAA">    completing 30% with 51 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 86.52 (MB)</font>
<font color="#AAAAAA">    completing 40% with 44 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 92.69 (MB)</font>
<font color="#AAAAAA">    completing 50% with 44 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 94.24 (MB)</font>
<font color="#AAAAAA">    completing 60% with 33 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 83.54 (MB)</font>
<font color="#AAAAAA">    completing 70% with 33 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 86.33 (MB)</font>
<font color="#AAAAAA">    completing 80% with 33 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:06, memory = 87.71 (MB)</font>
<font color="#AAAAAA">    completing 90% with 31 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:07, memory = 91.53 (MB)</font>
<font color="#AAAAAA">    completing 100% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:08, memory = 48.92 (MB)</font>
<font color="#AAAAAA">  number of violations = 13</font>
<font color="#AAAAAA">cpu time = 00:00:15, elapsed time = 00:00:09, memory = 45.70 (MB), peak = 396.19 (MB)</font>
<font color="#AAAAAA">total wire length = 76497 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 21 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29371 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47091 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 12 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3067</font>
<font color="#AAAAAA">up-via summary (total 3067):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1362</font>
<font color="#AAAAAA">           met1    1699</font>
<font color="#AAAAAA">           met2       6</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3067</font>


<font color="#AAAAAA">start 2nd optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 51.88 (MB)</font>
<font color="#AAAAAA">    completing 20% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 69.16 (MB)</font>
<font color="#AAAAAA">    completing 30% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 73.46 (MB)</font>
<font color="#AAAAAA">    completing 40% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 79.39 (MB)</font>
<font color="#AAAAAA">    completing 50% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 88.82 (MB)</font>
<font color="#AAAAAA">    completing 60% with 15 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 71.30 (MB)</font>
<font color="#AAAAAA">    completing 70% with 15 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 84.84 (MB)</font>
<font color="#AAAAAA">    completing 80% with 15 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 88.61 (MB)</font>
<font color="#AAAAAA">    completing 90% with 14 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 80.60 (MB)</font>
<font color="#AAAAAA">    completing 100% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 70.74 (MB)</font>
<font color="#AAAAAA">  number of violations = 13</font>
<font color="#AAAAAA">cpu time = 00:00:10, elapsed time = 00:00:06, memory = 64.61 (MB), peak = 414.14 (MB)</font>
<font color="#AAAAAA">total wire length = 76498 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 30 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29378 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47081 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 8 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3054</font>
<font color="#AAAAAA">up-via summary (total 3054):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1374</font>
<font color="#AAAAAA">           met1    1676</font>
<font color="#AAAAAA">           met2       4</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3054</font>


<font color="#AAAAAA">start 3rd optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 77.75 (MB)</font>
<font color="#AAAAAA">    completing 20% with 13 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 86.07 (MB)</font>
<font color="#AAAAAA">    completing 30% with 8 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 76.51 (MB)</font>
<font color="#AAAAAA">    completing 40% with 8 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 84.50 (MB)</font>
<font color="#AAAAAA">    completing 50% with 8 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 84.50 (MB)</font>
<font color="#AAAAAA">    completing 60% with 4 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 86.14 (MB)</font>
<font color="#AAAAAA">    completing 70% with 4 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 86.37 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 79.62 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 79.62 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 79.84 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:06, elapsed time = 00:00:06, memory = 80.32 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 17th optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 80.32 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 80.32 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 80.32 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 80.57 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 80.83 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 80.91 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:04, elapsed time = 00:00:05, memory = 80.91 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 25th optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 80.91 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 80.96 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 80.96 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 80.96 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 80.96 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:04, elapsed time = 00:00:05, memory = 81.07 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 33rd optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:05, elapsed time = 00:00:05, memory = 81.07 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 41st optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:06, memory = 81.07 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:05, elapsed time = 00:00:06, memory = 81.07 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 49th optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:05, elapsed time = 00:00:05, memory = 81.07 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">start 57th optimization iteration ...</font>
<font color="#AAAAAA">    completing 10% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 20% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:00, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 30% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:01, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 40% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 50% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:02, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 60% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 70% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:03, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 80% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:04, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 90% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">    completing 100% with 0 violations</font>
<font color="#AAAAAA">    elapsed time = 00:00:05, memory = 81.07 (MB)</font>
<font color="#AAAAAA">  number of violations = 0</font>
<font color="#AAAAAA">cpu time = 00:00:05, elapsed time = 00:00:05, memory = 81.07 (MB), peak = 422.46 (MB)</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>


<font color="#AAAAAA">complete detail routing</font>
<font color="#AAAAAA">total wire length = 76500 um</font>
<font color="#AAAAAA">total wire length on LAYER li1 = 29 um</font>
<font color="#AAAAAA">total wire length on LAYER met1 = 29376 um</font>
<font color="#AAAAAA">total wire length on LAYER met2 = 47080 um</font>
<font color="#AAAAAA">total wire length on LAYER met3 = 13 um</font>
<font color="#AAAAAA">total wire length on LAYER met4 = 0 um</font>
<font color="#AAAAAA">total wire length on LAYER met5 = 0 um</font>
<font color="#AAAAAA">total number of vias = 3058</font>
<font color="#AAAAAA">up-via summary (total 3058):</font>

<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA"> FR_MASTERSLICE       0</font>
<font color="#AAAAAA">            li1    1372</font>
<font color="#AAAAAA">           met1    1678</font>
<font color="#AAAAAA">           met2       8</font>
<font color="#AAAAAA">           met3       0</font>
<font color="#AAAAAA">           met4       0</font>
<font color="#AAAAAA">-----------------------</font>
<font color="#AAAAAA">                   3058</font>

<font color="#AAAAAA">cpu time = 00:01:20, elapsed time = 00:01:06, memory = 81.07 (MB), peak = 422.46 (MB)</font>

<font color="#AAAAAA">post processing ...</font>

<font color="#AAAAAA">Runtime taken (hrt): 72.2057</font>
<font color="#00AAAA">[INFO]: No DRC violations after detailed routing.</font>
<font color="#00AAAA">[INFO]: Changing layout from /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/21-addspacers.def to /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 24</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Routing completed for user_proj_example/13-06_18-43 in 0h6m36s</font>
<font color="#00AAAA">[INFO]: Writing Powered Verilog...</font>
<font color="#00AAAA">[INFO]: current step index: 25</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 620 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 9333 components and 37462 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1715 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">Top-level design name: user_proj_example</font>
<font color="#AAAAAA">Default power net:  vccd1</font>
<font color="#AAAAAA">Default ground net: vssd1</font>
<font color="#AAAAAA">Found a total of 4 power ports.</font>
<font color="#AAAAAA">Found a total of 4 ground ports.</font>
<font color="#AAAAAA">Modified power connections of 9333 cells (Remaining: 0 ).</font>
<font color="#00AAAA">[INFO]: Writing Verilog...</font>
<font color="#00AAAA">[INFO]: current step index: 26</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/25-user_proj_example.powered.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 612 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 9333 components and 37462 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1210 nets and 37245 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/tmp/routing/25-user_proj_example.powered.def</font>
<font color="#00AAAA">[INFO]: Yosys won&apos;t attempt to rewrite verilog, and the OpenROAD output will be used as is.</font>
<font color="#00AAAA">[INFO]: Changing netlist from /project/openlane/user_proj_example/runs/user_proj_example/results/synthesis/user_proj_example.synthesis_preroute.v to /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.powered.v</font>
<font color="#00AAAA">[INFO]: Running Magic to generate various views...</font>
<font color="#00AAAA">[INFO]: Streaming out GDS II...</font>
<font color="#00AAAA">[INFO]: current step index: 27</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/openLANE_flow/scripts/magic/mag_gds.tcl&quot; from command line.</font>
<font color="#AAAAAA">Reading LEF data from file /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read, Line 64 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 77 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 98 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 99 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 111 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 137 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 138 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 155 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 174 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 191 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 209 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 227 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 246 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 263 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read: Processed 769 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 65 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 62 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading DEF data from file /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">  Processed 5 vias total.</font>
<font color="#AAAAAA">  Processed 9333 subcell instances total.</font>
<font color="#AAAAAA">  Processed 620 pins total.</font>
<font color="#AAAAAA">  Processed 8 special nets total.</font>
<font color="#AAAAAA">  Processed 1208 nets total.</font>
<font color="#AAAAAA">DEF read: Processed 21075 lines.</font>
<font color="#AAAAAA">Root cell box:</font>
<font color="#AAAAAA">           width x height  (   llx,  lly  ), (   urx,  ury  )  area (units^2)</font>

<font color="#AAAAAA">microns:  300.00 x 300.00  (  0.00,  0.00 ), ( 300.00,  300.00)  90000.00  </font>
<font color="#AAAAAA">lambda:   30000.00 x 30000.00  (  0.00,  0.00 ), ( 30000.00,  30000.00)  900000000.00</font>
<font color="#AAAAAA">internal:  60000 x 60000   (     0,  0    ), ( 60000,  60000)  3600000000</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;HAX1&quot;.</font>
<font color="#AAAAAA">Warning:  cell HAX1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;INVX8&quot;.</font>
<font color="#AAAAAA">Warning:  cell INVX8 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;AND2X2&quot;.</font>
<font color="#AAAAAA">Warning:  cell AND2X2 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;XNOR2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell XNOR2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;OAI22X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell OAI22X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;AOI21X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell AOI21X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;NAND2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell NAND2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;OAI21X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell OAI21X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;INV&quot;.</font>
<font color="#AAAAAA">Warning:  cell INV already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;AOI22X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell AOI22X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;OR2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell OR2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;INVX1&quot;.</font>
<font color="#AAAAAA">Warning:  cell INVX1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;NOR2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell NOR2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;MUX2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell MUX2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;BUFX2&quot;.</font>
<font color="#AAAAAA">Warning:  cell BUFX2 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;AND2X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell AND2X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;NAND3X1&quot;.</font>
<font color="#AAAAAA">Warning:  cell NAND3X1 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;INVX2&quot;.</font>
<font color="#AAAAAA">Warning:  cell INVX2 already existed before reading GDS!</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 6.0</font>
<font color="#AAAAAA">Library name: LIB</font>
<font color="#AAAAAA">Reading &quot;INVX4&quot;.</font>
<font color="#AAAAAA">Warning:  cell INVX4 already existed before reading GDS!</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__decap_4</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__clkbuf_1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__decap_8</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__tapvpwrvgnd_1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__fill_diode_2</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__fill_1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__buf_2</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__clkbuf_2</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__buf_1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__conb_1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__diode_2</font>
<font color="#AAAAAA">   Generating output for cell OAI21X1</font>
<font color="#AAAAAA">   Generating output for cell INVX8</font>
<font color="#AAAAAA">   Generating output for cell INVX2</font>
<font color="#AAAAAA">   Generating output for cell INVX4</font>
<font color="#AAAAAA">   Generating output for cell INV</font>
<font color="#AAAAAA">   Generating output for cell AOI22X1</font>
<font color="#AAAAAA">   Generating output for cell INVX1</font>
<font color="#AAAAAA">   Generating output for cell OAI22X1</font>
<font color="#AAAAAA">   Generating output for cell MUX2X1</font>
<font color="#AAAAAA">   Generating output for cell AOI21X1</font>
<font color="#AAAAAA">   Generating output for cell OR2X1</font>
<font color="#AAAAAA">   Generating output for cell NAND3X1</font>
<font color="#AAAAAA">   Generating output for cell AND2X2</font>
<font color="#AAAAAA">   Generating output for cell AND2X1</font>
<font color="#AAAAAA">   Generating output for cell BUFX2</font>
<font color="#AAAAAA">   Generating output for cell NAND2X1</font>
<font color="#AAAAAA">   Generating output for cell NOR2X1</font>
<font color="#AAAAAA">   Generating output for cell XNOR2X1</font>
<font color="#AAAAAA">   Generating output for cell HAX1</font>
<font color="#AAAAAA">   Generating output for cell sky130_fd_sc_ls__clkbuf_4</font>
<font color="#AAAAAA">   Generating output for cell user_proj_example</font>
<font color="#AAAAAA">[INFO]: GDS Write Complete</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 28</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: current step index: 29</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/openLANE_flow/scripts/magic/gds_pointers.tcl&quot; from command line.</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 3.0</font>
<font color="#AAAAAA">Library name: user_proj_example</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__decap_4&quot;.</font>
<font color="#AAAAAA">CIF file read warning: CIF style sky130(): units rescaled by factor of 5 / 1</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__decap_8&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__tapvpwrvgnd_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__fill_diode_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__fill_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__buf_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__buf_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__conb_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__diode_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;OAI21X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX8&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX2&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX4&quot;.</font>
<font color="#AAAAAA">Reading &quot;INV&quot;.</font>
<font color="#AAAAAA">Reading &quot;AOI22X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX1&quot;.</font>
<font color="#AAAAAA">Reading &quot;OAI22X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;MUX2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;AOI21X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;OR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;NAND3X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;AND2X2&quot;.</font>
<font color="#AAAAAA">Reading &quot;AND2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;BUFX2&quot;.</font>
<font color="#AAAAAA">Reading &quot;NAND2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;NOR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;XNOR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;HAX1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_4&quot;.</font>
<font color="#AAAAAA">Reading &quot;user_proj_example&quot;.</font>
<font color="#AAAAAA">    100 uses</font>
<font color="#AAAAAA">    200 uses</font>
<font color="#AAAAAA">    300 uses</font>
<font color="#AAAAAA">    400 uses</font>
<font color="#AAAAAA">    500 uses</font>
<font color="#AAAAAA">    600 uses</font>
<font color="#AAAAAA">    700 uses</font>
<font color="#AAAAAA">    800 uses</font>
<font color="#AAAAAA">    900 uses</font>
<font color="#AAAAAA">    1000 uses</font>
<font color="#AAAAAA">    1100 uses</font>
<font color="#AAAAAA">    1200 uses</font>
<font color="#AAAAAA">    1300 uses</font>
<font color="#AAAAAA">    1400 uses</font>
<font color="#AAAAAA">    1500 uses</font>
<font color="#AAAAAA">    1600 uses</font>
<font color="#AAAAAA">    1700 uses</font>
<font color="#AAAAAA">    1800 uses</font>
<font color="#AAAAAA">    1900 uses</font>
<font color="#AAAAAA">    2000 uses</font>
<font color="#AAAAAA">    2100 uses</font>
<font color="#AAAAAA">    2200 uses</font>
<font color="#AAAAAA">    2300 uses</font>
<font color="#AAAAAA">    2400 uses</font>
<font color="#AAAAAA">    2500 uses</font>
<font color="#AAAAAA">    2600 uses</font>
<font color="#AAAAAA">    2700 uses</font>
<font color="#AAAAAA">    2800 uses</font>
<font color="#AAAAAA">    2900 uses</font>
<font color="#AAAAAA">    3000 uses</font>
<font color="#AAAAAA">    3100 uses</font>
<font color="#AAAAAA">    3200 uses</font>
<font color="#AAAAAA">    3300 uses</font>
<font color="#AAAAAA">    3400 uses</font>
<font color="#AAAAAA">    3500 uses</font>
<font color="#AAAAAA">    3600 uses</font>
<font color="#AAAAAA">    3700 uses</font>
<font color="#AAAAAA">    3800 uses</font>
<font color="#AAAAAA">    3900 uses</font>
<font color="#AAAAAA">    4000 uses</font>
<font color="#AAAAAA">    4100 uses</font>
<font color="#AAAAAA">    4200 uses</font>
<font color="#AAAAAA">    4300 uses</font>
<font color="#AAAAAA">    4400 uses</font>
<font color="#AAAAAA">    4500 uses</font>
<font color="#AAAAAA">    4600 uses</font>
<font color="#AAAAAA">    4700 uses</font>
<font color="#AAAAAA">    4800 uses</font>
<font color="#AAAAAA">    4900 uses</font>
<font color="#AAAAAA">    5000 uses</font>
<font color="#AAAAAA">    5100 uses</font>
<font color="#AAAAAA">    5200 uses</font>
<font color="#AAAAAA">    5300 uses</font>
<font color="#AAAAAA">    5400 uses</font>
<font color="#AAAAAA">    5500 uses</font>
<font color="#AAAAAA">    5600 uses</font>
<font color="#AAAAAA">    5700 uses</font>
<font color="#AAAAAA">    5800 uses</font>
<font color="#AAAAAA">    5900 uses</font>
<font color="#AAAAAA">    6000 uses</font>
<font color="#AAAAAA">    6100 uses</font>
<font color="#AAAAAA">    6200 uses</font>
<font color="#AAAAAA">    6300 uses</font>
<font color="#AAAAAA">    6400 uses</font>
<font color="#AAAAAA">    6500 uses</font>
<font color="#AAAAAA">    6600 uses</font>
<font color="#AAAAAA">    6700 uses</font>
<font color="#AAAAAA">    6800 uses</font>
<font color="#AAAAAA">    6900 uses</font>
<font color="#AAAAAA">    7000 uses</font>
<font color="#AAAAAA">    7100 uses</font>
<font color="#AAAAAA">    7200 uses</font>
<font color="#AAAAAA">    7300 uses</font>
<font color="#AAAAAA">    7400 uses</font>
<font color="#AAAAAA">    7500 uses</font>
<font color="#AAAAAA">    7600 uses</font>
<font color="#AAAAAA">    7700 uses</font>
<font color="#AAAAAA">    7800 uses</font>
<font color="#AAAAAA">    7900 uses</font>
<font color="#AAAAAA">    8000 uses</font>
<font color="#AAAAAA">    8100 uses</font>
<font color="#AAAAAA">    8200 uses</font>
<font color="#AAAAAA">    8300 uses</font>
<font color="#AAAAAA">    8400 uses</font>
<font color="#AAAAAA">    8500 uses</font>
<font color="#AAAAAA">    8600 uses</font>
<font color="#AAAAAA">    8700 uses</font>
<font color="#AAAAAA">    8800 uses</font>
<font color="#AAAAAA">    8900 uses</font>
<font color="#AAAAAA">    9000 uses</font>
<font color="#AAAAAA">    9100 uses</font>
<font color="#AAAAAA">    9200 uses</font>
<font color="#AAAAAA">    9300 uses</font>
<font color="#AAAAAA">[INFO]: Wrote /project/openlane/user_proj_example/runs/user_proj_example/tmp/magic/magic_gds_ptrs.mag including GDS pointers.</font>
<font color="#00AAAA">[INFO]: current step index: 30</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/openLANE_flow/scripts/magic/lef.tcl&quot; from command line.</font>
<font color="#AAAAAA">Reading LEF data from file /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read, Line 64 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 77 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 98 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 99 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 111 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 137 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 138 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 155 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 174 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 191 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 209 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 227 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 246 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 263 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read: Processed 769 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 65 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 62 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">user_proj_example: 10000 rects</font>
<font color="#AAAAAA">user_proj_example: 20000 rects</font>
<font color="#AAAAAA">user_proj_example: 30000 rects</font>
<font color="#AAAAAA">Processing timestamp mismatches: HAX1, XNOR2X1, NOR2X1, NAND2X1, BUFX2, AND2X1, AND2X2, NAND3X1, OR2X1, AOI21X1, MUX2X1, OAI22X1, INVX1, AOI22X1, INV, INVX4, INVX2, INVX8, OAI21X1.</font>
<font color="#AAAAAA">[INFO]: Writing abstract LEF</font>
<font color="#AAAAAA">Generating LEF output /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.lef for cell user_proj_example:</font>
<font color="#AAAAAA">Diagnostic:  Write LEF header for cell user_proj_example</font>
<font color="#AAAAAA">Diagnostic:  Writing LEF output for cell user_proj_example</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__decap_4&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__decap_4.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__decap_4.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__decap_8&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__decap_8.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__decap_8.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__fill_1&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__fill_1.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__fill_1.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__fill_diode_2&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__fill_diode_2.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__fill_diode_2.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__clkbuf_2&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__clkbuf_2.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__clkbuf_2.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__buf_1&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__buf_1.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__buf_1.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__tapvpwrvgnd_1&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__tapvpwrvgnd_1.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__tapvpwrvgnd_1.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__clkbuf_1&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__clkbuf_1.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__clkbuf_1.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__clkbuf_4&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__clkbuf_4.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__clkbuf_4.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__buf_2&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__buf_2.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__buf_2.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__diode_2&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__diode_2.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__diode_2.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Warning:  Parent cell lists instance of &quot;sky130_fd_sc_ls__conb_1&quot; at bad file path /project/openlane/user_proj_example/runs/user_proj_example/results/magic/sky130_fd_sc_ls__conb_1.mag.</font>
<font color="#AAAAAA">The cell exists in the search paths at /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/maglef/sky130_fd_sc_ls__conb_1.mag.</font>
<font color="#AAAAAA">The discovered version will be used.</font>
<font color="#AAAAAA">Diagnostic:  Scale value is 0.005000</font>
<font color="#AAAAAA">Processing timestamp mismatches: sky130_fd_sc_ls__conb_1, sky130_fd_sc_ls__diode_2, sky130_fd_sc_ls__buf_2, sky130_fd_sc_ls__clkbuf_4, sky130_fd_sc_ls__clkbuf_1, sky130_fd_sc_ls__tapvpwrvgnd_1, sky130_fd_sc_ls__buf_1, sky130_fd_sc_ls__clkbuf_2, sky130_fd_sc_ls__fill_diode_2, sky130_fd_sc_ls__fill_1, sky130_fd_sc_ls__decap_8, sky130_fd_sc_ls__decap_4.</font>
<font color="#AAAAAA">[INFO]: LEF Write Complete</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.156-0-g7e29496</font>
<font color="#00AAAA">[INFO]: current step index: 31</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/openLANE_flow/scripts/magic/maglef.tcl&quot; from command line.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 5230 lines.</font>
<font color="#AAAAAA">[INFO]: DONE GENERATING MAGLEF VIEW</font>
<font color="#00AAAA">[INFO]: Running Klayout to re-generate GDS-II...</font>
<font color="#00AAAA">[INFO]: Streaming out GDS II...</font>
<font color="#00AAAA">[INFO]: current step index: 32</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">Design Name: user_proj_example</font>
<font color="#AAAAAA">Output GDS will be: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds</font>
<font color="#AAAAAA">Extra GDSes:</font>
<font color="#AAAAAA">/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/gds/sky130_fd_sc_ls.gds /project/openlane/user_proj_example/../../cells/gds/HAX1.gds /project/openlane/user_proj_example/../../cells/gds/INVX8.gds /project/openlane/user_proj_example/../../cells/gds/AND2X2.gds /project/openlane/user_proj_example/../../cells/gds/XNOR2X1.gds /project/openlane/user_proj_example/../../cells/gds/OAI22X1.gds /project/openlane/user_proj_example/../../cells/gds/AOI21X1.gds /project/openlane/user_proj_example/../../cells/gds/NAND2X1.gds /project/openlane/user_proj_example/../../cells/gds/OAI21X1.gds /project/openlane/user_proj_example/../../cells/gds/INV.gds /project/openlane/user_proj_example/../../cells/gds/AOI22X1.gds /project/openlane/user_proj_example/../../cells/gds/OR2X1.gds /project/openlane/user_proj_example/../../cells/gds/INVX1.gds /project/openlane/user_proj_example/../../cells/gds/NOR2X1.gds /project/openlane/user_proj_example/../../cells/gds/MUX2X1.gds /project/openlane/user_proj_example/../../cells/gds/BUFX2.gds /project/openlane/user_proj_example/../../cells/gds/AND2X1.gds /project/openlane/user_proj_example/../../cells/gds/NAND3X1.gds /project/openlane/user_proj_example/../../cells/gds/INVX2.gds /project/openlane/user_proj_example/../../cells/gds/INVX4.gds</font>
<font color="#AAAAAA">[INFO] Clearing cells...</font>
<font color="#AAAAAA">[INFO] Merging GDS files...</font>
	<font color="#AAAAAA">/media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/gds/sky130_fd_sc_ls.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/HAX1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/INVX8.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/AND2X2.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/XNOR2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/OAI22X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/AOI21X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/NAND2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/OAI21X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/INV.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/AOI22X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/OR2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/INVX1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/NOR2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/MUX2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/BUFX2.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/AND2X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/NAND3X1.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/INVX2.gds</font>
	<font color="#AAAAAA">/project/openlane/user_proj_example/../../cells/gds/INVX4.gds</font>
<font color="#AAAAAA">[INFO] Copying toplevel cell &apos;user_proj_example&apos;</font>
<font color="#AAAAAA">WARNING: no fill config file specified</font>
<font color="#AAAAAA">[INFO] Checking for missing GDS...</font>
<font color="#AAAAAA">[INFO] All LEF cells have matching GDS cells</font>
<font color="#AAAAAA">[INFO] Writing out GDS &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Back-up GDS-II streamed out.</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 33</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: Running XOR on the layouts using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 34</font>
<font color="#AAAAAA">First Layout: /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds</font>
<font color="#AAAAAA">Second Layout: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds</font>
<font color="#AAAAAA">Design Name: user_proj_example</font>
<font color="#AAAAAA">Output GDS will be: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.gds</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds ..</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds ..</font>
<font color="#AAAAAA">--- Running XOR for 122/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.350s</font>
<font color="#AAAAAA">XOR differences: 123</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 235/4 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">XOR differences: 1</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 236/0 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.670s</font>
<font color="#AAAAAA">XOR differences: 3</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 237/0 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">XOR differences: 1</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 64/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.330s</font>
<font color="#AAAAAA">XOR differences: 162</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 64/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.660s</font>
<font color="#AAAAAA">XOR differences: 35</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 64/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.150s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 64/59 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.150s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 65/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.840s</font>
<font color="#AAAAAA">XOR differences: 14889</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 65/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.100s</font>
<font color="#AAAAAA">XOR differences: 1905</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 66/15 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 846</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 66/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 1.920s</font>
<font color="#AAAAAA">XOR differences: 17698</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 66/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 3.010s</font>
<font color="#AAAAAA">XOR differences: 99044</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.110s</font>
<font color="#AAAAAA">--- Running XOR for 67/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.270s</font>
<font color="#AAAAAA">XOR differences: 16501</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 67/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 4.590s</font>
<font color="#AAAAAA">XOR differences: 2548</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 67/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 2.290s</font>
<font color="#AAAAAA">XOR differences: 55661</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.070s</font>
<font color="#AAAAAA">--- Running XOR for 67/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.070s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 68/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.600s</font>
<font color="#AAAAAA">XOR differences: 210</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 68/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 1.250s</font>
<font color="#AAAAAA">XOR differences: 1734</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 68/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.100s</font>
<font color="#AAAAAA">XOR differences: 4684</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 68/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.180s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 978</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.280s</font>
<font color="#AAAAAA">XOR differences: 2002</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 1344</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.090s</font>
<font color="#AAAAAA">--- Running XOR for 70/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 340</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 70/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 1328</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 71/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">XOR differences: 31</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 71/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 31</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 71/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 78/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.380s</font>
<font color="#AAAAAA">XOR differences: 6545</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 81/23 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">XOR differences: 410</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 81/4 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.630s</font>
<font color="#AAAAAA">XOR differences: 3</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 83/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.160s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 93/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.640s</font>
<font color="#AAAAAA">XOR differences: 933</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 94/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.620s</font>
<font color="#AAAAAA">XOR differences: 890</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 95/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.320s</font>
<font color="#AAAAAA">XOR differences: 1616</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:41</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">Writing layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.gds ..</font>
<font color="#AAAAAA">Total run time: 25.760s</font>
<font color="#00AAAA">[INFO]: Taking a Screenshot of the Layout Using Klayout...</font>
<font color="#00AAAA">[INFO]: current step index: 35</font>
<font color="#AAAAAA">Using Techfile: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">Using layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.gds</font>
<font color="#AAAAAA">[INFO] Reading tech file: /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/klayout/sky130A.lyt</font>
<font color="#AAAAAA">[INFO] Reading Layout file: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.gds</font>
<font color="#AAAAAA">Warning: Record length larger than 0x8000 encountered: interpreting as unsigned (position=2407014, record number=149179, cell=XOR)</font>
<font color="#AAAAAA">Warning: Record length larger than 0x8000 encountered: interpreting as unsigned (position=12613030, record number=756854, cell=XOR)</font>
<font color="#AAAAAA">Warning: Record length larger than 0x8000 encountered: interpreting as unsigned (position=12658406, record number=756859, cell=XOR)</font>
<font color="#AAAAAA">[INFO] Writing out PNG screenshot &apos;/project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.gds.png&apos;</font>
<font color="#AAAAAA">Done</font>
<font color="#00AAAA">[INFO]: Screenshot taken.</font>
<font color="#00AAAA">[INFO]: current step index: 36</font>
<font color="#AAAAAA">First Layout: /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds</font>
<font color="#AAAAAA">Second Layout: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds</font>
<font color="#AAAAAA">Design Name: user_proj_example</font>
<font color="#AAAAAA">Output GDS will be: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.xml</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.gds ..</font>
<font color="#AAAAAA">Reading /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.gds ..</font>
<font color="#AAAAAA">--- Running XOR for 122/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.340s</font>
<font color="#AAAAAA">XOR differences: 123</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 235/4 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 1</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 236/0 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.680s</font>
<font color="#AAAAAA">XOR differences: 3</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 237/0 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">XOR differences: 1</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 64/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.320s</font>
<font color="#AAAAAA">XOR differences: 162</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 64/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.650s</font>
<font color="#AAAAAA">XOR differences: 35</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 64/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.160s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 64/59 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.160s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 65/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.850s</font>
<font color="#AAAAAA">XOR differences: 14889</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.100s</font>
<font color="#AAAAAA">--- Running XOR for 65/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.100s</font>
<font color="#AAAAAA">XOR differences: 1905</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 66/15 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 846</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 66/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 1.930s</font>
<font color="#AAAAAA">XOR differences: 17698</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.140s</font>
<font color="#AAAAAA">--- Running XOR for 66/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 2.920s</font>
<font color="#AAAAAA">XOR differences: 99044</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.670s</font>
<font color="#AAAAAA">--- Running XOR for 67/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.270s</font>
<font color="#AAAAAA">XOR differences: 16501</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.120s</font>
<font color="#AAAAAA">--- Running XOR for 67/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 4.560s</font>
<font color="#AAAAAA">XOR differences: 2548</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.070s</font>
<font color="#AAAAAA">--- Running XOR for 67/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 2.340s</font>
<font color="#AAAAAA">XOR differences: 55661</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.310s</font>
<font color="#AAAAAA">--- Running XOR for 67/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.070s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 68/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.620s</font>
<font color="#AAAAAA">XOR differences: 210</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">--- Running XOR for 68/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 1.250s</font>
<font color="#AAAAAA">XOR differences: 1734</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 68/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.110s</font>
<font color="#AAAAAA">XOR differences: 4684</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">--- Running XOR for 68/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.170s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.070s</font>
<font color="#AAAAAA">XOR differences: 978</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 69/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.290s</font>
<font color="#AAAAAA">XOR differences: 2002</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 69/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 1344</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 69/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 70/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 340</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 70/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 1328</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 71/16 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">XOR differences: 31</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 71/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">XOR differences: 31</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 71/5 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">--- Running XOR for 78/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.020s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.380s</font>
<font color="#AAAAAA">XOR differences: 6545</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.050s</font>
<font color="#AAAAAA">--- Running XOR for 81/23 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.060s</font>
<font color="#AAAAAA">XOR differences: 410</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 81/4 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.650s</font>
<font color="#AAAAAA">XOR differences: 3</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 83/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.160s</font>
<font color="#AAAAAA">XOR differences: 0</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 93/44 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.650s</font>
<font color="#AAAAAA">XOR differences: 933</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 94/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.630s</font>
<font color="#AAAAAA">XOR differences: 890</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">--- Running XOR for 95/20 ---</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;_input&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.030s</font>
<font color="#AAAAAA">&quot;^&quot; in: xor.drc:38</font>
<font color="#AAAAAA">Elapsed: 0.330s</font>
<font color="#AAAAAA">XOR differences: 1616</font>
<font color="#AAAAAA">&quot;_output&quot; in: xor.drc:40</font>
<font color="#AAAAAA">Elapsed: 0.040s</font>
<font color="#AAAAAA">Writing report database: /project/openlane/user_proj_example/runs/user_proj_example/results/klayout/user_proj_example.xor.xml ..</font>
<font color="#AAAAAA">Total run time: 42.890s</font>
<font color="#00AAAA">[INFO]: Klayout XOR Complete</font>
<font color="#00AAAA">[INFO]: Running Magic Spice Export from LEF...</font>
<font color="#00AAAA">[INFO]: current step index: 37</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/project/openlane/user_proj_example/runs/user_proj_example/tmp/magic_spice.tcl&quot; from command line.</font>
<font color="#AAAAAA">Reading LEF data from file /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.ref/sky130_fd_sc_ls/techlef/sky130_fd_sc_ls.tlef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read, Line 64 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 77 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 98 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 99 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 111 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 137 (Message): Unknown keyword &quot;MINENCLOSEDAREA&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 138 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 155 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 174 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 191 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 209 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 227 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 246 (Message): Unknown keyword &quot;MINWIDTH&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read, Line 263 (Message): Unknown keyword &quot;ANTENNADIFFSIDEAREARATIO&quot; in LEF file; ignoring.</font>
<font color="#AAAAAA">LEF read: Processed 769 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND3X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX8.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX4.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 65 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OAI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/HAX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI21X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 79 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/MUX2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 81 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/BUFX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/OR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 62 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/NAND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 68 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X2.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AOI22X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 90 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/XNOR2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 74 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/AND2X1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 64 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INVX1.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading LEF data from file /project/openlane/user_proj_example/../../cells/lef/INV.lef.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">LEF read: Processed 53 lines.</font>
<font color="#AAAAAA">Reading DEF data from file /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def.</font>
<font color="#AAAAAA">This action cannot be undone.</font>
<font color="#AAAAAA">  Processed 5 vias total.</font>
<font color="#AAAAAA">  Processed 9333 subcell instances total.</font>
<font color="#AAAAAA">  Processed 620 pins total.</font>
<font color="#AAAAAA">  Processed 8 special nets total.</font>
<font color="#AAAAAA">  Processed 1208 nets total.</font>
<font color="#AAAAAA">DEF read: Processed 21075 lines.</font>
<font color="#AAAAAA">Processing user_proj_example</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__clkbuf_4 into sky130_fd_sc_ls__clkbuf_4.ext:</font>
<font color="#AAAAAA">Extracting HAX1 into HAX1.ext:</font>
<font color="#AAAAAA">Extracting XNOR2X1 into XNOR2X1.ext:</font>
<font color="#AAAAAA">Extracting NOR2X1 into NOR2X1.ext:</font>
<font color="#AAAAAA">Extracting NAND2X1 into NAND2X1.ext:</font>
<font color="#AAAAAA">Extracting BUFX2 into BUFX2.ext:</font>
<font color="#AAAAAA">Extracting AND2X1 into AND2X1.ext:</font>
<font color="#AAAAAA">Extracting AND2X2 into AND2X2.ext:</font>
<font color="#AAAAAA">Extracting NAND3X1 into NAND3X1.ext:</font>
<font color="#AAAAAA">Extracting OR2X1 into OR2X1.ext:</font>
<font color="#AAAAAA">Extracting AOI21X1 into AOI21X1.ext:</font>
<font color="#AAAAAA">Extracting MUX2X1 into MUX2X1.ext:</font>
<font color="#AAAAAA">Extracting OAI22X1 into OAI22X1.ext:</font>
<font color="#AAAAAA">Extracting INVX1 into INVX1.ext:</font>
<font color="#AAAAAA">Extracting AOI22X1 into AOI22X1.ext:</font>
<font color="#AAAAAA">Extracting INV into INV.ext:</font>
<font color="#AAAAAA">Extracting INVX4 into INVX4.ext:</font>
<font color="#AAAAAA">Extracting INVX2 into INVX2.ext:</font>
<font color="#AAAAAA">Extracting INVX8 into INVX8.ext:</font>
<font color="#AAAAAA">Extracting OAI21X1 into OAI21X1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__diode_2 into sky130_fd_sc_ls__diode_2.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__conb_1 into sky130_fd_sc_ls__conb_1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__buf_1 into sky130_fd_sc_ls__buf_1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__clkbuf_2 into sky130_fd_sc_ls__clkbuf_2.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__buf_2 into sky130_fd_sc_ls__buf_2.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__fill_1 into sky130_fd_sc_ls__fill_1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__fill_diode_2 into sky130_fd_sc_ls__fill_diode_2.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__tapvpwrvgnd_1 into sky130_fd_sc_ls__tapvpwrvgnd_1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__decap_8 into sky130_fd_sc_ls__decap_8.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__clkbuf_1 into sky130_fd_sc_ls__clkbuf_1.ext:</font>
<font color="#AAAAAA">Extracting sky130_fd_sc_ls__decap_4 into sky130_fd_sc_ls__decap_4.ext:</font>
<font color="#AAAAAA">Extracting user_proj_example into user_proj_example.ext:</font>
<font color="#AAAAAA">exttospice finished.</font>
<font color="#AAAAAA">Using technology &quot;sky130A&quot;, version 1.0.156-0-g7e29496</font>
<font color="#00AAAA">[INFO]: No Illegal overlaps detected during extraction.</font>
<font color="#00AAAA">[INFO]: Saving Magic Views in /project</font>
<font color="#00AAAA">[INFO]: Running LEF LVS...</font>
<font color="#00AAAA">[INFO]: /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.spice against /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.powered.v</font>
<font color="#00AAAA">[INFO]: current step index: 38</font>
<font color="#AAAAAA">Netgen 1.5.167 compiled on Wed Feb 17 03:29:37 UTC 2021</font>
<font color="#AAAAAA">Warning: netgen command &apos;format&apos; use fully-qualified name &apos;::netgen::format&apos;</font>
<font color="#AAAAAA">Warning: netgen command &apos;global&apos; use fully-qualified name &apos;::netgen::global&apos;</font>
<font color="#AAAAAA">Generating JSON file result</font>
<font color="#AAAAAA">Reading netlist file /project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.spice</font>
<font color="#AAAAAA">Reading netlist file /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.powered.v</font>
<font color="#AAAAAA">Warning:  A case-insensitive file has been read and so the</font>	<font color="#AAAAAA">verilog file must be treated case-insensitive to match.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module AND2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module AND2X2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module AOI21X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module AOI22X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module BUFX2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module HAX1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module INV.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module INVX1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module INVX2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module INVX4.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module INVX8.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module MUX2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module NAND2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module NAND3X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module NOR2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module OAI21X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module OAI22X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module OR2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module XNOR2X1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__conb_1.</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _024_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _025_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _026_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _027_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _028_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _029_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _030_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _031_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _032_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _033_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _034_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _035_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _036_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _037_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _038_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _039_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _040_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _041_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _042_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _043_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _044_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _045_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _046_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _047_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _048_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _049_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _050_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _051_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _052_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _053_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _054_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _055_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _056_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _057_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _058_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _059_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _060_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _061_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _062_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _063_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _064_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _065_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _066_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _067_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _068_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _069_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _070_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _071_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _072_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _073_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _074_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _075_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _076_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _077_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _078_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _079_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _080_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _081_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _082_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _083_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _084_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _085_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _086_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _087_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _088_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _089_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _090_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _091_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _092_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _093_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _094_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _095_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _096_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _097_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _098_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _099_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _100_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _101_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _102_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _103_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _104_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _105_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _106_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _107_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _108_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _109_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _110_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _111_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _112_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _113_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _114_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _115_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _116_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _117_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _118_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _119_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _120_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _121_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _122_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _123_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _124_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _125_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _126_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _127_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _128_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _129_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _130_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _131_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _132_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _133_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _134_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _135_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _136_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _137_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _138_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _139_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _140_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _141_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _142_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _143_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _144_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _145_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _146_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _147_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _148_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _149_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _150_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _151_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _152_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _153_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _154_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _155_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _156_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _157_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _158_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _159_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _160_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _161_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _162_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _163_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _164_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _165_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _166_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _167_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _168_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _169_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _170_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _171_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _172_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _173_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _174_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _175_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _176_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _177_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _178_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _179_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _180_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _181_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _182_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _183_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _184_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _185_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _186_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _187_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _188_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _189_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _190_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _191_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _192_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _193_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _194_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _195_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _196_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _197_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _198_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _199_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _200_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _201_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _202_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _203_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _204_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _205_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _206_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _207_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _208_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _209_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _210_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _211_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _212_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _213_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _214_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _215_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Note:  Implicit pin HI in instance _216_ of sky130_fd_sc_ls__conb_1 in cell user_proj_example</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__decap_4.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__tapvpwrvgnd_1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__clkbuf_1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__clkbuf_2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__buf_2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__buf_1.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__clkbuf_4.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__diode_2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__decap_8.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__fill_diode_2.</font>
<font color="#AAAAAA">Creating placeholder cell definition for module sky130_fd_sc_ls__fill_1.</font>
<font color="#AAAAAA">Reading setup file /media/philipp/Daten/skywater/pdk-ls/sky130A/libs.tech/netgen/sky130A_setup.tcl</font>
<font color="#AAAAAA">Comparison output logged to file /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.lef.log</font>
<font color="#AAAAAA">Logging to file &quot;/project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.lef.log&quot; enabled</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__decap_8&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_8 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__decap_8&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_8 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_8 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__fill_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__fill_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__fill_diode_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_diode_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__fill_diode_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_diode_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__fill_diode_2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__decap_4&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__decap_4&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__decap_4 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__diode_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__diode_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__diode_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__diode_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__diode_2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__tapvpwrvgnd_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__tapvpwrvgnd_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 2 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__tapvpwrvgnd_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__tapvpwrvgnd_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__tapvpwrvgnd_1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__conb_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__conb_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__conb_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__conb_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__conb_1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;NAND2X1&apos;</font>
<font color="#AAAAAA">Circuit NAND2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;NAND2X1&apos;</font>
<font color="#AAAAAA">Circuit NAND2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit NAND2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__buf_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__buf_2&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__buf_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__buf_1&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__buf_1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;XNOR2X1&apos;</font>
<font color="#AAAAAA">Circuit XNOR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;XNOR2X1&apos;</font>
<font color="#AAAAAA">Circuit XNOR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit XNOR2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;AOI21X1&apos;</font>
<font color="#AAAAAA">Circuit AOI21X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;AOI21X1&apos;</font>
<font color="#AAAAAA">Circuit AOI21X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit AOI21X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;INVX1&apos;</font>
<font color="#AAAAAA">Circuit INVX1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;INVX1&apos;</font>
<font color="#AAAAAA">Circuit INVX1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit INVX1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;INVX2&apos;</font>
<font color="#AAAAAA">Circuit INVX2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;INVX2&apos;</font>
<font color="#AAAAAA">Circuit INVX2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit INVX2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;NOR2X1&apos;</font>
<font color="#AAAAAA">Circuit NOR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;NOR2X1&apos;</font>
<font color="#AAAAAA">Circuit NOR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit NOR2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;INVX4&apos;</font>
<font color="#AAAAAA">Circuit INVX4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;INVX4&apos;</font>
<font color="#AAAAAA">Circuit INVX4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit INVX4 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;OR2X1&apos;</font>
<font color="#AAAAAA">Circuit OR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;OR2X1&apos;</font>
<font color="#AAAAAA">Circuit OR2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit OR2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;INVX8&apos;</font>
<font color="#AAAAAA">Circuit INVX8 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;INVX8&apos;</font>
<font color="#AAAAAA">Circuit INVX8 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit INVX8 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;OAI22X1&apos;</font>
<font color="#AAAAAA">Circuit OAI22X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 7 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;OAI22X1&apos;</font>
<font color="#AAAAAA">Circuit OAI22X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit OAI22X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;BUFX2&apos;</font>
<font color="#AAAAAA">Circuit BUFX2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;BUFX2&apos;</font>
<font color="#AAAAAA">Circuit BUFX2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit BUFX2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;NAND3X1&apos;</font>
<font color="#AAAAAA">Circuit NAND3X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;NAND3X1&apos;</font>
<font color="#AAAAAA">Circuit NAND3X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit NAND3X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;INV&apos;</font>
<font color="#AAAAAA">Circuit INV contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 4 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;INV&apos;</font>
<font color="#AAAAAA">Circuit INV contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit INV contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_4&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;sky130_fd_sc_ls__clkbuf_4&apos;</font>
<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_4 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit sky130_fd_sc_ls__clkbuf_4 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;AOI22X1&apos;</font>
<font color="#AAAAAA">Circuit AOI22X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 7 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;AOI22X1&apos;</font>
<font color="#AAAAAA">Circuit AOI22X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit AOI22X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;MUX2X1&apos;</font>
<font color="#AAAAAA">Circuit MUX2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;MUX2X1&apos;</font>
<font color="#AAAAAA">Circuit MUX2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit MUX2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;AND2X1&apos;</font>
<font color="#AAAAAA">Circuit AND2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;AND2X1&apos;</font>
<font color="#AAAAAA">Circuit AND2X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit AND2X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;AND2X2&apos;</font>
<font color="#AAAAAA">Circuit AND2X2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 5 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;AND2X2&apos;</font>
<font color="#AAAAAA">Circuit AND2X2 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit AND2X2 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;OAI21X1&apos;</font>
<font color="#AAAAAA">Circuit OAI21X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;OAI21X1&apos;</font>
<font color="#AAAAAA">Circuit OAI21X1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit OAI21X1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;HAX1&apos;</font>
<font color="#AAAAAA">Circuit HAX1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets, and 6 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;HAX1&apos;</font>
<font color="#AAAAAA">Circuit HAX1 contains 0 device instances.</font>
<font color="#AAAAAA">Circuit contains 0 nets.</font>

<font color="#AAAAAA">Circuit HAX1 contains no devices.</font>
<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;user_proj_example&apos;</font>
<font color="#AAAAAA">Circuit user_proj_example contains 9333 device instances.</font>
<font color="#AAAAAA">  Class: OR2X1                 instances:   1</font>
<font color="#AAAAAA">  Class: MUX2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AOI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: NOR2X1                instances:   1</font>
<font color="#AAAAAA">  Class: INV                   instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_4 instances: 1464</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_8 instances: 4545</font>
<font color="#AAAAAA">  Class: NAND3X1               instances:   1</font>
<font color="#AAAAAA">  Class: HAX1                  instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_1 instances: 351</font>
<font color="#AAAAAA">  Class: OAI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: AOI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: NAND2X1               instances:   1</font>
<font color="#AAAAAA">  Class: OAI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_1 instances: 333</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_2 instances: 242</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_4 instances:   3</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__diode_2 instances: 230</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_diode_2 instances: 1021</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__tapvpwrvgnd_1 instances: 882</font>
<font color="#AAAAAA">  Class: XNOR2X1               instances:   1</font>
<font color="#AAAAAA">  Class: BUFX2                 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__conb_1 instances: 217</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_1 instances:  11</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_2 instances:  15</font>
<font color="#AAAAAA">  Class: AND2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AND2X2                instances:   1</font>
<font color="#AAAAAA">  Class: INVX1                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX2                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX4                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX8                 instances:   1</font>
<font color="#AAAAAA">Circuit contains 1427 nets, and 12 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;user_proj_example&apos;</font>
<font color="#AAAAAA">Circuit user_proj_example contains 9333 device instances.</font>
<font color="#AAAAAA">  Class: OR2X1                 instances:   1</font>
<font color="#AAAAAA">  Class: MUX2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AOI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: NOR2X1                instances:   1</font>
<font color="#AAAAAA">  Class: INV                   instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_4 instances: 1464</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_8 instances: 4545</font>
<font color="#AAAAAA">  Class: NAND3X1               instances:   1</font>
<font color="#AAAAAA">  Class: HAX1                  instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_1 instances: 351</font>
<font color="#AAAAAA">  Class: OAI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: AOI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: NAND2X1               instances:   1</font>
<font color="#AAAAAA">  Class: OAI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_1 instances: 333</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_2 instances: 242</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_4 instances:   3</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__diode_2 instances: 230</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_diode_2 instances: 1021</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__tapvpwrvgnd_1 instances: 882</font>
<font color="#AAAAAA">  Class: XNOR2X1               instances:   1</font>
<font color="#AAAAAA">  Class: BUFX2                 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__conb_1 instances: 217</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_1 instances:  11</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_2 instances:  15</font>
<font color="#AAAAAA">  Class: AND2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AND2X2                instances:   1</font>
<font color="#AAAAAA">  Class: INVX1                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX2                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX4                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX8                 instances:   1</font>
<font color="#AAAAAA">Circuit contains 1403 nets, and 6 disconnected pins.</font>

<font color="#AAAAAA">Circuit was modified by parallel/series device merging.</font>
<font color="#AAAAAA">New circuit summary:</font>

<font color="#AAAAAA">Contents of circuit 1:  Circuit: &apos;user_proj_example&apos;</font>
<font color="#AAAAAA">Circuit user_proj_example contains 963 device instances.</font>
<font color="#AAAAAA">  Class: OR2X1                 instances:   1</font>
<font color="#AAAAAA">  Class: MUX2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AOI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: NOR2X1                instances:   1</font>
<font color="#AAAAAA">  Class: INV                   instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_4 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_8 instances:   1</font>
<font color="#AAAAAA">  Class: NAND3X1               instances:   1</font>
<font color="#AAAAAA">  Class: HAX1                  instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_1 instances:   1</font>
<font color="#AAAAAA">  Class: OAI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: AOI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: NAND2X1               instances:   1</font>
<font color="#AAAAAA">  Class: OAI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_1 instances: 333</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_2 instances: 242</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_4 instances:   3</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__diode_2 instances: 118</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_diode_2 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__tapvpwrvgnd_1 instances:   1</font>
<font color="#AAAAAA">  Class: XNOR2X1               instances:   1</font>
<font color="#AAAAAA">  Class: BUFX2                 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__conb_1 instances: 217</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_1 instances:  11</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_2 instances:  15</font>
<font color="#AAAAAA">  Class: AND2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AND2X2                instances:   1</font>
<font color="#AAAAAA">  Class: INVX1                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX2                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX4                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX8                 instances:   1</font>
<font color="#AAAAAA">Circuit contains 1427 nets, and 12 disconnected pins.</font>
<font color="#AAAAAA">Contents of circuit 2:  Circuit: &apos;user_proj_example&apos;</font>
<font color="#AAAAAA">Circuit user_proj_example contains 963 device instances.</font>
<font color="#AAAAAA">  Class: OR2X1                 instances:   1</font>
<font color="#AAAAAA">  Class: MUX2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AOI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: NOR2X1                instances:   1</font>
<font color="#AAAAAA">  Class: INV                   instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_4 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__decap_8 instances:   1</font>
<font color="#AAAAAA">  Class: NAND3X1               instances:   1</font>
<font color="#AAAAAA">  Class: HAX1                  instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_1 instances:   1</font>
<font color="#AAAAAA">  Class: OAI22X1               instances:   1</font>
<font color="#AAAAAA">  Class: AOI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: NAND2X1               instances:   1</font>
<font color="#AAAAAA">  Class: OAI21X1               instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_1 instances: 333</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_2 instances: 242</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__clkbuf_4 instances:   3</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__diode_2 instances: 118</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__fill_diode_2 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__tapvpwrvgnd_1 instances:   1</font>
<font color="#AAAAAA">  Class: XNOR2X1               instances:   1</font>
<font color="#AAAAAA">  Class: BUFX2                 instances:   1</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__conb_1 instances: 217</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_1 instances:  11</font>
<font color="#AAAAAA">  Class: sky130_fd_sc_ls__buf_2 instances:  15</font>
<font color="#AAAAAA">  Class: AND2X1                instances:   1</font>
<font color="#AAAAAA">  Class: AND2X2                instances:   1</font>
<font color="#AAAAAA">  Class: INVX1                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX2                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX4                 instances:   1</font>
<font color="#AAAAAA">  Class: INVX8                 instances:   1</font>
<font color="#AAAAAA">Circuit contains 1403 nets, and 6 disconnected pins.</font>

<font color="#AAAAAA">Circuit 1 contains 963 devices, Circuit 2 contains 963 devices.</font>
<font color="#AAAAAA">Circuit 1 contains 1403 nets,    Circuit 2 contains 1403 nets.</font>

<font color="#AAAAAA">Circuits match with 21 symmetries.</font>
<font color="#AAAAAA">Resolving automorphisms by property value.</font>
<font color="#AAAAAA">Resolving automorphisms by pin name.</font>
<font color="#AAAAAA">Netlists match with 2 symmetries.</font>
<font color="#AAAAAA">Circuits match correctly.</font>
<font color="#AAAAAA">Result: Circuits match uniquely.</font>
<font color="#AAAAAA">Logging to file &quot;/project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs.lef.log&quot; disabled</font>
<font color="#AAAAAA">LVS Done.</font>
<font color="#AAAAAA">LVS reports no net, device, pin, or property mismatches.</font>

<font color="#AAAAAA">Total errors = 0</font>
<font color="#00AAAA">[INFO]: No LVS mismatches.</font>
<font color="#00AAAA">[INFO]: Running Magic DRC...</font>
<font color="#00AAAA">[INFO]: current step index: 39</font>

<font color="#AAAAAA">Magic 8.3 revision 145 - Compiled on Mon Mar 22 04:21:56 UTC 2021.</font>
<font color="#AAAAAA">Starting magic under Tcl interpreter</font>
<font color="#AAAAAA">Using the terminal as the console.</font>
<font color="#AAAAAA">Using NULL graphics device.</font>
<font color="#AAAAAA">Processing system .magicrc file</font>
<font color="#AAAAAA">Sourcing design .magicrc for technology sky130A ...</font>
<font color="#AAAAAA">2 Magic internal units = 1 Lambda</font>
<font color="#AAAAAA">Input style sky130(): scaleFactor=2, multiplier=2</font>
<font color="#AAAAAA">Scaled tech values by 2 / 1 to match internal grid scaling</font>
<font color="#AAAAAA">Loading sky130A Device Generator Menu ...</font>
<font color="#AAAAAA">Loading &quot;/openLANE_flow/scripts/magic/drc.tcl&quot; from command line.</font>
<font color="#AAAAAA">Warning: Calma reading is not undoable!  I hope that&apos;s OK.</font>
<font color="#AAAAAA">Library written using GDS-II Release 3.0</font>
<font color="#AAAAAA">Library name: user_proj_example</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__decap_4&quot;.</font>
<font color="#AAAAAA">CIF file read warning: CIF style sky130(): units rescaled by factor of 5 / 1</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__decap_8&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__tapvpwrvgnd_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__fill_diode_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__fill_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__buf_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__buf_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__conb_1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__diode_2&quot;.</font>
<font color="#AAAAAA">Reading &quot;OAI21X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX8&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX2&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX4&quot;.</font>
<font color="#AAAAAA">Reading &quot;INV&quot;.</font>
<font color="#AAAAAA">Reading &quot;AOI22X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;INVX1&quot;.</font>
<font color="#AAAAAA">Reading &quot;OAI22X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;MUX2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;AOI21X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;OR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;NAND3X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;AND2X2&quot;.</font>
<font color="#AAAAAA">Reading &quot;AND2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;BUFX2&quot;.</font>
<font color="#AAAAAA">Reading &quot;NAND2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;NOR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;XNOR2X1&quot;.</font>
<font color="#AAAAAA">Reading &quot;HAX1&quot;.</font>
<font color="#AAAAAA">Reading &quot;sky130_fd_sc_ls__clkbuf_4&quot;.</font>
<font color="#AAAAAA">Reading &quot;user_proj_example&quot;.</font>
<font color="#AAAAAA">    100 uses</font>
<font color="#AAAAAA">    200 uses</font>
<font color="#AAAAAA">    300 uses</font>
<font color="#AAAAAA">    400 uses</font>
<font color="#AAAAAA">    500 uses</font>
<font color="#AAAAAA">    600 uses</font>
<font color="#AAAAAA">    700 uses</font>
<font color="#AAAAAA">    800 uses</font>
<font color="#AAAAAA">    900 uses</font>
<font color="#AAAAAA">    1000 uses</font>
<font color="#AAAAAA">    1100 uses</font>
<font color="#AAAAAA">    1200 uses</font>
<font color="#AAAAAA">    1300 uses</font>
<font color="#AAAAAA">    1400 uses</font>
<font color="#AAAAAA">    1500 uses</font>
<font color="#AAAAAA">    1600 uses</font>
<font color="#AAAAAA">    1700 uses</font>
<font color="#AAAAAA">    1800 uses</font>
<font color="#AAAAAA">    1900 uses</font>
<font color="#AAAAAA">    2000 uses</font>
<font color="#AAAAAA">    2100 uses</font>
<font color="#AAAAAA">    2200 uses</font>
<font color="#AAAAAA">    2300 uses</font>
<font color="#AAAAAA">    2400 uses</font>
<font color="#AAAAAA">    2500 uses</font>
<font color="#AAAAAA">    2600 uses</font>
<font color="#AAAAAA">    2700 uses</font>
<font color="#AAAAAA">    2800 uses</font>
<font color="#AAAAAA">    2900 uses</font>
<font color="#AAAAAA">    3000 uses</font>
<font color="#AAAAAA">    3100 uses</font>
<font color="#AAAAAA">    3200 uses</font>
<font color="#AAAAAA">    3300 uses</font>
<font color="#AAAAAA">    3400 uses</font>
<font color="#AAAAAA">    3500 uses</font>
<font color="#AAAAAA">    3600 uses</font>
<font color="#AAAAAA">    3700 uses</font>
<font color="#AAAAAA">    3800 uses</font>
<font color="#AAAAAA">    3900 uses</font>
<font color="#AAAAAA">    4000 uses</font>
<font color="#AAAAAA">    4100 uses</font>
<font color="#AAAAAA">    4200 uses</font>
<font color="#AAAAAA">    4300 uses</font>
<font color="#AAAAAA">    4400 uses</font>
<font color="#AAAAAA">    4500 uses</font>
<font color="#AAAAAA">    4600 uses</font>
<font color="#AAAAAA">    4700 uses</font>
<font color="#AAAAAA">    4800 uses</font>
<font color="#AAAAAA">    4900 uses</font>
<font color="#AAAAAA">    5000 uses</font>
<font color="#AAAAAA">    5100 uses</font>
<font color="#AAAAAA">    5200 uses</font>
<font color="#AAAAAA">    5300 uses</font>
<font color="#AAAAAA">    5400 uses</font>
<font color="#AAAAAA">    5500 uses</font>
<font color="#AAAAAA">    5600 uses</font>
<font color="#AAAAAA">    5700 uses</font>
<font color="#AAAAAA">    5800 uses</font>
<font color="#AAAAAA">    5900 uses</font>
<font color="#AAAAAA">    6000 uses</font>
<font color="#AAAAAA">    6100 uses</font>
<font color="#AAAAAA">    6200 uses</font>
<font color="#AAAAAA">    6300 uses</font>
<font color="#AAAAAA">    6400 uses</font>
<font color="#AAAAAA">    6500 uses</font>
<font color="#AAAAAA">    6600 uses</font>
<font color="#AAAAAA">    6700 uses</font>
<font color="#AAAAAA">    6800 uses</font>
<font color="#AAAAAA">    6900 uses</font>
<font color="#AAAAAA">    7000 uses</font>
<font color="#AAAAAA">    7100 uses</font>
<font color="#AAAAAA">    7200 uses</font>
<font color="#AAAAAA">    7300 uses</font>
<font color="#AAAAAA">    7400 uses</font>
<font color="#AAAAAA">    7500 uses</font>
<font color="#AAAAAA">    7600 uses</font>
<font color="#AAAAAA">    7700 uses</font>
<font color="#AAAAAA">    7800 uses</font>
<font color="#AAAAAA">    7900 uses</font>
<font color="#AAAAAA">    8000 uses</font>
<font color="#AAAAAA">    8100 uses</font>
<font color="#AAAAAA">    8200 uses</font>
<font color="#AAAAAA">    8300 uses</font>
<font color="#AAAAAA">    8400 uses</font>
<font color="#AAAAAA">    8500 uses</font>
<font color="#AAAAAA">    8600 uses</font>
<font color="#AAAAAA">    8700 uses</font>
<font color="#AAAAAA">    8800 uses</font>
<font color="#AAAAAA">    8900 uses</font>
<font color="#AAAAAA">    9000 uses</font>
<font color="#AAAAAA">    9100 uses</font>
<font color="#AAAAAA">    9200 uses</font>
<font color="#AAAAAA">    9300 uses</font>
<font color="#AAAAAA">[INFO]: Loading user_proj_example</font>

<font color="#AAAAAA">DRC style is now &quot;drc(full)&quot;</font>
<font color="#AAAAAA">Loading DRC CIF style.</font>
<font color="#AAAAAA">[INFO]: COUNT: 4837</font>
<font color="#AAAAAA">[INFO]: Should be divided by 3 or 4</font>
<font color="#AAAAAA">[INFO]: DRC Checking DONE (/project/openlane/user_proj_example/runs/user_proj_example/reports/magic/39-magic.drc)</font>
<font color="#AAAAAA">[INFO]: Saving mag view with DRC errors(/project/openlane/user_proj_example/runs/user_proj_example/results/magic/user_proj_example.drc.mag)</font>
<font color="#AAAAAA">[INFO]: Saved</font>
<font color="#00AAAA">[INFO]: Converting Magic DRC Violations to Magic Readable Format...</font>
<font color="#00AAAA">[INFO]: Converting Magic DRC Violations to Klayout XML Database...</font>
<font color="#00AAAA">[INFO]: Converting DRC Violations to RDB Format...</font>
<font color="#00AAAA">[INFO]: Converted DRC Violations to RDB Format</font>
<font color="#AA0000">[ERROR]: There are violations in the design after Magic DRC.</font>
<font color="#AA0000">[ERROR]: Total Number of violations is 4837</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow failed for user_proj_example/13-06_18-43 in 0h10m16s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Magic DRC Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/reports/magic//39-magic.drc</font>
<font color="#00AAAA">Violation Message &quot;mcon.spacing &lt; 0.19um (mcon.2) &quot;found 200 Times.</font>
<font color="#00AAAA">Violation Message &quot;Local interconnect spacing &lt; 0.17um (li.3) &quot;found 945 Times.</font>
<font color="#00AAAA">Violation Message &quot;Local interconnect width &lt; 0.17um (li.1) &quot;found 1 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well spacing &lt; 1.27um (nwell.2a) &quot;found 201 Times.</font>
<font color="#00AAAA">Violation Message &quot;This layer can&apos;t abut or partially overlap between subcells &quot;found 8 Times.</font>
<font color="#00AAAA">Violation Message &quot;Metal1 spacing &lt; 0.14um (met1.2) &quot;found 85 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well overlap of P-Diffusion &lt; 0.18um (diff/tap.8) &quot;found 2145 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well width &lt; 0.84um (nwell.1) &quot;found 310 Times.</font>
<font color="#00AAAA">Violation Message &quot;All nwells must contain metal-connected N+ taps (nwell.4) &quot;found 59 Times.</font>
<font color="#00AAAA">Violation Message &quot;P-diff distance to N-tap must be &lt; 15.0um (LU.3) &quot;found 149 Times.</font>
<font color="#00AAAA">Violation Message &quot;Metal1 width &lt; 0.14um (met1.1) &quot;found 4 Times.</font>
<font color="#00AAAA">Violation Message &quot;Core local interconnect spacing &lt; 0.14um (li.c2) &quot;found 373 Times.</font>
<font color="#00AAAA">Violation Message &quot;poly contact spacing to P-diffusion &lt; 0.235um (licon.9 + psdm.5a) &quot;found 357 Times.</font>
<font color="#00AAAA">Total Magic DRC violations is 4837</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.lef.log</font>
<font color="#00AAAA">LVS reports no net, device, pin, or property mismatches.</font>
<font color="#00AAAA">Total errors = 0</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">No antenna report found.</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#AA0000">[ERROR]: Flow Failed.</font>
<font color="#00AAAA">[INFO]: Running Antenna Checks...</font>
<font color="#00AAAA">[INFO]: Running OpenROAD Antenna Rule Checker...</font>
<font color="#00AAAA">[INFO]: current step index: 40</font>
<font color="#AAAAAA">OpenROAD 0.9.0 1415572a73</font>
<font color="#AAAAAA">This program is licensed under the BSD-3 license. See the LICENSE file for details.</font>
<font color="#AAAAAA">Components of this program may be licensed under more restrictive licenses which must be honored.</font>
<font color="#AAAAAA">Notice 0: Reading LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0:     Created 13 technology layers</font>
<font color="#AAAAAA">Notice 0:     Created 25 technology vias</font>
<font color="#AAAAAA">Notice 0:     Created 418 library cells</font>
<font color="#AAAAAA">Notice 0: Finished LEF file:  /project/openlane/user_proj_example/runs/user_proj_example/tmp/merged_unpadded.lef</font>
<font color="#AAAAAA">Notice 0: </font>
<font color="#AAAAAA">Reading DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">Notice 0: Design: user_proj_example</font>
<font color="#AAAAAA">Notice 0:     Created 620 pins.</font>
<font color="#AAAAAA">Notice 0:     Created 9333 components and 37462 component-terminals.</font>
<font color="#AAAAAA">Notice 0:     Created 8 special nets and 0 connections.</font>
<font color="#AAAAAA">Notice 0:     Created 1208 nets and 1715 connections.</font>
<font color="#AAAAAA">Notice 0: Finished DEF file: /project/openlane/user_proj_example/runs/user_proj_example/results/routing/user_proj_example.def</font>
<font color="#AAAAAA">Notice 0: Split top of 7 T shapes.</font>
<font color="#AAAAAA">Number of pins violated: 6</font>
<font color="#AAAAAA">Number of nets violated: 6</font>
<font color="#AAAAAA">Total number of nets: 1208</font>
<font color="#00AAAA">[INFO]: current step index: 41</font>
<font color="#00AAAA">[INFO]: Your design contains macros, which is not supported by the current integration of CVC. So CVC won&apos;t run, however CVC is just a check so it&apos;s not critical to your design.</font>
<font color="#00AAAA">[INFO]: Calculating Runtime From the Start...</font>
<font color="#00AAAA">[INFO]: Flow completed for user_proj_example/13-06_18-43 in 0h10m33s</font>
<font color="#00AAAA">[INFO]: Generating Final Summary Report...</font>
<font color="#00AAAA">[INFO]: Design Name: user_proj_example</font>
<font color="#00AAAA">Run Directory: /project/openlane/user_proj_example/runs/user_proj_example</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Magic DRC Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/reports/magic//39-magic.drc</font>
<font color="#00AAAA">Violation Message &quot;mcon.spacing &lt; 0.19um (mcon.2) &quot;found 200 Times.</font>
<font color="#00AAAA">Violation Message &quot;Local interconnect spacing &lt; 0.17um (li.3) &quot;found 945 Times.</font>
<font color="#00AAAA">Violation Message &quot;Local interconnect width &lt; 0.17um (li.1) &quot;found 1 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well spacing &lt; 1.27um (nwell.2a) &quot;found 201 Times.</font>
<font color="#00AAAA">Violation Message &quot;This layer can&apos;t abut or partially overlap between subcells &quot;found 8 Times.</font>
<font color="#00AAAA">Violation Message &quot;Metal1 spacing &lt; 0.14um (met1.2) &quot;found 85 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well overlap of P-Diffusion &lt; 0.18um (diff/tap.8) &quot;found 2145 Times.</font>
<font color="#00AAAA">Violation Message &quot;N-well width &lt; 0.84um (nwell.1) &quot;found 310 Times.</font>
<font color="#00AAAA">Violation Message &quot;All nwells must contain metal-connected N+ taps (nwell.4) &quot;found 59 Times.</font>
<font color="#00AAAA">Violation Message &quot;P-diff distance to N-tap must be &lt; 15.0um (LU.3) &quot;found 149 Times.</font>
<font color="#00AAAA">Violation Message &quot;Metal1 width &lt; 0.14um (met1.1) &quot;found 4 Times.</font>
<font color="#00AAAA">Violation Message &quot;Core local interconnect spacing &lt; 0.14um (li.c2) &quot;found 373 Times.</font>
<font color="#00AAAA">Violation Message &quot;poly contact spacing to P-diffusion &lt; 0.235um (licon.9 + psdm.5a) &quot;found 357 Times.</font>
<font color="#00AAAA">Total Magic DRC violations is 4837</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">LVS Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/results/lvs/user_proj_example.lvs_parsed.lef.log</font>
<font color="#00AAAA">LVS reports no net, device, pin, or property mismatches.</font>
<font color="#00AAAA">Total errors = 0</font>
<font color="#00AAAA">----------------------------------------</font>

<font color="#00AAAA">Antenna Summary:</font>
<font color="#00AAAA">Source: /project/openlane/user_proj_example/runs/user_proj_example/reports/routing//41-antenna.rpt</font>
<font color="#00AAAA">Number of pins violated: 6</font>
<font color="#00AAAA">Number of nets violated: 6</font>
<font color="#00AAAA">[INFO]: check full report here: /project/openlane/user_proj_example/runs/user_proj_example/reports/final_summary_report.csv</font>
<font color="#00AA00">[SUCCESS]: Flow Completed Without Fatal Errors.</font>
<font color="#AAAAAA">mkdir -p ../signoff/user_proj_example/</font>
<font color="#AAAAAA">cp user_proj_example/runs/user_proj_example/OPENLANE_VERSION ../signoff/user_proj_example/</font>
<font color="#AAAAAA">cp user_proj_example/runs/user_proj_example/PDK_SOURCES ../signoff/user_proj_example/</font>
<font color="#AAAAAA">cp user_proj_example/runs/user_proj_example/reports/final_summary_report.csv ../signoff/user_proj_example/</font>
<font color="#AAAAAA">make[1]: Verzeichnis „/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/openlane“ wird verlassen</font>
<font color="#AAAAAA">Deployment done.</font>
<font color="#AAAAAA">philipp@philippina:/media/philipp/Daten/skywater/caravel_stdcelllib_stdcells_project/scripts$ </font>
</pre>
