From 60ba2ffc498e7403a29c02aa23f078bb9da70c39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?N=C3=A6=C3=BE=27n=20Lasseter?= Date: Thu, 17 Dec 2015 20:10:55 +0000 Subject: Day 7, doesnt return --- day7/Makefile | 1 + day7/day7.c | 3764 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ day7/day7.input | 339 +++++ day7/day7gen | Bin 0 -> 13213 bytes day7/day7gen.c | 175 +++ day7/logic | 3399 ++++++++++++++++++++++++++++++++++++++++++++++++ day7/override.mk | 11 + day7/preamble | 26 + day7/prototypes | 339 +++++ 9 files changed, 8054 insertions(+) create mode 120000 day7/Makefile create mode 100644 day7/day7.c create mode 100644 day7/day7.input create mode 100755 day7/day7gen create mode 100644 day7/day7gen.c create mode 100644 day7/logic create mode 100644 day7/override.mk create mode 100644 day7/preamble create mode 100644 day7/prototypes 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 +#include +#include +#include + +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 Binary files /dev/null and b/day7/day7gen differ 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 +#include +#include + +#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 \n#include \n#include \n#include \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 +#include +#include +#include + +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(); -- cgit v1.2.1