Day 7, doesnt return

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);
+}