these are all circuits from ISCA85 and EPFL.

src/io_generator/c17.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 5;
+extern const int PO_WIDTH = 2;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = n4 && n3;
+    bool n7 = !n6 && n2;
+    bool n8 = n3 && n1;
+    bool n9 = !n8 && !n7;
+    bool n10 = !n6 && n5;
+    bool n11 = !n10 && !n7;
+    po[0] = !n9;
+    po[1] = !n11;
+}
+#endif
\ No newline at end of file

src/io_generator/c432.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 36;
+extern const int PO_WIDTH = 7;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = pi[24];
+    bool n26 = pi[25];
+    bool n27 = pi[26];
+    bool n28 = pi[27];
+    bool n29 = pi[28];
+    bool n30 = pi[29];
+    bool n31 = pi[30];
+    bool n32 = pi[31];
+    bool n33 = pi[32];
+    bool n34 = pi[33];
+    bool n35 = pi[34];
+    bool n36 = pi[35];
+    bool n37 = n16 && !n1;
+    bool n38 = n9 && !n5;
+    bool n39 = !n38 && !n37;
+    bool n40 = n13 && !n11;
+    bool n41 = !n40 && n39;
+    bool n42 = n22 && !n20;
+    bool n43 = n18 && !n15;
+    bool n44 = !n43 && !n42;
+    bool n45 = n44 && n41;
+    bool n46 = n31 && !n28;
+    bool n47 = n26 && !n24;
+    bool n48 = !n47 && !n46;
+    bool n49 = n48 && n45;
+    bool n50 = n4 && !n2;
+    bool n51 = n35 && !n33;
+    bool n52 = !n51 && !n50;
+    bool n53 = n52 && n49;
+    bool n54 = !n30 && n16;
+    bool n55 = !n53 && n37;
+    bool n56 = n53 && !n37;
+    bool n57 = !n56 && !n55;
+    bool n58 = !n57 && n54;
+    bool n59 = !n53 && !n38;
+    bool n60 = n53 && n38;
+    bool n61 = !n60 && !n59;
+    bool n62 = !n10 && n9;
+    bool n63 = n62 && n61;
+    bool n64 = !n63 && !n58;
+    bool n65 = !n53 && !n40;
+    bool n66 = n53 && n40;
+    bool n67 = !n66 && !n65;
+    bool n68 = !n14 && n13;
+    bool n69 = n68 && n67;
+    bool n70 = !n69 && n64;
+    bool n71 = !n53 && !n42;
+    bool n72 = n53 && n42;
+    bool n73 = !n72 && !n71;
+    bool n74 = !n23 && n22;
+    bool n75 = n74 && n73;
+    bool n76 = !n53 && !n43;
+    bool n77 = n53 && n43;
+    bool n78 = !n77 && !n76;
+    bool n79 = !n19 && n18;
+    bool n80 = n79 && n78;
+    bool n81 = !n80 && !n75;
+    bool n82 = n81 && n70;
+    bool n83 = !n53 && !n46;
+    bool n84 = n53 && n46;
+    bool n85 = !n84 && !n83;
+    bool n86 = !n32 && n31;
+    bool n87 = n86 && n85;
+    bool n88 = !n53 && !n47;
+    bool n89 = n53 && n47;
+    bool n90 = !n89 && !n88;
+    bool n91 = !n27 && n26;
+    bool n92 = n91 && n90;
+    bool n93 = !n92 && !n87;
+    bool n94 = n93 && n82;
+    bool n95 = !n53 && !n50;
+    bool n96 = n53 && n50;
+    bool n97 = !n96 && !n95;
+    bool n98 = !n6 && n4;
+    bool n99 = n98 && n97;
+    bool n100 = !n53 && !n51;
+    bool n101 = n53 && n51;
+    bool n102 = !n101 && !n100;
+    bool n103 = !n36 && n35;
+    bool n104 = n103 && n102;
+    bool n105 = !n104 && !n99;
+    bool n106 = n105 && n94;
+    bool n107 = n16 && !n8;
+    bool n108 = n107 && !n57;
+    bool n109 = !n106 && n58;
+    bool n110 = n106 && !n58;
+    bool n111 = !n110 && !n109;
+    bool n112 = !n111 && n108;
+    bool n113 = !n106 && !n63;
+    bool n114 = n106 && n63;
+    bool n115 = !n114 && !n113;
+    bool n116 = !n12 && n9;
+    bool n117 = n116 && n61;
+    bool n118 = n117 && n115;
+    bool n119 = !n118 && !n112;
+    bool n120 = !n106 && !n69;
+    bool n121 = n106 && n69;
+    bool n122 = !n121 && !n120;
+    bool n123 = !n17 && n13;
+    bool n124 = n123 && n67;
+    bool n125 = n124 && n122;
+    bool n126 = !n125 && n119;
+    bool n127 = !n106 && !n75;
+    bool n128 = n106 && n75;
+    bool n129 = !n128 && !n127;
+    bool n130 = !n25 && n22;
+    bool n131 = n130 && n73;
+    bool n132 = n131 && n129;
+    bool n133 = !n106 && !n80;
+    bool n134 = n106 && n80;
+    bool n135 = !n134 && !n133;
+    bool n136 = !n21 && n18;
+    bool n137 = n136 && n78;
+    bool n138 = n137 && n135;
+    bool n139 = !n138 && !n132;
+    bool n140 = n139 && n126;
+    bool n141 = !n106 && !n87;
+    bool n142 = n106 && n87;
+    bool n143 = !n142 && !n141;
+    bool n144 = !n34 && n31;
+    bool n145 = n144 && n85;
+    bool n146 = n145 && n143;
+    bool n147 = !n106 && !n92;
+    bool n148 = n106 && n92;
+    bool n149 = !n148 && !n147;
+    bool n150 = !n29 && n26;
+    bool n151 = n150 && n90;
+    bool n152 = n151 && n149;
+    bool n153 = !n152 && !n146;
+    bool n154 = n153 && n140;
+    bool n155 = !n106 && !n99;
+    bool n156 = n106 && n99;
+    bool n157 = !n156 && !n155;
+    bool n158 = !n7 && n4;
+    bool n159 = n158 && n97;
+    bool n160 = n159 && n157;
+    bool n161 = !n106 && !n104;
+    bool n162 = n106 && n104;
+    bool n163 = !n162 && !n161;
+    bool n164 = n35 && !n3;
+    bool n165 = n164 && n102;
+    bool n166 = n165 && n163;
+    bool n167 = !n166 && !n160;
+    bool n168 = n167 && n154;
+    bool n169 = !n168 && n8;
+    bool n170 = !n106 && n30;
+    bool n171 = !n53 && n1;
+    bool n172 = !n171 && n16;
+    bool n173 = n172 && !n170;
+    bool n174 = n173 && !n169;
+    bool n175 = !n168 && n17;
+    bool n176 = !n106 && n14;
+    bool n177 = !n53 && n11;
+    bool n178 = !n177 && !n176;
+    bool n179 = n178 && !n175;
+    bool n180 = n179 && n13;
+    bool n181 = !n168 && n12;
+    bool n182 = !n106 && n10;
+    bool n183 = !n53 && n5;
+    bool n184 = !n183 && !n182;
+    bool n185 = n184 && !n181;
+    bool n186 = n185 && n9;
+    bool n187 = !n186 && !n180;
+    bool n188 = !n168 && n25;
+    bool n189 = !n106 && n23;
+    bool n190 = !n53 && n20;
+    bool n191 = !n190 && !n189;
+    bool n192 = n191 && !n188;
+    bool n193 = n192 && n22;
+    bool n194 = !n168 && n21;
+    bool n195 = !n106 && n19;
+    bool n196 = !n53 && n15;
+    bool n197 = !n196 && !n195;
+    bool n198 = n197 && !n194;
+    bool n199 = n198 && n18;
+    bool n200 = !n199 && !n193;
+    bool n201 = n200 && n187;
+    bool n202 = !n168 && n34;
+    bool n203 = !n106 && n32;
+    bool n204 = !n53 && n28;
+    bool n205 = !n204 && !n203;
+    bool n206 = n205 && !n202;
+    bool n207 = n206 && n31;
+    bool n208 = !n168 && n29;
+    bool n209 = !n106 && n27;
+    bool n210 = !n53 && n24;
+    bool n211 = !n210 && !n209;
+    bool n212 = n211 && !n208;
+    bool n213 = n212 && n26;
+    bool n214 = !n213 && !n207;
+    bool n215 = n214 && n201;
+    bool n216 = !n168 && n3;
+    bool n217 = !n106 && n36;
+    bool n218 = !n53 && n33;
+    bool n219 = !n218 && !n217;
+    bool n220 = n219 && !n216;
+    bool n221 = n220 && n35;
+    bool n222 = !n168 && n7;
+    bool n223 = !n106 && n6;
+    bool n224 = !n53 && n2;
+    bool n225 = !n224 && !n223;
+    bool n226 = n225 && !n222;
+    bool n227 = n226 && n4;
+    bool n228 = !n227 && !n221;
+    bool n229 = n228 && n215;
+    bool n230 = !n229 && !n174;
+    bool n231 = n199 && !n180;
+    bool n232 = !n231 && n187;
+    bool n233 = n232 && !n193;
+    bool n234 = n207 && n200;
+    bool n235 = !n199 && !n180;
+    bool n236 = n235 && n213;
+    bool n237 = n236 && !n193;
+    bool n238 = !n237 && n187;
+    bool n239 = n238 && !n234;
+    bool n240 = n235 && !n207;
+    bool n241 = n240 && n221;
+    bool n242 = !n231 && !n186;
+    bool n243 = n242 && !n237;
+    bool n244 = n243 && !n241;
+    po[0] = !n53;
+    po[1] = !n106;
+    po[2] = !n168;
+    po[3] = n230;
+    po[4] = !n233;
+    po[5] = !n239;
+    po[6] = !n244;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/Transfer16_1.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 41;
+extern const int PO_WIDTH = 25;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = pi[24];
+    bool n26 = pi[25];
+    bool n27 = pi[26];
+    bool n28 = pi[27];
+    bool n29 = pi[28];
+    bool n30 = pi[29];
+    bool n31 = pi[30];
+    bool n32 = pi[31];
+    bool n33 = pi[32];
+    bool n34 = pi[33];
+    bool n35 = pi[34];
+    bool n36 = pi[35];
+    bool n37 = pi[36];
+    bool n38 = pi[37];
+    bool n39 = pi[38];
+    bool n40 = pi[39];
+    bool n41 = pi[40];
+    bool n42 = n20 && n2;
+    bool n43 = n42 && n21;
+    bool n44 = n42 && n19;
+    bool n45 = n44 && !n43;
+    bool n46 = n45 && n42;
+    bool n47 = n42 && n22;
+    bool n48 = !n47 && n43;
+    bool n49 = n47 && !n43;
+    bool n50 = !n49 && !n48;
+    bool n51 = !n50 && n44;
+    bool n52 = n51 && n42;
+    bool n53 = n42 && n23;
+    bool n54 = n47 && n43;
+    bool n55 = n54 && !n53;
+    bool n56 = !n54 && n53;
+    bool n57 = !n56 && !n55;
+    bool n58 = !n57 && n44;
+    bool n59 = n58 && n42;
+    bool n60 = n42 && n24;
+    bool n61 = n54 && n53;
+    bool n62 = !n61 && n60;
+    bool n63 = n61 && !n60;
+    bool n64 = !n63 && !n62;
+    bool n65 = !n64 && n44;
+    bool n66 = n65 && n42;
+    bool n67 = n42 && n25;
+    bool n68 = !n67 && !n44;
+    bool n69 = !n47 && !n43;
+    bool n70 = !n60 && !n53;
+    bool n71 = n70 && n69;
+    bool n72 = n71 && n3;
+    bool n73 = !n72 && n44;
+    bool n74 = !n73 && !n68;
+    bool n75 = n74 && n42;
+    bool n76 = n42 && n26;
+    bool n77 = !n76 && !n44;
+    bool n78 = n71 && !n4;
+    bool n79 = !n71 && !n67;
+    bool n80 = !n79 && !n78;
+    bool n81 = !n80 && n44;
+    bool n82 = !n81 && !n77;
+    bool n83 = n82 && n42;
+    bool n84 = n42 && n27;
+    bool n85 = !n84 && !n44;
+    bool n86 = n71 && !n5;
+    bool n87 = !n76 && !n71;
+    bool n88 = !n87 && !n86;
+    bool n89 = !n88 && n44;
+    bool n90 = !n89 && !n85;
+    bool n91 = n90 && n42;
+    bool n92 = n42 && n28;
+    bool n93 = !n92 && !n44;
+    bool n94 = n71 && !n6;
+    bool n95 = !n84 && !n71;
+    bool n96 = !n95 && !n94;
+    bool n97 = !n96 && n44;
+    bool n98 = !n97 && !n93;
+    bool n99 = n98 && n42;
+    bool n100 = n42 && n29;
+    bool n101 = !n100 && !n44;
+    bool n102 = n71 && !n7;
+    bool n103 = !n92 && !n71;
+    bool n104 = !n103 && !n102;
+    bool n105 = !n104 && n44;
+    bool n106 = !n105 && !n101;
+    bool n107 = n106 && n42;
+    bool n108 = n42 && n30;
+    bool n109 = !n108 && !n44;
+    bool n110 = n71 && !n8;
+    bool n111 = !n100 && !n71;
+    bool n112 = !n111 && !n110;
+    bool n113 = !n112 && n44;
+    bool n114 = !n113 && !n109;
+    bool n115 = n114 && n42;
+    bool n116 = n42 && n31;
+    bool n117 = !n116 && !n44;
+    bool n118 = n71 && !n9;
+    bool n119 = !n108 && !n71;
+    bool n120 = !n119 && !n118;
+    bool n121 = !n120 && n44;
+    bool n122 = !n121 && !n117;
+    bool n123 = n122 && n42;
+    bool n124 = n42 && n32;
+    bool n125 = !n124 && !n44;
+    bool n126 = n71 && !n10;
+    bool n127 = !n116 && !n71;
+    bool n128 = !n127 && !n126;
+    bool n129 = !n128 && n44;
+    bool n130 = !n129 && !n125;
+    bool n131 = n130 && n42;
+    bool n132 = n42 && n33;
+    bool n133 = !n132 && !n44;
+    bool n134 = n71 && !n11;
+    bool n135 = !n124 && !n71;
+    bool n136 = !n135 && !n134;
+    bool n137 = !n136 && n44;
+    bool n138 = !n137 && !n133;
+    bool n139 = n138 && n42;
+    bool n140 = n42 && n34;
+    bool n141 = !n140 && !n44;
+    bool n142 = n71 && !n12;
+    bool n143 = !n132 && !n71;
+    bool n144 = !n143 && !n142;
+    bool n145 = !n144 && n44;
+    bool n146 = !n145 && !n141;
+    bool n147 = n146 && n42;
+    bool n148 = n42 && n35;
+    bool n149 = !n148 && !n44;
+    bool n150 = n71 && !n13;
+    bool n151 = !n140 && !n71;
+    bool n152 = !n151 && !n150;
+    bool n153 = !n152 && n44;
+    bool n154 = !n153 && !n149;
+    bool n155 = n154 && n42;
+    bool n156 = n42 && n36;
+    bool n157 = !n156 && !n44;
+    bool n158 = n71 && !n14;
+    bool n159 = !n148 && !n71;
+    bool n160 = !n159 && !n158;
+    bool n161 = !n160 && n44;
+    bool n162 = !n161 && !n157;
+    bool n163 = n162 && n42;
+    bool n164 = n42 && n37;
+    bool n165 = !n164 && !n44;
+    bool n166 = n71 && !n15;
+    bool n167 = !n156 && !n71;
+    bool n168 = !n167 && !n166;
+    bool n169 = !n168 && n44;
+    bool n170 = !n169 && !n165;
+    bool n171 = n170 && n42;
+    bool n172 = n42 && n38;
+    bool n173 = !n172 && !n44;
+    bool n174 = n71 && !n16;
+    bool n175 = !n164 && !n71;
+    bool n176 = !n175 && !n174;
+    bool n177 = !n176 && n44;
+    bool n178 = !n177 && !n173;
+    bool n179 = n178 && n42;
+    bool n180 = n42 && n39;
+    bool n181 = !n180 && !n44;
+    bool n182 = n71 && !n17;
+    bool n183 = !n172 && !n71;
+    bool n184 = !n183 && !n182;
+    bool n185 = !n184 && n44;
+    bool n186 = !n185 && !n181;
+    bool n187 = n186 && n42;
+    bool n188 = n42 && n40;
+    bool n189 = !n188 && !n44;
+    bool n190 = n71 && !n18;
+    bool n191 = !n180 && !n71;
+    bool n192 = !n191 && !n190;
+    bool n193 = !n192 && n44;
+    bool n194 = !n193 && !n189;
+    bool n195 = n194 && n42;
+    bool n196 = n42 && n41;
+    bool n197 = n196 && !n44;
+    bool n198 = n71 && n44;
+    bool n199 = !n198 && !n197;
+    bool n200 = !n199 && n42;
+    po[2] = n42;
+    po[3] = !n0;
+    po[4] = n46;
+    po[5] = n52;
+    po[6] = n59;
+    po[7] = n66;
+    po[8] = n75;
+    po[9] = n83;
+    po[10] = n91;
+    po[11] = n99;
+    po[12] = n107;
+    po[13] = n115;
+    po[14] = n123;
+    po[15] = n131;
+    po[16] = n139;
+    po[17] = n147;
+    po[18] = n155;
+    po[19] = n163;
+    po[20] = n171;
+    po[21] = n179;
+    po[22] = n187;
+    po[23] = n195;
+    po[24] = n200;
+    po[0] = n188;
+    po[1] = n196;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/Transfer8_1.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 24;
+extern const int PO_WIDTH = 16;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = n12 && n2;
+    bool n26 = n25 && n13;
+    bool n27 = n25 && n11;
+    bool n28 = n27 && !n26;
+    bool n29 = n28 && n25;
+    bool n30 = n25 && n14;
+    bool n31 = !n30 && n26;
+    bool n32 = n30 && !n26;
+    bool n33 = !n32 && !n31;
+    bool n34 = !n33 && n27;
+    bool n35 = n34 && n25;
+    bool n36 = n25 && n15;
+    bool n37 = n30 && n26;
+    bool n38 = !n37 && n36;
+    bool n39 = n37 && !n36;
+    bool n40 = !n39 && !n38;
+    bool n41 = !n40 && n27;
+    bool n42 = n41 && n25;
+    bool n43 = n25 && n16;
+    bool n44 = !n43 && !n27;
+    bool n45 = !n30 && !n26;
+    bool n46 = n45 && !n36;
+    bool n47 = n46 && n3;
+    bool n48 = !n47 && n27;
+    bool n49 = !n48 && !n44;
+    bool n50 = n49 && n25;
+    bool n51 = n25 && n17;
+    bool n52 = !n51 && !n27;
+    bool n53 = n46 && !n4;
+    bool n54 = !n46 && !n43;
+    bool n55 = !n54 && !n53;
+    bool n56 = !n55 && n27;
+    bool n57 = !n56 && !n52;
+    bool n58 = n57 && n25;
+    bool n59 = n25 && n18;
+    bool n60 = !n59 && !n27;
+    bool n61 = n46 && !n5;
+    bool n62 = !n51 && !n46;
+    bool n63 = !n62 && !n61;
+    bool n64 = !n63 && n27;
+    bool n65 = !n64 && !n60;
+    bool n66 = n65 && n25;
+    bool n67 = n25 && n19;
+    bool n68 = !n67 && !n27;
+    bool n69 = n46 && !n6;
+    bool n70 = !n59 && !n46;
+    bool n71 = !n70 && !n69;
+    bool n72 = !n71 && n27;
+    bool n73 = !n72 && !n68;
+    bool n74 = n73 && n25;
+    bool n75 = n25 && n20;
+    bool n76 = !n75 && !n27;
+    bool n77 = n46 && !n7;
+    bool n78 = !n67 && !n46;
+    bool n79 = !n78 && !n77;
+    bool n80 = !n79 && n27;
+    bool n81 = !n80 && !n76;
+    bool n82 = n81 && n25;
+    bool n83 = n25 && n21;
+    bool n84 = !n83 && !n27;
+    bool n85 = n46 && !n8;
+    bool n86 = !n75 && !n46;
+    bool n87 = !n86 && !n85;
+    bool n88 = !n87 && n27;
+    bool n89 = !n88 && !n84;
+    bool n90 = n89 && n25;
+    bool n91 = n25 && n22;
+    bool n92 = !n91 && !n27;
+    bool n93 = n46 && !n9;
+    bool n94 = !n83 && !n46;
+    bool n95 = !n94 && !n93;
+    bool n96 = !n95 && n27;
+    bool n97 = !n96 && !n92;
+    bool n98 = n97 && n25;
+    bool n99 = n25 && n23;
+    bool n100 = !n99 && !n27;
+    bool n101 = n46 && !n10;
+    bool n102 = !n91 && !n46;
+    bool n103 = !n102 && !n101;
+    bool n104 = !n103 && n27;
+    bool n105 = !n104 && !n100;
+    bool n106 = n105 && n25;
+    bool n107 = n25 && n24;
+    bool n108 = n107 && !n27;
+    bool n109 = n46 && n27;
+    bool n110 = !n109 && !n108;
+    bool n111 = !n110 && n25;
+    po[2] = n25;
+    po[3] = !n0;
+    po[4] = n29;
+    po[5] = n35;
+    po[6] = n42;
+    po[7] = n50;
+    po[8] = n58;
+    po[9] = n66;
+    po[10] = n74;
+    po[11] = n82;
+    po[12] = n90;
+    po[13] = n98;
+    po[14] = n106;
+    po[15] = n111;
+    po[0] = n99;
+    po[1] = n107;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/Transfer8_1_comb.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 24;
+extern const int PO_WIDTH = 16;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = n23 && n12;
+    bool n26 = n25 && n2;
+    bool n27 = n24 && n12;
+    bool n28 = n27 && n2;
+    bool n29 = n12 && n2;
+    bool n30 = !n13 && n11;
+    bool n31 = n30 && n12;
+    bool n32 = n31 && n2;
+    bool n33 = !n14 && !n13;
+    bool n34 = n14 && n13;
+    bool n35 = !n34 && !n33;
+    bool n36 = n35 && n11;
+    bool n37 = n36 && n12;
+    bool n38 = n37 && n2;
+    bool n39 = !n15 && !n14;
+    bool n40 = n15 && n14;
+    bool n41 = !n40 && !n39;
+    bool n42 = n41 && n13;
+    bool n43 = n15 && !n13;
+    bool n44 = !n43 && !n42;
+    bool n45 = !n44 && n11;
+    bool n46 = n45 && n12;
+    bool n47 = n46 && n2;
+    bool n48 = !n15 && !n14;
+    bool n49 = n48 && !n13;
+    bool n50 = !n49 && n11;
+    bool n51 = !n16 && !n11;
+    bool n52 = !n51 && !n50;
+    bool n53 = !n52 && n3;
+    bool n54 = n16 && !n11;
+    bool n55 = !n54 && !n3;
+    bool n56 = !n55 && !n53;
+    bool n57 = n56 && n12;
+    bool n58 = n57 && n2;
+    bool n59 = !n17 && !n11;
+    bool n60 = n59 && n4;
+    bool n61 = n48 && !n13;
+    bool n62 = n61 && n11;
+    bool n63 = !n17 && !n11;
+    bool n64 = !n63 && !n62;
+    bool n65 = !n64 && !n4;
+    bool n66 = !n65 && !n60;
+    bool n67 = !n66 && n16;
+    bool n68 = !n49 && n11;
+    bool n69 = !n17 && !n11;
+    bool n70 = !n69 && !n68;
+    bool n71 = !n70 && n4;
+    bool n72 = n17 && !n11;
+    bool n73 = !n72 && !n4;
+    bool n74 = !n73 && !n71;
+    bool n75 = !n74 && !n16;
+    bool n76 = !n75 && !n67;
+    bool n77 = n76 && n12;
+    bool n78 = n77 && n2;
+    bool n79 = !n18 && !n11;
+    bool n80 = n79 && n5;
+    bool n81 = n61 && n11;
+    bool n82 = !n18 && !n11;
+    bool n83 = !n82 && !n81;
+    bool n84 = !n83 && !n5;
+    bool n85 = !n84 && !n80;
+    bool n86 = !n85 && n17;
+    bool n87 = !n49 && n11;
+    bool n88 = !n18 && !n11;
+    bool n89 = !n88 && !n87;
+    bool n90 = !n89 && n5;
+    bool n91 = n18 && !n11;
+    bool n92 = !n91 && !n5;
+    bool n93 = !n92 && !n90;
+    bool n94 = !n93 && !n17;
+    bool n95 = !n94 && !n86;
+    bool n96 = n95 && n12;
+    bool n97 = n96 && n2;
+    bool n98 = n49 && !n6;
+    bool n99 = n98 && n11;
+    bool n100 = !n19 && !n11;
+    bool n101 = !n100 && !n99;
+    bool n102 = !n101 && n18;
+    bool n103 = n49 && n6;
+    bool n104 = !n103 && n11;
+    bool n105 = !n19 && !n11;
+    bool n106 = !n105 && !n104;
+    bool n107 = !n106 && !n18;
+    bool n108 = !n107 && !n102;
+    bool n109 = n108 && n12;
+    bool n110 = n109 && n2;
+    bool n111 = !n49 && !n19;
+    bool n112 = n111 && n11;
+    bool n113 = !n20 && !n11;
+    bool n114 = !n113 && !n112;
+    bool n115 = !n114 && n7;
+    bool n116 = !n49 && n19;
+    bool n117 = !n116 && n11;
+    bool n118 = !n20 && !n11;
+    bool n119 = !n118 && !n117;
+    bool n120 = !n119 && !n7;
+    bool n121 = !n120 && !n115;
+    bool n122 = n121 && n12;
+    bool n123 = n122 && n2;
+    bool n124 = n20 && n13;
+    bool n125 = n20 && n14;
+    bool n126 = n20 && n15;
+    bool n127 = !n15 && n8;
+    bool n128 = !n127 && !n126;
+    bool n129 = !n128 && !n14;
+    bool n130 = !n129 && !n125;
+    bool n131 = !n130 && !n13;
+    bool n132 = !n131 && !n124;
+    bool n133 = !n132 && n11;
+    bool n134 = n21 && !n11;
+    bool n135 = !n134 && !n133;
+    bool n136 = !n135 && n12;
+    bool n137 = n136 && n2;
+    bool n138 = n21 && n13;
+    bool n139 = n21 && n14;
+    bool n140 = n21 && n15;
+    bool n141 = !n15 && n9;
+    bool n142 = !n141 && !n140;
+    bool n143 = !n142 && !n14;
+    bool n144 = !n143 && !n139;
+    bool n145 = !n144 && !n13;
+    bool n146 = !n145 && !n138;
+    bool n147 = !n146 && n11;
+    bool n148 = n22 && !n11;
+    bool n149 = !n148 && !n147;
+    bool n150 = !n149 && n12;
+    bool n151 = n150 && n2;
+    bool n152 = n22 && n13;
+    bool n153 = n22 && n14;
+    bool n154 = n22 && n15;
+    bool n155 = !n15 && n10;
+    bool n156 = !n155 && !n154;
+    bool n157 = !n156 && !n14;
+    bool n158 = !n157 && !n153;
+    bool n159 = !n158 && !n13;
+    bool n160 = !n159 && !n152;
+    bool n161 = !n160 && n11;
+    bool n162 = n23 && !n11;
+    bool n163 = !n162 && !n161;
+    bool n164 = !n163 && n12;
+    bool n165 = n164 && n2;
+    bool n166 = n61 && n11;
+    bool n167 = n24 && !n11;
+    bool n168 = !n167 && !n166;
+    bool n169 = !n168 && n12;
+    bool n170 = n169 && n2;
+    po[0] = n26;
+    po[1] = n28;
+    po[2] = n29;
+    po[3] = !n0;
+    po[4] = n32;
+    po[5] = n38;
+    po[6] = n47;
+    po[7] = n58;
+    po[8] = n78;
+    po[9] = n97;
+    po[10] = n110;
+    po[11] = n123;
+    po[12] = n137;
+    po[13] = n151;
+    po[14] = n165;
+    po[15] = n170;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/parallel_serial_16.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 38;
+extern const int PO_WIDTH = 23;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = pi[24];
+    bool n26 = pi[25];
+    bool n27 = pi[26];
+    bool n28 = pi[27];
+    bool n29 = pi[28];
+    bool n30 = pi[29];
+    bool n31 = pi[30];
+    bool n32 = pi[31];
+    bool n33 = pi[32];
+    bool n34 = pi[33];
+    bool n35 = pi[34];
+    bool n36 = pi[35];
+    bool n37 = pi[36];
+    bool n38 = pi[37];
+    bool n39 = !n18 && n17;
+    bool n40 = n18 && n17;
+    bool n41 = n19 && n17;
+    bool n42 = n41 && !n40;
+    bool n43 = !n41 && n40;
+    bool n44 = !n43 && !n42;
+    bool n45 = !n44 && n17;
+    bool n46 = n20 && n17;
+    bool n47 = n41 && n40;
+    bool n48 = !n47 && n46;
+    bool n49 = n47 && !n46;
+    bool n50 = !n49 && !n48;
+    bool n51 = !n50 && n17;
+    bool n52 = n21 && n17;
+    bool n53 = n47 && n46;
+    bool n54 = !n53 && n52;
+    bool n55 = n53 && !n52;
+    bool n56 = !n55 && !n54;
+    bool n57 = !n56 && n17;
+    bool n58 = n52 && n46;
+    bool n59 = n58 && n47;
+    bool n60 = n59 && n17;
+    bool n61 = n59 && n1;
+    bool n62 = n61 && n17;
+    bool n63 = n59 && n2;
+    bool n64 = n23 && n17;
+    bool n65 = n64 && !n59;
+    bool n66 = !n65 && !n63;
+    bool n67 = !n66 && n17;
+    bool n68 = n59 && n3;
+    bool n69 = n24 && n17;
+    bool n70 = n69 && !n59;
+    bool n71 = !n70 && !n68;
+    bool n72 = !n71 && n17;
+    bool n73 = n59 && n4;
+    bool n74 = n25 && n17;
+    bool n75 = n74 && !n59;
+    bool n76 = !n75 && !n73;
+    bool n77 = !n76 && n17;
+    bool n78 = n59 && n5;
+    bool n79 = n26 && n17;
+    bool n80 = n79 && !n59;
+    bool n81 = !n80 && !n78;
+    bool n82 = !n81 && n17;
+    bool n83 = n59 && n6;
+    bool n84 = n27 && n17;
+    bool n85 = n84 && !n59;
+    bool n86 = !n85 && !n83;
+    bool n87 = !n86 && n17;
+    bool n88 = n59 && n7;
+    bool n89 = n28 && n17;
+    bool n90 = n89 && !n59;
+    bool n91 = !n90 && !n88;
+    bool n92 = !n91 && n17;
+    bool n93 = n59 && n8;
+    bool n94 = n29 && n17;
+    bool n95 = n94 && !n59;
+    bool n96 = !n95 && !n93;
+    bool n97 = !n96 && n17;
+    bool n98 = n59 && n9;
+    bool n99 = n30 && n17;
+    bool n100 = n99 && !n59;
+    bool n101 = !n100 && !n98;
+    bool n102 = !n101 && n17;
+    bool n103 = n59 && n10;
+    bool n104 = n31 && n17;
+    bool n105 = n104 && !n59;
+    bool n106 = !n105 && !n103;
+    bool n107 = !n106 && n17;
+    bool n108 = n59 && n11;
+    bool n109 = n32 && n17;
+    bool n110 = n109 && !n59;
+    bool n111 = !n110 && !n108;
+    bool n112 = !n111 && n17;
+    bool n113 = n59 && n12;
+    bool n114 = n33 && n17;
+    bool n115 = n114 && !n59;
+    bool n116 = !n115 && !n113;
+    bool n117 = !n116 && n17;
+    bool n118 = n59 && n13;
+    bool n119 = n34 && n17;
+    bool n120 = n119 && !n59;
+    bool n121 = !n120 && !n118;
+    bool n122 = !n121 && n17;
+    bool n123 = n59 && n14;
+    bool n124 = n35 && n17;
+    bool n125 = n124 && !n59;
+    bool n126 = !n125 && !n123;
+    bool n127 = !n126 && n17;
+    bool n128 = n59 && n15;
+    bool n129 = n36 && n17;
+    bool n130 = n129 && !n59;
+    bool n131 = !n130 && !n128;
+    bool n132 = !n131 && n17;
+    bool n133 = n59 && n16;
+    bool n134 = n37 && n17;
+    bool n135 = n134 && !n59;
+    bool n136 = !n135 && !n133;
+    bool n137 = !n136 && n17;
+    bool n138 = n22 && n17;
+    bool n139 = n38 && n17;
+    po[2] = n39;
+    po[3] = n45;
+    po[4] = n51;
+    po[5] = n57;
+    po[6] = n60;
+    po[7] = n62;
+    po[8] = n67;
+    po[9] = n72;
+    po[10] = n77;
+    po[11] = n82;
+    po[12] = n87;
+    po[13] = n92;
+    po[14] = n97;
+    po[15] = n102;
+    po[16] = n107;
+    po[17] = n112;
+    po[18] = n117;
+    po[19] = n122;
+    po[20] = n127;
+    po[21] = n132;
+    po[22] = n137;
+    po[0] = n138;
+    po[1] = n139;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/parallel_serial_4.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 12;
+extern const int PO_WIDTH = 9;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = !n6 && n5;
+    bool n14 = n6 && n5;
+    bool n15 = n7 && n5;
+    bool n16 = n15 && !n14;
+    bool n17 = !n15 && n14;
+    bool n18 = !n17 && !n16;
+    bool n19 = !n18 && n5;
+    bool n20 = n15 && n14;
+    bool n21 = n20 && n5;
+    bool n22 = n20 && n1;
+    bool n23 = n22 && n5;
+    bool n24 = n20 && n2;
+    bool n25 = n9 && n5;
+    bool n26 = n25 && !n20;
+    bool n27 = !n26 && !n24;
+    bool n28 = !n27 && n5;
+    bool n29 = n20 && n3;
+    bool n30 = n10 && n5;
+    bool n31 = n30 && !n20;
+    bool n32 = !n31 && !n29;
+    bool n33 = !n32 && n5;
+    bool n34 = n20 && n4;
+    bool n35 = n11 && n5;
+    bool n36 = n35 && !n20;
+    bool n37 = !n36 && !n34;
+    bool n38 = !n37 && n5;
+    bool n39 = n8 && n5;
+    bool n40 = n12 && n5;
+    po[2] = n13;
+    po[3] = n19;
+    po[4] = n21;
+    po[5] = n23;
+    po[6] = n28;
+    po[7] = n33;
+    po[8] = n38;
+    po[0] = n39;
+    po[1] = n40;
+}
+#endif
\ No newline at end of file

src/io_generator/cpp_comb/seq_transfer8.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 24;
+extern const int PO_WIDTH = 16;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = pi[11];
+    bool n13 = pi[12];
+    bool n14 = pi[13];
+    bool n15 = pi[14];
+    bool n16 = pi[15];
+    bool n17 = pi[16];
+    bool n18 = pi[17];
+    bool n19 = pi[18];
+    bool n20 = pi[19];
+    bool n21 = pi[20];
+    bool n22 = pi[21];
+    bool n23 = pi[22];
+    bool n24 = pi[23];
+    bool n25 = n23 && n12;
+    bool n26 = n25 && n2;
+    bool n27 = n24 && n12;
+    bool n28 = n27 && n2;
+    bool n29 = n12 && n2;
+    bool n30 = !n13 && n11;
+    bool n31 = n30 && n12;
+    bool n32 = n31 && n2;
+    bool n33 = !n14 && !n13;
+    bool n34 = n14 && n13;
+    bool n35 = !n34 && !n33;
+    bool n36 = n35 && n11;
+    bool n37 = n36 && n12;
+    bool n38 = n37 && n2;
+    bool n39 = !n15 && !n14;
+    bool n40 = n15 && n14;
+    bool n41 = !n40 && !n39;
+    bool n42 = n41 && n13;
+    bool n43 = n15 && !n13;
+    bool n44 = !n43 && !n42;
+    bool n45 = !n44 && n11;
+    bool n46 = n45 && n12;
+    bool n47 = n46 && n2;
+    bool n48 = !n15 && !n14;
+    bool n49 = n48 && !n13;
+    bool n50 = n49 && n3;
+    bool n51 = n50 && n11;
+    bool n52 = n16 && !n11;
+    bool n53 = !n52 && !n51;
+    bool n54 = !n53 && n12;
+    bool n55 = n54 && n2;
+    bool n56 = n16 && n13;
+    bool n57 = n16 && n14;
+    bool n58 = n16 && n15;
+    bool n59 = !n15 && n4;
+    bool n60 = !n59 && !n58;
+    bool n61 = !n60 && !n14;
+    bool n62 = !n61 && !n57;
+    bool n63 = !n62 && !n13;
+    bool n64 = !n63 && !n56;
+    bool n65 = !n64 && n11;
+    bool n66 = n17 && !n11;
+    bool n67 = !n66 && !n65;
+    bool n68 = !n67 && n12;
+    bool n69 = n68 && n2;
+    bool n70 = n17 && n13;
+    bool n71 = n17 && n14;
+    bool n72 = n17 && n15;
+    bool n73 = !n15 && n5;
+    bool n74 = !n73 && !n72;
+    bool n75 = !n74 && !n14;
+    bool n76 = !n75 && !n71;
+    bool n77 = !n76 && !n13;
+    bool n78 = !n77 && !n70;
+    bool n79 = !n78 && n11;
+    bool n80 = n18 && !n11;
+    bool n81 = !n80 && !n79;
+    bool n82 = !n81 && n12;
+    bool n83 = n82 && n2;
+    bool n84 = n18 && n13;
+    bool n85 = n18 && n14;
+    bool n86 = n18 && n15;
+    bool n87 = !n15 && n6;
+    bool n88 = !n87 && !n86;
+    bool n89 = !n88 && !n14;
+    bool n90 = !n89 && !n85;
+    bool n91 = !n90 && !n13;
+    bool n92 = !n91 && !n84;
+    bool n93 = !n92 && n11;
+    bool n94 = n19 && !n11;
+    bool n95 = !n94 && !n93;
+    bool n96 = !n95 && n12;
+    bool n97 = n96 && n2;
+    bool n98 = n19 && n13;
+    bool n99 = n19 && n14;
+    bool n100 = n19 && n15;
+    bool n101 = !n15 && n7;
+    bool n102 = !n101 && !n100;
+    bool n103 = !n102 && !n14;
+    bool n104 = !n103 && !n99;
+    bool n105 = !n104 && !n13;
+    bool n106 = !n105 && !n98;
+    bool n107 = !n106 && n11;
+    bool n108 = n20 && !n11;
+    bool n109 = !n108 && !n107;
+    bool n110 = !n109 && n12;
+    bool n111 = n110 && n2;
+    bool n112 = n20 && n13;
+    bool n113 = n20 && n14;
+    bool n114 = n20 && n15;
+    bool n115 = !n15 && n8;
+    bool n116 = !n115 && !n114;
+    bool n117 = !n116 && !n14;
+    bool n118 = !n117 && !n113;
+    bool n119 = !n118 && !n13;
+    bool n120 = !n119 && !n112;
+    bool n121 = !n120 && n11;
+    bool n122 = n21 && !n11;
+    bool n123 = !n122 && !n121;
+    bool n124 = !n123 && n12;
+    bool n125 = n124 && n2;
+    bool n126 = n21 && n13;
+    bool n127 = n21 && n14;
+    bool n128 = n21 && n15;
+    bool n129 = !n15 && n9;
+    bool n130 = !n129 && !n128;
+    bool n131 = !n130 && !n14;
+    bool n132 = !n131 && !n127;
+    bool n133 = !n132 && !n13;
+    bool n134 = !n133 && !n126;
+    bool n135 = !n134 && n11;
+    bool n136 = n22 && !n11;
+    bool n137 = !n136 && !n135;
+    bool n138 = !n137 && n12;
+    bool n139 = n138 && n2;
+    bool n140 = n22 && n13;
+    bool n141 = n22 && n14;
+    bool n142 = n22 && n15;
+    bool n143 = !n15 && n10;
+    bool n144 = !n143 && !n142;
+    bool n145 = !n144 && !n14;
+    bool n146 = !n145 && !n141;
+    bool n147 = !n146 && !n13;
+    bool n148 = !n147 && !n140;
+    bool n149 = !n148 && n11;
+    bool n150 = n23 && !n11;
+    bool n151 = !n150 && !n149;
+    bool n152 = !n151 && n12;
+    bool n153 = n152 && n2;
+    bool n154 = !n49 && n11;
+    bool n155 = !n24 && !n11;
+    bool n156 = !n155 && !n154;
+    bool n157 = n156 && n12;
+    bool n158 = n157 && n2;
+    po[0] = n26;
+    po[1] = n28;
+    po[2] = n29;
+    po[3] = !n0;
+    po[4] = n32;
+    po[5] = n38;
+    po[6] = n47;
+    po[7] = n55;
+    po[8] = n69;
+    po[9] = n83;
+    po[10] = n97;
+    po[11] = n111;
+    po[12] = n125;
+    po[13] = n139;
+    po[14] = n153;
+    po[15] = n158;
+}
+#endif
\ No newline at end of file

src/io_generator/ctrl.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 7;
+extern const int PO_WIDTH = 26;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = !n7 && n6;
+    bool n9 = !n8 && n3;
+    bool n10 = !n4 && n3;
+    bool n11 = n10 && !n9;
+    bool n12 = !n11 && !n5;
+    bool n13 = n6 && n1;
+    bool n14 = n7 && n6;
+    bool n15 = n6 && !n1;
+    bool n16 = n15 && !n14;
+    bool n17 = !n16 && !n13;
+    bool n18 = n4 && n3;
+    bool n19 = n18 && !n17;
+    bool n20 = !n19 && n12;
+    bool n21 = n14 && !n3;
+    bool n22 = n21 && n4;
+    bool n23 = n7 && n6;
+    bool n24 = n23 && !n4;
+    bool n25 = !n24 && !n22;
+    bool n26 = n25 && n5;
+    bool n27 = !n26 && !n20;
+    bool n28 = n7 && !n6;
+    bool n29 = n28 && n3;
+    bool n30 = n29 && n5;
+    bool n31 = n7 && n1;
+    bool n32 = n6 && !n3;
+    bool n33 = n32 && n31;
+    bool n34 = !n17 && n2;
+    bool n35 = n6 && !n2;
+    bool n36 = n35 && !n14;
+    bool n37 = !n36 && !n34;
+    bool n38 = !n37 && n3;
+    bool n39 = !n38 && !n33;
+    bool n40 = !n39 && n4;
+    bool n41 = n40 && !n5;
+    bool n42 = !n41 && !n30;
+    bool n43 = n28 && n5;
+    bool n44 = n6 && n2;
+    bool n45 = !n44 && !n36;
+    bool n46 = !n45 && !n5;
+    bool n47 = !n46 && !n43;
+    bool n48 = !n47 && n4;
+    bool n49 = n6 && n5;
+    bool n50 = n49 && n7;
+    bool n51 = !n7 && !n6;
+    bool n52 = !n51 && n3;
+    bool n53 = !n23 && !n3;
+    bool n54 = n53 && !n51;
+    bool n55 = !n54 && !n52;
+    bool n56 = !n55 && n4;
+    bool n57 = !n23 && !n4;
+    bool n58 = n57 && !n51;
+    bool n59 = !n58 && !n56;
+    bool n60 = !n59 && !n5;
+    bool n61 = !n60 && !n50;
+    bool n62 = n14 && n10;
+    bool n63 = !n6 && !n3;
+    bool n64 = n63 && !n28;
+    bool n65 = !n51 && !n23;
+    bool n66 = !n65 && n3;
+    bool n67 = !n66 && !n64;
+    bool n68 = !n67 && n4;
+    bool n69 = !n68 && !n62;
+    bool n70 = !n69 && n5;
+    bool n71 = !n21 && !n4;
+    bool n72 = !n5 && !n4;
+    bool n73 = n72 && !n71;
+    bool n74 = !n73 && !n70;
+    bool n75 = n5 && n4;
+    bool n76 = n75 && !n65;
+    bool n77 = n28 && !n3;
+    bool n78 = !n77 && n4;
+    bool n79 = !n5 && n4;
+    bool n80 = n79 && !n78;
+    bool n81 = !n80 && !n76;
+    bool n82 = n51 && n4;
+    bool n83 = n82 && n5;
+    bool n84 = n77 && n4;
+    bool n85 = n23 && !n4;
+    bool n86 = !n85 && !n84;
+    bool n87 = !n86 && !n5;
+    bool n88 = !n87 && !n83;
+    bool n89 = !n28 && n5;
+    bool n90 = !n51 && n3;
+    bool n91 = n6 && !n3;
+    bool n92 = !n91 && !n90;
+    bool n93 = !n92 && n4;
+    bool n94 = !n58 && !n5;
+    bool n95 = n94 && !n93;
+    bool n96 = !n95 && !n89;
+    bool n97 = n8 && !n3;
+    bool n98 = n97 && !n4;
+    bool n99 = n98 && n5;
+    bool n100 = n8 && n3;
+    bool n101 = n100 && n4;
+    bool n102 = n101 && n5;
+    bool n103 = n97 && n4;
+    bool n104 = n103 && n5;
+    bool n105 = n100 && !n4;
+    bool n106 = n105 && n5;
+    bool n107 = n51 && !n3;
+    bool n108 = n107 && !n4;
+    bool n109 = n108 && !n5;
+    bool n110 = n23 && n1;
+    bool n111 = n110 && !n2;
+    bool n112 = n111 && n3;
+    bool n113 = !n112 && n4;
+    bool n114 = !n100 && !n4;
+    bool n115 = !n114 && !n113;
+    bool n116 = n115 && !n5;
+    bool n117 = !n25 && n5;
+    bool n118 = !n37 && n18;
+    bool n119 = n118 && !n5;
+    bool n120 = !n119 && !n117;
+    bool n121 = n51 && n5;
+    bool n122 = n29 && n4;
+    bool n123 = n77 && !n4;
+    bool n124 = !n123 && !n122;
+    bool n125 = !n124 && !n5;
+    bool n126 = !n8 && n4;
+    bool n127 = n7 && !n4;
+    bool n128 = !n127 && !n126;
+    bool n129 = !n128 && n5;
+    bool n130 = !n51 && n4;
+    bool n131 = !n92 && !n4;
+    bool n132 = !n131 && !n130;
+    bool n133 = !n132 && !n5;
+    bool n134 = !n133 && !n129;
+    bool n135 = n8 && n3;
+    bool n136 = n65 && !n3;
+    bool n137 = !n136 && !n135;
+    bool n138 = !n137 && n4;
+    bool n139 = n21 && !n4;
+    bool n140 = !n139 && !n138;
+    bool n141 = !n140 && !n5;
+    bool n142 = n28 && n5;
+    bool n143 = n28 && n4;
+    bool n144 = n67 && !n4;
+    bool n145 = !n144 && !n143;
+    bool n146 = !n145 && !n5;
+    bool n147 = !n146 && !n142;
+    bool n148 = n51 && n3;
+    bool n149 = n148 && n5;
+    bool n150 = n107 && n5;
+    bool n151 = !n65 && n4;
+    bool n152 = n6 && !n4;
+    bool n153 = n152 && n7;
+    bool n154 = !n153 && !n151;
+    bool n155 = !n154 && n5;
+    bool n156 = n6 && n4;
+    bool n157 = n156 && n7;
+    bool n158 = !n157 && !n62;
+    bool n159 = !n158 && !n5;
+    bool n160 = !n159 && !n155;
+    bool n161 = n82 && n5;
+    bool n162 = n28 && n4;
+    bool n163 = n21 && !n4;
+    bool n164 = !n163 && !n162;
+    bool n165 = !n164 && !n5;
+    bool n166 = !n165 && !n161;
+    bool n167 = n29 && !n4;
+    bool n168 = n167 && !n5;
+    po[0] = n27;
+    po[1] = !n42;
+    po[2] = n48;
+    po[3] = !n61;
+    po[4] = !n74;
+    po[5] = !n81;
+    po[6] = !n88;
+    po[7] = n96;
+    po[8] = n99;
+    po[9] = n102;
+    po[10] = n104;
+    po[11] = n106;
+    po[12] = n109;
+    po[13] = n116;
+    po[14] = !n120;
+    po[15] = n121;
+    po[16] = n125;
+    po[17] = !n134;
+    po[18] = n141;
+    po[19] = !n147;
+    po[20] = n149;
+    po[21] = n150;
+    po[22] = !n160;
+    po[23] = !n166;
+    po[24] = n168;
+    po[25] = !n0;
+}
+#endif
\ No newline at end of file

src/io_generator/int2float.h

+#ifndef IO_GENERATOR_OUTER_H
+#define IO_GENERATOR_OUTER_H
+extern const int PI_WIDTH = 11;
+extern const int PO_WIDTH = 7;
+void io_generator_outer(bool* pi, bool* po) {
+    bool n0 = false;
+    bool n1 = pi[0];
+    bool n2 = pi[1];
+    bool n3 = pi[2];
+    bool n4 = pi[3];
+    bool n5 = pi[4];
+    bool n6 = pi[5];
+    bool n7 = pi[6];
+    bool n8 = pi[7];
+    bool n9 = pi[8];
+    bool n10 = pi[9];
+    bool n11 = pi[10];
+    bool n12 = n4 && n3;
+    bool n13 = !n12 && !n8;
+    bool n14 = n13 && n7;
+    bool n15 = !n14 && !n11;
+    bool n16 = !n9 && n8;
+    bool n17 = !n16 && !n6;
+    bool n18 = n8 && n7;
+    bool n19 = !n9 && n6;
+    bool n20 = n19 && n18;
+    bool n21 = n3 && n1;
+    bool n22 = !n8 && !n7;
+    bool n23 = n22 && n21;
+    bool n24 = !n23 && !n20;
+    bool n25 = !n24 && n5;
+    bool n26 = n25 && n4;
+    bool n27 = !n26 && !n17;
+    bool n28 = n27 && n15;
+    bool n29 = !n18 && n9;
+    bool n30 = !n8 && n7;
+    bool n31 = !n30 && !n9;
+    bool n32 = !n31 && !n5;
+    bool n33 = !n32 && !n29;
+    bool n34 = n33 && n28;
+    bool n35 = !n34 && !n10;
+    bool n36 = n18 && n9;
+    bool n37 = !n36 && n11;
+    bool n38 = !n11 && n9;
+    bool n39 = n10 && n5;
+    bool n40 = !n5 && n4;
+    bool n41 = !n40 && !n39;
+    bool n42 = !n41 && n6;
+    bool n43 = n42 && n18;
+    bool n44 = n43 && n38;
+    bool n45 = !n44 && !n37;
+    bool n46 = n45 && !n35;
+    bool n47 = !n46 && !n2;
+    bool n48 = n5 && n4;
+    bool n49 = n8 && n6;
+    bool n50 = n49 && n48;
+    bool n51 = n50 && n7;
+    bool n52 = !n8 && !n7;
+    bool n53 = !n52 && !n51;
+    bool n54 = n53 && !n9;
+    bool n55 = n54 && !n10;
+    bool n56 = !n11 && !n2;
+    bool n57 = n10 && n8;
+    bool n58 = n9 && n7;
+    bool n59 = n58 && n57;
+    bool n60 = !n9 && !n7;
+    bool n61 = n60 && n21;
+    bool n62 = !n10 && n5;
+    bool n63 = n62 && n61;
+    bool n64 = !n63 && !n59;
+    bool n65 = !n64 && n4;
+    bool n66 = n58 && n10;
+    bool n67 = n66 && n5;
+    bool n68 = n67 && n8;
+    bool n69 = !n68 && !n65;
+    bool n70 = !n69 && n6;
+    bool n71 = !n70 && n56;
+    bool n72 = n71 && !n55;
+    bool n73 = n6 && n5;
+    bool n74 = n73 && n4;
+    bool n75 = n74 && n18;
+    bool n76 = !n10 && !n9;
+    bool n77 = n76 && !n2;
+    bool n78 = n77 && !n11;
+    bool n79 = n78 && !n75;
+    bool n80 = !n8 && n2;
+    bool n81 = n80 && n9;
+    bool n82 = !n5 && !n4;
+    bool n83 = n5 && n4;
+    bool n84 = !n83 && !n82;
+    bool n85 = n84 && !n11;
+    bool n86 = n85 && !n10;
+    bool n87 = !n86 && !n2;
+    bool n88 = !n87 && !n9;
+    bool n89 = n11 && n2;
+    bool n90 = n89 && n10;
+    bool n91 = !n90 && !n88;
+    bool n92 = !n91 && n8;
+    bool n93 = !n92 && !n81;
+    bool n94 = n10 && n6;
+    bool n95 = n6 && n3;
+    bool n96 = n10 && !n6;
+    bool n97 = !n96 && !n95;
+    bool n98 = !n97 && n1;
+    bool n99 = n6 && n3;
+    bool n100 = !n99 && !n1;
+    bool n101 = !n100 && !n98;
+    bool n102 = n101 && !n8;
+    bool n103 = n102 && !n9;
+    bool n104 = !n103 && !n94;
+    bool n105 = !n104 && !n7;
+    bool n106 = n10 && n7;
+    bool n107 = n106 && !n6;
+    bool n108 = n9 && !n6;
+    bool n109 = !n9 && n7;
+    bool n110 = !n4 && n3;
+    bool n111 = n110 && n109;
+    bool n112 = !n111 && !n108;
+    bool n113 = n112 && n5;
+    bool n114 = n9 && n6;
+    bool n115 = !n114 && !n5;
+    bool n116 = !n115 && !n113;
+    bool n117 = n116 && !n10;
+    bool n118 = !n117 && !n107;
+    bool n119 = n118 && !n105;
+    bool n120 = !n119 && !n11;
+    bool n121 = !n10 && n6;
+    bool n122 = n121 && !n5;
+    bool n123 = !n9 && !n6;
+    bool n124 = !n123 && !n122;
+    bool n125 = !n124 && !n4;
+    bool n126 = n125 && n3;
+    bool n127 = n4 && !n3;
+    bool n128 = n127 && n76;
+    bool n129 = !n128 && !n11;
+    bool n130 = n129 && !n126;
+    bool n131 = !n130 && !n8;
+    bool n132 = n131 && n7;
+    bool n133 = n11 && n8;
+    bool n134 = n133 && !n7;
+    bool n135 = !n134 && !n132;
+    bool n136 = n135 && !n120;
+    bool n137 = !n136 && !n2;
+    bool n138 = !n137 && n93;
+    bool n139 = !n11 && !n6;
+    bool n140 = !n9 && !n4;
+    bool n141 = !n140 && !n139;
+    bool n142 = !n141 && !n3;
+    bool n143 = !n11 && n10;
+    bool n144 = !n12 && n1;
+    bool n145 = n4 && !n1;
+    bool n146 = !n145 && !n144;
+    bool n147 = n146 && !n9;
+    bool n148 = n147 && n6;
+    bool n149 = !n148 && !n143;
+    bool n150 = n149 && !n142;
+    bool n151 = !n150 && !n8;
+    bool n152 = n11 && !n9;
+    bool n153 = !n11 && !n10;
+    bool n154 = n153 && n9;
+    bool n155 = n154 && !n73;
+    bool n156 = !n155 && !n152;
+    bool n157 = n156 && !n151;
+    bool n158 = !n157 && !n7;
+    bool n159 = n143 && !n6;
+    bool n160 = !n159 && !n152;
+    bool n161 = !n160 && !n8;
+    bool n162 = !n153 && n6;
+    bool n163 = !n9 && !n8;
+    bool n164 = !n163 && !n6;
+    bool n165 = !n164 && !n162;
+    bool n166 = n165 && n4;
+    bool n167 = n166 && n3;
+    bool n168 = n121 && n38;
+    bool n169 = !n168 && !n167;
+    bool n170 = !n169 && n5;
+    bool n171 = n143 && n6;
+    bool n172 = n11 && n9;
+    bool n173 = !n172 && !n171;
+    bool n174 = !n173 && n8;
+    bool n175 = !n174 && !n170;
+    bool n176 = !n175 && n7;
+    bool n177 = !n176 && !n161;
+    bool n178 = n177 && !n158;
+    bool n179 = !n178 && !n2;
+    bool n180 = n143 && n9;
+    bool n181 = n180 && n8;
+    bool n182 = n181 && n2;
+    bool n183 = !n11 && n8;
+    bool n184 = n183 && n6;
+    bool n185 = n184 && n48;
+    bool n186 = n183 && !n6;
+    bool n187 = n30 && !n3;
+    bool n188 = !n187 && !n186;
+    bool n189 = !n188 && !n5;
+    bool n190 = n30 && !n5;
+    bool n191 = !n190 && !n186;
+    bool n192 = !n191 && !n4;
+    bool n193 = !n192 && !n189;
+    bool n194 = n193 && !n185;
+    bool n195 = n194 && !n2;
+    bool n196 = !n195 && !n9;
+    bool n197 = !n196 && !n80;
+    bool n198 = !n197 && !n10;
+    bool n199 = !n198 && !n182;
+    bool n200 = n199 && !n179;
+    bool n201 = !n58 && n10;
+    bool n202 = !n201 && !n2;
+    bool n203 = !n202 && n11;
+    bool n204 = n10 && n2;
+    bool n205 = n11 && !n10;
+    bool n206 = n205 && n7;
+    bool n207 = !n206 && !n204;
+    bool n208 = !n207 && n9;
+    bool n209 = n208 && n8;
+    bool n210 = !n209 && !n203;
+    bool n211 = n7 && !n6;
+    bool n212 = !n211 && n5;
+    bool n213 = !n8 && n6;
+    bool n214 = n213 && n1;
+    bool n215 = !n214 && !n5;
+    bool n216 = !n215 && !n212;
+    bool n217 = n216 && n3;
+    bool n218 = !n8 && !n6;
+    bool n219 = !n21 && n6;
+    bool n220 = n219 && n5;
+    bool n221 = !n220 && !n218;
+    bool n222 = !n221 && !n7;
+    bool n223 = !n222 && !n217;
+    bool n224 = !n223 && n4;
+    bool n225 = !n8 && n5;
+    bool n226 = n225 && !n4;
+    bool n227 = n7 && !n5;
+    bool n228 = !n227 && !n226;
+    bool n229 = !n228 && n6;
+    bool n230 = !n229 && !n224;
+    bool n231 = !n230 && !n9;
+    bool n232 = !n73 && n7;
+    bool n233 = n232 && n8;
+    bool n234 = n8 && !n7;
+    bool n235 = n234 && n4;
+    bool n236 = !n235 && !n187;
+    bool n237 = !n236 && n6;
+    bool n238 = n237 && n5;
+    bool n239 = !n238 && !n233;
+    bool n240 = n239 && !n231;
+    bool n241 = !n240 && !n10;
+    bool n242 = n7 && n6;
+    bool n243 = !n242 && n9;
+    bool n244 = n243 && n8;
+    bool n245 = n9 && !n8;
+    bool n246 = n245 && n5;
+    bool n247 = n16 && !n4;
+    bool n248 = !n247 && !n246;
+    bool n249 = !n248 && n7;
+    bool n250 = n249 && n6;
+    bool n251 = !n250 && !n244;
+    bool n252 = n251 && !n241;
+    bool n253 = !n252 && !n11;
+    bool n254 = n109 && n49;
+    bool n255 = !n254 && !n245;
+    bool n256 = !n255 && n10;
+    bool n257 = !n256 && !n253;
+    bool n258 = !n257 && !n2;
+    bool n259 = !n258 && n210;
+    bool n260 = n8 && !n4;
+    bool n261 = n94 && n58;
+    bool n262 = n261 && n260;
+    bool n263 = !n10 && !n6;
+    bool n264 = n263 && !n7;
+    bool n265 = n264 && n163;
+    bool n266 = !n265 && !n262;
+    bool n267 = n56 && !n5;
+    bool n268 = n267 && !n266;
+    po[0] = !n47;
+    po[1] = !n72;
+    po[2] = !n79;
+    po[3] = !n138;
+    po[4] = n200;
+    po[5] = !n259;
+    po[6] = !n268;
+}
+#endif
\ No newline at end of file