Day 7, doesnt return

9 files changed, 8054 insertions, 0 deletions

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