aboutsummaryrefslogtreecommitdiff
path: root/day7/logic
diff options
context:
space:
mode:
Diffstat (limited to 'day7/logic')
-rw-r--r--day7/logic3399
1 files changed, 3399 insertions, 0 deletions
diff --git a/day7/logic b/day7/logic
new file mode 100644
index 0000000..024b8f9
--- /dev/null
+++ b/day7/logic
@@ -0,0 +1,3399 @@
+uint16_t wire_ls() {
+ uint16_t out;
+ if(iscached("ls"))
+ return getcache("ls");
+ else {
+ out = (wire_lf() & wire_lq());
+ putcache("ls", out);
+ return out;
+ }
+}
+uint16_t wire_jn() {
+ uint16_t out;
+ if(iscached("jn"))
+ return getcache("jn");
+ else {
+ out = (wire_iu() >> 1);
+ putcache("jn", out);
+ return out;
+ }
+}
+uint16_t wire_bv() {
+ uint16_t out;
+ if(iscached("bv"))
+ return getcache("bv");
+ else {
+ out = (wire_bo() | wire_bu());
+ putcache("bv", out);
+ return out;
+ }
+}
+uint16_t wire_hc() {
+ uint16_t out;
+ if(iscached("hc"))
+ return getcache("hc");
+ else {
+ out = (wire_gj() >> 1);
+ putcache("hc", out);
+ return out;
+ }
+}
+uint16_t wire_eu() {
+ uint16_t out;
+ if(iscached("eu"))
+ return getcache("eu");
+ else {
+ out = (wire_et() >> 2);
+ putcache("eu", out);
+ return out;
+ }
+}
+uint16_t wire_by() {
+ uint16_t out;
+ if(iscached("by"))
+ return getcache("by");
+ else {
+ out = (wire_bv() & wire_bx());
+ putcache("by", out);
+ return out;
+ }
+}
+uint16_t wire_iu() {
+ uint16_t out;
+ if(iscached("iu"))
+ return getcache("iu");
+ else {
+ out = (wire_is() | wire_it());
+ putcache("iu", out);
+ return out;
+ }
+}
+uint16_t wire_o() {
+ uint16_t out;
+ if(iscached("o"))
+ return getcache("o");
+ else {
+ out = (wire_b() | wire_n());
+ putcache("o", out);
+ return out;
+ }
+}
+uint16_t wire_gg() {
+ uint16_t out;
+ if(iscached("gg"))
+ return getcache("gg");
+ else {
+ out = (wire_gf() | wire_ge());
+ putcache("gg", out);
+ return out;
+ }
+}
+uint16_t wire_ku() {
+ uint16_t out;
+ if(iscached("ku"))
+ return getcache("ku");
+ else {
+ out = ~wire_kt();
+ putcache("ku", out);
+ return out;
+ }
+}
+uint16_t wire_ed() {
+ uint16_t out;
+ if(iscached("ed"))
+ return getcache("ed");
+ else {
+ out = (wire_ea() & wire_eb());
+ putcache("ed", out);
+ return out;
+ }
+}
+uint16_t wire_ks() {
+ uint16_t out;
+ if(iscached("ks"))
+ return getcache("ks");
+ else {
+ out = (wire_kl() | wire_kr());
+ putcache("ks", out);
+ return out;
+ }
+}
+uint16_t wire_hl() {
+ uint16_t out;
+ if(iscached("hl"))
+ return getcache("hl");
+ else {
+ out = (wire_hi() & wire_hk());
+ putcache("hl", out);
+ return out;
+ }
+}
+uint16_t wire_ax() {
+ uint16_t out;
+ if(iscached("ax"))
+ return getcache("ax");
+ else {
+ out = (wire_au() & wire_av());
+ putcache("ax", out);
+ return out;
+ }
+}
+uint16_t wire_lg() {
+ uint16_t out;
+ if(iscached("lg"))
+ return getcache("lg");
+ else {
+ out = (wire_lf() >> 2);
+ putcache("lg", out);
+ return out;
+ }
+}
+uint16_t wire_df() {
+ uint16_t out;
+ if(iscached("df"))
+ return getcache("df");
+ else {
+ out = (wire_dd() >> 3);
+ putcache("df", out);
+ return out;
+ }
+}
+uint16_t wire_fc() {
+ uint16_t out;
+ if(iscached("fc"))
+ return getcache("fc");
+ else {
+ out = (wire_eu() & wire_fa());
+ putcache("fc", out);
+ return out;
+ }
+}
+uint16_t wire_di() {
+ uint16_t out;
+ if(iscached("di"))
+ return getcache("di");
+ else {
+ out = (wire_df() & wire_dg());
+ putcache("di", out);
+ return out;
+ }
+}
+uint16_t wire_it() {
+ uint16_t out;
+ if(iscached("it"))
+ return getcache("it");
+ else {
+ out = (wire_ip() << 15);
+ putcache("it", out);
+ return out;
+ }
+}
+uint16_t wire_em() {
+ uint16_t out;
+ if(iscached("em"))
+ return getcache("em");
+ else {
+ out = ~wire_el();
+ putcache("em", out);
+ return out;
+ }
+}
+uint16_t wire_ff() {
+ uint16_t out;
+ if(iscached("ff"))
+ return getcache("ff");
+ else {
+ out = (wire_et() | wire_fe());
+ putcache("ff", out);
+ return out;
+ }
+}
+uint16_t wire_fn() {
+ uint16_t out;
+ if(iscached("fn"))
+ return getcache("fn");
+ else {
+ out = (wire_fj() << 15);
+ putcache("fn", out);
+ return out;
+ }
+}
+uint16_t wire_u() {
+ uint16_t out;
+ if(iscached("u"))
+ return getcache("u");
+ else {
+ out = (wire_t() | wire_s());
+ putcache("u", out);
+ return out;
+ }
+}
+uint16_t wire_ma() {
+ uint16_t out;
+ if(iscached("ma"))
+ return getcache("ma");
+ else {
+ out = (wire_ly() | wire_lz());
+ putcache("ma", out);
+ return out;
+ }
+}
+uint16_t wire_kr() {
+ uint16_t out;
+ if(iscached("kr"))
+ return getcache("kr");
+ else {
+ out = (wire_ko() & wire_kq());
+ putcache("kr", out);
+ return out;
+ }
+}
+uint16_t wire_fy() {
+ uint16_t out;
+ if(iscached("fy"))
+ return getcache("fy");
+ else {
+ out = ~wire_fx();
+ putcache("fy", out);
+ return out;
+ }
+}
+uint16_t wire_fm() {
+ uint16_t out;
+ if(iscached("fm"))
+ return getcache("fm");
+ else {
+ out = (wire_et() >> 1);
+ putcache("fm", out);
+ return out;
+ }
+}
+uint16_t wire_fb() {
+ uint16_t out;
+ if(iscached("fb"))
+ return getcache("fb");
+ else {
+ out = (wire_eu() | wire_fa());
+ putcache("fb", out);
+ return out;
+ }
+}
+uint16_t wire_de() {
+ uint16_t out;
+ if(iscached("de"))
+ return getcache("de");
+ else {
+ out = (wire_dd() >> 2);
+ putcache("de", out);
+ return out;
+ }
+}
+uint16_t wire_gp() {
+ uint16_t out;
+ if(iscached("gp"))
+ return getcache("gp");
+ else {
+ out = ~wire_go();
+ putcache("gp", out);
+ return out;
+ }
+}
+uint16_t wire_ke() {
+ uint16_t out;
+ if(iscached("ke"))
+ return getcache("ke");
+ else {
+ out = (wire_kb() & wire_kd());
+ putcache("ke", out);
+ return out;
+ }
+}
+uint16_t wire_hi() {
+ uint16_t out;
+ if(iscached("hi"))
+ return getcache("hi");
+ else {
+ out = (wire_hg() | wire_hh());
+ putcache("hi", out);
+ return out;
+ }
+}
+uint16_t wire_kg() {
+ uint16_t out;
+ if(iscached("kg"))
+ return getcache("kg");
+ else {
+ out = (wire_jm() << 1);
+ putcache("kg", out);
+ return out;
+ }
+}
+uint16_t wire_co() {
+ uint16_t out;
+ if(iscached("co"))
+ return getcache("co");
+ else {
+ out = ~wire_cn();
+ putcache("co", out);
+ return out;
+ }
+}
+uint16_t wire_jq() {
+ uint16_t out;
+ if(iscached("jq"))
+ return getcache("jq");
+ else {
+ out = (wire_jp() >> 2);
+ putcache("jq", out);
+ return out;
+ }
+}
+uint16_t wire_js() {
+ uint16_t out;
+ if(iscached("js"))
+ return getcache("js");
+ else {
+ out = (wire_jp() >> 5);
+ putcache("js", out);
+ return out;
+ }
+}
+uint16_t wire_ip() {
+ uint16_t out;
+ if(iscached("ip"))
+ return getcache("ip");
+ else {
+ out = (1 & wire_io());
+ putcache("ip", out);
+ return out;
+ }
+}
+uint16_t wire_es() {
+ uint16_t out;
+ if(iscached("es"))
+ return getcache("es");
+ else {
+ out = (wire_eo() << 15);
+ putcache("es", out);
+ return out;
+ }
+}
+uint16_t wire_jk() {
+ uint16_t out;
+ if(iscached("jk"))
+ return getcache("jk");
+ else {
+ out = (1 & wire_jj());
+ putcache("jk", out);
+ return out;
+ }
+}
+uint16_t wire_j() {
+ uint16_t out;
+ if(iscached("j"))
+ return getcache("j");
+ else {
+ out = (wire_g() & wire_i());
+ putcache("j", out);
+ return out;
+ }
+}
+uint16_t wire_ck() {
+ uint16_t out;
+ if(iscached("ck"))
+ return getcache("ck");
+ else {
+ out = (wire_ci() >> 3);
+ putcache("ck", out);
+ return out;
+ }
+}
+uint16_t wire_gq() {
+ uint16_t out;
+ if(iscached("gq"))
+ return getcache("gq");
+ else {
+ out = (wire_gn() & wire_gp());
+ putcache("gq", out);
+ return out;
+ }
+}
+uint16_t wire_fv() {
+ uint16_t out;
+ if(iscached("fv"))
+ return getcache("fv");
+ else {
+ out = (wire_fs() & wire_fu());
+ putcache("fv", out);
+ return out;
+ }
+}
+uint16_t wire_lm() {
+ uint16_t out;
+ if(iscached("lm"))
+ return getcache("lm");
+ else {
+ out = (wire_lj() & wire_ll());
+ putcache("lm", out);
+ return out;
+ }
+}
+uint16_t wire_jo() {
+ uint16_t out;
+ if(iscached("jo"))
+ return getcache("jo");
+ else {
+ out = (wire_jk() << 15);
+ putcache("jo", out);
+ return out;
+ }
+}
+uint16_t wire_iw() {
+ uint16_t out;
+ if(iscached("iw"))
+ return getcache("iw");
+ else {
+ out = (wire_iu() >> 3);
+ putcache("iw", out);
+ return out;
+ }
+}
+uint16_t wire_ij() {
+ uint16_t out;
+ if(iscached("ij"))
+ return getcache("ij");
+ else {
+ out = ~wire_ii();
+ putcache("ij", out);
+ return out;
+ }
+}
+uint16_t wire_cd() {
+ uint16_t out;
+ if(iscached("cd"))
+ return getcache("cd");
+ else {
+ out = (1 & wire_cc());
+ putcache("cd", out);
+ return out;
+ }
+}
+uint16_t wire_bp() {
+ uint16_t out;
+ if(iscached("bp"))
+ return getcache("bp");
+ else {
+ out = (wire_bn() >> 3);
+ putcache("bp", out);
+ return out;
+ }
+}
+uint16_t wire_gx() {
+ uint16_t out;
+ if(iscached("gx"))
+ return getcache("gx");
+ else {
+ out = ~wire_gw();
+ putcache("gx", out);
+ return out;
+ }
+}
+uint16_t wire_fu() {
+ uint16_t out;
+ if(iscached("fu"))
+ return getcache("fu");
+ else {
+ out = ~wire_ft();
+ putcache("fu", out);
+ return out;
+ }
+}
+uint16_t wire_jp() {
+ uint16_t out;
+ if(iscached("jp"))
+ return getcache("jp");
+ else {
+ out = (wire_jn() | wire_jo());
+ putcache("jp", out);
+ return out;
+ }
+}
+uint16_t wire_jc() {
+ uint16_t out;
+ if(iscached("jc"))
+ return getcache("jc");
+ else {
+ out = (wire_iv() | wire_jb());
+ putcache("jc", out);
+ return out;
+ }
+}
+uint16_t wire_hw() {
+ uint16_t out;
+ if(iscached("hw"))
+ return getcache("hw");
+ else {
+ out = (wire_hv() | wire_hu());
+ putcache("hw", out);
+ return out;
+ }
+}
+uint16_t wire_b() {
+ uint16_t out;
+ if(iscached("b"))
+ return getcache("b");
+ else {
+ out = 19138;
+ putcache("b", out);
+ return out;
+ }
+}
+uint16_t wire_gm() {
+ uint16_t out;
+ if(iscached("gm"))
+ return getcache("gm");
+ else {
+ out = (wire_gj() >> 5);
+ putcache("gm", out);
+ return out;
+ }
+}
+uint16_t wire_ht() {
+ uint16_t out;
+ if(iscached("ht"))
+ return getcache("ht");
+ else {
+ out = (wire_hq() & wire_hs());
+ putcache("ht", out);
+ return out;
+ }
+}
+uint16_t wire_er() {
+ uint16_t out;
+ if(iscached("er"))
+ return getcache("er");
+ else {
+ out = (wire_dy() >> 1);
+ putcache("er", out);
+ return out;
+ }
+}
+uint16_t wire_ap() {
+ uint16_t out;
+ if(iscached("ap"))
+ return getcache("ap");
+ else {
+ out = (wire_ao() | wire_an());
+ putcache("ap", out);
+ return out;
+ }
+}
+uint16_t wire_lf() {
+ uint16_t out;
+ if(iscached("lf"))
+ return getcache("lf");
+ else {
+ out = (wire_ld() | wire_le());
+ putcache("lf", out);
+ return out;
+ }
+}
+uint16_t wire_ce() {
+ uint16_t out;
+ if(iscached("ce"))
+ return getcache("ce");
+ else {
+ out = (wire_bk() << 1);
+ putcache("ce", out);
+ return out;
+ }
+}
+uint16_t wire_cc() {
+ uint16_t out;
+ if(iscached("cc"))
+ return getcache("cc");
+ else {
+ out = (wire_bz() & wire_cb());
+ putcache("cc", out);
+ return out;
+ }
+}
+uint16_t wire_bm() {
+ uint16_t out;
+ if(iscached("bm"))
+ return getcache("bm");
+ else {
+ out = (wire_bi() << 15);
+ putcache("bm", out);
+ return out;
+ }
+}
+uint16_t wire_io() {
+ uint16_t out;
+ if(iscached("io"))
+ return getcache("io");
+ else {
+ out = (wire_il() & wire_in());
+ putcache("io", out);
+ return out;
+ }
+}
+uint16_t wire_ai() {
+ uint16_t out;
+ if(iscached("ai"))
+ return getcache("ai");
+ else {
+ out = (wire_af() & wire_ah());
+ putcache("ai", out);
+ return out;
+ }
+}
+uint16_t wire_bl() {
+ uint16_t out;
+ if(iscached("bl"))
+ return getcache("bl");
+ else {
+ out = (wire_as() >> 1);
+ putcache("bl", out);
+ return out;
+ }
+}
+uint16_t wire_lh() {
+ uint16_t out;
+ if(iscached("lh"))
+ return getcache("lh");
+ else {
+ out = (wire_lf() >> 3);
+ putcache("lh", out);
+ return out;
+ }
+}
+uint16_t wire_et() {
+ uint16_t out;
+ if(iscached("et"))
+ return getcache("et");
+ else {
+ out = (wire_er() | wire_es());
+ putcache("et", out);
+ return out;
+ }
+}
+uint16_t wire_ay() {
+ uint16_t out;
+ if(iscached("ay"))
+ return getcache("ay");
+ else {
+ out = ~wire_ax();
+ putcache("ay", out);
+ return out;
+ }
+}
+uint16_t wire_db() {
+ uint16_t out;
+ if(iscached("db"))
+ return getcache("db");
+ else {
+ out = (wire_ci() >> 1);
+ putcache("db", out);
+ return out;
+ }
+}
+uint16_t wire_fg() {
+ uint16_t out;
+ if(iscached("fg"))
+ return getcache("fg");
+ else {
+ out = (wire_et() & wire_fe());
+ putcache("fg", out);
+ return out;
+ }
+}
+uint16_t wire_ln() {
+ uint16_t out;
+ if(iscached("ln"))
+ return getcache("ln");
+ else {
+ out = (wire_lg() | wire_lm());
+ putcache("ln", out);
+ return out;
+ }
+}
+uint16_t wire_n() {
+ uint16_t out;
+ if(iscached("n"))
+ return getcache("n");
+ else {
+ out = (wire_k() & wire_m());
+ putcache("n", out);
+ return out;
+ }
+}
+uint16_t wire_ia() {
+ uint16_t out;
+ if(iscached("ia"))
+ return getcache("ia");
+ else {
+ out = (wire_hz() >> 2);
+ putcache("ia", out);
+ return out;
+ }
+}
+uint16_t wire_lb() {
+ uint16_t out;
+ if(iscached("lb"))
+ return getcache("lb");
+ else {
+ out = (wire_kh() << 1);
+ putcache("lb", out);
+ return out;
+ }
+}
+uint16_t wire_ez() {
+ uint16_t out;
+ if(iscached("ez"))
+ return getcache("ez");
+ else {
+ out = ~wire_ey();
+ putcache("ez", out);
+ return out;
+ }
+}
+uint16_t wire_dj() {
+ uint16_t out;
+ if(iscached("dj"))
+ return getcache("dj");
+ else {
+ out = ~wire_di();
+ putcache("dj", out);
+ return out;
+ }
+}
+uint16_t wire_eg() {
+ uint16_t out;
+ if(iscached("eg"))
+ return getcache("eg");
+ else {
+ out = (wire_dz() | wire_ef());
+ putcache("eg", out);
+ return out;
+ }
+}
+uint16_t wire_a() {
+ uint16_t out;
+ if(iscached("a"))
+ return getcache("a");
+ else {
+ out = wire_lx();
+ putcache("a", out);
+ return out;
+ }
+}
+uint16_t wire_ja() {
+ uint16_t out;
+ if(iscached("ja"))
+ return getcache("ja");
+ else {
+ out = ~wire_iz();
+ putcache("ja", out);
+ return out;
+ }
+}
+uint16_t wire_hd() {
+ uint16_t out;
+ if(iscached("hd"))
+ return getcache("hd");
+ else {
+ out = (wire_gz() << 15);
+ putcache("hd", out);
+ return out;
+ }
+}
+uint16_t wire_cf() {
+ uint16_t out;
+ if(iscached("cf"))
+ return getcache("cf");
+ else {
+ out = (wire_ce() | wire_cd());
+ putcache("cf", out);
+ return out;
+ }
+}
+uint16_t wire_ft() {
+ uint16_t out;
+ if(iscached("ft"))
+ return getcache("ft");
+ else {
+ out = (wire_fq() & wire_fr());
+ putcache("ft", out);
+ return out;
+ }
+}
+uint16_t wire_bb() {
+ uint16_t out;
+ if(iscached("bb"))
+ return getcache("bb");
+ else {
+ out = (wire_at() & wire_az());
+ putcache("bb", out);
+ return out;
+ }
+}
+uint16_t wire_hb() {
+ uint16_t out;
+ if(iscached("hb"))
+ return getcache("hb");
+ else {
+ out = (wire_ha() | wire_gz());
+ putcache("hb", out);
+ return out;
+ }
+}
+uint16_t wire_fx() {
+ uint16_t out;
+ if(iscached("fx"))
+ return getcache("fx");
+ else {
+ out = (wire_fp() & wire_fv());
+ putcache("fx", out);
+ return out;
+ }
+}
+uint16_t wire_gc() {
+ uint16_t out;
+ if(iscached("gc"))
+ return getcache("gc");
+ else {
+ out = ~wire_gb();
+ putcache("gc", out);
+ return out;
+ }
+}
+uint16_t wire_ii() {
+ uint16_t out;
+ if(iscached("ii"))
+ return getcache("ii");
+ else {
+ out = (wire_ia() & wire_ig());
+ putcache("ii", out);
+ return out;
+ }
+}
+uint16_t wire_gn() {
+ uint16_t out;
+ if(iscached("gn"))
+ return getcache("gn");
+ else {
+ out = (wire_gl() | wire_gm());
+ putcache("gn", out);
+ return out;
+ }
+}
+uint16_t wire_c() {
+ uint16_t out;
+ if(iscached("c"))
+ return getcache("c");
+ else {
+ out = 0;
+ putcache("c", out);
+ return out;
+ }
+}
+uint16_t wire_cb() {
+ uint16_t out;
+ if(iscached("cb"))
+ return getcache("cb");
+ else {
+ out = ~wire_ca();
+ putcache("cb", out);
+ return out;
+ }
+}
+uint16_t wire_cg() {
+ uint16_t out;
+ if(iscached("cg"))
+ return getcache("cg");
+ else {
+ out = (wire_bn() >> 1);
+ putcache("cg", out);
+ return out;
+ }
+}
+uint16_t wire_t() {
+ uint16_t out;
+ if(iscached("t"))
+ return getcache("t");
+ else {
+ out = (wire_c() << 1);
+ putcache("t", out);
+ return out;
+ }
+}
+uint16_t wire_iy() {
+ uint16_t out;
+ if(iscached("iy"))
+ return getcache("iy");
+ else {
+ out = (wire_iw() | wire_ix());
+ putcache("iy", out);
+ return out;
+ }
+}
+uint16_t wire_kh() {
+ uint16_t out;
+ if(iscached("kh"))
+ return getcache("kh");
+ else {
+ out = (wire_kg() | wire_kf());
+ putcache("kh", out);
+ return out;
+ }
+}
+uint16_t wire_ek() {
+ uint16_t out;
+ if(iscached("ek"))
+ return getcache("ek");
+ else {
+ out = (wire_dy() | wire_ej());
+ putcache("ek", out);
+ return out;
+ }
+}
+uint16_t wire_kp() {
+ uint16_t out;
+ if(iscached("kp"))
+ return getcache("kp");
+ else {
+ out = (wire_km() & wire_kn());
+ putcache("kp", out);
+ return out;
+ }
+}
+uint16_t wire_fd() {
+ uint16_t out;
+ if(iscached("fd"))
+ return getcache("fd");
+ else {
+ out = ~wire_fc();
+ putcache("fd", out);
+ return out;
+ }
+}
+uint16_t wire_ib() {
+ uint16_t out;
+ if(iscached("ib"))
+ return getcache("ib");
+ else {
+ out = (wire_hz() >> 3);
+ putcache("ib", out);
+ return out;
+ }
+}
+uint16_t wire_dr() {
+ uint16_t out;
+ if(iscached("dr"))
+ return getcache("dr");
+ else {
+ out = ~wire_dq();
+ putcache("dr", out);
+ return out;
+ }
+}
+uint16_t wire_fh() {
+ uint16_t out;
+ if(iscached("fh"))
+ return getcache("fh");
+ else {
+ out = ~wire_fg();
+ putcache("fh", out);
+ return out;
+ }
+}
+uint16_t wire_dz() {
+ uint16_t out;
+ if(iscached("dz"))
+ return getcache("dz");
+ else {
+ out = (wire_dy() >> 2);
+ putcache("dz", out);
+ return out;
+ }
+}
+uint16_t wire_kl() {
+ uint16_t out;
+ if(iscached("kl"))
+ return getcache("kl");
+ else {
+ out = (wire_kk() >> 2);
+ putcache("kl", out);
+ return out;
+ }
+}
+uint16_t wire_fj() {
+ uint16_t out;
+ if(iscached("fj"))
+ return getcache("fj");
+ else {
+ out = (1 & wire_fi());
+ putcache("fj", out);
+ return out;
+ }
+}
+uint16_t wire_hs() {
+ uint16_t out;
+ if(iscached("hs"))
+ return getcache("hs");
+ else {
+ out = ~wire_hr();
+ putcache("hs", out);
+ return out;
+ }
+}
+uint16_t wire_ki() {
+ uint16_t out;
+ if(iscached("ki"))
+ return getcache("ki");
+ else {
+ out = (wire_jp() >> 1);
+ putcache("ki", out);
+ return out;
+ }
+}
+uint16_t wire_bn() {
+ uint16_t out;
+ if(iscached("bn"))
+ return getcache("bn");
+ else {
+ out = (wire_bl() | wire_bm());
+ putcache("bn", out);
+ return out;
+ }
+}
+uint16_t wire_gz() {
+ uint16_t out;
+ if(iscached("gz"))
+ return getcache("gz");
+ else {
+ out = (1 & wire_gy());
+ putcache("gz", out);
+ return out;
+ }
+}
+uint16_t wire_gu() {
+ uint16_t out;
+ if(iscached("gu"))
+ return getcache("gu");
+ else {
+ out = (wire_gr() & wire_gt());
+ putcache("gu", out);
+ return out;
+ }
+}
+uint16_t wire_dd() {
+ uint16_t out;
+ if(iscached("dd"))
+ return getcache("dd");
+ else {
+ out = (wire_db() | wire_dc());
+ putcache("dd", out);
+ return out;
+ }
+}
+uint16_t wire_dl() {
+ uint16_t out;
+ if(iscached("dl"))
+ return getcache("dl");
+ else {
+ out = (wire_de() | wire_dk());
+ putcache("dl", out);
+ return out;
+ }
+}
+uint16_t wire_av() {
+ uint16_t out;
+ if(iscached("av"))
+ return getcache("av");
+ else {
+ out = (wire_as() >> 5);
+ putcache("av", out);
+ return out;
+ }
+}
+uint16_t wire_li() {
+ uint16_t out;
+ if(iscached("li"))
+ return getcache("li");
+ else {
+ out = (wire_lf() >> 5);
+ putcache("li", out);
+ return out;
+ }
+}
+uint16_t wire_hp() {
+ uint16_t out;
+ if(iscached("hp"))
+ return getcache("hp");
+ else {
+ out = (wire_hm() & wire_ho());
+ putcache("hp", out);
+ return out;
+ }
+}
+uint16_t wire_ci() {
+ uint16_t out;
+ if(iscached("ci"))
+ return getcache("ci");
+ else {
+ out = (wire_cg() | wire_ch());
+ putcache("ci", out);
+ return out;
+ }
+}
+uint16_t wire_gw() {
+ uint16_t out;
+ if(iscached("gw"))
+ return getcache("gw");
+ else {
+ out = (wire_gj() & wire_gu());
+ putcache("gw", out);
+ return out;
+ }
+}
+uint16_t wire_gi() {
+ uint16_t out;
+ if(iscached("gi"))
+ return getcache("gi");
+ else {
+ out = (wire_ge() << 15);
+ putcache("gi", out);
+ return out;
+ }
+}
+uint16_t wire_g() {
+ uint16_t out;
+ if(iscached("g"))
+ return getcache("g");
+ else {
+ out = (wire_e() | wire_f());
+ putcache("g", out);
+ return out;
+ }
+}
+uint16_t wire_fw() {
+ uint16_t out;
+ if(iscached("fw"))
+ return getcache("fw");
+ else {
+ out = (wire_fp() | wire_fv());
+ putcache("fw", out);
+ return out;
+ }
+}
+uint16_t wire_fe() {
+ uint16_t out;
+ if(iscached("fe"))
+ return getcache("fe");
+ else {
+ out = (wire_fb() & wire_fd());
+ putcache("fe", out);
+ return out;
+ }
+}
+uint16_t wire_ch() {
+ uint16_t out;
+ if(iscached("ch"))
+ return getcache("ch");
+ else {
+ out = (wire_cd() << 15);
+ putcache("ch", out);
+ return out;
+ }
+}
+uint16_t wire_v() {
+ uint16_t out;
+ if(iscached("v"))
+ return getcache("v");
+ else {
+ out = (wire_b() >> 1);
+ putcache("v", out);
+ return out;
+ }
+}
+uint16_t wire_ba() {
+ uint16_t out;
+ if(iscached("ba"))
+ return getcache("ba");
+ else {
+ out = (wire_at() | wire_az());
+ putcache("ba", out);
+ return out;
+ }
+}
+uint16_t wire_bo() {
+ uint16_t out;
+ if(iscached("bo"))
+ return getcache("bo");
+ else {
+ out = (wire_bn() >> 2);
+ putcache("bo", out);
+ return out;
+ }
+}
+uint16_t wire_lk() {
+ uint16_t out;
+ if(iscached("lk"))
+ return getcache("lk");
+ else {
+ out = (wire_lh() & wire_li());
+ putcache("lk", out);
+ return out;
+ }
+}
+uint16_t wire_do() {
+ uint16_t out;
+ if(iscached("do"))
+ return getcache("do");
+ else {
+ out = (wire_dl() & wire_dn());
+ putcache("do", out);
+ return out;
+ }
+}
+uint16_t wire_ej() {
+ uint16_t out;
+ if(iscached("ej"))
+ return getcache("ej");
+ else {
+ out = (wire_eg() & wire_ei());
+ putcache("ej", out);
+ return out;
+ }
+}
+uint16_t wire_fa() {
+ uint16_t out;
+ if(iscached("fa"))
+ return getcache("fa");
+ else {
+ out = (wire_ex() & wire_ez());
+ putcache("fa", out);
+ return out;
+ }
+}
+uint16_t wire_kq() {
+ uint16_t out;
+ if(iscached("kq"))
+ return getcache("kq");
+ else {
+ out = ~wire_kp();
+ putcache("kq", out);
+ return out;
+ }
+}
+uint16_t wire_ll() {
+ uint16_t out;
+ if(iscached("ll"))
+ return getcache("ll");
+ else {
+ out = ~wire_lk();
+ putcache("ll", out);
+ return out;
+ }
+}
+uint16_t wire_ak() {
+ uint16_t out;
+ if(iscached("ak"))
+ return getcache("ak");
+ else {
+ out = (wire_x() & wire_ai());
+ putcache("ak", out);
+ return out;
+ }
+}
+uint16_t wire_kb() {
+ uint16_t out;
+ if(iscached("kb"))
+ return getcache("kb");
+ else {
+ out = (wire_jp() | wire_ka());
+ putcache("kb", out);
+ return out;
+ }
+}
+uint16_t wire_je() {
+ uint16_t out;
+ if(iscached("je"))
+ return getcache("je");
+ else {
+ out = ~wire_jd();
+ putcache("je", out);
+ return out;
+ }
+}
+uint16_t wire_jb() {
+ uint16_t out;
+ if(iscached("jb"))
+ return getcache("jb");
+ else {
+ out = (wire_iy() & wire_ja());
+ putcache("jb", out);
+ return out;
+ }
+}
+uint16_t wire_jr() {
+ uint16_t out;
+ if(iscached("jr"))
+ return getcache("jr");
+ else {
+ out = (wire_jp() >> 3);
+ putcache("jr", out);
+ return out;
+ }
+}
+uint16_t wire_ga() {
+ uint16_t out;
+ if(iscached("ga"))
+ return getcache("ga");
+ else {
+ out = (wire_fo() | wire_fz());
+ putcache("ga", out);
+ return out;
+ }
+}
+uint16_t wire_dh() {
+ uint16_t out;
+ if(iscached("dh"))
+ return getcache("dh");
+ else {
+ out = (wire_df() | wire_dg());
+ putcache("dh", out);
+ return out;
+ }
+}
+uint16_t wire_gk() {
+ uint16_t out;
+ if(iscached("gk"))
+ return getcache("gk");
+ else {
+ out = (wire_gj() >> 2);
+ putcache("gk", out);
+ return out;
+ }
+}
+uint16_t wire_gv() {
+ uint16_t out;
+ if(iscached("gv"))
+ return getcache("gv");
+ else {
+ out = (wire_gj() | wire_gu());
+ putcache("gv", out);
+ return out;
+ }
+}
+uint16_t wire_ji() {
+ uint16_t out;
+ if(iscached("ji"))
+ return getcache("ji");
+ else {
+ out = ~wire_jh();
+ putcache("ji", out);
+ return out;
+ }
+}
+uint16_t wire_bj() {
+ uint16_t out;
+ if(iscached("bj"))
+ return getcache("bj");
+ else {
+ out = (wire_ap() << 1);
+ putcache("bj", out);
+ return out;
+ }
+}
+uint16_t wire_lt() {
+ uint16_t out;
+ if(iscached("lt"))
+ return getcache("lt");
+ else {
+ out = ~wire_ls();
+ putcache("lt", out);
+ return out;
+ }
+}
+uint16_t wire_jl() {
+ uint16_t out;
+ if(iscached("jl"))
+ return getcache("jl");
+ else {
+ out = (wire_ir() << 1);
+ putcache("jl", out);
+ return out;
+ }
+}
+uint16_t wire_ca() {
+ uint16_t out;
+ if(iscached("ca"))
+ return getcache("ca");
+ else {
+ out = (wire_bn() & wire_by());
+ putcache("ca", out);
+ return out;
+ }
+}
+uint16_t wire_lz() {
+ uint16_t out;
+ if(iscached("lz"))
+ return getcache("lz");
+ else {
+ out = (wire_lv() << 15);
+ putcache("lz", out);
+ return out;
+ }
+}
+uint16_t wire_bd() {
+ uint16_t out;
+ if(iscached("bd"))
+ return getcache("bd");
+ else {
+ out = (wire_ba() & wire_bc());
+ putcache("bd", out);
+ return out;
+ }
+}
+uint16_t wire_dc() {
+ uint16_t out;
+ if(iscached("dc"))
+ return getcache("dc");
+ else {
+ out = (wire_cy() << 15);
+ putcache("dc", out);
+ return out;
+ }
+}
+uint16_t wire_lq() {
+ uint16_t out;
+ if(iscached("lq"))
+ return getcache("lq");
+ else {
+ out = (wire_ln() & wire_lp());
+ putcache("lq", out);
+ return out;
+ }
+}
+uint16_t wire_aq() {
+ uint16_t out;
+ if(iscached("aq"))
+ return getcache("aq");
+ else {
+ out = (wire_x() >> 1);
+ putcache("aq", out);
+ return out;
+ }
+}
+uint16_t wire_gr() {
+ uint16_t out;
+ if(iscached("gr"))
+ return getcache("gr");
+ else {
+ out = (wire_gk() | wire_gq());
+ putcache("gr", out);
+ return out;
+ }
+}
+uint16_t wire_ky() {
+ uint16_t out;
+ if(iscached("ky"))
+ return getcache("ky");
+ else {
+ out = ~wire_kx();
+ putcache("ky", out);
+ return out;
+ }
+}
+uint16_t wire_jj() {
+ uint16_t out;
+ if(iscached("jj"))
+ return getcache("jj");
+ else {
+ out = (wire_jg() & wire_ji());
+ putcache("jj", out);
+ return out;
+ }
+}
+uint16_t wire_bz() {
+ uint16_t out;
+ if(iscached("bz"))
+ return getcache("bz");
+ else {
+ out = (wire_bn() | wire_by());
+ putcache("bz", out);
+ return out;
+ }
+}
+uint16_t wire_gf() {
+ uint16_t out;
+ if(iscached("gf"))
+ return getcache("gf");
+ else {
+ out = (wire_fl() << 1);
+ putcache("gf", out);
+ return out;
+ }
+}
+uint16_t wire_br() {
+ uint16_t out;
+ if(iscached("br"))
+ return getcache("br");
+ else {
+ out = (wire_bp() | wire_bq());
+ putcache("br", out);
+ return out;
+ }
+}
+uint16_t wire_hq() {
+ uint16_t out;
+ if(iscached("hq"))
+ return getcache("hq");
+ else {
+ out = (wire_he() | wire_hp());
+ putcache("hq", out);
+ return out;
+ }
+}
+uint16_t wire_ew() {
+ uint16_t out;
+ if(iscached("ew"))
+ return getcache("ew");
+ else {
+ out = (wire_et() >> 5);
+ putcache("ew", out);
+ return out;
+ }
+}
+uint16_t wire_iv() {
+ uint16_t out;
+ if(iscached("iv"))
+ return getcache("iv");
+ else {
+ out = (wire_iu() >> 2);
+ putcache("iv", out);
+ return out;
+ }
+}
+uint16_t wire_go() {
+ uint16_t out;
+ if(iscached("go"))
+ return getcache("go");
+ else {
+ out = (wire_gl() & wire_gm());
+ putcache("go", out);
+ return out;
+ }
+}
+uint16_t wire_aj() {
+ uint16_t out;
+ if(iscached("aj"))
+ return getcache("aj");
+ else {
+ out = (wire_x() | wire_ai());
+ putcache("aj", out);
+ return out;
+ }
+}
+uint16_t wire_he() {
+ uint16_t out;
+ if(iscached("he"))
+ return getcache("he");
+ else {
+ out = (wire_hc() | wire_hd());
+ putcache("he", out);
+ return out;
+ }
+}
+uint16_t wire_lo() {
+ uint16_t out;
+ if(iscached("lo"))
+ return getcache("lo");
+ else {
+ out = (wire_lg() & wire_lm());
+ putcache("lo", out);
+ return out;
+ }
+}
+uint16_t wire_lj() {
+ uint16_t out;
+ if(iscached("lj"))
+ return getcache("lj");
+ else {
+ out = (wire_lh() | wire_li());
+ putcache("lj", out);
+ return out;
+ }
+}
+uint16_t wire_du() {
+ uint16_t out;
+ if(iscached("du"))
+ return getcache("du");
+ else {
+ out = (wire_da() << 1);
+ putcache("du", out);
+ return out;
+ }
+}
+uint16_t wire_fp() {
+ uint16_t out;
+ if(iscached("fp"))
+ return getcache("fp");
+ else {
+ out = (wire_fo() >> 2);
+ putcache("fp", out);
+ return out;
+ }
+}
+uint16_t wire_gs() {
+ uint16_t out;
+ if(iscached("gs"))
+ return getcache("gs");
+ else {
+ out = (wire_gk() & wire_gq());
+ putcache("gs", out);
+ return out;
+ }
+}
+uint16_t wire_bk() {
+ uint16_t out;
+ if(iscached("bk"))
+ return getcache("bk");
+ else {
+ out = (wire_bj() | wire_bi());
+ putcache("bk", out);
+ return out;
+ }
+}
+uint16_t wire_lr() {
+ uint16_t out;
+ if(iscached("lr"))
+ return getcache("lr");
+ else {
+ out = (wire_lf() | wire_lq());
+ putcache("lr", out);
+ return out;
+ }
+}
+uint16_t wire_cr() {
+ uint16_t out;
+ if(iscached("cr"))
+ return getcache("cr");
+ else {
+ out = (wire_cj() & wire_cp());
+ putcache("cr", out);
+ return out;
+ }
+}
+uint16_t wire_hy() {
+ uint16_t out;
+ if(iscached("hy"))
+ return getcache("hy");
+ else {
+ out = (wire_hu() << 15);
+ putcache("hy", out);
+ return out;
+ }
+}
+uint16_t wire_bi() {
+ uint16_t out;
+ if(iscached("bi"))
+ return getcache("bi");
+ else {
+ out = (1 & wire_bh());
+ putcache("bi", out);
+ return out;
+ }
+}
+uint16_t wire_fq() {
+ uint16_t out;
+ if(iscached("fq"))
+ return getcache("fq");
+ else {
+ out = (wire_fo() >> 3);
+ putcache("fq", out);
+ return out;
+ }
+}
+uint16_t wire_lp() {
+ uint16_t out;
+ if(iscached("lp"))
+ return getcache("lp");
+ else {
+ out = ~wire_lo();
+ putcache("lp", out);
+ return out;
+ }
+}
+uint16_t wire_iq() {
+ uint16_t out;
+ if(iscached("iq"))
+ return getcache("iq");
+ else {
+ out = (wire_hw() << 1);
+ putcache("iq", out);
+ return out;
+ }
+}
+uint16_t wire_dw() {
+ uint16_t out;
+ if(iscached("dw"))
+ return getcache("dw");
+ else {
+ out = (wire_dd() >> 1);
+ putcache("dw", out);
+ return out;
+ }
+}
+uint16_t wire_dx() {
+ uint16_t out;
+ if(iscached("dx"))
+ return getcache("dx");
+ else {
+ out = (wire_dt() << 15);
+ putcache("dx", out);
+ return out;
+ }
+}
+uint16_t wire_el() {
+ uint16_t out;
+ if(iscached("el"))
+ return getcache("el");
+ else {
+ out = (wire_dy() & wire_ej());
+ putcache("el", out);
+ return out;
+ }
+}
+uint16_t wire_ar() {
+ uint16_t out;
+ if(iscached("ar"))
+ return getcache("ar");
+ else {
+ out = (wire_an() << 15);
+ putcache("ar", out);
+ return out;
+ }
+}
+uint16_t wire_as() {
+ uint16_t out;
+ if(iscached("as"))
+ return getcache("as");
+ else {
+ out = (wire_aq() | wire_ar());
+ putcache("as", out);
+ return out;
+ }
+}
+uint16_t wire_s() {
+ uint16_t out;
+ if(iscached("s"))
+ return getcache("s");
+ else {
+ out = (1 & wire_r());
+ putcache("s", out);
+ return out;
+ }
+}
+uint16_t wire_fz() {
+ uint16_t out;
+ if(iscached("fz"))
+ return getcache("fz");
+ else {
+ out = (wire_fw() & wire_fy());
+ putcache("fz", out);
+ return out;
+ }
+}
+uint16_t wire_in() {
+ uint16_t out;
+ if(iscached("in"))
+ return getcache("in");
+ else {
+ out = ~wire_im();
+ putcache("in", out);
+ return out;
+ }
+}
+uint16_t wire_ev() {
+ uint16_t out;
+ if(iscached("ev"))
+ return getcache("ev");
+ else {
+ out = (wire_et() >> 3);
+ putcache("ev", out);
+ return out;
+ }
+}
+uint16_t wire_dt() {
+ uint16_t out;
+ if(iscached("dt"))
+ return getcache("dt");
+ else {
+ out = (1 & wire_ds());
+ putcache("dt", out);
+ return out;
+ }
+}
+uint16_t wire_ef() {
+ uint16_t out;
+ if(iscached("ef"))
+ return getcache("ef");
+ else {
+ out = (wire_ec() & wire_ee());
+ putcache("ef", out);
+ return out;
+ }
+}
+uint16_t wire_al() {
+ uint16_t out;
+ if(iscached("al"))
+ return getcache("al");
+ else {
+ out = ~wire_ak();
+ putcache("al", out);
+ return out;
+ }
+}
+uint16_t wire_jm() {
+ uint16_t out;
+ if(iscached("jm"))
+ return getcache("jm");
+ else {
+ out = (wire_jl() | wire_jk());
+ putcache("jm", out);
+ return out;
+ }
+}
+uint16_t wire_eo() {
+ uint16_t out;
+ if(iscached("eo"))
+ return getcache("eo");
+ else {
+ out = (1 & wire_en());
+ putcache("eo", out);
+ return out;
+ }
+}
+uint16_t wire_lc() {
+ uint16_t out;
+ if(iscached("lc"))
+ return getcache("lc");
+ else {
+ out = (wire_lb() | wire_la());
+ putcache("lc", out);
+ return out;
+ }
+}
+uint16_t wire_jh() {
+ uint16_t out;
+ if(iscached("jh"))
+ return getcache("jh");
+ else {
+ out = (wire_iu() & wire_jf());
+ putcache("jh", out);
+ return out;
+ }
+}
+uint16_t wire_ix() {
+ uint16_t out;
+ if(iscached("ix"))
+ return getcache("ix");
+ else {
+ out = (wire_iu() >> 5);
+ putcache("ix", out);
+ return out;
+ }
+}
+uint16_t wire_bw() {
+ uint16_t out;
+ if(iscached("bw"))
+ return getcache("bw");
+ else {
+ out = (wire_bo() & wire_bu());
+ putcache("bw", out);
+ return out;
+ }
+}
+uint16_t wire_da() {
+ uint16_t out;
+ if(iscached("da"))
+ return getcache("da");
+ else {
+ out = (wire_cz() | wire_cy());
+ putcache("da", out);
+ return out;
+ }
+}
+uint16_t wire_jd() {
+ uint16_t out;
+ if(iscached("jd"))
+ return getcache("jd");
+ else {
+ out = (wire_iv() & wire_jb());
+ putcache("jd", out);
+ return out;
+ }
+}
+uint16_t wire_iz() {
+ uint16_t out;
+ if(iscached("iz"))
+ return getcache("iz");
+ else {
+ out = (wire_iw() & wire_ix());
+ putcache("iz", out);
+ return out;
+ }
+}
+uint16_t wire_ly() {
+ uint16_t out;
+ if(iscached("ly"))
+ return getcache("ly");
+ else {
+ out = (wire_lf() >> 1);
+ putcache("ly", out);
+ return out;
+ }
+}
+uint16_t wire_jg() {
+ uint16_t out;
+ if(iscached("jg"))
+ return getcache("jg");
+ else {
+ out = (wire_iu() | wire_jf());
+ putcache("jg", out);
+ return out;
+ }
+}
+uint16_t wire_dn() {
+ uint16_t out;
+ if(iscached("dn"))
+ return getcache("dn");
+ else {
+ out = ~wire_dm();
+ putcache("dn", out);
+ return out;
+ }
+}
+uint16_t wire_lx() {
+ uint16_t out;
+ if(iscached("lx"))
+ return getcache("lx");
+ else {
+ out = (wire_lw() | wire_lv());
+ putcache("lx", out);
+ return out;
+ }
+}
+uint16_t wire_ha() {
+ uint16_t out;
+ if(iscached("ha"))
+ return getcache("ha");
+ else {
+ out = (wire_gg() << 1);
+ putcache("ha", out);
+ return out;
+ }
+}
+uint16_t wire_lu() {
+ uint16_t out;
+ if(iscached("lu"))
+ return getcache("lu");
+ else {
+ out = (wire_lr() & wire_lt());
+ putcache("lu", out);
+ return out;
+ }
+}
+uint16_t wire_fo() {
+ uint16_t out;
+ if(iscached("fo"))
+ return getcache("fo");
+ else {
+ out = (wire_fm() | wire_fn());
+ putcache("fo", out);
+ return out;
+ }
+}
+uint16_t wire_hg() {
+ uint16_t out;
+ if(iscached("hg"))
+ return getcache("hg");
+ else {
+ out = (wire_he() >> 3);
+ putcache("hg", out);
+ return out;
+ }
+}
+uint16_t wire_am() {
+ uint16_t out;
+ if(iscached("am"))
+ return getcache("am");
+ else {
+ out = (wire_aj() & wire_al());
+ putcache("am", out);
+ return out;
+ }
+}
+uint16_t wire_la() {
+ uint16_t out;
+ if(iscached("la"))
+ return getcache("la");
+ else {
+ out = (1 & wire_kz());
+ putcache("la", out);
+ return out;
+ }
+}
+uint16_t wire_eb() {
+ uint16_t out;
+ if(iscached("eb"))
+ return getcache("eb");
+ else {
+ out = (wire_dy() >> 5);
+ putcache("eb", out);
+ return out;
+ }
+}
+uint16_t wire_jf() {
+ uint16_t out;
+ if(iscached("jf"))
+ return getcache("jf");
+ else {
+ out = (wire_jc() & wire_je());
+ putcache("jf", out);
+ return out;
+ }
+}
+uint16_t wire_cp() {
+ uint16_t out;
+ if(iscached("cp"))
+ return getcache("cp");
+ else {
+ out = (wire_cm() & wire_co());
+ putcache("cp", out);
+ return out;
+ }
+}
+uint16_t wire_gy() {
+ uint16_t out;
+ if(iscached("gy"))
+ return getcache("gy");
+ else {
+ out = (wire_gv() & wire_gx());
+ putcache("gy", out);
+ return out;
+ }
+}
+uint16_t wire_ex() {
+ uint16_t out;
+ if(iscached("ex"))
+ return getcache("ex");
+ else {
+ out = (wire_ev() | wire_ew());
+ putcache("ex", out);
+ return out;
+ }
+}
+uint16_t wire_kc() {
+ uint16_t out;
+ if(iscached("kc"))
+ return getcache("kc");
+ else {
+ out = (wire_jp() & wire_ka());
+ putcache("kc", out);
+ return out;
+ }
+}
+uint16_t wire_fl() {
+ uint16_t out;
+ if(iscached("fl"))
+ return getcache("fl");
+ else {
+ out = (wire_fk() | wire_fj());
+ putcache("fl", out);
+ return out;
+ }
+}
+uint16_t wire_ea() {
+ uint16_t out;
+ if(iscached("ea"))
+ return getcache("ea");
+ else {
+ out = (wire_dy() >> 3);
+ putcache("ea", out);
+ return out;
+ }
+}
+uint16_t wire_bt() {
+ uint16_t out;
+ if(iscached("bt"))
+ return getcache("bt");
+ else {
+ out = ~wire_bs();
+ putcache("bt", out);
+ return out;
+ }
+}
+uint16_t wire_ah() {
+ uint16_t out;
+ if(iscached("ah"))
+ return getcache("ah");
+ else {
+ out = ~wire_ag();
+ putcache("ah", out);
+ return out;
+ }
+}
+uint16_t wire_eh() {
+ uint16_t out;
+ if(iscached("eh"))
+ return getcache("eh");
+ else {
+ out = (wire_dz() & wire_ef());
+ putcache("eh", out);
+ return out;
+ }
+}
+uint16_t wire_cz() {
+ uint16_t out;
+ if(iscached("cz"))
+ return getcache("cz");
+ else {
+ out = (wire_cf() << 1);
+ putcache("cz", out);
+ return out;
+ }
+}
+uint16_t wire_cw() {
+ uint16_t out;
+ if(iscached("cw"))
+ return getcache("cw");
+ else {
+ out = ~wire_cv();
+ putcache("cw", out);
+ return out;
+ }
+}
+uint16_t wire_cy() {
+ uint16_t out;
+ if(iscached("cy"))
+ return getcache("cy");
+ else {
+ out = (1 & wire_cx());
+ putcache("cy", out);
+ return out;
+ }
+}
+uint16_t wire_dm() {
+ uint16_t out;
+ if(iscached("dm"))
+ return getcache("dm");
+ else {
+ out = (wire_de() & wire_dk());
+ putcache("dm", out);
+ return out;
+ }
+}
+uint16_t wire_cn() {
+ uint16_t out;
+ if(iscached("cn"))
+ return getcache("cn");
+ else {
+ out = (wire_ck() & wire_cl());
+ putcache("cn", out);
+ return out;
+ }
+}
+uint16_t wire_aa() {
+ uint16_t out;
+ if(iscached("aa"))
+ return getcache("aa");
+ else {
+ out = (wire_x() >> 5);
+ putcache("aa", out);
+ return out;
+ }
+}
+uint16_t wire_ep() {
+ uint16_t out;
+ if(iscached("ep"))
+ return getcache("ep");
+ else {
+ out = (wire_dv() << 1);
+ putcache("ep", out);
+ return out;
+ }
+}
+uint16_t wire_hf() {
+ uint16_t out;
+ if(iscached("hf"))
+ return getcache("hf");
+ else {
+ out = (wire_he() >> 2);
+ putcache("hf", out);
+ return out;
+ }
+}
+uint16_t wire_bx() {
+ uint16_t out;
+ if(iscached("bx"))
+ return getcache("bx");
+ else {
+ out = ~wire_bw();
+ putcache("bx", out);
+ return out;
+ }
+}
+uint16_t wire_cm() {
+ uint16_t out;
+ if(iscached("cm"))
+ return getcache("cm");
+ else {
+ out = (wire_ck() | wire_cl());
+ putcache("cm", out);
+ return out;
+ }
+}
+uint16_t wire_bs() {
+ uint16_t out;
+ if(iscached("bs"))
+ return getcache("bs");
+ else {
+ out = (wire_bp() & wire_bq());
+ putcache("bs", out);
+ return out;
+ }
+}
+uint16_t wire_be() {
+ uint16_t out;
+ if(iscached("be"))
+ return getcache("be");
+ else {
+ out = (wire_as() | wire_bd());
+ putcache("be", out);
+ return out;
+ }
+}
+uint16_t wire_hr() {
+ uint16_t out;
+ if(iscached("hr"))
+ return getcache("hr");
+ else {
+ out = (wire_he() & wire_hp());
+ putcache("hr", out);
+ return out;
+ }
+}
+uint16_t wire_ey() {
+ uint16_t out;
+ if(iscached("ey"))
+ return getcache("ey");
+ else {
+ out = (wire_ev() & wire_ew());
+ putcache("ey", out);
+ return out;
+ }
+}
+uint16_t wire_lv() {
+ uint16_t out;
+ if(iscached("lv"))
+ return getcache("lv");
+ else {
+ out = (1 & wire_lu());
+ putcache("lv", out);
+ return out;
+ }
+}
+uint16_t wire_km() {
+ uint16_t out;
+ if(iscached("km"))
+ return getcache("km");
+ else {
+ out = (wire_kk() >> 3);
+ putcache("km", out);
+ return out;
+ }
+}
+uint16_t wire_p() {
+ uint16_t out;
+ if(iscached("p"))
+ return getcache("p");
+ else {
+ out = (wire_b() & wire_n());
+ putcache("p", out);
+ return out;
+ }
+}
+uint16_t wire_kd() {
+ uint16_t out;
+ if(iscached("kd"))
+ return getcache("kd");
+ else {
+ out = ~wire_kc();
+ putcache("kd", out);
+ return out;
+ }
+}
+uint16_t wire_lw() {
+ uint16_t out;
+ if(iscached("lw"))
+ return getcache("lw");
+ else {
+ out = (wire_lc() << 1);
+ putcache("lw", out);
+ return out;
+ }
+}
+uint16_t wire_ko() {
+ uint16_t out;
+ if(iscached("ko"))
+ return getcache("ko");
+ else {
+ out = (wire_km() | wire_kn());
+ putcache("ko", out);
+ return out;
+ }
+}
+uint16_t wire_ig() {
+ uint16_t out;
+ if(iscached("ig"))
+ return getcache("ig");
+ else {
+ out = (wire_id() & wire_if());
+ putcache("ig", out);
+ return out;
+ }
+}
+uint16_t wire_ik() {
+ uint16_t out;
+ if(iscached("ik"))
+ return getcache("ik");
+ else {
+ out = (wire_ih() & wire_ij());
+ putcache("ik", out);
+ return out;
+ }
+}
+uint16_t wire_ju() {
+ uint16_t out;
+ if(iscached("ju"))
+ return getcache("ju");
+ else {
+ out = (wire_jr() & wire_js());
+ putcache("ju", out);
+ return out;
+ }
+}
+uint16_t wire_cl() {
+ uint16_t out;
+ if(iscached("cl"))
+ return getcache("cl");
+ else {
+ out = (wire_ci() >> 5);
+ putcache("cl", out);
+ return out;
+ }
+}
+uint16_t wire_is() {
+ uint16_t out;
+ if(iscached("is"))
+ return getcache("is");
+ else {
+ out = (wire_hz() >> 1);
+ putcache("is", out);
+ return out;
+ }
+}
+uint16_t wire_kf() {
+ uint16_t out;
+ if(iscached("kf"))
+ return getcache("kf");
+ else {
+ out = (1 & wire_ke());
+ putcache("kf", out);
+ return out;
+ }
+}
+uint16_t wire_gt() {
+ uint16_t out;
+ if(iscached("gt"))
+ return getcache("gt");
+ else {
+ out = ~wire_gs();
+ putcache("gt", out);
+ return out;
+ }
+}
+uint16_t wire_az() {
+ uint16_t out;
+ if(iscached("az"))
+ return getcache("az");
+ else {
+ out = (wire_aw() & wire_ay());
+ putcache("az", out);
+ return out;
+ }
+}
+uint16_t wire_y() {
+ uint16_t out;
+ if(iscached("y"))
+ return getcache("y");
+ else {
+ out = (wire_x() >> 2);
+ putcache("y", out);
+ return out;
+ }
+}
+uint16_t wire_ae() {
+ uint16_t out;
+ if(iscached("ae"))
+ return getcache("ae");
+ else {
+ out = (wire_ab() & wire_ad());
+ putcache("ae", out);
+ return out;
+ }
+}
+uint16_t wire_fi() {
+ uint16_t out;
+ if(iscached("fi"))
+ return getcache("fi");
+ else {
+ out = (wire_ff() & wire_fh());
+ putcache("fi", out);
+ return out;
+ }
+}
+uint16_t wire_cv() {
+ uint16_t out;
+ if(iscached("cv"))
+ return getcache("cv");
+ else {
+ out = (wire_ci() & wire_ct());
+ putcache("cv", out);
+ return out;
+ }
+}
+uint16_t wire_fk() {
+ uint16_t out;
+ if(iscached("fk"))
+ return getcache("fk");
+ else {
+ out = (wire_eq() << 1);
+ putcache("fk", out);
+ return out;
+ }
+}
+uint16_t wire_gl() {
+ uint16_t out;
+ if(iscached("gl"))
+ return getcache("gl");
+ else {
+ out = (wire_gj() >> 3);
+ putcache("gl", out);
+ return out;
+ }
+}
+uint16_t wire_ao() {
+ uint16_t out;
+ if(iscached("ao"))
+ return getcache("ao");
+ else {
+ out = (wire_u() << 1);
+ putcache("ao", out);
+ return out;
+ }
+}
+uint16_t wire_bc() {
+ uint16_t out;
+ if(iscached("bc"))
+ return getcache("bc");
+ else {
+ out = ~wire_bb();
+ putcache("bc", out);
+ return out;
+ }
+}
+uint16_t wire_hk() {
+ uint16_t out;
+ if(iscached("hk"))
+ return getcache("hk");
+ else {
+ out = ~wire_hj();
+ putcache("hk", out);
+ return out;
+ }
+}
+uint16_t wire_kz() {
+ uint16_t out;
+ if(iscached("kz"))
+ return getcache("kz");
+ else {
+ out = (wire_kw() & wire_ky());
+ putcache("kz", out);
+ return out;
+ }
+}
+uint16_t wire_bf() {
+ uint16_t out;
+ if(iscached("bf"))
+ return getcache("bf");
+ else {
+ out = (wire_as() & wire_bd());
+ putcache("bf", out);
+ return out;
+ }
+}
+uint16_t wire_dy() {
+ uint16_t out;
+ if(iscached("dy"))
+ return getcache("dy");
+ else {
+ out = (wire_dw() | wire_dx());
+ putcache("dy", out);
+ return out;
+ }
+}
+uint16_t wire_bu() {
+ uint16_t out;
+ if(iscached("bu"))
+ return getcache("bu");
+ else {
+ out = (wire_br() & wire_bt());
+ putcache("bu", out);
+ return out;
+ }
+}
+uint16_t wire_kx() {
+ uint16_t out;
+ if(iscached("kx"))
+ return getcache("kx");
+ else {
+ out = (wire_kk() & wire_kv());
+ putcache("kx", out);
+ return out;
+ }
+}
+uint16_t wire_eq() {
+ uint16_t out;
+ if(iscached("eq"))
+ return getcache("eq");
+ else {
+ out = (wire_ep() | wire_eo());
+ putcache("eq", out);
+ return out;
+ }
+}
+uint16_t wire_hx() {
+ uint16_t out;
+ if(iscached("hx"))
+ return getcache("hx");
+ else {
+ out = (wire_he() >> 1);
+ putcache("hx", out);
+ return out;
+ }
+}
+uint16_t wire_kk() {
+ uint16_t out;
+ if(iscached("kk"))
+ return getcache("kk");
+ else {
+ out = (wire_ki() | wire_kj());
+ putcache("kk", out);
+ return out;
+ }
+}
+uint16_t wire_jv() {
+ uint16_t out;
+ if(iscached("jv"))
+ return getcache("jv");
+ else {
+ out = ~wire_ju();
+ putcache("jv", out);
+ return out;
+ }
+}
+uint16_t wire_en() {
+ uint16_t out;
+ if(iscached("en"))
+ return getcache("en");
+ else {
+ out = (wire_ek() & wire_em());
+ putcache("en", out);
+ return out;
+ }
+}
+uint16_t wire_kn() {
+ uint16_t out;
+ if(iscached("kn"))
+ return getcache("kn");
+ else {
+ out = (wire_kk() >> 5);
+ putcache("kn", out);
+ return out;
+ }
+}
+uint16_t wire_ei() {
+ uint16_t out;
+ if(iscached("ei"))
+ return getcache("ei");
+ else {
+ out = ~wire_eh();
+ putcache("ei", out);
+ return out;
+ }
+}
+uint16_t wire_hz() {
+ uint16_t out;
+ if(iscached("hz"))
+ return getcache("hz");
+ else {
+ out = (wire_hx() | wire_hy());
+ putcache("hz", out);
+ return out;
+ }
+}
+uint16_t wire_ec() {
+ uint16_t out;
+ if(iscached("ec"))
+ return getcache("ec");
+ else {
+ out = (wire_ea() | wire_eb());
+ putcache("ec", out);
+ return out;
+ }
+}
+uint16_t wire_w() {
+ uint16_t out;
+ if(iscached("w"))
+ return getcache("w");
+ else {
+ out = (wire_s() << 15);
+ putcache("w", out);
+ return out;
+ }
+}
+uint16_t wire_gh() {
+ uint16_t out;
+ if(iscached("gh"))
+ return getcache("gh");
+ else {
+ out = (wire_fo() >> 1);
+ putcache("gh", out);
+ return out;
+ }
+}
+uint16_t wire_kw() {
+ uint16_t out;
+ if(iscached("kw"))
+ return getcache("kw");
+ else {
+ out = (wire_kk() | wire_kv());
+ putcache("kw", out);
+ return out;
+ }
+}
+uint16_t wire_bq() {
+ uint16_t out;
+ if(iscached("bq"))
+ return getcache("bq");
+ else {
+ out = (wire_bn() >> 5);
+ putcache("bq", out);
+ return out;
+ }
+}
+uint16_t wire_ee() {
+ uint16_t out;
+ if(iscached("ee"))
+ return getcache("ee");
+ else {
+ out = ~wire_ed();
+ putcache("ee", out);
+ return out;
+ }
+}
+uint16_t wire_hu() {
+ uint16_t out;
+ if(iscached("hu"))
+ return getcache("hu");
+ else {
+ out = (1 & wire_ht());
+ putcache("hu", out);
+ return out;
+ }
+}
+uint16_t wire_cx() {
+ uint16_t out;
+ if(iscached("cx"))
+ return getcache("cx");
+ else {
+ out = (wire_cu() & wire_cw());
+ putcache("cx", out);
+ return out;
+ }
+}
+uint16_t wire_f() {
+ uint16_t out;
+ if(iscached("f"))
+ return getcache("f");
+ else {
+ out = (wire_b() >> 5);
+ putcache("f", out);
+ return out;
+ }
+}
+uint16_t wire_kt() {
+ uint16_t out;
+ if(iscached("kt"))
+ return getcache("kt");
+ else {
+ out = (wire_kl() & wire_kr());
+ putcache("kt", out);
+ return out;
+ }
+}
+uint16_t wire_ir() {
+ uint16_t out;
+ if(iscached("ir"))
+ return getcache("ir");
+ else {
+ out = (wire_iq() | wire_ip());
+ putcache("ir", out);
+ return out;
+ }
+}
+uint16_t wire_cj() {
+ uint16_t out;
+ if(iscached("cj"))
+ return getcache("cj");
+ else {
+ out = (wire_ci() >> 2);
+ putcache("cj", out);
+ return out;
+ }
+}
+uint16_t wire_cq() {
+ uint16_t out;
+ if(iscached("cq"))
+ return getcache("cq");
+ else {
+ out = (wire_cj() | wire_cp());
+ putcache("cq", out);
+ return out;
+ }
+}
+uint16_t wire_r() {
+ uint16_t out;
+ if(iscached("r"))
+ return getcache("r");
+ else {
+ out = (wire_o() & wire_q());
+ putcache("r", out);
+ return out;
+ }
+}
+uint16_t wire_dg() {
+ uint16_t out;
+ if(iscached("dg"))
+ return getcache("dg");
+ else {
+ out = (wire_dd() >> 5);
+ putcache("dg", out);
+ return out;
+ }
+}
+uint16_t wire_d() {
+ uint16_t out;
+ if(iscached("d"))
+ return getcache("d");
+ else {
+ out = (wire_b() >> 2);
+ putcache("d", out);
+ return out;
+ }
+}
+uint16_t wire_kv() {
+ uint16_t out;
+ if(iscached("kv"))
+ return getcache("kv");
+ else {
+ out = (wire_ks() & wire_ku());
+ putcache("kv", out);
+ return out;
+ }
+}
+uint16_t wire_e() {
+ uint16_t out;
+ if(iscached("e"))
+ return getcache("e");
+ else {
+ out = (wire_b() >> 3);
+ putcache("e", out);
+ return out;
+ }
+}
+uint16_t wire_k() {
+ uint16_t out;
+ if(iscached("k"))
+ return getcache("k");
+ else {
+ out = (wire_d() | wire_j());
+ putcache("k", out);
+ return out;
+ }
+}
+uint16_t wire_q() {
+ uint16_t out;
+ if(iscached("q"))
+ return getcache("q");
+ else {
+ out = ~wire_p();
+ putcache("q", out);
+ return out;
+ }
+}
+uint16_t wire_cs() {
+ uint16_t out;
+ if(iscached("cs"))
+ return getcache("cs");
+ else {
+ out = ~wire_cr();
+ putcache("cs", out);
+ return out;
+ }
+}
+uint16_t wire_dv() {
+ uint16_t out;
+ if(iscached("dv"))
+ return getcache("dv");
+ else {
+ out = (wire_du() | wire_dt());
+ putcache("dv", out);
+ return out;
+ }
+}
+uint16_t wire_kj() {
+ uint16_t out;
+ if(iscached("kj"))
+ return getcache("kj");
+ else {
+ out = (wire_kf() << 15);
+ putcache("kj", out);
+ return out;
+ }
+}
+uint16_t wire_ad() {
+ uint16_t out;
+ if(iscached("ad"))
+ return getcache("ad");
+ else {
+ out = ~wire_ac();
+ putcache("ad", out);
+ return out;
+ }
+}
+uint16_t wire_fr() {
+ uint16_t out;
+ if(iscached("fr"))
+ return getcache("fr");
+ else {
+ out = (wire_fo() >> 5);
+ putcache("fr", out);
+ return out;
+ }
+}
+uint16_t wire_il() {
+ uint16_t out;
+ if(iscached("il"))
+ return getcache("il");
+ else {
+ out = (wire_hz() | wire_ik());
+ putcache("il", out);
+ return out;
+ }
+}
+uint16_t wire_ka() {
+ uint16_t out;
+ if(iscached("ka"))
+ return getcache("ka");
+ else {
+ out = (wire_jx() & wire_jz());
+ putcache("ka", out);
+ return out;
+ }
+}
+uint16_t wire_gj() {
+ uint16_t out;
+ if(iscached("gj"))
+ return getcache("gj");
+ else {
+ out = (wire_gh() | wire_gi());
+ putcache("gj", out);
+ return out;
+ }
+}
+uint16_t wire_ld() {
+ uint16_t out;
+ if(iscached("ld"))
+ return getcache("ld");
+ else {
+ out = (wire_kk() >> 1);
+ putcache("ld", out);
+ return out;
+ }
+}
+uint16_t wire_ic() {
+ uint16_t out;
+ if(iscached("ic"))
+ return getcache("ic");
+ else {
+ out = (wire_hz() >> 5);
+ putcache("ic", out);
+ return out;
+ }
+}
+uint16_t wire_at() {
+ uint16_t out;
+ if(iscached("at"))
+ return getcache("at");
+ else {
+ out = (wire_as() >> 2);
+ putcache("at", out);
+ return out;
+ }
+}
+uint16_t wire_jz() {
+ uint16_t out;
+ if(iscached("jz"))
+ return getcache("jz");
+ else {
+ out = ~wire_jy();
+ putcache("jz", out);
+ return out;
+ }
+}
+uint16_t wire_an() {
+ uint16_t out;
+ if(iscached("an"))
+ return getcache("an");
+ else {
+ out = (1 & wire_am());
+ putcache("an", out);
+ return out;
+ }
+}
+uint16_t wire_cu() {
+ uint16_t out;
+ if(iscached("cu"))
+ return getcache("cu");
+ else {
+ out = (wire_ci() | wire_ct());
+ putcache("cu", out);
+ return out;
+ }
+}
+uint16_t wire_hj() {
+ uint16_t out;
+ if(iscached("hj"))
+ return getcache("hj");
+ else {
+ out = (wire_hg() & wire_hh());
+ putcache("hj", out);
+ return out;
+ }
+}
+uint16_t wire_jx() {
+ uint16_t out;
+ if(iscached("jx"))
+ return getcache("jx");
+ else {
+ out = (wire_jq() | wire_jw());
+ putcache("jx", out);
+ return out;
+ }
+}
+uint16_t wire_x() {
+ uint16_t out;
+ if(iscached("x"))
+ return getcache("x");
+ else {
+ out = (wire_v() | wire_w());
+ putcache("x", out);
+ return out;
+ }
+}
+uint16_t wire_le() {
+ uint16_t out;
+ if(iscached("le"))
+ return getcache("le");
+ else {
+ out = (wire_la() << 15);
+ putcache("le", out);
+ return out;
+ }
+}
+uint16_t wire_dk() {
+ uint16_t out;
+ if(iscached("dk"))
+ return getcache("dk");
+ else {
+ out = (wire_dh() & wire_dj());
+ putcache("dk", out);
+ return out;
+ }
+}
+uint16_t wire_ds() {
+ uint16_t out;
+ if(iscached("ds"))
+ return getcache("ds");
+ else {
+ out = (wire_dp() & wire_dr());
+ putcache("ds", out);
+ return out;
+ }
+}
+uint16_t wire_jy() {
+ uint16_t out;
+ if(iscached("jy"))
+ return getcache("jy");
+ else {
+ out = (wire_jq() & wire_jw());
+ putcache("jy", out);
+ return out;
+ }
+}
+uint16_t wire_aw() {
+ uint16_t out;
+ if(iscached("aw"))
+ return getcache("aw");
+ else {
+ out = (wire_au() | wire_av());
+ putcache("aw", out);
+ return out;
+ }
+}
+uint16_t wire_bg() {
+ uint16_t out;
+ if(iscached("bg"))
+ return getcache("bg");
+ else {
+ out = ~wire_bf();
+ putcache("bg", out);
+ return out;
+ }
+}
+uint16_t wire_ab() {
+ uint16_t out;
+ if(iscached("ab"))
+ return getcache("ab");
+ else {
+ out = (wire_z() | wire_aa());
+ putcache("ab", out);
+ return out;
+ }
+}
+uint16_t wire_gd() {
+ uint16_t out;
+ if(iscached("gd"))
+ return getcache("gd");
+ else {
+ out = (wire_ga() & wire_gc());
+ putcache("gd", out);
+ return out;
+ }
+}
+uint16_t wire_im() {
+ uint16_t out;
+ if(iscached("im"))
+ return getcache("im");
+ else {
+ out = (wire_hz() & wire_ik());
+ putcache("im", out);
+ return out;
+ }
+}
+uint16_t wire_jw() {
+ uint16_t out;
+ if(iscached("jw"))
+ return getcache("jw");
+ else {
+ out = (wire_jt() & wire_jv());
+ putcache("jw", out);
+ return out;
+ }
+}
+uint16_t wire_ac() {
+ uint16_t out;
+ if(iscached("ac"))
+ return getcache("ac");
+ else {
+ out = (wire_z() & wire_aa());
+ putcache("ac", out);
+ return out;
+ }
+}
+uint16_t wire_jt() {
+ uint16_t out;
+ if(iscached("jt"))
+ return getcache("jt");
+ else {
+ out = (wire_jr() | wire_js());
+ putcache("jt", out);
+ return out;
+ }
+}
+uint16_t wire_hv() {
+ uint16_t out;
+ if(iscached("hv"))
+ return getcache("hv");
+ else {
+ out = (wire_hb() << 1);
+ putcache("hv", out);
+ return out;
+ }
+}
+uint16_t wire_hm() {
+ uint16_t out;
+ if(iscached("hm"))
+ return getcache("hm");
+ else {
+ out = (wire_hf() | wire_hl());
+ putcache("hm", out);
+ return out;
+ }
+}
+uint16_t wire_id() {
+ uint16_t out;
+ if(iscached("id"))
+ return getcache("id");
+ else {
+ out = (wire_ib() | wire_ic());
+ putcache("id", out);
+ return out;
+ }
+}
+uint16_t wire_fs() {
+ uint16_t out;
+ if(iscached("fs"))
+ return getcache("fs");
+ else {
+ out = (wire_fq() | wire_fr());
+ putcache("fs", out);
+ return out;
+ }
+}
+uint16_t wire_ct() {
+ uint16_t out;
+ if(iscached("ct"))
+ return getcache("ct");
+ else {
+ out = (wire_cq() & wire_cs());
+ putcache("ct", out);
+ return out;
+ }
+}
+uint16_t wire_ih() {
+ uint16_t out;
+ if(iscached("ih"))
+ return getcache("ih");
+ else {
+ out = (wire_ia() | wire_ig());
+ putcache("ih", out);
+ return out;
+ }
+}
+uint16_t wire_dp() {
+ uint16_t out;
+ if(iscached("dp"))
+ return getcache("dp");
+ else {
+ out = (wire_dd() | wire_do());
+ putcache("dp", out);
+ return out;
+ }
+}
+uint16_t wire_l() {
+ uint16_t out;
+ if(iscached("l"))
+ return getcache("l");
+ else {
+ out = (wire_d() & wire_j());
+ putcache("l", out);
+ return out;
+ }
+}
+uint16_t wire_ie() {
+ uint16_t out;
+ if(iscached("ie"))
+ return getcache("ie");
+ else {
+ out = (wire_ib() & wire_ic());
+ putcache("ie", out);
+ return out;
+ }
+}
+uint16_t wire_au() {
+ uint16_t out;
+ if(iscached("au"))
+ return getcache("au");
+ else {
+ out = (wire_as() >> 3);
+ putcache("au", out);
+ return out;
+ }
+}
+uint16_t wire_bh() {
+ uint16_t out;
+ if(iscached("bh"))
+ return getcache("bh");
+ else {
+ out = (wire_be() & wire_bg());
+ putcache("bh", out);
+ return out;
+ }
+}
+uint16_t wire_dq() {
+ uint16_t out;
+ if(iscached("dq"))
+ return getcache("dq");
+ else {
+ out = (wire_dd() & wire_do());
+ putcache("dq", out);
+ return out;
+ }
+}
+uint16_t wire_m() {
+ uint16_t out;
+ if(iscached("m"))
+ return getcache("m");
+ else {
+ out = ~wire_l();
+ putcache("m", out);
+ return out;
+ }
+}
+uint16_t wire_ge() {
+ uint16_t out;
+ if(iscached("ge"))
+ return getcache("ge");
+ else {
+ out = (1 & wire_gd());
+ putcache("ge", out);
+ return out;
+ }
+}
+uint16_t wire_ag() {
+ uint16_t out;
+ if(iscached("ag"))
+ return getcache("ag");
+ else {
+ out = (wire_y() & wire_ae());
+ putcache("ag", out);
+ return out;
+ }
+}
+uint16_t wire_gb() {
+ uint16_t out;
+ if(iscached("gb"))
+ return getcache("gb");
+ else {
+ out = (wire_fo() & wire_fz());
+ putcache("gb", out);
+ return out;
+ }
+}
+uint16_t wire_if() {
+ uint16_t out;
+ if(iscached("if"))
+ return getcache("if");
+ else {
+ out = ~wire_ie();
+ putcache("if", out);
+ return out;
+ }
+}
+uint16_t wire_h() {
+ uint16_t out;
+ if(iscached("h"))
+ return getcache("h");
+ else {
+ out = (wire_e() & wire_f());
+ putcache("h", out);
+ return out;
+ }
+}
+uint16_t wire_z() {
+ uint16_t out;
+ if(iscached("z"))
+ return getcache("z");
+ else {
+ out = (wire_x() >> 3);
+ putcache("z", out);
+ return out;
+ }
+}
+uint16_t wire_af() {
+ uint16_t out;
+ if(iscached("af"))
+ return getcache("af");
+ else {
+ out = (wire_y() | wire_ae());
+ putcache("af", out);
+ return out;
+ }
+}
+uint16_t wire_hn() {
+ uint16_t out;
+ if(iscached("hn"))
+ return getcache("hn");
+ else {
+ out = (wire_hf() & wire_hl());
+ putcache("hn", out);
+ return out;
+ }
+}
+uint16_t wire_i() {
+ uint16_t out;
+ if(iscached("i"))
+ return getcache("i");
+ else {
+ out = ~wire_h();
+ putcache("i", out);
+ return out;
+ }
+}
+uint16_t wire_ho() {
+ uint16_t out;
+ if(iscached("ho"))
+ return getcache("ho");
+ else {
+ out = ~wire_hn();
+ putcache("ho", out);
+ return out;
+ }
+}
+uint16_t wire_hh() {
+ uint16_t out;
+ if(iscached("hh"))
+ return getcache("hh");
+ else {
+ out = (wire_he() >> 5);
+ putcache("hh", out);
+ return out;
+ }
+}
+
+int main() {
+ cache = (uint16_t*) malloc(26*26*sizeof(uint16_t));
+ incache = (char*) malloc(26*26*sizeof(char));
+ memset(incache, 0, 26*26);
+ printf("Value of wire a: %d\n", wire_a());
+ free(cache);
+ free(incache);
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-09-19 02:03:03 +0000