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