From ba86ff938a6b17c171dd68ebdf897ca3e30550f8 Mon Sep 17 00:00:00 2001 From: Paul Cercueil Date: Sat, 26 Aug 2023 10:38:41 +0200 Subject: [PATCH] git subrepo pull (merge) --force deps/lightning subrepo: subdir: "deps/lightning" merged: "fe12b4b8d9" upstream: origin: "https://github.com/pcercuei/gnu_lightning.git" branch: "pcsx_rearmed" commit: "fe12b4b8d9" git-subrepo: version: "0.4.6" origin: "https://github.com/ingydotnet/git-subrepo.git" commit: "110b9eb" --- deps/lightning/.gitrepo | 6 +- deps/lightning/ChangeLog | 170 + deps/lightning/check/.gitignore | 10 + deps/lightning/check/Makefile.am | 134 +- deps/lightning/check/all.tst | 52 + deps/lightning/check/alu_hmul.ok | 1 + deps/lightning/check/alu_hmul.tst | 31 + deps/lightning/check/alu_rot.ok | 1 + deps/lightning/check/alu_rot.tst | 39 + deps/lightning/check/bit.tst | 2 +- deps/lightning/check/callee.c | 157 + deps/lightning/check/catomic.c | 47 +- deps/lightning/check/cvt.tst | 197 + deps/lightning/check/ext.ok | 1 + deps/lightning/check/ext.tst | 15438 ++++++++++++++++ deps/lightning/check/fma.ok | 1 + deps/lightning/check/fma.tst | 425 + deps/lightning/check/gen_cbit.c | 603 + deps/lightning/check/imm.ok | 1 + deps/lightning/check/imm.tst | 239 + deps/lightning/check/lightning.c | 431 +- deps/lightning/check/popcnt.ok | 1 + deps/lightning/check/popcnt.tst | 123 + deps/lightning/check/qalu_shift.ok | 1 + deps/lightning/check/qalu_shift.tst | 748 + deps/lightning/check/rbit.ok | 1 + deps/lightning/check/rbit.tst | 232 + deps/lightning/check/unldst.ok | 1 + deps/lightning/check/unldst.tst | 2468 +++ deps/lightning/configure.ac | 2 +- deps/lightning/doc/body.texi | 181 +- deps/lightning/include/lightning.h.in | 249 +- deps/lightning/include/lightning/jit_arm.h | 57 + deps/lightning/include/lightning/jit_hppa.h | 14 + deps/lightning/include/lightning/jit_ia64.h | 2 + .../include/lightning/jit_loongarch.h | 11 + deps/lightning/include/lightning/jit_mips.h | 10 + .../lightning/include/lightning/jit_private.h | 46 +- deps/lightning/include/lightning/jit_riscv.h | 20 + deps/lightning/include/lightning/jit_x86.h | 4 + deps/lightning/lib/Makefile.am | 2 +- deps/lightning/lib/jit_aarch64-cpu.c | 371 +- deps/lightning/lib/jit_aarch64-fpu.c | 125 +- deps/lightning/lib/jit_aarch64-sz.c | 222 +- deps/lightning/lib/jit_aarch64.c | 169 + deps/lightning/lib/jit_alpha-cpu.c | 659 +- deps/lightning/lib/jit_alpha-fpu.c | 167 + deps/lightning/lib/jit_alpha-sz.c | 141 +- deps/lightning/lib/jit_alpha.c | 186 +- deps/lightning/lib/jit_arm-cpu.c | 296 +- deps/lightning/lib/jit_arm-swf.c | 506 +- deps/lightning/lib/jit_arm-sz.c | 848 +- deps/lightning/lib/jit_arm-vfp.c | 672 +- deps/lightning/lib/jit_arm.c | 206 +- deps/lightning/lib/jit_fallback.c | 4024 +++- deps/lightning/lib/jit_hppa-cpu.c | 227 +- deps/lightning/lib/jit_hppa-fpu.c | 175 + deps/lightning/lib/jit_hppa-sz.c | 502 +- deps/lightning/lib/jit_hppa.c | 189 + deps/lightning/lib/jit_ia64-cpu.c | 455 +- deps/lightning/lib/jit_ia64-fpu.c | 119 +- deps/lightning/lib/jit_ia64-sz.c | 643 +- deps/lightning/lib/jit_ia64.c | 162 +- deps/lightning/lib/jit_loongarch-cpu.c | 137 + deps/lightning/lib/jit_loongarch-fpu.c | 86 +- deps/lightning/lib/jit_loongarch-sz.c | 91 +- deps/lightning/lib/jit_loongarch.c | 165 + deps/lightning/lib/jit_mips-cpu.c | 1165 +- deps/lightning/lib/jit_mips-fpu.c | 537 +- deps/lightning/lib/jit_mips-sz.c | 200 +- deps/lightning/lib/jit_mips.c | 299 +- deps/lightning/lib/jit_names.c | 78 +- deps/lightning/lib/jit_note.c | 6 +- deps/lightning/lib/jit_ppc-cpu.c | 655 +- deps/lightning/lib/jit_ppc-fpu.c | 100 +- deps/lightning/lib/jit_ppc-sz.c | 2094 ++- deps/lightning/lib/jit_ppc.c | 327 +- deps/lightning/lib/jit_print.c | 78 +- deps/lightning/lib/jit_riscv-cpu.c | 95 + deps/lightning/lib/jit_riscv-fpu.c | 86 +- deps/lightning/lib/jit_riscv-sz.c | 477 +- deps/lightning/lib/jit_riscv.c | 173 + deps/lightning/lib/jit_s390-cpu.c | 172 +- deps/lightning/lib/jit_s390-fpu.c | 201 + deps/lightning/lib/jit_s390-sz.c | 202 +- deps/lightning/lib/jit_s390.c | 218 +- deps/lightning/lib/jit_sparc-cpu.c | 109 +- deps/lightning/lib/jit_sparc-fpu.c | 208 +- deps/lightning/lib/jit_sparc-sz.c | 1202 +- deps/lightning/lib/jit_sparc.c | 217 + deps/lightning/lib/jit_x86-cpu.c | 736 +- deps/lightning/lib/jit_x86-sse.c | 480 +- deps/lightning/lib/jit_x86-sz.c | 688 +- deps/lightning/lib/jit_x86-x87.c | 306 + deps/lightning/lib/jit_x86.c | 250 +- deps/lightning/lib/lightning.c | 1537 +- deps/lightning/size.c | 7 +- 97 files changed, 42549 insertions(+), 4056 deletions(-) create mode 100644 deps/lightning/check/alu_hmul.ok create mode 100644 deps/lightning/check/alu_hmul.tst create mode 100644 deps/lightning/check/alu_rot.ok create mode 100644 deps/lightning/check/alu_rot.tst create mode 100644 deps/lightning/check/callee.c create mode 100644 deps/lightning/check/ext.ok create mode 100644 deps/lightning/check/ext.tst create mode 100644 deps/lightning/check/fma.ok create mode 100644 deps/lightning/check/fma.tst create mode 100644 deps/lightning/check/gen_cbit.c create mode 100644 deps/lightning/check/imm.ok create mode 100644 deps/lightning/check/imm.tst create mode 100644 deps/lightning/check/popcnt.ok create mode 100644 deps/lightning/check/popcnt.tst create mode 100644 deps/lightning/check/qalu_shift.ok create mode 100644 deps/lightning/check/qalu_shift.tst create mode 100644 deps/lightning/check/rbit.ok create mode 100644 deps/lightning/check/rbit.tst create mode 100644 deps/lightning/check/unldst.ok create mode 100644 deps/lightning/check/unldst.tst diff --git a/deps/lightning/.gitrepo b/deps/lightning/.gitrepo index 17edd68d..0ea98e59 100644 --- a/deps/lightning/.gitrepo +++ b/deps/lightning/.gitrepo @@ -6,7 +6,7 @@ [subrepo] remote = https://github.com/pcercuei/gnu_lightning.git branch = pcsx_rearmed - commit = b1983e9036d35933ffa773d81b61eedbf3ae3b93 - parent = 638335fabe3ba77b2a5c624a4c4aec52c18488f7 + commit = fe12b4b8d9989addcdb812db6da16fac3b3a9fa1 + parent = 56e500f3428614e677ba5e9719f002046e87d980 method = merge - cmdver = 0.4.3 + cmdver = 0.4.6 diff --git a/deps/lightning/ChangeLog b/deps/lightning/ChangeLog index 2cd52735..8a5588af 100644 --- a/deps/lightning/ChangeLog +++ b/deps/lightning/ChangeLog @@ -1,3 +1,173 @@ +2023-08-21 Paulo Andrade + + * check/Makefile.am, check/lightning.c: Add new hmul tests. + * doc/body.texi: Document hmul. + * include/lightning.h.in: Create the new hmul codes. + * lib/jit_aarch64-cpu.c, lib/jit_aarch64-sz.c, lib/jit_aarch64.c, + lib/jit_alpha-cpu.c, lib/jit_alpha-sz.c, lib/jit_alpha.c, + lib/jit_arm-cpu.c, lib/jit_arm-sz.c, lib/jit_arm.c, + lib/jit_hppa-cpu.c, lib/jit_hppa-sz.c, lib/jit_hppa.c, + lib/jit_ia64-cpu.c, lib/jit_ia64-sz.c, lib/jit_ia64.c, + lib/jit_loongarch-cpu.c, lib/jit_loongarch-sz.c, lib/jit_loongarch.c, + lib/jit_mips-cpu.c, lib/jit_mips-sz.c, lib/jit_mips.c, + lib/jit_ppc-cpu.c, lib/jit_ppc-sz.c, lib/jit_ppc.c, + lib/jit_riscv-cpu.c, lib/jit_riscv-sz.c, lib/jit_riscv.c, + lib/jit_s390-cpu.c, lib/jit_s390-sz.c, lib/jit_s390.c, + lib/jit_sparc-cpu.c, lib/jit_sparc-sz.c, lib/jit_sparc.c, + lib/jit_x86-cpu.c, lib/jit_x86-sz.c, lib/jit_x86.c: Implement + hmul and update the *-sz.c files. + * lib/jit_names.c, lib/lightning.c: Add knowledge of hmul. + +2023-04-18 Paulo Andrade + + * include/lightning.h.in: Define new fmar_f, fmai_f, fmsr_f, + fmsi_f, fmar_d, fmai_d, fmsr_d and fmsi_d instructions, that + add support for fused multiply add/sub, in the format + r0 = r1 * r2 +/- r3. + * include/lightning/jit_private.h: Add helper macros for debug + output. + * lib/jit_names.c: Add strings for debug output. + * lib/jit_print.c: Print debug output for the new instructions. + * lib/lightning.c: Add logic for the new register pair in the + 'v' (second) field of jit_node_t. The new pattern is required + to allow having a 'double' immediate in the last argument, for + the versions with immediates. The versions with immediates are + added for consistency, as they should be very rarely used in + common usage of fused multiply add/sub. + +2023-04-06 Paulo Andrade + + * include/lightning.h.in: Define new movi_w_f, movi_w_d and + movi_ww_d instructions, to have an inverse counterpart to + movi_f_w, movi_d_w and movi_d_ww. + * lib/lightning.c: Update for the new instructions. + * lib/jit_names.c, lib/jit_print.c: Update debug information. + +2023-04-05 Paulo Andrade + + * include/lightning.h.in: Define new unldr, unldi, unldr_x, + unldi_x, unstr, unsti, unldr_x and unstr_x instructions. + Remove comment about internal backend specific codes, as they + are required by unldr_x and unstr_x in some code paths. + * lib/lightning.c: Implement generic movi_f_w, movi_d_w and + movi_d_ww that are actually the same for all ports. + Define generic load/store implementations when unaligned memory + access does not trap. + +2023-03-23 Paulo Andrade + + * include/lightning.h.in: Define new qlshr, qlshi, qlshr_u, + qlshi_u, qrshr, qrshi, qrshr_u and qrshi_u instructions. + * lib/jit_fallback.c: Implement new fallbacks. + * lib/jit_names.c: Update debug information. + * lib/lightning.c: Add code to update regsets, matching other + instructions with two outputs. + +2023-03-20 Paulo Andrade + + * check/all.tst: Add missing instructions to debug encoding. + * check/lightning.c: Implement calls to the new rich set of + instructions, with an immediate argument, mostly which are resolved + at code generation time. With the exception of jit_negi_{f,d}, + jit_absi{f,d} and jit_sqrti_{f,d} that generate code to execute at + runtime. This is required because the code generator should create + the proper float environment with rounding modes, exceptions, etc. + The new jit_depi is just a wrapper to have the second operand as an + immediate and call jit_depr. + * include/lightning.h.in: Declare new instructions code and function + prototypes as appropriate. + * include/lightning/jit_private.h: Add 4 new macros to generate + synthetic debug for float operations with an immediate argument. + * lib/jit_aarch64.c, lib/jit_alpha.c, lib/jit_arm.c, lib/jit_hppa.c, + lib/jit_ia64.c, lib/jit_loongarch.c, lib/jit_mips.c, lib/jit_ppc.c, + lib/jit_riscv.c, lib/jit_s390.c, lib/jit_sparc.c, lib/jit_x86.c: + Add code to call the generic code to implement new instructions + with immediate operands. + * lib/jit_names.c, lib/jit_print.c: Add debug for the new instructions + with immediate operands. + * lib/lightning.c: Add code to handle regsets and actually implement + the generic new instructions. + +2023-03-17 Paulo Andrade + + * lib/jit_fallback.c: Implement fallbacks for new instructions + ext, ext_u and dep. + * lib/lightning.c: Add code to understand the new instructions + and update regsets as appropriate. + * lib/jit_names.c, lib/jit_print.c: Update for debug information + of ext, ext_u and dep. + * include/lightning.h.in: Define jit_code_t for ext, ext_u and dep. + * check/lightning.c: Handle the new instructions. + * check/all.tst: Add new instructions for the full disassembly. + +2023-03-07 Paulo Andrade + + * check/alu_rot.tst, check/alu_rot.ok: New test files for the new + lrotr, lroti, rrotr and rroti instructions. + * check/Makefile.am, check/lightning.c, include/lightning.h.in, + lib/jit_names.c: lib/lightning.c, doc/body.texi: Update for the + new instructions. + * lib/jit_aarch64-cpu.c, lib/jit_aarch64.c, lib/jit_arm-cpu.c, + lib/jit_arm.c: Implement optimized rrotr and rroti. lrotr and + lroti just adjust parameters for a left shift rotate. + * lib/jit_alpha-cpu.c, lib/jit_alpha.c, lib/jit_ia64-cpu, + lib/jit_ia64.c, lib/jit_riscv-cpu.c, lib/jit_riscv.c, + jit_sparc-cpu.c, jit_sparc.c: Implement calls to fallback lrotr, + lroti, rrotr and rroti. + * lib/jit_hppa-cpu.c, lib/jit_hppa.c: Implement optimized rroti. + Other instructions use fallbacks. + * lib/jit_loongarch-cpu.c, lib/jit_loongarch.c: Implement optimized + rrotr and rroti. lrotr and lroti just adapt arguments and use a + right shift. + * lib/jit_mips-cpu.c, lib/jit_mips.c: If mips2, Implement optimized + rrotr and rroti. lrotr and lroti just adapt arguments and use a + right shift. If mips1 use fallbacks. + * lib/jit_ppc-cpu.c, lib/jit_ppc.c, jit_s390-cpu.c, jit_s390.c, + lib/jit_x86-cpu.c, lib/jit_x86.c: Implement optimized lrotr, + lroti, rrotr, rroti. + * lib/jit_fallback.c: Implement fallbacks for lrotr, lroti, + rrotr and rroti. Also add extra macro to avoid segfaults in s390, + that cannot use register zero for some addressing instructions. + +2023-03-02 Paulo Andrade + + * check/popcnt.tst, check/popcnt.ok: New test files for the new + popcntr instruction. + * check/Makefile.am, check/lightning.c, include/lightning.h.in, + lib/jit_names.c: lib/lightning.c, doc/body.texi: Update for popcntr. + * lib/jit_aarch64-fpu.c, lib/jit_aarch64.c: Implement optimized + popcntr using the fpu. + * lib/jit_alpha-cpu.c, lib/jit_alpha.c: Implement optimized + popcntr using the ctpop instruction. + * lib/jit_arm-vfp.c, lib/jit_arm-cpu.c, lib/jit_arm.c: Implement + untested optimized popcntr using vfp >= 4, otherwise use a + software fallback. + * lib/jit_ia64-cpu.c, lib/jit_jia64.c: Implement optimized + popcntr using the popcnt instruction. + * lib/jit_ppc-cpu.c, lib/jit_ppc.c: Implement optimized + popcntr using the popcntb, plus mullr and rshi_u instruction. + * lib/jit_x86-cpu.c, lib/jit_x86.c: Implement optimized + popcntr instruction using the popcnt instruction if available, + otherwise use an optimized fallback. + * lib/jit_fallback.c: Implement simple fallback popcnt. + * lib/jit_hppa.c, lib/jit_loongarch.c, lib/jit_mips.c, + lib/jit_riscv.c, lib/jit_s390.c, lib/jit_sparc.c: Use fallback + popcnt. + +2023-02-26 Paulo Andrade + + * check/bit.tst: Correct 32 bit sample ctz implementation. + * include/lightning/jit_mips.h: Add jit_cpu flags for instructions + that cannot be used in delay slot. + * lib/jit_fallback.c: Mips fallbacks now might need a flush of + instructions to get correct label addresses, due to pending + instruction candidate to delay slot. + * lib/jit_mips-cpu.c: Flush any pending instruction if it cannot + be used in the delay slot. Add calls to fallback clo, clz, cto and + ctz for mips 1. + * lib/jit_mips.c: Add code to set defaults or detect if can use + certain instructions to delay slots. + 2023-02-23 Paulo Andrade * include/lightning/jit_private.h: Add new 'inst' field to diff --git a/deps/lightning/check/.gitignore b/deps/lightning/check/.gitignore index 3ca81ec2..ee629868 100644 --- a/deps/lightning/check/.gitignore +++ b/deps/lightning/check/.gitignore @@ -2,6 +2,7 @@ nodata *.log *.trs +*.x87 3to2 bswap @@ -18,18 +19,21 @@ alu_mul alu_neg alu_or alu_rem +alu_rot alu_rsb alu_rsh alu_sub alu_xor alux_add alux_sub +bit bp branch call carg carry catomic +cbit ccall clobber ctramp @@ -40,6 +44,7 @@ fib float fop_abs fop_sqrt +gen_cbit hton jmpr ldsti @@ -52,11 +57,15 @@ ldstxr-c lightning live movzr +popcnt +protect put qalu_div qalu_mul range ranger +rbit +riprel ret rpn self @@ -65,3 +74,4 @@ stack tramp va_list varargs +cbit.c diff --git a/deps/lightning/check/Makefile.am b/deps/lightning/check/Makefile.am index c77f5cd3..1f086eff 100644 --- a/deps/lightning/check/Makefile.am +++ b/deps/lightning/check/Makefile.am @@ -18,7 +18,7 @@ AM_CFLAGS = -I$(top_builddir)/include -I$(top_srcdir)/include \ -D_GNU_SOURCE $(LIGHTNING_CFLAGS) check_PROGRAMS = lightning ccall self setcode nodata ctramp carg cva_list \ - catomic protect riprel + catomic protect riprel cbit callee lightning_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB) lightning_SOURCES = lightning.c @@ -53,6 +53,26 @@ protect_SOURCES = protect.c riprel_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB) riprel_SOURCES = riprel.c +# Actually, gcc 4.1.2 does not like unknown -Wno-option and errors out; +# better to just have warnings. +if cpu_ia64 +cbit_CFLAGS = $(AM_CFLAGS) -fwrapv +else +cbit_CFLAGS = $(AM_CFLAGS) -fwrapv -Wno-overflow -Wno-integer-overflow \ + -Wno-shift-count-overflow +endif +cbit_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB) +cbit_SOURCES = cbit.c + +callee_LDADD = $(top_builddir)/lib/liblightning.la -lm $(SHLIB) +callee_SOURCES = callee.c + +noinst_PROGRAMS = gen_cbit +gen_cbit_SOURCES = gen_cbit.c + +cbit.c: gen_cbit + $(top_builddir)/check/gen_cbit > cbit.c + $(top_builddir)/lib/liblightning.la: cd $(top_builddir)/lib; $(MAKE) $(AM_MAKEFLAGS) liblightning.la @@ -74,6 +94,7 @@ EXTRA_DIST = \ ldstr-c.tst ldstr-c.ok \ ldstxr-c.tst ldstxr-c.ok \ ldstxi-c.tst ldstxi-c.ok \ + ext.tst ext.ok \ cvt.tst cvt.ok \ hton.tst hton.ok \ bswap.tst bswap.ok \ @@ -85,6 +106,7 @@ EXTRA_DIST = \ alux_sub.tst alux_sub.ok \ alu_rsb.tst alu_rsb.ok \ alu_mul.tst alu_mul.ok \ + alu_hmul.tst alu_hmul.ok \ alu_div.tst alu_div.ok \ alu_rem.tst alu_rem.ok \ alu_and.tst alu_and.ok \ @@ -94,6 +116,7 @@ EXTRA_DIST = \ alu_rsh.tst alu_rsh.ok \ alu_com.tst alu_com.ok \ alu_neg.tst alu_neg.ok \ + alu_rot.tst alu_rot.ok \ movzr.tst movzr.ok \ fop_abs.tst fop_abs.ok \ fop_sqrt.tst fop_sqrt.ok \ @@ -103,12 +126,14 @@ EXTRA_DIST = \ carry.tst carry.ok \ call.tst call.ok \ float.tst float.ok \ + fma.tst fma.ok \ jmpr.tst jmpr.ok \ live.tst live.ok \ put.tst put.ok \ qalu.inc \ qalu_mul.tst qalu_mul.ok \ qalu_div.tst qalu_div.ok \ + qalu_shift.tst qalu_shift.ok \ range.tst range.ok \ ranger.tst ranger.ok \ ret.tst ret.ok \ @@ -116,6 +141,10 @@ EXTRA_DIST = \ tramp.tst tramp.ok \ va_list.tst va_list.ok \ bit.tst bit.ok \ + rbit.tst rbit.ok \ + popcnt.tst popcnt.ok \ + imm.tst imm.ok \ + unldst.tst unldst.ok \ check.sh \ check.x87.sh \ check.arm.sh check.swf.sh \ @@ -124,7 +153,8 @@ EXTRA_DIST = \ check.nodata.sh \ check.x87.nodata.sh \ run-test all.tst \ - collatz.tst factorial.tst + collatz.tst factorial.tst \ + gen_cbit.c base_TESTS = \ 3to2 add align allocai \ @@ -132,21 +162,23 @@ base_TESTS = \ ldstr ldsti \ ldstxr ldstxi \ ldstr-c ldstxr-c ldstxi-c \ - cvt hton bswap branch \ + ext cvt hton bswap branch \ alu_add alux_add \ alu_sub alux_sub alu_rsb \ - alu_mul alu_div alu_rem \ + alu_mul alu_hmul \ + alu_div alu_rem \ alu_and alu_or alu_xor \ alu_lsh alu_rsh \ - alu_com alu_neg \ - movzr \ + alu_com alu_neg alu_rot \ + movzr fma \ fop_abs fop_sqrt \ varargs stack \ clobber carry call \ float jmpr live put \ - qalu_mul qalu_div \ + qalu_mul qalu_div qalu_shift \ range ranger ret skip tramp \ - va_list bit + va_list bit rbit popcnt imm \ + unldst $(base_TESTS): check.sh $(LN_S) $(srcdir)/check.sh $@ @@ -161,19 +193,20 @@ x87_TESTS = \ rpn.x87 ldstr.x87 ldsti.x87 \ ldstxr.x87 ldstxi.x87 \ ldstr-c.x87 ldstxr-c.x87 ldstxi-c.x87 \ - cvt.x87 branch.x87 \ + ext.x87 cvt.x87 branch.x87 \ alu_add.x87 alux_add.x87 \ alu_sub.x87 alux_sub.x87 alu_rsb.x87 \ - alu_mul.x87 alu_div.x87 alu_rem.x87 \ + alu_mul.x87 alu_hmul.x87 \ + alu_div.x87 alu_rem.x87 \ alu_and.x87 alu_or.x87 alu_xor.x87 \ - alu_lsh.x87 alu_rsh.x87 \ + alu_lsh.x87 alu_rsh.x87 alu_rot.x87 \ alu_com.x87 alu_neg.x87 \ - movzr.x87 \ + movzr.x87 fma.x87 \ fop_abs.x87 fop_sqrt.x87 \ varargs.x87 stack.x87 \ clobber.x87 carry.x87 call.x87 \ float.x87 jmpr.x87 put.x87 \ - va_list.x87 + va_list.x87 imm.x87 unldst.x87 $(x87_TESTS): check.x87.sh $(LN_S) $(srcdir)/check.x87.sh $@ TESTS += $(x87_TESTS) @@ -185,19 +218,20 @@ x87_nodata_TESTS = \ rpn.x87.nodata ldstr.x87.nodata ldsti.x87.nodata \ ldstxr.x87.nodata ldstxi.x87.nodata \ ldstr-c.x87.nodata ldstxr-c.x87.nodata ldstxi-c.x87.nodata \ - cvt.x87.nodata branch.x87.nodata \ + ext.x87.nodata cvt.x87.nodata branch.x87.nodata \ alu_add.x87.nodata alux_add.x87.nodata \ alu_sub.x87.nodata alux_sub.x87.nodata alu_rsb.x87.nodata \ - alu_mul.x87.nodata alu_div.x87.nodata alu_rem.x87.nodata \ + alu_mul.x87.nodata alu_hmul.x87.nodata \ + alu_div.x87.nodata alu_rem.x87.nodata \ alu_and.x87.nodata alu_or.x87.nodata alu_xor.x87.nodata \ - alu_lsh.x87.nodata alu_rsh.x87.nodata \ + alu_lsh.x87.nodata alu_rsh.x87.nodata alu_rot.x87.nodata \ alu_com.x87.nodata alu_neg.x87.nodata \ - movzr.x87.nodata \ + movzr.x87.nodata fma.x87.nodata \ fop_abs.x87.nodata fop_sqrt.x87.nodata \ varargs.x87.nodata stack.x87.nodata \ clobber.x87.nodata carry.x87.nodata call.x87.nodata \ float.x87.nodata jmpr.x87.nodata put.x87.nodata \ - va_list.x87.nodata + va_list.x87.nodata imm.x87.nodata unldst.x87.nodata $(x87_nodata_TESTS): check.x87.nodata.sh $(LN_S) $(srcdir)/check.x87.nodata.sh $@ TESTS += $(x87_nodata_TESTS) @@ -211,19 +245,21 @@ arm_TESTS = \ rpn.arm ldstr.arm ldsti.arm \ ldstxr.arm ldstxi.arm \ ldstr-c.arm ldstxr-c.arm ldstxi-c.arm \ - cvt.arm hton.arm bswap.arm branch.arm \ - alu_add.arm alux_add.arm \ + ext.arm cvt.arm hton.arm bswap.arm \ + branch.arm alu_add.arm alux_add.arm \ alu_sub.arm alux_sub.arm alu_rsb.arm \ - alu_mul.arm alu_div.arm alu_rem.arm \ + alu_mul.arm alu_hmul.arm \ + alu_div.arm alu_rem.arm \ alu_and.arm alu_or.arm alu_xor.arm \ - alu_lsh.arm alu_rsh.arm \ + alu_lsh.arm alu_rsh.arm alu_rot.arm \ alu_com.arm alu_neg.arm \ - movzr.arm \ + movzr.arm fma.arm \ fop_abs.arm fop_sqrt.arm \ varargs.arm stack.arm \ clobber.arm carry.arm call.arm \ float.arm jmpr.arm tramp.arm range.arm \ - ranger.arm put.arm va_list.arm + ranger.arm put.arm va_list.arm imm.arm \ + unldst.arm $(arm_TESTS): check.arm.sh $(LN_S) $(srcdir)/check.arm.sh $@ TESTS += $(arm_TESTS) @@ -237,19 +273,21 @@ swf_TESTS = \ rpn.swf ldstr.swf ldsti.swf \ ldstxr.swf ldstxi.swf \ ldstr-c.swf ldstxr-c.swf ldstxi-c.swf \ - cvt.swf hton.swf bswap.swf branch.swf \ - alu_add.swf alux_add.swf \ + ext.swf cvt.swf hton.swf bswap.swf \ + branch.swf alu_add.swf alux_add.swf \ alu_sub.swf alux_sub.swf alu_rsb.swf \ - alu_mul.swf alu_div.swf alu_rem.swf \ + alu_mul.swf alu_hmul.swf \ + alu_div.swf alu_rem.swf \ alu_and.swf alu_or.swf alu_xor.swf \ - alu_lsh.swf alu_rsh.swf \ + alu_lsh.swf alu_rsh.swf alu_rot.swf \ alu_com.swf alu_neg.swf \ - movzr.swf \ + movzr.swf fma.swf \ fop_abs.swf fop_sqrt.swf \ varargs.swf stack.swf \ clobber.swf carry.swf call.swf \ float.swf jmpr.swf tramp.swf range.swf \ - ranger.swf put.swf va_list.swf + ranger.swf put.swf va_list.swf imm.swf \ + unldst.swf $(swf_TESTS): check.swf.sh $(LN_S) $(srcdir)/check.swf.sh $@ TESTS += $(swf_TESTS) @@ -261,19 +299,20 @@ arm_swf_TESTS = \ rpn.arm.swf ldstr.arm.swf ldsti.arm.swf \ ldstxr.arm.swf ldstxi.arm.swf \ ldstr-c.arm.swf ldstxr-c.arm.swf ldstxi-c.arm.swf \ - cvt.arm.swf hton.arm.swf bswap.arm.swf branch.arm.swf \ - alu_add.arm.swf alux_add.arm.swf \ + ext.arm.swf cvt.arm.swf hton.arm.swf bswap.arm.swf \ + branch.arm.swf alu_add.arm.swf alux_add.arm.swf \ alu_sub.arm.swf alux_sub.arm.swf alu_rsb.arm.swf \ alu_mul.arm.swf alu_div.arm.swf alu_rem.arm.swf \ alu_and.arm.swf alu_or.arm.swf alu_xor.arm.swf \ - alu_lsh.arm.swf alu_rsh.arm.swf \ + alu_lsh.arm.swf alu_rsh.arm.swf alu_rot.arm.swf \ alu_com.arm.swf alu_neg.arm.swf \ - movzr.arm.swf \ + movzr.arm.swf fma.arm.swf \ fop_abs.arm.swf fop_sqrt.arm.swf \ varargs.arm.swf stack.arm.swf \ clobber.arm.swf carry.arm.swf call.arm.swf \ float.arm.swf jmpr.arm.swf tramp.arm.swf range.arm.swf \ - ranger.arm.swf put.arm.swf va_list.arm.swf + ranger.arm.swf put.arm.swf va_list.arm.swf imm.arm.swf \ + unldst.arm.swf $(arm_swf_TESTS): check.arm.swf.sh $(LN_S) $(srcdir)/check.arm.swf.sh $@ TESTS += $(arm_swf_TESTS) @@ -286,20 +325,21 @@ arm4_swf_TESTS = \ rpn.arm4.swf ldstr.arm4.swf ldsti.arm4.swf \ ldstxr.arm4.swf ldstxi.arm4.swf \ ldstr-c.arm4.swf ldstxr-c.arm4.swf ldstxi-c.arm4.swf \ - cvt.arm4.swf hton.arm4.swf bswap.arm4.swf \ + ext.arm4.swf cvt.arm4.swf hton.arm4.swf bswap.arm4.swf \ branch.arm4.swf alu_add.arm4.swf alux_add.arm4.swf \ alu_sub.arm4.swf alux_sub.arm4.swf alu_rsb.arm4.swf \ alu_mul.arm4.swf alu_div.arm4.swf alu_rem.arm4.swf \ alu_and.arm4.swf alu_or.arm4.swf alu_xor.arm4.swf \ - alu_lsh.arm4.swf alu_rsh.arm4.swf \ + alu_lsh.arm4.swf alu_rsh.arm4.swf alu_rot.arm4.swf \ alu_com.arm4.swf alu_neg.arm4.swf \ - movzr.arm4.swf \ + movzr.arm4.swf fma.arm4.swf \ fop_abs.arm4.swf fop_sqrt.arm4.swf \ varargs.arm4.swf stack.arm4.swf \ clobber.arm4.swf carry.arm4.swf call.arm4.swf \ float.arm4.swf jmpr.arm4.swf tramp.arm4.swf \ range.arm4.swf ranger.arm4.swf put.arm4.swf \ - va_list.arm4.swf + va_list.arm4.swf imm.arm4.swf \ + unldst.arm4.swf $(arm4_swf_TESTS): check.arm4.swf.sh $(LN_S) $(srcdir)/check.arm4.swf.sh $@ TESTS += $(arm4_swf_TESTS) @@ -314,28 +354,30 @@ nodata_TESTS = \ rpn.nodata ldstr.nodata ldsti.nodata \ ldstxr.nodata ldstxi.nodata \ ldstr-c.nodata ldstxr-c.nodata ldstxi-c.nodata \ - cvt.nodata branch.nodata \ + ext.nodata cvt.nodata branch.nodata \ alu_add.nodata alux_add.nodata \ alu_sub.nodata alux_sub.nodata alu_rsb.nodata \ - alu_mul.nodata alu_div.nodata alu_rem.nodata \ + alu_mul.nodata alu_hmul.nodata \ + alu_div.nodata alu_rem.nodata \ alu_and.nodata alu_or.nodata alu_xor.nodata \ - alu_lsh.nodata alu_rsh.nodata \ + alu_lsh.nodata alu_rsh.nodata alu_rot.nodata \ alu_com.nodata alu_neg.nodata \ - movzr.nodata \ + movzr.nodata fma.nodata \ fop_abs.nodata fop_sqrt.nodata \ varargs.nodata stack.nodata \ clobber.nodata carry.nodata call.nodata \ float.nodata jmpr.nodata tramp.nodata \ range.nodata ranger.nodata put.nodata \ - va_list.nodata bit.nodata + va_list.nodata bit.nodata imm.nodata \ + unldst.nodata $(nodata_TESTS): check.nodata.sh $(LN_S) $(srcdir)/check.nodata.sh $@ TESTS += $(nodata_TESTS) endif TESTS += ccall self setcode nodata ctramp carg cva_list catomic \ - protect riprel -CLEANFILES = $(TESTS) + protect riprel cbit callee +CLEANFILES = $(TESTS) gen_cbit cbit.c #TESTS_ENVIRONMENT=$(srcdir)/run-test; diff --git a/deps/lightning/check/all.tst b/deps/lightning/check/all.tst index d24f7ae0..2257ac63 100644 --- a/deps/lightning/check/all.tst +++ b/deps/lightning/check/all.tst @@ -83,11 +83,25 @@ rshr_u %r0 %r1 %r2 rshi_u %r0 %r1 2 negr %r0 %r1 + negi %r0 1 comr %r0 %r1 + comi %r0 1 clor %r0 %r1 + cloi %r0 0xfffffffe clzr %r0 %r1 + clzi %r0 1 ctor %r0 %r1 + ctoi %r0 -1 + ctzi %r0 0x80000000 ctzr %r0 %r1 + rbitr %r0 %r1 + rbiti %r0 0x02468ace + popcntr %r0 %r1 + popcnti %r0 0x8a13c851 + lrotr %r0 %r1 %r2 + lroti %r0 %r1 0x1f + rrotr %r0 %r1 %r2 + rroti %r0 %r1 0x1f ltr %r0 %r1 %r2 lti %r0 %r1 2 ltr_u %r0 %r1 %r2 @@ -110,16 +124,48 @@ nei %r0 %r1 2 movr %r0 %r1 movi %r0 1 + extr %r0 %r1 4 3 + exti %r0 0xa5a5a584 4 3 + extr_u %r0 %r1 4 3 + exti_u %r0 0xa5a5a584 4 3 + depr %r0 %r1 4 3 + depi %r0 0xa5a5a584 4 3 extr_c %r0 %r1 + exti_c %r0 0xfff extr_uc %r0 %r1 + exti_uc %r0 0xfff extr_s %r0 %r1 + exti_s %r0 0xfffff extr_us %r0 %r1 + exti_us %r0 0xfffff #if __WORDSIZE == 64 extr_i %r0 %r1 + exti_i %r0 0x80000000 extr_ui %r0 %r1 + exti_ui %r0 0x80000000 +#endif + htonr_us %r0 %r1 + htoni_us %r0 0xff1234 + htonr_ui %r0 %r1 + htoni_ui %r0 0x12345678 +#if __WORDSIZE == 64 + htonr_ul %r0 %r1 + htoni_ul %r0 0x123456789abcdef0 #endif htonr %r0 %r1 ntohr %r0 %r1 + htoni %r0 0x12345678 + ntohi %r0 0x12345678 + bswapr_us %r0 %r1 + bswapi_us %r0 0xff1234 + bswapr_ui %r0 %r1 + bswapi_ui %r0 0x12345678 +#if __WORDSIZE == 64 + bswapr_ul %r0 %r1 + bswapi_ul %r0 0x123456789abcdef0 +#endif + bswapr %r0 %r1 + bswapi %r0 0x12345678 ldr_c %r0 %r1 ldi_c %r0 0x80000000 ldr_uc %r0 %r1 @@ -278,8 +324,11 @@ label: divr_f %f0 %f1 %f2 divi_f %f0 %f1 0.5 negr_f %f0 %f1 + negi_f %f0 -1 absr_f %f0 %f1 + absi_f %f0 -1 sqrtr_f %f0 %f1 + sqrti_f %f0 -1 ltr_f %r0 %f0 %f1 lti_f %r0 %f0 0.5 ler_f %r0 %f0 %f1 @@ -378,8 +427,11 @@ unordi: divr_d %f0 %f1 %f2 divi_d %f0 %f1 0.5 negr_d %f0 %f1 + negi_d %f0 -1 absr_d %f0 %f1 + absi_d %f0 -1 sqrtr_d %f0 %f1 + sqrti_d %f0 -1 ltr_d %r0 %f0 %f1 lti_d %r0 %f0 0.5 ler_d %r0 %f0 %f1 diff --git a/deps/lightning/check/alu_hmul.ok b/deps/lightning/check/alu_hmul.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/alu_hmul.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/alu_hmul.tst b/deps/lightning/check/alu_hmul.tst new file mode 100644 index 00000000..ef47a4dd --- /dev/null +++ b/deps/lightning/check/alu_hmul.tst @@ -0,0 +1,31 @@ +#include "alu.inc" + +.code + prolog +#define HMUL(N, I0, I1, V) ALU(N, , hmul, I0, I1, V) +#define UHMUL(N, I0, I1, V) ALU(N, _u, hmul, I0, I1, V) + HMUL(0, -2, -1, 0) + HMUL(1, 0, -1, 0) + HMUL(2, -1, 0, 0) + HMUL(3, 1, -1, -1) +#if __WORDSIZE == 32 + HMUL(4, 0x7ffff, 0x7ffff, 0x3f) + UHMUL(5, 0xffffff, 0xffffff, 0xffff) + HMUL(6, 0x80000000, -2, 1) + HMUL(7, 0x80000000, 2, -1) + HMUL(8, 0x80000001, 3, -2) + HMUL(9, 0x80000001, -3, 1) +#else + HMUL(4, 0x7ffffffff, 0x7ffffffff, 0x3f) + UHMUL(5, 0xffffffffff, 0xffffffffff, 0xffff) + HMUL(6, 0x8000000000000000, -2, 1) + HMUL(7, 0x8000000000000000, 2, -1) + HMUL(8, 0x8000000000000001, 3, -2) + HMUL(9, 0x8000000000000001, -3, 1) +#endif + prepare + pushargi ok + ellipsis + finishi @printf + ret + epilog diff --git a/deps/lightning/check/alu_rot.ok b/deps/lightning/check/alu_rot.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/alu_rot.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/alu_rot.tst b/deps/lightning/check/alu_rot.tst new file mode 100644 index 00000000..6ab7bf02 --- /dev/null +++ b/deps/lightning/check/alu_rot.tst @@ -0,0 +1,39 @@ +#include "alu.inc" + +.code + prolog + +#define LROT(N, I0, I1, V) ALU(N, , lrot, I0, I1, V) + LROT(0, 0x7f, 1, 0xfe) +#if __WORDSIZE == 32 + LROT(1, 0xfffffffe, 31, 0x7fffffff) + LROT(2, 0x12345678, 11, 0xa2b3c091) + LROT(3, 0x80000001, 1, 0x03) +#else + LROT(1, 0xfffffffffffffffe, 31, 0xffffffff7fffffff) + LROT(2, 0x123456789abcdef0, 43, 0xe6f78091a2b3c4d5) + LROT(3, 0x00000001ffffffff, 32, 0xffffffff00000001) + LROT(4, 0x80000001, 33, 0x200000001) + LROT(5, 0x8000000000, 35, 0x400) +#endif + +#define RROT(N, I0, I1, V) ALU(N, , rrot, I0, I1, V) + RROT(0, 0xfe, 1, 0x7f) +#if __WORDSIZE == 32 + RROT(1, 0xfffffffe, 31, 0xfffffffd) + RROT(2, 0x12345678, 11, 0xcf02468a) + RROT(3, 0x80000001, 3, 0x30000000) +#else + RROT(1, 0xfffffffffffffffe, 31, 0xfffffffdffffffff) + RROT(2, 0x123456789abcdef0, 43, 0xcf13579bde02468a) + RROT(3, 0x00000001ffffffff, 32, 0xffffffff00000001) + RROT(4, 0x80000001, 33, 0x4000000080000000) + RROT(5, 0x8000000000, 35, 0x10) +#endif + + prepare + pushargi ok + ellipsis + finishi @printf + ret + epilog diff --git a/deps/lightning/check/bit.tst b/deps/lightning/check/bit.tst index b721d5c9..2d2344c2 100644 --- a/deps/lightning/check/bit.tst +++ b/deps/lightning/check/bit.tst @@ -250,8 +250,8 @@ ctz: bnei tun %r1 0 reti __WORDSIZE tun: -#if __WORDSIZE == 64 movi %r0 0 +#if __WORDSIZE == 64 movi %r2 0xffffffff bmsr t32 %r1 %r2 rshi_u %r1 %r1 32 diff --git a/deps/lightning/check/callee.c b/deps/lightning/check/callee.c new file mode 100644 index 00000000..2f21fe46 --- /dev/null +++ b/deps/lightning/check/callee.c @@ -0,0 +1,157 @@ +#include +#include + +//#define DEBUG 1 + +jit_state_t *_jit; + +int +main(int argc, char *argv[]) +{ + int off; + void (*code)(void); + jit_node_t *jmp, *inner, *fail; + + init_jit(argv[0]); + _jit = jit_new_state(); + + jmp = jit_jmpi(); + + /* Create a simple function that changes all available JIT_Vx */ + inner = jit_label(); + jit_prolog(); + for (off = JIT_R_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_R(off))) + jit_movi(JIT_R(off), (off + 1) * 2); + } + for (off = JIT_V_NUM - 1; off >= 0; --off) + jit_movi(JIT_V(off), -(off + 1)); + /* If fprs are callee save, also test them */ + for (off = JIT_F_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_F(off))) + jit_movi_d(JIT_F(off), -(off + 1)); + } + /* Add some noise as there might be some error in the stack frame and + * a standard C function might clobber registers saved in the stack */ + jit_prepare(); + jit_pushargi((jit_word_t)stderr); + jit_pushargi((jit_word_t) + "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d " + "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n"); + jit_ellipsis(); + jit_pushargi(1); + jit_pushargi(2); + jit_pushargi(3); + jit_pushargi(4); + jit_pushargi(5); + jit_pushargi(6); + jit_pushargi(7); + jit_pushargi(8); + jit_pushargi(9); + jit_pushargi(10); + jit_pushargi(11); + jit_pushargi(12); + jit_pushargi(13); + jit_pushargi(14); + jit_pushargi(15); + jit_pushargi(16); + jit_pushargi(17); + jit_pushargi(18); + jit_pushargi(19); + jit_pushargi(20); + jit_pushargi_d(1); + jit_pushargi_d(2); + jit_pushargi_d(3); + jit_pushargi_d(4); + jit_pushargi_d(5); + jit_pushargi_d(6); + jit_pushargi_d(7); + jit_pushargi_d(8); + jit_pushargi_d(9); + jit_pushargi_d(10); + jit_pushargi_d(11); + jit_pushargi_d(12); + jit_pushargi_d(13); + jit_pushargi_d(14); + jit_pushargi_d(15); + jit_pushargi_d(16); + jit_pushargi_d(17); + jit_pushargi_d(18); + jit_pushargi_d(19); + jit_pushargi_d(20); + jit_finishi(fprintf); + jit_ret(); + jit_epilog(); + + jit_patch(jmp); + jit_prolog(); + + for (off = JIT_R_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_R(off))) + jit_movi(JIT_R(off), -(off + 1) * 2); + } + for (off = JIT_V_NUM - 1; off >= 0; --off) + jit_movi(JIT_V(off), 0x7fffffff - (off + 1)); + /* If fprs are callee save, also test them */ + for (off = JIT_F_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_F(off))) + jit_movi_d(JIT_F(off), 0x7fffffff - (off + 1)); + } + jit_patch_at(jit_calli(NULL), inner); + + /* Now validate no register has been clobbered */ + fail = jit_forward(); + + for (off = JIT_R_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_R(off))) { +#if DEBUG + jmp = jit_beqi(JIT_R(off), -(off + 1) * 2); + jit_calli(abort); + jit_patch(jmp); +#else + jit_patch_at(jit_bnei(JIT_R(off), -(off + 1) * 2), fail); +#endif + } + } + for (off = JIT_V_NUM - 1; off >= 0; --off) { +#if DEBUG + jmp = jit_beqi(JIT_V(off), 0x7fffffff - (off + 1)); + jit_calli(abort); + jit_patch(jmp); +#else + jit_patch_at(jit_bnei(JIT_V(off), 0x7fffffff - (off + 1)), fail); +#endif + } + for (off = JIT_F_NUM - 1; off >= 0; --off) { + if (jit_callee_save_p(JIT_F(off))) { +#if DEBUG + jmp = jit_beqi_d(JIT_F(off), 0x7fffffff - (off + 1)); + jit_calli(abort); + jit_patch(jmp); +#else + jit_patch_at(jit_bnei_d(JIT_F(off), 0x7fffffff - (off + 1)), fail); +#endif + } + } +#if !DEBUG + /* Done if passed all tests */ + jmp = jit_jmpi(); + /* Where to land if there was any register clobber */ + jit_link(fail); + jit_calli(abort); + /* done */ + jit_patch(jmp); +#endif + + jit_ret(); + jit_epilog(); + + code = jit_emit(); + jit_clear_state(); + + (*code)(); + + jit_destroy_state(); + finish_jit(); + return (0); +} diff --git a/deps/lightning/check/catomic.c b/deps/lightning/check/catomic.c index e1e2ea76..50ddd0d2 100644 --- a/deps/lightning/check/catomic.c +++ b/deps/lightning/check/catomic.c @@ -4,6 +4,43 @@ #include #include +/* FIXME Remove the "0 &&" below to make the test pass. + * This should not be a Lightning issue. It is crashing + * like this at exit: + * Thread 2 "catomic" received signal SIGSEGV, Segmentation fault. + * [Switching to Thread 0xf6acc480 (LWP 2561)] + * _IO_acquire_lock_fct (p=) at libioP.h:797 + * 797 libioP.h: No such file or directory. + * (gdb) bt + * #0 _IO_acquire_lock_fct (p=) at libioP.h:797 + * #1 _IO_puts (str=0x1 ) + * at ioputs.c:36 + * #2 0xf8eca180 in ?? () + * unless using these hacks, to not use stdio. + * Note that the problem will still happen on purpose, to not risk hiding + * a problem. + */ +#if 0 && defined(__hppa__) +# if DEBUG +# define DEBUG 0 +# define PRINT_OK() \ + do { \ + jit_prepare(); \ + jit_pushargi(STDOUT_FILENO); \ + jit_pushargi((jit_word_t)"ok\n"); \ + jit_pushargri(3); \ + jit_finishi(write); \ + } while (0) +# endif +#else +# define PRINT_OK() \ + do { \ + jit_prepare(); \ + jit_pushargi((jit_word_t)"ok"); \ + jit_finishi(puts); \ + } while (0) +#endif + #if DEBUG volatile #endif @@ -106,11 +143,7 @@ main(int argc, char *argv[]) * while holding the lock */ \ jit_pushargi(10000); \ jit_finishi(usleep); \ - jit_prepare(); \ - /* for make check, just print "ok" */ \ - jit_pushargi((jit_word_t)"ok"); \ - /*jit_pushargi((jit_word_t)#name);*/ \ - jit_finishi(puts); \ + PRINT_OK(); \ /* release lock */ \ DEBUG_UNLOCK(); \ jit_movi(JIT_V1, 0); \ @@ -164,9 +197,7 @@ main(int argc, char *argv[]) join(2); join(3); - jit_prepare(); - jit_pushargi((jit_word_t)"ok"); - jit_finishi(puts); + PRINT_OK(); jit_ret(); jit_epilog(); diff --git a/deps/lightning/check/cvt.tst b/deps/lightning/check/cvt.tst index 18282597..8f401356 100644 --- a/deps/lightning/check/cvt.tst +++ b/deps/lightning/check/cvt.tst @@ -277,6 +277,139 @@ dfc##_##R0: EXTDFC1(R4) \ EXTDFC1(R5) +#define MVFW(R0, F0, F1) \ + movi_f %F0 0.5 \ + movr_f_w %R0 %F0 \ + movr_w_f %F1 %R0 \ + beqr_f fw##R0##F0##F1 %F0 %F1 \ + calli @abort \ +fw##R0##F0##F1: +#define FW(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVFW(R0, F0, F1) \ + MVFW(R1, F1, F2) \ + MVFW(R2, F2, F3) \ + MVFW(R3, F3, F4) \ + MVFW(R4, F4, F5) \ + MVFW(R5, F5, F0) +#define MVFWI(R0, F0, F1) \ + movi_f %F1 0.25 \ + movi_f_w %R0 0.25 \ + movr_w_f %F0 %R0 \ + beqr_f ifw##R0##F0##F1 %F0 %F1 \ + calli @abort \ +ifw##R0##F0##F1: +#define FWI(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVFWI(R0, F0, F1) \ + MVFWI(R1, F1, F2) \ + MVFWI(R2, F2, F3) \ + MVFWI(R3, F3, F4) \ + MVFWI(R4, F4, F5) \ + MVFWI(R5, F5, F0) + +#if __WORDSIZE == 32 +# define MVDW(R0, R1, F0, F1) \ + movi_d %F0 0.5 \ + movr_d_ww %R0 %R1 %F0 \ + movr_ww_d %F1 %R0 %R1 \ + beqr_d dw##R0##R1##F0##F1 %F0 %F1 \ + calli @abort \ +dw##R0##R1##F0##F1: +# define DW(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVDW(R0, R1, F0, F1) \ + MVDW(R1, R2, F1, F2) \ + MVDW(R2, R3, F2, F3) \ + MVDW(R3, R4, F3, F4) \ + MVDW(R4, R5, F4, F5) \ + MVDW(R5, R0, F5, F0) +# define MVDWI(R0, R1, F0, F1) \ + movi_d %F1 0.25 \ + movi_d_ww %R0 %R1 0.25 \ + movr_ww_d %F0 %R0 %R1 \ + beqr_d idw##R0##R1##F0##F1 %F0 %F1 \ + calli @abort \ +idw##R0##R1##F0##F1: +# define DWI(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVDWI(R0, R1, F0, F1) \ + MVDWI(R1, R2, F1, F2) \ + MVDWI(R2, R3, F2, F3) \ + MVDWI(R3, R4, F3, F4) \ + MVDWI(R4, R5, F4, F5) \ + MVDWI(R5, R0, F5, F0) +#else +# define MVDW(R0, F0, F1) \ + movi_d %F0 0.5 \ + movr_d_w %R0 %F0 \ + movr_w_d %F1 %R0 \ + beqr_d dw##R0##F0##F1 %F0 %F1 \ + calli @abort \ +dw##R0##F0##F1: +# define DW(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVDW(R0, F0, F1) \ + MVDW(R1, F1, F2) \ + MVDW(R2, F2, F3) \ + MVDW(R3, F3, F4) \ + MVDW(R4, F4, F5) \ + MVDW(R5, F5, F0) +# define MVDWI(R0, F0, F1) \ + movi_d %F1 0.25 \ + movi_d_w %R0 0.25 \ + movr_w_d %F0 %R0 \ + beqr_d idw##R0##F0##F1 %F0 %F1 \ + calli @abort \ +idw##R0##F0##F1: +# define DWI(R0, R1, R2, R3, R4, R5, F0, F1, F2, F3, F4, F5) \ + MVDWI(R0, F0, F1) \ + MVDWI(R1, F1, F2) \ + MVDWI(R2, F2, F3) \ + MVDWI(R3, F3, F4) \ + MVDWI(R4, F4, F5) \ + MVDWI(R5, F5, F0) +#endif + +#define MVWFI(F0, F1) \ + movi_f %F1 0.25 \ + movi_w_f %F0 0x3e800000 \ + beqr_f iwf##F0##F1 %F0 %F1 \ + calli @abort \ +iwf##F0##F1: +#define WFI(F0, F1, F2, F3, F4, F5) \ + MVWFI(F0, F1) \ + MVWFI(F1, F2) \ + MVWFI(F2, F3) \ + MVWFI(F3, F4) \ + MVWFI(F4, F5) \ + MVWFI(F5, F0) + +#if __WORDSIZE == 32 +# define MVWDI(F0, F1) \ + movi_d %F1 0.5 \ + movi_ww_d %F0 0 0x3fe00000 \ + beqr_d iwwd##F0##F1 %F0 %F1 \ + calli @abort \ +iwwd##F0##F1: +# define WDI(F0, F1, F2, F3, F4, F5) \ + MVWDI(F0, F1) \ + MVWDI(F1, F2) \ + MVWDI(F2, F3) \ + MVWDI(F3, F4) \ + MVWDI(F4, F5) \ + MVWDI(F5, F0) +#else +# define MVWDI(F0, F1) \ + movi_d %F1 0.5 \ + movi_w_d %F0 0x3fe0000000000000 \ + beqr_d iwd##F0##F1 %F0 %F1 \ + calli @abort \ +iwd##F0##F1: +#define WDI(F0, F1, F2, F3, F4, F5) \ + MVWDI(F0, F1) \ + MVWDI(F1, F2) \ + MVWDI(F2, F3) \ + MVWDI(F3, F4) \ + MVWDI(F4, F5) \ + MVWDI(F5, F0) +#endif + .code prolog @@ -357,6 +490,64 @@ xfd: beqi_f xdf %f1 0.5 calli @abort xdf: + movi_f %f0 0.5 + movr_f_w %r0 %f0 + movr_w_f %f1 %r0 + beqr_f fw %f0 %f1 + calli @abort +fw: + movi_f %f1 0.25 + movi_f_w %r0 0.25 + movr_w_f %f0 %r0 + beqr_f ifw %f0 %f1 + calli @abort +ifw: +#if __WORDSIZE == 32 + movi_d %f0 0.5 + movr_d_ww %r0 %r1 %f0 + movr_ww_d %f1 %r0 %r1 + beqr_d dww %f0 %f1 + calli @abort +dww: + movi_d %f1 0.25 + movi_d_ww %r0 %r1 0.25 + movr_ww_d %f0 %r0 %r1 + beqr_d idww %f0 %f1 + calli @abort +idww: +#else + movi_d %f0 0.5 + movr_d_w %r0 %f0 + movr_w_d %f1 %r0 + beqr_d dw %f0 %f1 + calli @abort +dw: + movi_d %f1 0.25 + movi_d_w %r0 0.25 + movr_w_d %f0 %r0 + beqr_d idw %f0 %f1 + calli @abort +idw: +#endif + + movi_f %f1 0.25 + movi_w_f %f0 0x3e800000 + beqr_f iwf %f0 %f1 + calli @abort +iwf: +#if __WORDSIZE == 32 + movi_d %f1 0.5 + movi_ww_d %f0 0 0x3fe00000 + beqr_d iwwd %f0 %f1 + calli @abort +iwwd: +#else + movi_d %f1 0.5 + movi_w_d %f0 0x3fe0000000000000 + beqr_d iwd %f0 %f1 + calli @abort +iwd: +#endif EXTII(v0, v1, v2, r0, r1, r2) EXIF(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) @@ -369,6 +560,12 @@ xdf: EXDI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) EXTFD(f0, f1, f2, f3, f4, f5) EXTDF(f0, f1, f2, f3, f4, f5) + FW(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) + FWI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) + DW(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) + DWI(v0, v1, v2, r0, r1, r2, f0, f1, f2, f3, f4, f5) + WFI(f0, f1, f2, f3, f4, f5) + WDI(f0, f1, f2, f3, f4, f5) // just to know did not abort prepare diff --git a/deps/lightning/check/ext.ok b/deps/lightning/check/ext.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/ext.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/ext.tst b/deps/lightning/check/ext.tst new file mode 100644 index 00000000..58a46eee --- /dev/null +++ b/deps/lightning/check/ext.tst @@ -0,0 +1,15438 @@ +.data 256 +#if __WORDSIZE == 32 +fmt_ext: +.c "\tEXT( 0x%08x, %d, %d, 0x%08x)\n" +fmt_ext_u: +.c "\tEXTU(0x%08x, %d, %d, 0x%08x)\n" +fmt_dep: +.c "\tDEP( 0x%08x, %d, %d, %d, 0x%08x)\n" +#else +fmt_ext: +.c "\tEXT( 0x%016lx, %d, %d, 0x%016lx)\n" +fmt_ext_u: +.c "\tEXTU(0x%016lx, %d, %d, 0x%016lx)\n" +fmt_dep: +.c "\tDEP( 0x%016lx, %ld, %d, %d, 0x%016lx)\n" +#endif +dbg_ext: +.c " ext %lx 1 2 = %lx\n" +dbg_ext_u: +.c "ext_u %lx 1 2 = %lx\n" +dbg_dep: +.c " dep %lx %lx 1 2 = %lx\n" +ok: +.c "ok\n" + +#define GENERATE_TABLE 0 +/* Only do it to test more combinations. The important test is to check all + * possible bitfields, to ensure there is no incorrect code generation */ +#define EXPAND_FULL 0 + +#define EXTRACT(OP, R0, R1, OFF, LEN, VAL, RES) \ + movi %R1 VAL \ + OP %R0 %R1 OFF LEN \ + beqi OP##R0##R1##OFF##LEN##VAL %R0 RES \ + calli @abort \ +OP##R0##R1##OFF##LEN##VAL: +#define DEPOSIT(R0, R1, OFF, LEN, VAL, BIT, RES) \ + movi %R1 BIT \ + movi %R0 VAL \ + depr %R0 %R1 OFF LEN \ + beqi dep##R0##R1##OFF##LEN##VAL %R0 RES \ + calli @abort \ +dep##R0##R1##OFF##LEN##VAL: + +#if EXPAND_FULL +# define OPTIONAL(OPT) OPT +#else +# define OPTIONAL(OPT) /**/ +#endif + +#define EXT2(OP, OFF, LEN, VAL, RES, R0, R1, R2, V0, V1, V2) \ + /* Testing same register as input output is not optional */ \ + EXTRACT(OP, R0, R0, OFF, LEN, VAL, RES) \ + OPTIONAL(EXTRACT(OP, R0, R1, OFF, LEN, VAL, RES)) \ + EXTRACT(OP, R0, R2, OFF, LEN, VAL, RES) \ + EXTRACT(OP, R0, V0, OFF, LEN, VAL, RES) \ + OPTIONAL(EXTRACT(OP, R0, V1, OFF, LEN, VAL, RES)) \ + OPTIONAL(EXTRACT(OP, R0, V2, OFF, LEN, VAL, RES)) +#define EXT1(OP, OFF, LEN, VAL, RES, R0, R1, R2, V0, V1, V2) \ + EXT2(OP, OFF, LEN, VAL, RES, R0, R1, R2, V0, V1, V2) \ + OPTIONAL(EXT2(OP, OFF, LEN, VAL, RES, R1, R2, V0, V1, V2, R0)) \ + OPTIONAL(EXT2(OP, OFF, LEN, VAL, RES, R2, V0, V1, V2, R0, R1)) \ + OPTIONAL(EXT2(OP, OFF, LEN, VAL, RES, V0, V1, V2, R0, R1, R2)) \ + OPTIONAL(EXT2(OP, OFF, LEN, VAL, RES, V1, V2, R0, R1, R2, V0)) \ + OPTIONAL(EXT2(OP, OFF, LEN, VAL, RES, V2, R0, R1, R2, V0, V1)) + +#define DEP2(OFF, LEN, VAL, BIT, RES, R0, R1, R2, V0, V1, V2) \ + DEPOSIT(R0, R1, OFF, LEN, VAL, BIT, RES) \ + OPTIONAL(DEPOSIT(R0, R2, OFF, LEN, VAL, BIT, RES)) \ + DEPOSIT(R0, V0, OFF, LEN, VAL, BIT, RES) \ + OPTIONAL(DEPOSIT(R0, V1, OFF, LEN, VAL, BIT, RES)) \ + OPTIONAL(DEPOSIT(R0, V2, OFF, LEN, VAL, BIT, RES)) +#define DEP1(OFF, LEN, VAL, BIT, RES, R0, R1, R2, V0, V1, V2) \ + DEP2(OFF, LEN, VAL, BIT, RES, R0, R1, R2, V0, V1, V2) \ + OPTIONAL(DEP2(OFF, LEN, VAL, BIT, RES, R1, R2, V0, V1, V2, R0)) \ + OPTIONAL(DEP2(OFF, LEN, VAL, BIT, RES, R2, V0, V1, V2, R0, R1)) \ + OPTIONAL(DEP2(OFF, LEN, VAL, BIT, RES, V0, V1, V2, R0, R1, R2)) \ + OPTIONAL(DEP2(OFF, LEN, VAL, BIT, RES, V1, V2, R0, R1, R2, V0)) \ + OPTIONAL(DEP2(OFF, LEN, VAL, BIT, RES, V2, R0, R1, R2, V0, V1)) + +#define EXT(VAL, OFF, LEN, RES) \ + EXT1(extr, OFF, LEN, VAL, RES, r0, r1, r2, v0, v1, v2) +#define EXTU(VAL, OFF, LEN, RES) \ + EXT1(extr_u, OFF, LEN, VAL, RES, r0, r1, r2, v0, v1, v2) +#define DEP(VAL, BIT, OFF, LEN, RES) \ + DEP1(OFF, LEN, VAL, BIT, RES, r0, r1, r2, v0, v1, v2) + +.code + jmpi main + +/* + * jit_word_t ext(jit_word_t val, int base, int len) { + * assert(base >= 0 && len >= 1 && base + len <= __WORDSIZE); + * #if __BYTE_ORDER == __BIG_ENDIAN + * base = __WORDSIZE - (base + len); + * #endif + * jit_word_t res = val << (__WORDSIZE - (base + len)); + * return (res >> (__WORDSIZE - len)); + * } + */ +name func_ext +func_ext: + prolog + arg $val + arg $base + arg $len + getarg %r0 $val // r0 = val + getarg %r1 $base // r1 = base + getarg %r2 $len // r2 = len +#ifndef NDEBUG + blti func_ext_assert %r1 0 + blti func_ext_assert %r2 1 +#endif +#if __BYTE_ORDER == __BIG_ENDIAN + addr %r1 %r1 %r2 + rsbi %r1 %r1 __WORDSIZE +#endif + addr %r1 %r1 %r2 // r1 = base + len +#ifndef NDEBUG +#if __BYTE_ORDER == __BIG_ENDIAN + blei func_ext_ok %r1 __WORDSIZE +#else + blti func_ext_ok %r1 __WORDSIZE +#endif +func_ext_assert: + calli @abort +func_ext_ok: +#endif + rsbi %r1 %r1 __WORDSIZE // r1 = __WORDSIZE - r1 + lshr %r0 %r0 %r1 // r0 = val << r1 + rsbi %r2 %r2 __WORDSIZE + rshr %r0 %r0 %r2 // r0 >>= r2 + retr %r0 + epilog + +/* + * jit_uword_t ext_u(jit_uword_t val, int base, int len) { + * assert(base >= 0 && len >= 1 && base + len <= __WORDSIZE); + * #if __BYTE_ORDER == __BIG_ENDIAN + * base = __WORDSIZE - (base + len); + * #endif + * jit_uword_t res = val << (__WORDSIZE - (base + len)); + * return (res >> (__WORDSIZE - len)); + * } + */ +name func_ext_u +func_ext_u: + prolog + arg $val + arg $base + arg $len + getarg %r0 $val // r0 = val + getarg %r1 $base // r1 = base + getarg %r2 $len // r2 = len +#ifndef NDEBUG + blti func_ext_u_assert %r1 0 + blti func_ext_u_assert %r2 1 +#endif +#if __BYTE_ORDER == __BIG_ENDIAN + addr %r1 %r1 %r2 + rsbi %r1 %r1 __WORDSIZE +#endif + addr %r1 %r1 %r2 // r1 = base + len +#ifndef NDEBUG +#if __BYTE_ORDER == __BIG_ENDIAN + blei func_ext_u_ok %r2 __WORDSIZE +#else + blti func_ext_u_ok %r2 __WORDSIZE +#endif +func_ext_u_assert: + calli @abort +func_ext_u_ok: +#endif + rsbi %r1 %r1 __WORDSIZE // r1 = __WORDSIZE - r1 + lshr %r0 %r0 %r1 // r0 = val << r1 + rsbi %r2 %r2 __WORDSIZE + rshr_u %r0 %r0 %r2 // r0 >>= r2 + retr %r0 + epilog + +/* + * jit_word_t dep(jit_word_t res, jit_uword_t val, int base, int len) { + * assert(base >= 0 && len >= 1 && base + len <= __WORDSIZE); + * #if __BYTE_ORDER == __BIG_ENDIAN + * base = __WORDSIZE - (base + len); + * #endif + * jit_word_t mask = (1 << len) - 1; + * val &= mask; + * val <<= base; + * mask <<= base; + * res &= ~mask; + * return (res | val); + * } + */ +name func_dep +func_dep: + prolog + arg $res + arg $val + arg $base + arg $len + getarg %r0 $res + getarg %r1 $val + getarg %v0 $base + getarg %v1 $len +#ifndef NDEBUG + blti func_dep_assert %v0 0 + blti func_dep_assert %v1 1 +#if __BYTE_ORDER == __BIG_ENDIAN + addr %v0 %v0 %v1 + rsbi %v0 %v0 __WORDSIZE +#endif + addr %r2 %v0 %v1 +#if __BYTE_ORDER == __BIG_ENDIAN + blei func_dep_ok %r2 __WORDSIZE +#else + blti func_dep_ok %r2 __WORDSIZE +#endif +func_dep_assert: + calli @abort +func_dep_ok: +#endif + movi %r2 1 // r2 = 1 + lshr %r2 %r2 %v1 // r2 = 1 << base + subi %r2 %r2 1 // r2 = (1 << base) - 1 + andr %r1 %r1 %r2 // val &= mask + lshr %r1 %r1 %v0 // val <<= base + lshr %r2 %r2 %v0 // mask <<= base + comr %r2 %r2 // mask = ~mask + andr %r0 %r0 %r2 // res &= mask + orr %r0 %r0 %r1 // res |= val + retr %r0 + epilog + +#if GENERATE_TABLE + name main +main: + prolog + +# if __WORDSIZE == 32 + movi %v0 0xa5a5a5a5 +# else + movi %v0 0xa5a5a5a5a5a5a5a5 +# endif + movi %v1 0 + movi %v2 1 + +loop: + subi %v0 %v0 1 + prepare + pushargr %v0 + pushargr %v1 + pushargr %v2 + finishi func_ext + retval %r0 + prepare + pushargi fmt_ext + ellipsis + pushargr %v0 + pushargr %v1 + pushargr %v2 + pushargr %r0 + finishi @printf + + prepare + pushargr %v0 + pushargr %v1 + pushargr %v2 + finishi func_ext_u + retval %r0 + prepare + pushargi fmt_ext_u + ellipsis + pushargr %v0 + pushargr %v1 + pushargr %v2 + pushargr %r0 + finishi @printf + + movi %r1 1 + subi %r2 %v2 1 + lshr %r1 %r1 %r2 + subi %r1 %r1 1 + prepare + pushargr %v0 + pushargr %r1 + pushargr %v1 + pushargr %v2 + finishi func_dep + retval %r0 + movi %r1 1 + subi %r2 %v2 1 + lshr %r1 %r1 %r2 + subi %r1 %r1 1 + prepare + pushargi fmt_dep + ellipsis + pushargr %v0 + pushargr %r1 + pushargr %v1 + pushargr %v2 + pushargr %r0 + finishi @printf + + addi %v2 %v2 1 + addr %r0 %v1 %v2 + blti loop %r0 __WORDSIZE + addi %v1 %v1 1 + bgei done %v1 $(__WORDSIZE - 1) + movi %v2 1 + jmpi loop +done: + ret + epilog +#else + name main +main: + prolog + +/* Simple encoding debug */ +#if 0 + movi %v0 0x12345678 + extr %v1 %v0 1 2 + prepare + pushargi dbg_ext + ellipsis + pushargr %v0 + pushargr %v1 + finishi @printf + extr_u %v1 %v0 1 2 + prepare + pushargi dbg_ext_u + ellipsis + pushargr %v0 + pushargr %v1 + finishi @printf + movi %v1 1 + depr %v0 %v1 1 2 + prepare + pushargi dbg_dep + ellipsis + pushargi 0xffffffff + pushargi 1 + pushargr %v0 + finishi @printf +#else + +# if __WORDSIZE == 32 +# if __BYTE_ORDER == __LITTLE_ENDIAN + EXT( 0xa5a5a5a4, 0, 1, 0x00000000) + EXTU(0xa5a5a5a4, 0, 1, 0x00000000) + DEP( 0xa5a5a5a4, 0, 0, 1, 0xa5a5a5a4) + EXT( 0xa5a5a5a3, 0, 2, 0xffffffff) + EXTU(0xa5a5a5a3, 0, 2, 0x00000003) + DEP( 0xa5a5a5a3, 1, 0, 2, 0xa5a5a5a1) + EXT( 0xa5a5a5a2, 0, 3, 0x00000002) + EXTU(0xa5a5a5a2, 0, 3, 0x00000002) + DEP( 0xa5a5a5a2, 3, 0, 3, 0xa5a5a5a3) + EXT( 0xa5a5a5a1, 0, 4, 0x00000001) + EXTU(0xa5a5a5a1, 0, 4, 0x00000001) + DEP( 0xa5a5a5a1, 7, 0, 4, 0xa5a5a5a7) + EXT( 0xa5a5a5a0, 0, 5, 0x00000000) + EXTU(0xa5a5a5a0, 0, 5, 0x00000000) + DEP( 0xa5a5a5a0, 15, 0, 5, 0xa5a5a5af) + EXT( 0xa5a5a59f, 0, 6, 0x0000001f) + EXTU(0xa5a5a59f, 0, 6, 0x0000001f) + DEP( 0xa5a5a59f, 31, 0, 6, 0xa5a5a59f) + EXT( 0xa5a5a59e, 0, 7, 0x0000001e) + EXTU(0xa5a5a59e, 0, 7, 0x0000001e) + DEP( 0xa5a5a59e, 63, 0, 7, 0xa5a5a5bf) + EXT( 0xa5a5a59d, 0, 8, 0xffffff9d) + EXTU(0xa5a5a59d, 0, 8, 0x0000009d) + DEP( 0xa5a5a59d, 127, 0, 8, 0xa5a5a57f) + EXT( 0xa5a5a59c, 0, 9, 0xffffff9c) + EXTU(0xa5a5a59c, 0, 9, 0x0000019c) + DEP( 0xa5a5a59c, 255, 0, 9, 0xa5a5a4ff) + EXT( 0xa5a5a59b, 0, 10, 0x0000019b) + EXTU(0xa5a5a59b, 0, 10, 0x0000019b) + DEP( 0xa5a5a59b, 511, 0, 10, 0xa5a5a5ff) + EXT( 0xa5a5a59a, 0, 11, 0xfffffd9a) + EXTU(0xa5a5a59a, 0, 11, 0x0000059a) + DEP( 0xa5a5a59a, 1023, 0, 11, 0xa5a5a3ff) + EXT( 0xa5a5a599, 0, 12, 0x00000599) + EXTU(0xa5a5a599, 0, 12, 0x00000599) + DEP( 0xa5a5a599, 2047, 0, 12, 0xa5a5a7ff) + EXT( 0xa5a5a598, 0, 13, 0x00000598) + EXTU(0xa5a5a598, 0, 13, 0x00000598) + DEP( 0xa5a5a598, 4095, 0, 13, 0xa5a5afff) + EXT( 0xa5a5a597, 0, 14, 0xffffe597) + EXTU(0xa5a5a597, 0, 14, 0x00002597) + DEP( 0xa5a5a597, 8191, 0, 14, 0xa5a59fff) + EXT( 0xa5a5a596, 0, 15, 0x00002596) + EXTU(0xa5a5a596, 0, 15, 0x00002596) + DEP( 0xa5a5a596, 16383, 0, 15, 0xa5a5bfff) + EXT( 0xa5a5a595, 0, 16, 0xffffa595) + EXTU(0xa5a5a595, 0, 16, 0x0000a595) + DEP( 0xa5a5a595, 32767, 0, 16, 0xa5a57fff) + EXT( 0xa5a5a594, 0, 17, 0xffffa594) + EXTU(0xa5a5a594, 0, 17, 0x0001a594) + DEP( 0xa5a5a594, 65535, 0, 17, 0xa5a4ffff) + EXT( 0xa5a5a593, 0, 18, 0x0001a593) + EXTU(0xa5a5a593, 0, 18, 0x0001a593) + DEP( 0xa5a5a593, 131071, 0, 18, 0xa5a5ffff) + EXT( 0xa5a5a592, 0, 19, 0xfffda592) + EXTU(0xa5a5a592, 0, 19, 0x0005a592) + DEP( 0xa5a5a592, 262143, 0, 19, 0xa5a3ffff) + EXT( 0xa5a5a591, 0, 20, 0x0005a591) + EXTU(0xa5a5a591, 0, 20, 0x0005a591) + DEP( 0xa5a5a591, 524287, 0, 20, 0xa5a7ffff) + EXT( 0xa5a5a590, 0, 21, 0x0005a590) + EXTU(0xa5a5a590, 0, 21, 0x0005a590) + DEP( 0xa5a5a590, 1048575, 0, 21, 0xa5afffff) + EXT( 0xa5a5a58f, 0, 22, 0xffe5a58f) + EXTU(0xa5a5a58f, 0, 22, 0x0025a58f) + DEP( 0xa5a5a58f, 2097151, 0, 22, 0xa59fffff) + EXT( 0xa5a5a58e, 0, 23, 0x0025a58e) + EXTU(0xa5a5a58e, 0, 23, 0x0025a58e) + DEP( 0xa5a5a58e, 4194303, 0, 23, 0xa5bfffff) + EXT( 0xa5a5a58d, 0, 24, 0xffa5a58d) + EXTU(0xa5a5a58d, 0, 24, 0x00a5a58d) + DEP( 0xa5a5a58d, 8388607, 0, 24, 0xa57fffff) + EXT( 0xa5a5a58c, 0, 25, 0xffa5a58c) + EXTU(0xa5a5a58c, 0, 25, 0x01a5a58c) + DEP( 0xa5a5a58c, 16777215, 0, 25, 0xa4ffffff) + EXT( 0xa5a5a58b, 0, 26, 0x01a5a58b) + EXTU(0xa5a5a58b, 0, 26, 0x01a5a58b) + DEP( 0xa5a5a58b, 33554431, 0, 26, 0xa5ffffff) + EXT( 0xa5a5a58a, 0, 27, 0xfda5a58a) + EXTU(0xa5a5a58a, 0, 27, 0x05a5a58a) + DEP( 0xa5a5a58a, 67108863, 0, 27, 0xa3ffffff) + EXT( 0xa5a5a589, 0, 28, 0x05a5a589) + EXTU(0xa5a5a589, 0, 28, 0x05a5a589) + DEP( 0xa5a5a589, 134217727, 0, 28, 0xa7ffffff) + EXT( 0xa5a5a588, 0, 29, 0x05a5a588) + EXTU(0xa5a5a588, 0, 29, 0x05a5a588) + DEP( 0xa5a5a588, 268435455, 0, 29, 0xafffffff) + EXT( 0xa5a5a587, 0, 30, 0xe5a5a587) + EXTU(0xa5a5a587, 0, 30, 0x25a5a587) + DEP( 0xa5a5a587, 536870911, 0, 30, 0x9fffffff) + EXT( 0xa5a5a586, 0, 31, 0x25a5a586) + EXTU(0xa5a5a586, 0, 31, 0x25a5a586) + DEP( 0xa5a5a586, 1073741823, 0, 31, 0xbfffffff) + EXT( 0xa5a5a585, 1, 1, 0x00000000) + EXTU(0xa5a5a585, 1, 1, 0x00000000) + DEP( 0xa5a5a585, 0, 1, 1, 0xa5a5a585) + EXT( 0xa5a5a584, 1, 2, 0xfffffffe) + EXTU(0xa5a5a584, 1, 2, 0x00000002) + DEP( 0xa5a5a584, 1, 1, 2, 0xa5a5a582) + EXT( 0xa5a5a583, 1, 3, 0x00000001) + EXTU(0xa5a5a583, 1, 3, 0x00000001) + DEP( 0xa5a5a583, 3, 1, 3, 0xa5a5a587) + EXT( 0xa5a5a582, 1, 4, 0x00000001) + EXTU(0xa5a5a582, 1, 4, 0x00000001) + DEP( 0xa5a5a582, 7, 1, 4, 0xa5a5a58e) + EXT( 0xa5a5a581, 1, 5, 0x00000000) + EXTU(0xa5a5a581, 1, 5, 0x00000000) + DEP( 0xa5a5a581, 15, 1, 5, 0xa5a5a59f) + EXT( 0xa5a5a580, 1, 6, 0x00000000) + EXTU(0xa5a5a580, 1, 6, 0x00000000) + DEP( 0xa5a5a580, 31, 1, 6, 0xa5a5a5be) + EXT( 0xa5a5a57f, 1, 7, 0x0000003f) + EXTU(0xa5a5a57f, 1, 7, 0x0000003f) + DEP( 0xa5a5a57f, 63, 1, 7, 0xa5a5a57f) + EXT( 0xa5a5a57e, 1, 8, 0xffffffbf) + EXTU(0xa5a5a57e, 1, 8, 0x000000bf) + DEP( 0xa5a5a57e, 127, 1, 8, 0xa5a5a4fe) + EXT( 0xa5a5a57d, 1, 9, 0x000000be) + EXTU(0xa5a5a57d, 1, 9, 0x000000be) + DEP( 0xa5a5a57d, 255, 1, 9, 0xa5a5a5ff) + EXT( 0xa5a5a57c, 1, 10, 0xfffffebe) + EXTU(0xa5a5a57c, 1, 10, 0x000002be) + DEP( 0xa5a5a57c, 511, 1, 10, 0xa5a5a3fe) + EXT( 0xa5a5a57b, 1, 11, 0x000002bd) + EXTU(0xa5a5a57b, 1, 11, 0x000002bd) + DEP( 0xa5a5a57b, 1023, 1, 11, 0xa5a5a7ff) + EXT( 0xa5a5a57a, 1, 12, 0x000002bd) + EXTU(0xa5a5a57a, 1, 12, 0x000002bd) + DEP( 0xa5a5a57a, 2047, 1, 12, 0xa5a5affe) + EXT( 0xa5a5a579, 1, 13, 0xfffff2bc) + EXTU(0xa5a5a579, 1, 13, 0x000012bc) + DEP( 0xa5a5a579, 4095, 1, 13, 0xa5a59fff) + EXT( 0xa5a5a578, 1, 14, 0x000012bc) + EXTU(0xa5a5a578, 1, 14, 0x000012bc) + DEP( 0xa5a5a578, 8191, 1, 14, 0xa5a5bffe) + EXT( 0xa5a5a577, 1, 15, 0xffffd2bb) + EXTU(0xa5a5a577, 1, 15, 0x000052bb) + DEP( 0xa5a5a577, 16383, 1, 15, 0xa5a57fff) + EXT( 0xa5a5a576, 1, 16, 0xffffd2bb) + EXTU(0xa5a5a576, 1, 16, 0x0000d2bb) + DEP( 0xa5a5a576, 32767, 1, 16, 0xa5a4fffe) + EXT( 0xa5a5a575, 1, 17, 0x0000d2ba) + EXTU(0xa5a5a575, 1, 17, 0x0000d2ba) + DEP( 0xa5a5a575, 65535, 1, 17, 0xa5a5ffff) + EXT( 0xa5a5a574, 1, 18, 0xfffed2ba) + EXTU(0xa5a5a574, 1, 18, 0x0002d2ba) + DEP( 0xa5a5a574, 131071, 1, 18, 0xa5a3fffe) + EXT( 0xa5a5a573, 1, 19, 0x0002d2b9) + EXTU(0xa5a5a573, 1, 19, 0x0002d2b9) + DEP( 0xa5a5a573, 262143, 1, 19, 0xa5a7ffff) + EXT( 0xa5a5a572, 1, 20, 0x0002d2b9) + EXTU(0xa5a5a572, 1, 20, 0x0002d2b9) + DEP( 0xa5a5a572, 524287, 1, 20, 0xa5affffe) + EXT( 0xa5a5a571, 1, 21, 0xfff2d2b8) + EXTU(0xa5a5a571, 1, 21, 0x0012d2b8) + DEP( 0xa5a5a571, 1048575, 1, 21, 0xa59fffff) + EXT( 0xa5a5a570, 1, 22, 0x0012d2b8) + EXTU(0xa5a5a570, 1, 22, 0x0012d2b8) + DEP( 0xa5a5a570, 2097151, 1, 22, 0xa5bffffe) + EXT( 0xa5a5a56f, 1, 23, 0xffd2d2b7) + EXTU(0xa5a5a56f, 1, 23, 0x0052d2b7) + DEP( 0xa5a5a56f, 4194303, 1, 23, 0xa57fffff) + EXT( 0xa5a5a56e, 1, 24, 0xffd2d2b7) + EXTU(0xa5a5a56e, 1, 24, 0x00d2d2b7) + DEP( 0xa5a5a56e, 8388607, 1, 24, 0xa4fffffe) + EXT( 0xa5a5a56d, 1, 25, 0x00d2d2b6) + EXTU(0xa5a5a56d, 1, 25, 0x00d2d2b6) + DEP( 0xa5a5a56d, 16777215, 1, 25, 0xa5ffffff) + EXT( 0xa5a5a56c, 1, 26, 0xfed2d2b6) + EXTU(0xa5a5a56c, 1, 26, 0x02d2d2b6) + DEP( 0xa5a5a56c, 33554431, 1, 26, 0xa3fffffe) + EXT( 0xa5a5a56b, 1, 27, 0x02d2d2b5) + EXTU(0xa5a5a56b, 1, 27, 0x02d2d2b5) + DEP( 0xa5a5a56b, 67108863, 1, 27, 0xa7ffffff) + EXT( 0xa5a5a56a, 1, 28, 0x02d2d2b5) + EXTU(0xa5a5a56a, 1, 28, 0x02d2d2b5) + DEP( 0xa5a5a56a, 134217727, 1, 28, 0xaffffffe) + EXT( 0xa5a5a569, 1, 29, 0xf2d2d2b4) + EXTU(0xa5a5a569, 1, 29, 0x12d2d2b4) + DEP( 0xa5a5a569, 268435455, 1, 29, 0x9fffffff) + EXT( 0xa5a5a568, 1, 30, 0x12d2d2b4) + EXTU(0xa5a5a568, 1, 30, 0x12d2d2b4) + DEP( 0xa5a5a568, 536870911, 1, 30, 0xbffffffe) + EXT( 0xa5a5a567, 2, 1, 0xffffffff) + EXTU(0xa5a5a567, 2, 1, 0x00000001) + DEP( 0xa5a5a567, 0, 2, 1, 0xa5a5a563) + EXT( 0xa5a5a566, 2, 2, 0x00000001) + EXTU(0xa5a5a566, 2, 2, 0x00000001) + DEP( 0xa5a5a566, 1, 2, 2, 0xa5a5a566) + EXT( 0xa5a5a565, 2, 3, 0x00000001) + EXTU(0xa5a5a565, 2, 3, 0x00000001) + DEP( 0xa5a5a565, 3, 2, 3, 0xa5a5a56d) + EXT( 0xa5a5a564, 2, 4, 0xfffffff9) + EXTU(0xa5a5a564, 2, 4, 0x00000009) + DEP( 0xa5a5a564, 7, 2, 4, 0xa5a5a55c) + EXT( 0xa5a5a563, 2, 5, 0xfffffff8) + EXTU(0xa5a5a563, 2, 5, 0x00000018) + DEP( 0xa5a5a563, 15, 2, 5, 0xa5a5a53f) + EXT( 0xa5a5a562, 2, 6, 0x00000018) + EXTU(0xa5a5a562, 2, 6, 0x00000018) + DEP( 0xa5a5a562, 31, 2, 6, 0xa5a5a57e) + EXT( 0xa5a5a561, 2, 7, 0xffffffd8) + EXTU(0xa5a5a561, 2, 7, 0x00000058) + DEP( 0xa5a5a561, 63, 2, 7, 0xa5a5a4fd) + EXT( 0xa5a5a560, 2, 8, 0x00000058) + EXTU(0xa5a5a560, 2, 8, 0x00000058) + DEP( 0xa5a5a560, 127, 2, 8, 0xa5a5a5fc) + EXT( 0xa5a5a55f, 2, 9, 0xffffff57) + EXTU(0xa5a5a55f, 2, 9, 0x00000157) + DEP( 0xa5a5a55f, 255, 2, 9, 0xa5a5a3ff) + EXT( 0xa5a5a55e, 2, 10, 0x00000157) + EXTU(0xa5a5a55e, 2, 10, 0x00000157) + DEP( 0xa5a5a55e, 511, 2, 10, 0xa5a5a7fe) + EXT( 0xa5a5a55d, 2, 11, 0x00000157) + EXTU(0xa5a5a55d, 2, 11, 0x00000157) + DEP( 0xa5a5a55d, 1023, 2, 11, 0xa5a5affd) + EXT( 0xa5a5a55c, 2, 12, 0xfffff957) + EXTU(0xa5a5a55c, 2, 12, 0x00000957) + DEP( 0xa5a5a55c, 2047, 2, 12, 0xa5a59ffc) + EXT( 0xa5a5a55b, 2, 13, 0x00000956) + EXTU(0xa5a5a55b, 2, 13, 0x00000956) + DEP( 0xa5a5a55b, 4095, 2, 13, 0xa5a5bfff) + EXT( 0xa5a5a55a, 2, 14, 0xffffe956) + EXTU(0xa5a5a55a, 2, 14, 0x00002956) + DEP( 0xa5a5a55a, 8191, 2, 14, 0xa5a57ffe) + EXT( 0xa5a5a559, 2, 15, 0xffffe956) + EXTU(0xa5a5a559, 2, 15, 0x00006956) + DEP( 0xa5a5a559, 16383, 2, 15, 0xa5a4fffd) + EXT( 0xa5a5a558, 2, 16, 0x00006956) + EXTU(0xa5a5a558, 2, 16, 0x00006956) + DEP( 0xa5a5a558, 32767, 2, 16, 0xa5a5fffc) + EXT( 0xa5a5a557, 2, 17, 0xffff6955) + EXTU(0xa5a5a557, 2, 17, 0x00016955) + DEP( 0xa5a5a557, 65535, 2, 17, 0xa5a3ffff) + EXT( 0xa5a5a556, 2, 18, 0x00016955) + EXTU(0xa5a5a556, 2, 18, 0x00016955) + DEP( 0xa5a5a556, 131071, 2, 18, 0xa5a7fffe) + EXT( 0xa5a5a555, 2, 19, 0x00016955) + EXTU(0xa5a5a555, 2, 19, 0x00016955) + DEP( 0xa5a5a555, 262143, 2, 19, 0xa5affffd) + EXT( 0xa5a5a554, 2, 20, 0xfff96955) + EXTU(0xa5a5a554, 2, 20, 0x00096955) + DEP( 0xa5a5a554, 524287, 2, 20, 0xa59ffffc) + EXT( 0xa5a5a553, 2, 21, 0x00096954) + EXTU(0xa5a5a553, 2, 21, 0x00096954) + DEP( 0xa5a5a553, 1048575, 2, 21, 0xa5bfffff) + EXT( 0xa5a5a552, 2, 22, 0xffe96954) + EXTU(0xa5a5a552, 2, 22, 0x00296954) + DEP( 0xa5a5a552, 2097151, 2, 22, 0xa57ffffe) + EXT( 0xa5a5a551, 2, 23, 0xffe96954) + EXTU(0xa5a5a551, 2, 23, 0x00696954) + DEP( 0xa5a5a551, 4194303, 2, 23, 0xa4fffffd) + EXT( 0xa5a5a550, 2, 24, 0x00696954) + EXTU(0xa5a5a550, 2, 24, 0x00696954) + DEP( 0xa5a5a550, 8388607, 2, 24, 0xa5fffffc) + EXT( 0xa5a5a54f, 2, 25, 0xff696953) + EXTU(0xa5a5a54f, 2, 25, 0x01696953) + DEP( 0xa5a5a54f, 16777215, 2, 25, 0xa3ffffff) + EXT( 0xa5a5a54e, 2, 26, 0x01696953) + EXTU(0xa5a5a54e, 2, 26, 0x01696953) + DEP( 0xa5a5a54e, 33554431, 2, 26, 0xa7fffffe) + EXT( 0xa5a5a54d, 2, 27, 0x01696953) + EXTU(0xa5a5a54d, 2, 27, 0x01696953) + DEP( 0xa5a5a54d, 67108863, 2, 27, 0xaffffffd) + EXT( 0xa5a5a54c, 2, 28, 0xf9696953) + EXTU(0xa5a5a54c, 2, 28, 0x09696953) + DEP( 0xa5a5a54c, 134217727, 2, 28, 0x9ffffffc) + EXT( 0xa5a5a54b, 2, 29, 0x09696952) + EXTU(0xa5a5a54b, 2, 29, 0x09696952) + DEP( 0xa5a5a54b, 268435455, 2, 29, 0xbfffffff) + EXT( 0xa5a5a54a, 3, 1, 0xffffffff) + EXTU(0xa5a5a54a, 3, 1, 0x00000001) + DEP( 0xa5a5a54a, 0, 3, 1, 0xa5a5a542) + EXT( 0xa5a5a549, 3, 2, 0x00000001) + EXTU(0xa5a5a549, 3, 2, 0x00000001) + DEP( 0xa5a5a549, 1, 3, 2, 0xa5a5a549) + EXT( 0xa5a5a548, 3, 3, 0x00000001) + EXTU(0xa5a5a548, 3, 3, 0x00000001) + DEP( 0xa5a5a548, 3, 3, 3, 0xa5a5a558) + EXT( 0xa5a5a547, 3, 4, 0xfffffff8) + EXTU(0xa5a5a547, 3, 4, 0x00000008) + DEP( 0xa5a5a547, 7, 3, 4, 0xa5a5a53f) + EXT( 0xa5a5a546, 3, 5, 0x00000008) + EXTU(0xa5a5a546, 3, 5, 0x00000008) + DEP( 0xa5a5a546, 15, 3, 5, 0xa5a5a57e) + EXT( 0xa5a5a545, 3, 6, 0xffffffe8) + EXTU(0xa5a5a545, 3, 6, 0x00000028) + DEP( 0xa5a5a545, 31, 3, 6, 0xa5a5a4fd) + EXT( 0xa5a5a544, 3, 7, 0x00000028) + EXTU(0xa5a5a544, 3, 7, 0x00000028) + DEP( 0xa5a5a544, 63, 3, 7, 0xa5a5a5fc) + EXT( 0xa5a5a543, 3, 8, 0xffffffa8) + EXTU(0xa5a5a543, 3, 8, 0x000000a8) + DEP( 0xa5a5a543, 127, 3, 8, 0xa5a5a3fb) + EXT( 0xa5a5a542, 3, 9, 0x000000a8) + EXTU(0xa5a5a542, 3, 9, 0x000000a8) + DEP( 0xa5a5a542, 255, 3, 9, 0xa5a5a7fa) + EXT( 0xa5a5a541, 3, 10, 0x000000a8) + EXTU(0xa5a5a541, 3, 10, 0x000000a8) + DEP( 0xa5a5a541, 511, 3, 10, 0xa5a5aff9) + EXT( 0xa5a5a540, 3, 11, 0xfffffca8) + EXTU(0xa5a5a540, 3, 11, 0x000004a8) + DEP( 0xa5a5a540, 1023, 3, 11, 0xa5a59ff8) + EXT( 0xa5a5a53f, 3, 12, 0x000004a7) + EXTU(0xa5a5a53f, 3, 12, 0x000004a7) + DEP( 0xa5a5a53f, 2047, 3, 12, 0xa5a5bfff) + EXT( 0xa5a5a53e, 3, 13, 0xfffff4a7) + EXTU(0xa5a5a53e, 3, 13, 0x000014a7) + DEP( 0xa5a5a53e, 4095, 3, 13, 0xa5a57ffe) + EXT( 0xa5a5a53d, 3, 14, 0xfffff4a7) + EXTU(0xa5a5a53d, 3, 14, 0x000034a7) + DEP( 0xa5a5a53d, 8191, 3, 14, 0xa5a4fffd) + EXT( 0xa5a5a53c, 3, 15, 0x000034a7) + EXTU(0xa5a5a53c, 3, 15, 0x000034a7) + DEP( 0xa5a5a53c, 16383, 3, 15, 0xa5a5fffc) + EXT( 0xa5a5a53b, 3, 16, 0xffffb4a7) + EXTU(0xa5a5a53b, 3, 16, 0x0000b4a7) + DEP( 0xa5a5a53b, 32767, 3, 16, 0xa5a3fffb) + EXT( 0xa5a5a53a, 3, 17, 0x0000b4a7) + EXTU(0xa5a5a53a, 3, 17, 0x0000b4a7) + DEP( 0xa5a5a53a, 65535, 3, 17, 0xa5a7fffa) + EXT( 0xa5a5a539, 3, 18, 0x0000b4a7) + EXTU(0xa5a5a539, 3, 18, 0x0000b4a7) + DEP( 0xa5a5a539, 131071, 3, 18, 0xa5affff9) + EXT( 0xa5a5a538, 3, 19, 0xfffcb4a7) + EXTU(0xa5a5a538, 3, 19, 0x0004b4a7) + DEP( 0xa5a5a538, 262143, 3, 19, 0xa59ffff8) + EXT( 0xa5a5a537, 3, 20, 0x0004b4a6) + EXTU(0xa5a5a537, 3, 20, 0x0004b4a6) + DEP( 0xa5a5a537, 524287, 3, 20, 0xa5bfffff) + EXT( 0xa5a5a536, 3, 21, 0xfff4b4a6) + EXTU(0xa5a5a536, 3, 21, 0x0014b4a6) + DEP( 0xa5a5a536, 1048575, 3, 21, 0xa57ffffe) + EXT( 0xa5a5a535, 3, 22, 0xfff4b4a6) + EXTU(0xa5a5a535, 3, 22, 0x0034b4a6) + DEP( 0xa5a5a535, 2097151, 3, 22, 0xa4fffffd) + EXT( 0xa5a5a534, 3, 23, 0x0034b4a6) + EXTU(0xa5a5a534, 3, 23, 0x0034b4a6) + DEP( 0xa5a5a534, 4194303, 3, 23, 0xa5fffffc) + EXT( 0xa5a5a533, 3, 24, 0xffb4b4a6) + EXTU(0xa5a5a533, 3, 24, 0x00b4b4a6) + DEP( 0xa5a5a533, 8388607, 3, 24, 0xa3fffffb) + EXT( 0xa5a5a532, 3, 25, 0x00b4b4a6) + EXTU(0xa5a5a532, 3, 25, 0x00b4b4a6) + DEP( 0xa5a5a532, 16777215, 3, 25, 0xa7fffffa) + EXT( 0xa5a5a531, 3, 26, 0x00b4b4a6) + EXTU(0xa5a5a531, 3, 26, 0x00b4b4a6) + DEP( 0xa5a5a531, 33554431, 3, 26, 0xaffffff9) + EXT( 0xa5a5a530, 3, 27, 0xfcb4b4a6) + EXTU(0xa5a5a530, 3, 27, 0x04b4b4a6) + DEP( 0xa5a5a530, 67108863, 3, 27, 0x9ffffff8) + EXT( 0xa5a5a52f, 3, 28, 0x04b4b4a5) + EXTU(0xa5a5a52f, 3, 28, 0x04b4b4a5) + DEP( 0xa5a5a52f, 134217727, 3, 28, 0xbfffffff) + EXT( 0xa5a5a52e, 4, 1, 0x00000000) + EXTU(0xa5a5a52e, 4, 1, 0x00000000) + DEP( 0xa5a5a52e, 0, 4, 1, 0xa5a5a52e) + EXT( 0xa5a5a52d, 4, 2, 0xfffffffe) + EXTU(0xa5a5a52d, 4, 2, 0x00000002) + DEP( 0xa5a5a52d, 1, 4, 2, 0xa5a5a51d) + EXT( 0xa5a5a52c, 4, 3, 0x00000002) + EXTU(0xa5a5a52c, 4, 3, 0x00000002) + DEP( 0xa5a5a52c, 3, 4, 3, 0xa5a5a53c) + EXT( 0xa5a5a52b, 4, 4, 0x00000002) + EXTU(0xa5a5a52b, 4, 4, 0x00000002) + DEP( 0xa5a5a52b, 7, 4, 4, 0xa5a5a57b) + EXT( 0xa5a5a52a, 4, 5, 0xfffffff2) + EXTU(0xa5a5a52a, 4, 5, 0x00000012) + DEP( 0xa5a5a52a, 15, 4, 5, 0xa5a5a4fa) + EXT( 0xa5a5a529, 4, 6, 0x00000012) + EXTU(0xa5a5a529, 4, 6, 0x00000012) + DEP( 0xa5a5a529, 31, 4, 6, 0xa5a5a5f9) + EXT( 0xa5a5a528, 4, 7, 0xffffffd2) + EXTU(0xa5a5a528, 4, 7, 0x00000052) + DEP( 0xa5a5a528, 63, 4, 7, 0xa5a5a3f8) + EXT( 0xa5a5a527, 4, 8, 0x00000052) + EXTU(0xa5a5a527, 4, 8, 0x00000052) + DEP( 0xa5a5a527, 127, 4, 8, 0xa5a5a7f7) + EXT( 0xa5a5a526, 4, 9, 0x00000052) + EXTU(0xa5a5a526, 4, 9, 0x00000052) + DEP( 0xa5a5a526, 255, 4, 9, 0xa5a5aff6) + EXT( 0xa5a5a525, 4, 10, 0xfffffe52) + EXTU(0xa5a5a525, 4, 10, 0x00000252) + DEP( 0xa5a5a525, 511, 4, 10, 0xa5a59ff5) + EXT( 0xa5a5a524, 4, 11, 0x00000252) + EXTU(0xa5a5a524, 4, 11, 0x00000252) + DEP( 0xa5a5a524, 1023, 4, 11, 0xa5a5bff4) + EXT( 0xa5a5a523, 4, 12, 0xfffffa52) + EXTU(0xa5a5a523, 4, 12, 0x00000a52) + DEP( 0xa5a5a523, 2047, 4, 12, 0xa5a57ff3) + EXT( 0xa5a5a522, 4, 13, 0xfffffa52) + EXTU(0xa5a5a522, 4, 13, 0x00001a52) + DEP( 0xa5a5a522, 4095, 4, 13, 0xa5a4fff2) + EXT( 0xa5a5a521, 4, 14, 0x00001a52) + EXTU(0xa5a5a521, 4, 14, 0x00001a52) + DEP( 0xa5a5a521, 8191, 4, 14, 0xa5a5fff1) + EXT( 0xa5a5a520, 4, 15, 0xffffda52) + EXTU(0xa5a5a520, 4, 15, 0x00005a52) + DEP( 0xa5a5a520, 16383, 4, 15, 0xa5a3fff0) + EXT( 0xa5a5a51f, 4, 16, 0x00005a51) + EXTU(0xa5a5a51f, 4, 16, 0x00005a51) + DEP( 0xa5a5a51f, 32767, 4, 16, 0xa5a7ffff) + EXT( 0xa5a5a51e, 4, 17, 0x00005a51) + EXTU(0xa5a5a51e, 4, 17, 0x00005a51) + DEP( 0xa5a5a51e, 65535, 4, 17, 0xa5affffe) + EXT( 0xa5a5a51d, 4, 18, 0xfffe5a51) + EXTU(0xa5a5a51d, 4, 18, 0x00025a51) + DEP( 0xa5a5a51d, 131071, 4, 18, 0xa59ffffd) + EXT( 0xa5a5a51c, 4, 19, 0x00025a51) + EXTU(0xa5a5a51c, 4, 19, 0x00025a51) + DEP( 0xa5a5a51c, 262143, 4, 19, 0xa5bffffc) + EXT( 0xa5a5a51b, 4, 20, 0xfffa5a51) + EXTU(0xa5a5a51b, 4, 20, 0x000a5a51) + DEP( 0xa5a5a51b, 524287, 4, 20, 0xa57ffffb) + EXT( 0xa5a5a51a, 4, 21, 0xfffa5a51) + EXTU(0xa5a5a51a, 4, 21, 0x001a5a51) + DEP( 0xa5a5a51a, 1048575, 4, 21, 0xa4fffffa) + EXT( 0xa5a5a519, 4, 22, 0x001a5a51) + EXTU(0xa5a5a519, 4, 22, 0x001a5a51) + DEP( 0xa5a5a519, 2097151, 4, 22, 0xa5fffff9) + EXT( 0xa5a5a518, 4, 23, 0xffda5a51) + EXTU(0xa5a5a518, 4, 23, 0x005a5a51) + DEP( 0xa5a5a518, 4194303, 4, 23, 0xa3fffff8) + EXT( 0xa5a5a517, 4, 24, 0x005a5a51) + EXTU(0xa5a5a517, 4, 24, 0x005a5a51) + DEP( 0xa5a5a517, 8388607, 4, 24, 0xa7fffff7) + EXT( 0xa5a5a516, 4, 25, 0x005a5a51) + EXTU(0xa5a5a516, 4, 25, 0x005a5a51) + DEP( 0xa5a5a516, 16777215, 4, 25, 0xaffffff6) + EXT( 0xa5a5a515, 4, 26, 0xfe5a5a51) + EXTU(0xa5a5a515, 4, 26, 0x025a5a51) + DEP( 0xa5a5a515, 33554431, 4, 26, 0x9ffffff5) + EXT( 0xa5a5a514, 4, 27, 0x025a5a51) + EXTU(0xa5a5a514, 4, 27, 0x025a5a51) + DEP( 0xa5a5a514, 67108863, 4, 27, 0xbffffff4) + EXT( 0xa5a5a513, 5, 1, 0x00000000) + EXTU(0xa5a5a513, 5, 1, 0x00000000) + DEP( 0xa5a5a513, 0, 5, 1, 0xa5a5a513) + EXT( 0xa5a5a512, 5, 2, 0x00000000) + EXTU(0xa5a5a512, 5, 2, 0x00000000) + DEP( 0xa5a5a512, 1, 5, 2, 0xa5a5a532) + EXT( 0xa5a5a511, 5, 3, 0x00000000) + EXTU(0xa5a5a511, 5, 3, 0x00000000) + DEP( 0xa5a5a511, 3, 5, 3, 0xa5a5a571) + EXT( 0xa5a5a510, 5, 4, 0xfffffff8) + EXTU(0xa5a5a510, 5, 4, 0x00000008) + DEP( 0xa5a5a510, 7, 5, 4, 0xa5a5a4f0) + EXT( 0xa5a5a50f, 5, 5, 0x00000008) + EXTU(0xa5a5a50f, 5, 5, 0x00000008) + DEP( 0xa5a5a50f, 15, 5, 5, 0xa5a5a5ef) + EXT( 0xa5a5a50e, 5, 6, 0xffffffe8) + EXTU(0xa5a5a50e, 5, 6, 0x00000028) + DEP( 0xa5a5a50e, 31, 5, 6, 0xa5a5a3ee) + EXT( 0xa5a5a50d, 5, 7, 0x00000028) + EXTU(0xa5a5a50d, 5, 7, 0x00000028) + DEP( 0xa5a5a50d, 63, 5, 7, 0xa5a5a7ed) + EXT( 0xa5a5a50c, 5, 8, 0x00000028) + EXTU(0xa5a5a50c, 5, 8, 0x00000028) + DEP( 0xa5a5a50c, 127, 5, 8, 0xa5a5afec) + EXT( 0xa5a5a50b, 5, 9, 0xffffff28) + EXTU(0xa5a5a50b, 5, 9, 0x00000128) + DEP( 0xa5a5a50b, 255, 5, 9, 0xa5a59feb) + EXT( 0xa5a5a50a, 5, 10, 0x00000128) + EXTU(0xa5a5a50a, 5, 10, 0x00000128) + DEP( 0xa5a5a50a, 511, 5, 10, 0xa5a5bfea) + EXT( 0xa5a5a509, 5, 11, 0xfffffd28) + EXTU(0xa5a5a509, 5, 11, 0x00000528) + DEP( 0xa5a5a509, 1023, 5, 11, 0xa5a57fe9) + EXT( 0xa5a5a508, 5, 12, 0xfffffd28) + EXTU(0xa5a5a508, 5, 12, 0x00000d28) + DEP( 0xa5a5a508, 2047, 5, 12, 0xa5a4ffe8) + EXT( 0xa5a5a507, 5, 13, 0x00000d28) + EXTU(0xa5a5a507, 5, 13, 0x00000d28) + DEP( 0xa5a5a507, 4095, 5, 13, 0xa5a5ffe7) + EXT( 0xa5a5a506, 5, 14, 0xffffed28) + EXTU(0xa5a5a506, 5, 14, 0x00002d28) + DEP( 0xa5a5a506, 8191, 5, 14, 0xa5a3ffe6) + EXT( 0xa5a5a505, 5, 15, 0x00002d28) + EXTU(0xa5a5a505, 5, 15, 0x00002d28) + DEP( 0xa5a5a505, 16383, 5, 15, 0xa5a7ffe5) + EXT( 0xa5a5a504, 5, 16, 0x00002d28) + EXTU(0xa5a5a504, 5, 16, 0x00002d28) + DEP( 0xa5a5a504, 32767, 5, 16, 0xa5afffe4) + EXT( 0xa5a5a503, 5, 17, 0xffff2d28) + EXTU(0xa5a5a503, 5, 17, 0x00012d28) + DEP( 0xa5a5a503, 65535, 5, 17, 0xa59fffe3) + EXT( 0xa5a5a502, 5, 18, 0x00012d28) + EXTU(0xa5a5a502, 5, 18, 0x00012d28) + DEP( 0xa5a5a502, 131071, 5, 18, 0xa5bfffe2) + EXT( 0xa5a5a501, 5, 19, 0xfffd2d28) + EXTU(0xa5a5a501, 5, 19, 0x00052d28) + DEP( 0xa5a5a501, 262143, 5, 19, 0xa57fffe1) + EXT( 0xa5a5a500, 5, 20, 0xfffd2d28) + EXTU(0xa5a5a500, 5, 20, 0x000d2d28) + DEP( 0xa5a5a500, 524287, 5, 20, 0xa4ffffe0) + EXT( 0xa5a5a4ff, 5, 21, 0x000d2d27) + EXTU(0xa5a5a4ff, 5, 21, 0x000d2d27) + DEP( 0xa5a5a4ff, 1048575, 5, 21, 0xa5ffffff) + EXT( 0xa5a5a4fe, 5, 22, 0xffed2d27) + EXTU(0xa5a5a4fe, 5, 22, 0x002d2d27) + DEP( 0xa5a5a4fe, 2097151, 5, 22, 0xa3fffffe) + EXT( 0xa5a5a4fd, 5, 23, 0x002d2d27) + EXTU(0xa5a5a4fd, 5, 23, 0x002d2d27) + DEP( 0xa5a5a4fd, 4194303, 5, 23, 0xa7fffffd) + EXT( 0xa5a5a4fc, 5, 24, 0x002d2d27) + EXTU(0xa5a5a4fc, 5, 24, 0x002d2d27) + DEP( 0xa5a5a4fc, 8388607, 5, 24, 0xaffffffc) + EXT( 0xa5a5a4fb, 5, 25, 0xff2d2d27) + EXTU(0xa5a5a4fb, 5, 25, 0x012d2d27) + DEP( 0xa5a5a4fb, 16777215, 5, 25, 0x9ffffffb) + EXT( 0xa5a5a4fa, 5, 26, 0x012d2d27) + EXTU(0xa5a5a4fa, 5, 26, 0x012d2d27) + DEP( 0xa5a5a4fa, 33554431, 5, 26, 0xbffffffa) + EXT( 0xa5a5a4f9, 6, 1, 0xffffffff) + EXTU(0xa5a5a4f9, 6, 1, 0x00000001) + DEP( 0xa5a5a4f9, 0, 6, 1, 0xa5a5a4b9) + EXT( 0xa5a5a4f8, 6, 2, 0xffffffff) + EXTU(0xa5a5a4f8, 6, 2, 0x00000003) + DEP( 0xa5a5a4f8, 1, 6, 2, 0xa5a5a478) + EXT( 0xa5a5a4f7, 6, 3, 0x00000003) + EXTU(0xa5a5a4f7, 6, 3, 0x00000003) + DEP( 0xa5a5a4f7, 3, 6, 3, 0xa5a5a4f7) + EXT( 0xa5a5a4f6, 6, 4, 0x00000003) + EXTU(0xa5a5a4f6, 6, 4, 0x00000003) + DEP( 0xa5a5a4f6, 7, 6, 4, 0xa5a5a5f6) + EXT( 0xa5a5a4f5, 6, 5, 0xfffffff3) + EXTU(0xa5a5a4f5, 6, 5, 0x00000013) + DEP( 0xa5a5a4f5, 15, 6, 5, 0xa5a5a3f5) + EXT( 0xa5a5a4f4, 6, 6, 0x00000013) + EXTU(0xa5a5a4f4, 6, 6, 0x00000013) + DEP( 0xa5a5a4f4, 31, 6, 6, 0xa5a5a7f4) + EXT( 0xa5a5a4f3, 6, 7, 0x00000013) + EXTU(0xa5a5a4f3, 6, 7, 0x00000013) + DEP( 0xa5a5a4f3, 63, 6, 7, 0xa5a5aff3) + EXT( 0xa5a5a4f2, 6, 8, 0xffffff93) + EXTU(0xa5a5a4f2, 6, 8, 0x00000093) + DEP( 0xa5a5a4f2, 127, 6, 8, 0xa5a59ff2) + EXT( 0xa5a5a4f1, 6, 9, 0x00000093) + EXTU(0xa5a5a4f1, 6, 9, 0x00000093) + DEP( 0xa5a5a4f1, 255, 6, 9, 0xa5a5bff1) + EXT( 0xa5a5a4f0, 6, 10, 0xfffffe93) + EXTU(0xa5a5a4f0, 6, 10, 0x00000293) + DEP( 0xa5a5a4f0, 511, 6, 10, 0xa5a57ff0) + EXT( 0xa5a5a4ef, 6, 11, 0xfffffe93) + EXTU(0xa5a5a4ef, 6, 11, 0x00000693) + DEP( 0xa5a5a4ef, 1023, 6, 11, 0xa5a4ffef) + EXT( 0xa5a5a4ee, 6, 12, 0x00000693) + EXTU(0xa5a5a4ee, 6, 12, 0x00000693) + DEP( 0xa5a5a4ee, 2047, 6, 12, 0xa5a5ffee) + EXT( 0xa5a5a4ed, 6, 13, 0xfffff693) + EXTU(0xa5a5a4ed, 6, 13, 0x00001693) + DEP( 0xa5a5a4ed, 4095, 6, 13, 0xa5a3ffed) + EXT( 0xa5a5a4ec, 6, 14, 0x00001693) + EXTU(0xa5a5a4ec, 6, 14, 0x00001693) + DEP( 0xa5a5a4ec, 8191, 6, 14, 0xa5a7ffec) + EXT( 0xa5a5a4eb, 6, 15, 0x00001693) + EXTU(0xa5a5a4eb, 6, 15, 0x00001693) + DEP( 0xa5a5a4eb, 16383, 6, 15, 0xa5afffeb) + EXT( 0xa5a5a4ea, 6, 16, 0xffff9693) + EXTU(0xa5a5a4ea, 6, 16, 0x00009693) + DEP( 0xa5a5a4ea, 32767, 6, 16, 0xa59fffea) + EXT( 0xa5a5a4e9, 6, 17, 0x00009693) + EXTU(0xa5a5a4e9, 6, 17, 0x00009693) + DEP( 0xa5a5a4e9, 65535, 6, 17, 0xa5bfffe9) + EXT( 0xa5a5a4e8, 6, 18, 0xfffe9693) + EXTU(0xa5a5a4e8, 6, 18, 0x00029693) + DEP( 0xa5a5a4e8, 131071, 6, 18, 0xa57fffe8) + EXT( 0xa5a5a4e7, 6, 19, 0xfffe9693) + EXTU(0xa5a5a4e7, 6, 19, 0x00069693) + DEP( 0xa5a5a4e7, 262143, 6, 19, 0xa4ffffe7) + EXT( 0xa5a5a4e6, 6, 20, 0x00069693) + EXTU(0xa5a5a4e6, 6, 20, 0x00069693) + DEP( 0xa5a5a4e6, 524287, 6, 20, 0xa5ffffe6) + EXT( 0xa5a5a4e5, 6, 21, 0xfff69693) + EXTU(0xa5a5a4e5, 6, 21, 0x00169693) + DEP( 0xa5a5a4e5, 1048575, 6, 21, 0xa3ffffe5) + EXT( 0xa5a5a4e4, 6, 22, 0x00169693) + EXTU(0xa5a5a4e4, 6, 22, 0x00169693) + DEP( 0xa5a5a4e4, 2097151, 6, 22, 0xa7ffffe4) + EXT( 0xa5a5a4e3, 6, 23, 0x00169693) + EXTU(0xa5a5a4e3, 6, 23, 0x00169693) + DEP( 0xa5a5a4e3, 4194303, 6, 23, 0xafffffe3) + EXT( 0xa5a5a4e2, 6, 24, 0xff969693) + EXTU(0xa5a5a4e2, 6, 24, 0x00969693) + DEP( 0xa5a5a4e2, 8388607, 6, 24, 0x9fffffe2) + EXT( 0xa5a5a4e1, 6, 25, 0x00969693) + EXTU(0xa5a5a4e1, 6, 25, 0x00969693) + DEP( 0xa5a5a4e1, 16777215, 6, 25, 0xbfffffe1) + EXT( 0xa5a5a4e0, 7, 1, 0xffffffff) + EXTU(0xa5a5a4e0, 7, 1, 0x00000001) + DEP( 0xa5a5a4e0, 0, 7, 1, 0xa5a5a460) + EXT( 0xa5a5a4df, 7, 2, 0x00000001) + EXTU(0xa5a5a4df, 7, 2, 0x00000001) + DEP( 0xa5a5a4df, 1, 7, 2, 0xa5a5a4df) + EXT( 0xa5a5a4de, 7, 3, 0x00000001) + EXTU(0xa5a5a4de, 7, 3, 0x00000001) + DEP( 0xa5a5a4de, 3, 7, 3, 0xa5a5a5de) + EXT( 0xa5a5a4dd, 7, 4, 0xfffffff9) + EXTU(0xa5a5a4dd, 7, 4, 0x00000009) + DEP( 0xa5a5a4dd, 7, 7, 4, 0xa5a5a3dd) + EXT( 0xa5a5a4dc, 7, 5, 0x00000009) + EXTU(0xa5a5a4dc, 7, 5, 0x00000009) + DEP( 0xa5a5a4dc, 15, 7, 5, 0xa5a5a7dc) + EXT( 0xa5a5a4db, 7, 6, 0x00000009) + EXTU(0xa5a5a4db, 7, 6, 0x00000009) + DEP( 0xa5a5a4db, 31, 7, 6, 0xa5a5afdb) + EXT( 0xa5a5a4da, 7, 7, 0xffffffc9) + EXTU(0xa5a5a4da, 7, 7, 0x00000049) + DEP( 0xa5a5a4da, 63, 7, 7, 0xa5a59fda) + EXT( 0xa5a5a4d9, 7, 8, 0x00000049) + EXTU(0xa5a5a4d9, 7, 8, 0x00000049) + DEP( 0xa5a5a4d9, 127, 7, 8, 0xa5a5bfd9) + EXT( 0xa5a5a4d8, 7, 9, 0xffffff49) + EXTU(0xa5a5a4d8, 7, 9, 0x00000149) + DEP( 0xa5a5a4d8, 255, 7, 9, 0xa5a57fd8) + EXT( 0xa5a5a4d7, 7, 10, 0xffffff49) + EXTU(0xa5a5a4d7, 7, 10, 0x00000349) + DEP( 0xa5a5a4d7, 511, 7, 10, 0xa5a4ffd7) + EXT( 0xa5a5a4d6, 7, 11, 0x00000349) + EXTU(0xa5a5a4d6, 7, 11, 0x00000349) + DEP( 0xa5a5a4d6, 1023, 7, 11, 0xa5a5ffd6) + EXT( 0xa5a5a4d5, 7, 12, 0xfffffb49) + EXTU(0xa5a5a4d5, 7, 12, 0x00000b49) + DEP( 0xa5a5a4d5, 2047, 7, 12, 0xa5a3ffd5) + EXT( 0xa5a5a4d4, 7, 13, 0x00000b49) + EXTU(0xa5a5a4d4, 7, 13, 0x00000b49) + DEP( 0xa5a5a4d4, 4095, 7, 13, 0xa5a7ffd4) + EXT( 0xa5a5a4d3, 7, 14, 0x00000b49) + EXTU(0xa5a5a4d3, 7, 14, 0x00000b49) + DEP( 0xa5a5a4d3, 8191, 7, 14, 0xa5afffd3) + EXT( 0xa5a5a4d2, 7, 15, 0xffffcb49) + EXTU(0xa5a5a4d2, 7, 15, 0x00004b49) + DEP( 0xa5a5a4d2, 16383, 7, 15, 0xa59fffd2) + EXT( 0xa5a5a4d1, 7, 16, 0x00004b49) + EXTU(0xa5a5a4d1, 7, 16, 0x00004b49) + DEP( 0xa5a5a4d1, 32767, 7, 16, 0xa5bfffd1) + EXT( 0xa5a5a4d0, 7, 17, 0xffff4b49) + EXTU(0xa5a5a4d0, 7, 17, 0x00014b49) + DEP( 0xa5a5a4d0, 65535, 7, 17, 0xa57fffd0) + EXT( 0xa5a5a4cf, 7, 18, 0xffff4b49) + EXTU(0xa5a5a4cf, 7, 18, 0x00034b49) + DEP( 0xa5a5a4cf, 131071, 7, 18, 0xa4ffffcf) + EXT( 0xa5a5a4ce, 7, 19, 0x00034b49) + EXTU(0xa5a5a4ce, 7, 19, 0x00034b49) + DEP( 0xa5a5a4ce, 262143, 7, 19, 0xa5ffffce) + EXT( 0xa5a5a4cd, 7, 20, 0xfffb4b49) + EXTU(0xa5a5a4cd, 7, 20, 0x000b4b49) + DEP( 0xa5a5a4cd, 524287, 7, 20, 0xa3ffffcd) + EXT( 0xa5a5a4cc, 7, 21, 0x000b4b49) + EXTU(0xa5a5a4cc, 7, 21, 0x000b4b49) + DEP( 0xa5a5a4cc, 1048575, 7, 21, 0xa7ffffcc) + EXT( 0xa5a5a4cb, 7, 22, 0x000b4b49) + EXTU(0xa5a5a4cb, 7, 22, 0x000b4b49) + DEP( 0xa5a5a4cb, 2097151, 7, 22, 0xafffffcb) + EXT( 0xa5a5a4ca, 7, 23, 0xffcb4b49) + EXTU(0xa5a5a4ca, 7, 23, 0x004b4b49) + DEP( 0xa5a5a4ca, 4194303, 7, 23, 0x9fffffca) + EXT( 0xa5a5a4c9, 7, 24, 0x004b4b49) + EXTU(0xa5a5a4c9, 7, 24, 0x004b4b49) + DEP( 0xa5a5a4c9, 8388607, 7, 24, 0xbfffffc9) + EXT( 0xa5a5a4c8, 8, 1, 0x00000000) + EXTU(0xa5a5a4c8, 8, 1, 0x00000000) + DEP( 0xa5a5a4c8, 0, 8, 1, 0xa5a5a4c8) + EXT( 0xa5a5a4c7, 8, 2, 0x00000000) + EXTU(0xa5a5a4c7, 8, 2, 0x00000000) + DEP( 0xa5a5a4c7, 1, 8, 2, 0xa5a5a5c7) + EXT( 0xa5a5a4c6, 8, 3, 0xfffffffc) + EXTU(0xa5a5a4c6, 8, 3, 0x00000004) + DEP( 0xa5a5a4c6, 3, 8, 3, 0xa5a5a3c6) + EXT( 0xa5a5a4c5, 8, 4, 0x00000004) + EXTU(0xa5a5a4c5, 8, 4, 0x00000004) + DEP( 0xa5a5a4c5, 7, 8, 4, 0xa5a5a7c5) + EXT( 0xa5a5a4c4, 8, 5, 0x00000004) + EXTU(0xa5a5a4c4, 8, 5, 0x00000004) + DEP( 0xa5a5a4c4, 15, 8, 5, 0xa5a5afc4) + EXT( 0xa5a5a4c3, 8, 6, 0xffffffe4) + EXTU(0xa5a5a4c3, 8, 6, 0x00000024) + DEP( 0xa5a5a4c3, 31, 8, 6, 0xa5a59fc3) + EXT( 0xa5a5a4c2, 8, 7, 0x00000024) + EXTU(0xa5a5a4c2, 8, 7, 0x00000024) + DEP( 0xa5a5a4c2, 63, 8, 7, 0xa5a5bfc2) + EXT( 0xa5a5a4c1, 8, 8, 0xffffffa4) + EXTU(0xa5a5a4c1, 8, 8, 0x000000a4) + DEP( 0xa5a5a4c1, 127, 8, 8, 0xa5a57fc1) + EXT( 0xa5a5a4c0, 8, 9, 0xffffffa4) + EXTU(0xa5a5a4c0, 8, 9, 0x000001a4) + DEP( 0xa5a5a4c0, 255, 8, 9, 0xa5a4ffc0) + EXT( 0xa5a5a4bf, 8, 10, 0x000001a4) + EXTU(0xa5a5a4bf, 8, 10, 0x000001a4) + DEP( 0xa5a5a4bf, 511, 8, 10, 0xa5a5ffbf) + EXT( 0xa5a5a4be, 8, 11, 0xfffffda4) + EXTU(0xa5a5a4be, 8, 11, 0x000005a4) + DEP( 0xa5a5a4be, 1023, 8, 11, 0xa5a3ffbe) + EXT( 0xa5a5a4bd, 8, 12, 0x000005a4) + EXTU(0xa5a5a4bd, 8, 12, 0x000005a4) + DEP( 0xa5a5a4bd, 2047, 8, 12, 0xa5a7ffbd) + EXT( 0xa5a5a4bc, 8, 13, 0x000005a4) + EXTU(0xa5a5a4bc, 8, 13, 0x000005a4) + DEP( 0xa5a5a4bc, 4095, 8, 13, 0xa5afffbc) + EXT( 0xa5a5a4bb, 8, 14, 0xffffe5a4) + EXTU(0xa5a5a4bb, 8, 14, 0x000025a4) + DEP( 0xa5a5a4bb, 8191, 8, 14, 0xa59fffbb) + EXT( 0xa5a5a4ba, 8, 15, 0x000025a4) + EXTU(0xa5a5a4ba, 8, 15, 0x000025a4) + DEP( 0xa5a5a4ba, 16383, 8, 15, 0xa5bfffba) + EXT( 0xa5a5a4b9, 8, 16, 0xffffa5a4) + EXTU(0xa5a5a4b9, 8, 16, 0x0000a5a4) + DEP( 0xa5a5a4b9, 32767, 8, 16, 0xa57fffb9) + EXT( 0xa5a5a4b8, 8, 17, 0xffffa5a4) + EXTU(0xa5a5a4b8, 8, 17, 0x0001a5a4) + DEP( 0xa5a5a4b8, 65535, 8, 17, 0xa4ffffb8) + EXT( 0xa5a5a4b7, 8, 18, 0x0001a5a4) + EXTU(0xa5a5a4b7, 8, 18, 0x0001a5a4) + DEP( 0xa5a5a4b7, 131071, 8, 18, 0xa5ffffb7) + EXT( 0xa5a5a4b6, 8, 19, 0xfffda5a4) + EXTU(0xa5a5a4b6, 8, 19, 0x0005a5a4) + DEP( 0xa5a5a4b6, 262143, 8, 19, 0xa3ffffb6) + EXT( 0xa5a5a4b5, 8, 20, 0x0005a5a4) + EXTU(0xa5a5a4b5, 8, 20, 0x0005a5a4) + DEP( 0xa5a5a4b5, 524287, 8, 20, 0xa7ffffb5) + EXT( 0xa5a5a4b4, 8, 21, 0x0005a5a4) + EXTU(0xa5a5a4b4, 8, 21, 0x0005a5a4) + DEP( 0xa5a5a4b4, 1048575, 8, 21, 0xafffffb4) + EXT( 0xa5a5a4b3, 8, 22, 0xffe5a5a4) + EXTU(0xa5a5a4b3, 8, 22, 0x0025a5a4) + DEP( 0xa5a5a4b3, 2097151, 8, 22, 0x9fffffb3) + EXT( 0xa5a5a4b2, 8, 23, 0x0025a5a4) + EXTU(0xa5a5a4b2, 8, 23, 0x0025a5a4) + DEP( 0xa5a5a4b2, 4194303, 8, 23, 0xbfffffb2) + EXT( 0xa5a5a4b1, 9, 1, 0x00000000) + EXTU(0xa5a5a4b1, 9, 1, 0x00000000) + DEP( 0xa5a5a4b1, 0, 9, 1, 0xa5a5a4b1) + EXT( 0xa5a5a4b0, 9, 2, 0xfffffffe) + EXTU(0xa5a5a4b0, 9, 2, 0x00000002) + DEP( 0xa5a5a4b0, 1, 9, 2, 0xa5a5a2b0) + EXT( 0xa5a5a4af, 9, 3, 0x00000002) + EXTU(0xa5a5a4af, 9, 3, 0x00000002) + DEP( 0xa5a5a4af, 3, 9, 3, 0xa5a5a6af) + EXT( 0xa5a5a4ae, 9, 4, 0x00000002) + EXTU(0xa5a5a4ae, 9, 4, 0x00000002) + DEP( 0xa5a5a4ae, 7, 9, 4, 0xa5a5aeae) + EXT( 0xa5a5a4ad, 9, 5, 0xfffffff2) + EXTU(0xa5a5a4ad, 9, 5, 0x00000012) + DEP( 0xa5a5a4ad, 15, 9, 5, 0xa5a59ead) + EXT( 0xa5a5a4ac, 9, 6, 0x00000012) + EXTU(0xa5a5a4ac, 9, 6, 0x00000012) + DEP( 0xa5a5a4ac, 31, 9, 6, 0xa5a5beac) + EXT( 0xa5a5a4ab, 9, 7, 0xffffffd2) + EXTU(0xa5a5a4ab, 9, 7, 0x00000052) + DEP( 0xa5a5a4ab, 63, 9, 7, 0xa5a57eab) + EXT( 0xa5a5a4aa, 9, 8, 0xffffffd2) + EXTU(0xa5a5a4aa, 9, 8, 0x000000d2) + DEP( 0xa5a5a4aa, 127, 9, 8, 0xa5a4feaa) + EXT( 0xa5a5a4a9, 9, 9, 0x000000d2) + EXTU(0xa5a5a4a9, 9, 9, 0x000000d2) + DEP( 0xa5a5a4a9, 255, 9, 9, 0xa5a5fea9) + EXT( 0xa5a5a4a8, 9, 10, 0xfffffed2) + EXTU(0xa5a5a4a8, 9, 10, 0x000002d2) + DEP( 0xa5a5a4a8, 511, 9, 10, 0xa5a3fea8) + EXT( 0xa5a5a4a7, 9, 11, 0x000002d2) + EXTU(0xa5a5a4a7, 9, 11, 0x000002d2) + DEP( 0xa5a5a4a7, 1023, 9, 11, 0xa5a7fea7) + EXT( 0xa5a5a4a6, 9, 12, 0x000002d2) + EXTU(0xa5a5a4a6, 9, 12, 0x000002d2) + DEP( 0xa5a5a4a6, 2047, 9, 12, 0xa5affea6) + EXT( 0xa5a5a4a5, 9, 13, 0xfffff2d2) + EXTU(0xa5a5a4a5, 9, 13, 0x000012d2) + DEP( 0xa5a5a4a5, 4095, 9, 13, 0xa59ffea5) + EXT( 0xa5a5a4a4, 9, 14, 0x000012d2) + EXTU(0xa5a5a4a4, 9, 14, 0x000012d2) + DEP( 0xa5a5a4a4, 8191, 9, 14, 0xa5bffea4) + EXT( 0xa5a5a4a3, 9, 15, 0xffffd2d2) + EXTU(0xa5a5a4a3, 9, 15, 0x000052d2) + DEP( 0xa5a5a4a3, 16383, 9, 15, 0xa57ffea3) + EXT( 0xa5a5a4a2, 9, 16, 0xffffd2d2) + EXTU(0xa5a5a4a2, 9, 16, 0x0000d2d2) + DEP( 0xa5a5a4a2, 32767, 9, 16, 0xa4fffea2) + EXT( 0xa5a5a4a1, 9, 17, 0x0000d2d2) + EXTU(0xa5a5a4a1, 9, 17, 0x0000d2d2) + DEP( 0xa5a5a4a1, 65535, 9, 17, 0xa5fffea1) + EXT( 0xa5a5a4a0, 9, 18, 0xfffed2d2) + EXTU(0xa5a5a4a0, 9, 18, 0x0002d2d2) + DEP( 0xa5a5a4a0, 131071, 9, 18, 0xa3fffea0) + EXT( 0xa5a5a49f, 9, 19, 0x0002d2d2) + EXTU(0xa5a5a49f, 9, 19, 0x0002d2d2) + DEP( 0xa5a5a49f, 262143, 9, 19, 0xa7fffe9f) + EXT( 0xa5a5a49e, 9, 20, 0x0002d2d2) + EXTU(0xa5a5a49e, 9, 20, 0x0002d2d2) + DEP( 0xa5a5a49e, 524287, 9, 20, 0xaffffe9e) + EXT( 0xa5a5a49d, 9, 21, 0xfff2d2d2) + EXTU(0xa5a5a49d, 9, 21, 0x0012d2d2) + DEP( 0xa5a5a49d, 1048575, 9, 21, 0x9ffffe9d) + EXT( 0xa5a5a49c, 9, 22, 0x0012d2d2) + EXTU(0xa5a5a49c, 9, 22, 0x0012d2d2) + DEP( 0xa5a5a49c, 2097151, 9, 22, 0xbffffe9c) + EXT( 0xa5a5a49b, 10, 1, 0xffffffff) + EXTU(0xa5a5a49b, 10, 1, 0x00000001) + DEP( 0xa5a5a49b, 0, 10, 1, 0xa5a5a09b) + EXT( 0xa5a5a49a, 10, 2, 0x00000001) + EXTU(0xa5a5a49a, 10, 2, 0x00000001) + DEP( 0xa5a5a49a, 1, 10, 2, 0xa5a5a49a) + EXT( 0xa5a5a499, 10, 3, 0x00000001) + EXTU(0xa5a5a499, 10, 3, 0x00000001) + DEP( 0xa5a5a499, 3, 10, 3, 0xa5a5ac99) + EXT( 0xa5a5a498, 10, 4, 0xfffffff9) + EXTU(0xa5a5a498, 10, 4, 0x00000009) + DEP( 0xa5a5a498, 7, 10, 4, 0xa5a59c98) + EXT( 0xa5a5a497, 10, 5, 0x00000009) + EXTU(0xa5a5a497, 10, 5, 0x00000009) + DEP( 0xa5a5a497, 15, 10, 5, 0xa5a5bc97) + EXT( 0xa5a5a496, 10, 6, 0xffffffe9) + EXTU(0xa5a5a496, 10, 6, 0x00000029) + DEP( 0xa5a5a496, 31, 10, 6, 0xa5a57c96) + EXT( 0xa5a5a495, 10, 7, 0xffffffe9) + EXTU(0xa5a5a495, 10, 7, 0x00000069) + DEP( 0xa5a5a495, 63, 10, 7, 0xa5a4fc95) + EXT( 0xa5a5a494, 10, 8, 0x00000069) + EXTU(0xa5a5a494, 10, 8, 0x00000069) + DEP( 0xa5a5a494, 127, 10, 8, 0xa5a5fc94) + EXT( 0xa5a5a493, 10, 9, 0xffffff69) + EXTU(0xa5a5a493, 10, 9, 0x00000169) + DEP( 0xa5a5a493, 255, 10, 9, 0xa5a3fc93) + EXT( 0xa5a5a492, 10, 10, 0x00000169) + EXTU(0xa5a5a492, 10, 10, 0x00000169) + DEP( 0xa5a5a492, 511, 10, 10, 0xa5a7fc92) + EXT( 0xa5a5a491, 10, 11, 0x00000169) + EXTU(0xa5a5a491, 10, 11, 0x00000169) + DEP( 0xa5a5a491, 1023, 10, 11, 0xa5affc91) + EXT( 0xa5a5a490, 10, 12, 0xfffff969) + EXTU(0xa5a5a490, 10, 12, 0x00000969) + DEP( 0xa5a5a490, 2047, 10, 12, 0xa59ffc90) + EXT( 0xa5a5a48f, 10, 13, 0x00000969) + EXTU(0xa5a5a48f, 10, 13, 0x00000969) + DEP( 0xa5a5a48f, 4095, 10, 13, 0xa5bffc8f) + EXT( 0xa5a5a48e, 10, 14, 0xffffe969) + EXTU(0xa5a5a48e, 10, 14, 0x00002969) + DEP( 0xa5a5a48e, 8191, 10, 14, 0xa57ffc8e) + EXT( 0xa5a5a48d, 10, 15, 0xffffe969) + EXTU(0xa5a5a48d, 10, 15, 0x00006969) + DEP( 0xa5a5a48d, 16383, 10, 15, 0xa4fffc8d) + EXT( 0xa5a5a48c, 10, 16, 0x00006969) + EXTU(0xa5a5a48c, 10, 16, 0x00006969) + DEP( 0xa5a5a48c, 32767, 10, 16, 0xa5fffc8c) + EXT( 0xa5a5a48b, 10, 17, 0xffff6969) + EXTU(0xa5a5a48b, 10, 17, 0x00016969) + DEP( 0xa5a5a48b, 65535, 10, 17, 0xa3fffc8b) + EXT( 0xa5a5a48a, 10, 18, 0x00016969) + EXTU(0xa5a5a48a, 10, 18, 0x00016969) + DEP( 0xa5a5a48a, 131071, 10, 18, 0xa7fffc8a) + EXT( 0xa5a5a489, 10, 19, 0x00016969) + EXTU(0xa5a5a489, 10, 19, 0x00016969) + DEP( 0xa5a5a489, 262143, 10, 19, 0xaffffc89) + EXT( 0xa5a5a488, 10, 20, 0xfff96969) + EXTU(0xa5a5a488, 10, 20, 0x00096969) + DEP( 0xa5a5a488, 524287, 10, 20, 0x9ffffc88) + EXT( 0xa5a5a487, 10, 21, 0x00096969) + EXTU(0xa5a5a487, 10, 21, 0x00096969) + DEP( 0xa5a5a487, 1048575, 10, 21, 0xbffffc87) + EXT( 0xa5a5a486, 11, 1, 0x00000000) + EXTU(0xa5a5a486, 11, 1, 0x00000000) + DEP( 0xa5a5a486, 0, 11, 1, 0xa5a5a486) + EXT( 0xa5a5a485, 11, 2, 0x00000000) + EXTU(0xa5a5a485, 11, 2, 0x00000000) + DEP( 0xa5a5a485, 1, 11, 2, 0xa5a5ac85) + EXT( 0xa5a5a484, 11, 3, 0xfffffffc) + EXTU(0xa5a5a484, 11, 3, 0x00000004) + DEP( 0xa5a5a484, 3, 11, 3, 0xa5a59c84) + EXT( 0xa5a5a483, 11, 4, 0x00000004) + EXTU(0xa5a5a483, 11, 4, 0x00000004) + DEP( 0xa5a5a483, 7, 11, 4, 0xa5a5bc83) + EXT( 0xa5a5a482, 11, 5, 0xfffffff4) + EXTU(0xa5a5a482, 11, 5, 0x00000014) + DEP( 0xa5a5a482, 15, 11, 5, 0xa5a57c82) + EXT( 0xa5a5a481, 11, 6, 0xfffffff4) + EXTU(0xa5a5a481, 11, 6, 0x00000034) + DEP( 0xa5a5a481, 31, 11, 6, 0xa5a4fc81) + EXT( 0xa5a5a480, 11, 7, 0x00000034) + EXTU(0xa5a5a480, 11, 7, 0x00000034) + DEP( 0xa5a5a480, 63, 11, 7, 0xa5a5fc80) + EXT( 0xa5a5a47f, 11, 8, 0xffffffb4) + EXTU(0xa5a5a47f, 11, 8, 0x000000b4) + DEP( 0xa5a5a47f, 127, 11, 8, 0xa5a3fc7f) + EXT( 0xa5a5a47e, 11, 9, 0x000000b4) + EXTU(0xa5a5a47e, 11, 9, 0x000000b4) + DEP( 0xa5a5a47e, 255, 11, 9, 0xa5a7fc7e) + EXT( 0xa5a5a47d, 11, 10, 0x000000b4) + EXTU(0xa5a5a47d, 11, 10, 0x000000b4) + DEP( 0xa5a5a47d, 511, 11, 10, 0xa5affc7d) + EXT( 0xa5a5a47c, 11, 11, 0xfffffcb4) + EXTU(0xa5a5a47c, 11, 11, 0x000004b4) + DEP( 0xa5a5a47c, 1023, 11, 11, 0xa59ffc7c) + EXT( 0xa5a5a47b, 11, 12, 0x000004b4) + EXTU(0xa5a5a47b, 11, 12, 0x000004b4) + DEP( 0xa5a5a47b, 2047, 11, 12, 0xa5bffc7b) + EXT( 0xa5a5a47a, 11, 13, 0xfffff4b4) + EXTU(0xa5a5a47a, 11, 13, 0x000014b4) + DEP( 0xa5a5a47a, 4095, 11, 13, 0xa57ffc7a) + EXT( 0xa5a5a479, 11, 14, 0xfffff4b4) + EXTU(0xa5a5a479, 11, 14, 0x000034b4) + DEP( 0xa5a5a479, 8191, 11, 14, 0xa4fffc79) + EXT( 0xa5a5a478, 11, 15, 0x000034b4) + EXTU(0xa5a5a478, 11, 15, 0x000034b4) + DEP( 0xa5a5a478, 16383, 11, 15, 0xa5fffc78) + EXT( 0xa5a5a477, 11, 16, 0xffffb4b4) + EXTU(0xa5a5a477, 11, 16, 0x0000b4b4) + DEP( 0xa5a5a477, 32767, 11, 16, 0xa3fffc77) + EXT( 0xa5a5a476, 11, 17, 0x0000b4b4) + EXTU(0xa5a5a476, 11, 17, 0x0000b4b4) + DEP( 0xa5a5a476, 65535, 11, 17, 0xa7fffc76) + EXT( 0xa5a5a475, 11, 18, 0x0000b4b4) + EXTU(0xa5a5a475, 11, 18, 0x0000b4b4) + DEP( 0xa5a5a475, 131071, 11, 18, 0xaffffc75) + EXT( 0xa5a5a474, 11, 19, 0xfffcb4b4) + EXTU(0xa5a5a474, 11, 19, 0x0004b4b4) + DEP( 0xa5a5a474, 262143, 11, 19, 0x9ffffc74) + EXT( 0xa5a5a473, 11, 20, 0x0004b4b4) + EXTU(0xa5a5a473, 11, 20, 0x0004b4b4) + DEP( 0xa5a5a473, 524287, 11, 20, 0xbffffc73) + EXT( 0xa5a5a472, 12, 1, 0x00000000) + EXTU(0xa5a5a472, 12, 1, 0x00000000) + DEP( 0xa5a5a472, 0, 12, 1, 0xa5a5a472) + EXT( 0xa5a5a471, 12, 2, 0xfffffffe) + EXTU(0xa5a5a471, 12, 2, 0x00000002) + DEP( 0xa5a5a471, 1, 12, 2, 0xa5a59471) + EXT( 0xa5a5a470, 12, 3, 0x00000002) + EXTU(0xa5a5a470, 12, 3, 0x00000002) + DEP( 0xa5a5a470, 3, 12, 3, 0xa5a5b470) + EXT( 0xa5a5a46f, 12, 4, 0xfffffffa) + EXTU(0xa5a5a46f, 12, 4, 0x0000000a) + DEP( 0xa5a5a46f, 7, 12, 4, 0xa5a5746f) + EXT( 0xa5a5a46e, 12, 5, 0xfffffffa) + EXTU(0xa5a5a46e, 12, 5, 0x0000001a) + DEP( 0xa5a5a46e, 15, 12, 5, 0xa5a4f46e) + EXT( 0xa5a5a46d, 12, 6, 0x0000001a) + EXTU(0xa5a5a46d, 12, 6, 0x0000001a) + DEP( 0xa5a5a46d, 31, 12, 6, 0xa5a5f46d) + EXT( 0xa5a5a46c, 12, 7, 0xffffffda) + EXTU(0xa5a5a46c, 12, 7, 0x0000005a) + DEP( 0xa5a5a46c, 63, 12, 7, 0xa5a3f46c) + EXT( 0xa5a5a46b, 12, 8, 0x0000005a) + EXTU(0xa5a5a46b, 12, 8, 0x0000005a) + DEP( 0xa5a5a46b, 127, 12, 8, 0xa5a7f46b) + EXT( 0xa5a5a46a, 12, 9, 0x0000005a) + EXTU(0xa5a5a46a, 12, 9, 0x0000005a) + DEP( 0xa5a5a46a, 255, 12, 9, 0xa5aff46a) + EXT( 0xa5a5a469, 12, 10, 0xfffffe5a) + EXTU(0xa5a5a469, 12, 10, 0x0000025a) + DEP( 0xa5a5a469, 511, 12, 10, 0xa59ff469) + EXT( 0xa5a5a468, 12, 11, 0x0000025a) + EXTU(0xa5a5a468, 12, 11, 0x0000025a) + DEP( 0xa5a5a468, 1023, 12, 11, 0xa5bff468) + EXT( 0xa5a5a467, 12, 12, 0xfffffa5a) + EXTU(0xa5a5a467, 12, 12, 0x00000a5a) + DEP( 0xa5a5a467, 2047, 12, 12, 0xa57ff467) + EXT( 0xa5a5a466, 12, 13, 0xfffffa5a) + EXTU(0xa5a5a466, 12, 13, 0x00001a5a) + DEP( 0xa5a5a466, 4095, 12, 13, 0xa4fff466) + EXT( 0xa5a5a465, 12, 14, 0x00001a5a) + EXTU(0xa5a5a465, 12, 14, 0x00001a5a) + DEP( 0xa5a5a465, 8191, 12, 14, 0xa5fff465) + EXT( 0xa5a5a464, 12, 15, 0xffffda5a) + EXTU(0xa5a5a464, 12, 15, 0x00005a5a) + DEP( 0xa5a5a464, 16383, 12, 15, 0xa3fff464) + EXT( 0xa5a5a463, 12, 16, 0x00005a5a) + EXTU(0xa5a5a463, 12, 16, 0x00005a5a) + DEP( 0xa5a5a463, 32767, 12, 16, 0xa7fff463) + EXT( 0xa5a5a462, 12, 17, 0x00005a5a) + EXTU(0xa5a5a462, 12, 17, 0x00005a5a) + DEP( 0xa5a5a462, 65535, 12, 17, 0xaffff462) + EXT( 0xa5a5a461, 12, 18, 0xfffe5a5a) + EXTU(0xa5a5a461, 12, 18, 0x00025a5a) + DEP( 0xa5a5a461, 131071, 12, 18, 0x9ffff461) + EXT( 0xa5a5a460, 12, 19, 0x00025a5a) + EXTU(0xa5a5a460, 12, 19, 0x00025a5a) + DEP( 0xa5a5a460, 262143, 12, 19, 0xbffff460) + EXT( 0xa5a5a45f, 13, 1, 0xffffffff) + EXTU(0xa5a5a45f, 13, 1, 0x00000001) + DEP( 0xa5a5a45f, 0, 13, 1, 0xa5a5845f) + EXT( 0xa5a5a45e, 13, 2, 0x00000001) + EXTU(0xa5a5a45e, 13, 2, 0x00000001) + DEP( 0xa5a5a45e, 1, 13, 2, 0xa5a5a45e) + EXT( 0xa5a5a45d, 13, 3, 0xfffffffd) + EXTU(0xa5a5a45d, 13, 3, 0x00000005) + DEP( 0xa5a5a45d, 3, 13, 3, 0xa5a5645d) + EXT( 0xa5a5a45c, 13, 4, 0xfffffffd) + EXTU(0xa5a5a45c, 13, 4, 0x0000000d) + DEP( 0xa5a5a45c, 7, 13, 4, 0xa5a4e45c) + EXT( 0xa5a5a45b, 13, 5, 0x0000000d) + EXTU(0xa5a5a45b, 13, 5, 0x0000000d) + DEP( 0xa5a5a45b, 15, 13, 5, 0xa5a5e45b) + EXT( 0xa5a5a45a, 13, 6, 0xffffffed) + EXTU(0xa5a5a45a, 13, 6, 0x0000002d) + DEP( 0xa5a5a45a, 31, 13, 6, 0xa5a3e45a) + EXT( 0xa5a5a459, 13, 7, 0x0000002d) + EXTU(0xa5a5a459, 13, 7, 0x0000002d) + DEP( 0xa5a5a459, 63, 13, 7, 0xa5a7e459) + EXT( 0xa5a5a458, 13, 8, 0x0000002d) + EXTU(0xa5a5a458, 13, 8, 0x0000002d) + DEP( 0xa5a5a458, 127, 13, 8, 0xa5afe458) + EXT( 0xa5a5a457, 13, 9, 0xffffff2d) + EXTU(0xa5a5a457, 13, 9, 0x0000012d) + DEP( 0xa5a5a457, 255, 13, 9, 0xa59fe457) + EXT( 0xa5a5a456, 13, 10, 0x0000012d) + EXTU(0xa5a5a456, 13, 10, 0x0000012d) + DEP( 0xa5a5a456, 511, 13, 10, 0xa5bfe456) + EXT( 0xa5a5a455, 13, 11, 0xfffffd2d) + EXTU(0xa5a5a455, 13, 11, 0x0000052d) + DEP( 0xa5a5a455, 1023, 13, 11, 0xa57fe455) + EXT( 0xa5a5a454, 13, 12, 0xfffffd2d) + EXTU(0xa5a5a454, 13, 12, 0x00000d2d) + DEP( 0xa5a5a454, 2047, 13, 12, 0xa4ffe454) + EXT( 0xa5a5a453, 13, 13, 0x00000d2d) + EXTU(0xa5a5a453, 13, 13, 0x00000d2d) + DEP( 0xa5a5a453, 4095, 13, 13, 0xa5ffe453) + EXT( 0xa5a5a452, 13, 14, 0xffffed2d) + EXTU(0xa5a5a452, 13, 14, 0x00002d2d) + DEP( 0xa5a5a452, 8191, 13, 14, 0xa3ffe452) + EXT( 0xa5a5a451, 13, 15, 0x00002d2d) + EXTU(0xa5a5a451, 13, 15, 0x00002d2d) + DEP( 0xa5a5a451, 16383, 13, 15, 0xa7ffe451) + EXT( 0xa5a5a450, 13, 16, 0x00002d2d) + EXTU(0xa5a5a450, 13, 16, 0x00002d2d) + DEP( 0xa5a5a450, 32767, 13, 16, 0xafffe450) + EXT( 0xa5a5a44f, 13, 17, 0xffff2d2d) + EXTU(0xa5a5a44f, 13, 17, 0x00012d2d) + DEP( 0xa5a5a44f, 65535, 13, 17, 0x9fffe44f) + EXT( 0xa5a5a44e, 13, 18, 0x00012d2d) + EXTU(0xa5a5a44e, 13, 18, 0x00012d2d) + DEP( 0xa5a5a44e, 131071, 13, 18, 0xbfffe44e) + EXT( 0xa5a5a44d, 14, 1, 0x00000000) + EXTU(0xa5a5a44d, 14, 1, 0x00000000) + DEP( 0xa5a5a44d, 0, 14, 1, 0xa5a5a44d) + EXT( 0xa5a5a44c, 14, 2, 0xfffffffe) + EXTU(0xa5a5a44c, 14, 2, 0x00000002) + DEP( 0xa5a5a44c, 1, 14, 2, 0xa5a5644c) + EXT( 0xa5a5a44b, 14, 3, 0xfffffffe) + EXTU(0xa5a5a44b, 14, 3, 0x00000006) + DEP( 0xa5a5a44b, 3, 14, 3, 0xa5a4e44b) + EXT( 0xa5a5a44a, 14, 4, 0x00000006) + EXTU(0xa5a5a44a, 14, 4, 0x00000006) + DEP( 0xa5a5a44a, 7, 14, 4, 0xa5a5e44a) + EXT( 0xa5a5a449, 14, 5, 0xfffffff6) + EXTU(0xa5a5a449, 14, 5, 0x00000016) + DEP( 0xa5a5a449, 15, 14, 5, 0xa5a3e449) + EXT( 0xa5a5a448, 14, 6, 0x00000016) + EXTU(0xa5a5a448, 14, 6, 0x00000016) + DEP( 0xa5a5a448, 31, 14, 6, 0xa5a7e448) + EXT( 0xa5a5a447, 14, 7, 0x00000016) + EXTU(0xa5a5a447, 14, 7, 0x00000016) + DEP( 0xa5a5a447, 63, 14, 7, 0xa5afe447) + EXT( 0xa5a5a446, 14, 8, 0xffffff96) + EXTU(0xa5a5a446, 14, 8, 0x00000096) + DEP( 0xa5a5a446, 127, 14, 8, 0xa59fe446) + EXT( 0xa5a5a445, 14, 9, 0x00000096) + EXTU(0xa5a5a445, 14, 9, 0x00000096) + DEP( 0xa5a5a445, 255, 14, 9, 0xa5bfe445) + EXT( 0xa5a5a444, 14, 10, 0xfffffe96) + EXTU(0xa5a5a444, 14, 10, 0x00000296) + DEP( 0xa5a5a444, 511, 14, 10, 0xa57fe444) + EXT( 0xa5a5a443, 14, 11, 0xfffffe96) + EXTU(0xa5a5a443, 14, 11, 0x00000696) + DEP( 0xa5a5a443, 1023, 14, 11, 0xa4ffe443) + EXT( 0xa5a5a442, 14, 12, 0x00000696) + EXTU(0xa5a5a442, 14, 12, 0x00000696) + DEP( 0xa5a5a442, 2047, 14, 12, 0xa5ffe442) + EXT( 0xa5a5a441, 14, 13, 0xfffff696) + EXTU(0xa5a5a441, 14, 13, 0x00001696) + DEP( 0xa5a5a441, 4095, 14, 13, 0xa3ffe441) + EXT( 0xa5a5a440, 14, 14, 0x00001696) + EXTU(0xa5a5a440, 14, 14, 0x00001696) + DEP( 0xa5a5a440, 8191, 14, 14, 0xa7ffe440) + EXT( 0xa5a5a43f, 14, 15, 0x00001696) + EXTU(0xa5a5a43f, 14, 15, 0x00001696) + DEP( 0xa5a5a43f, 16383, 14, 15, 0xafffe43f) + EXT( 0xa5a5a43e, 14, 16, 0xffff9696) + EXTU(0xa5a5a43e, 14, 16, 0x00009696) + DEP( 0xa5a5a43e, 32767, 14, 16, 0x9fffe43e) + EXT( 0xa5a5a43d, 14, 17, 0x00009696) + EXTU(0xa5a5a43d, 14, 17, 0x00009696) + DEP( 0xa5a5a43d, 65535, 14, 17, 0xbfffe43d) + EXT( 0xa5a5a43c, 15, 1, 0xffffffff) + EXTU(0xa5a5a43c, 15, 1, 0x00000001) + DEP( 0xa5a5a43c, 0, 15, 1, 0xa5a5243c) + EXT( 0xa5a5a43b, 15, 2, 0xffffffff) + EXTU(0xa5a5a43b, 15, 2, 0x00000003) + DEP( 0xa5a5a43b, 1, 15, 2, 0xa5a4a43b) + EXT( 0xa5a5a43a, 15, 3, 0x00000003) + EXTU(0xa5a5a43a, 15, 3, 0x00000003) + DEP( 0xa5a5a43a, 3, 15, 3, 0xa5a5a43a) + EXT( 0xa5a5a439, 15, 4, 0xfffffffb) + EXTU(0xa5a5a439, 15, 4, 0x0000000b) + DEP( 0xa5a5a439, 7, 15, 4, 0xa5a3a439) + EXT( 0xa5a5a438, 15, 5, 0x0000000b) + EXTU(0xa5a5a438, 15, 5, 0x0000000b) + DEP( 0xa5a5a438, 15, 15, 5, 0xa5a7a438) + EXT( 0xa5a5a437, 15, 6, 0x0000000b) + EXTU(0xa5a5a437, 15, 6, 0x0000000b) + DEP( 0xa5a5a437, 31, 15, 6, 0xa5afa437) + EXT( 0xa5a5a436, 15, 7, 0xffffffcb) + EXTU(0xa5a5a436, 15, 7, 0x0000004b) + DEP( 0xa5a5a436, 63, 15, 7, 0xa59fa436) + EXT( 0xa5a5a435, 15, 8, 0x0000004b) + EXTU(0xa5a5a435, 15, 8, 0x0000004b) + DEP( 0xa5a5a435, 127, 15, 8, 0xa5bfa435) + EXT( 0xa5a5a434, 15, 9, 0xffffff4b) + EXTU(0xa5a5a434, 15, 9, 0x0000014b) + DEP( 0xa5a5a434, 255, 15, 9, 0xa57fa434) + EXT( 0xa5a5a433, 15, 10, 0xffffff4b) + EXTU(0xa5a5a433, 15, 10, 0x0000034b) + DEP( 0xa5a5a433, 511, 15, 10, 0xa4ffa433) + EXT( 0xa5a5a432, 15, 11, 0x0000034b) + EXTU(0xa5a5a432, 15, 11, 0x0000034b) + DEP( 0xa5a5a432, 1023, 15, 11, 0xa5ffa432) + EXT( 0xa5a5a431, 15, 12, 0xfffffb4b) + EXTU(0xa5a5a431, 15, 12, 0x00000b4b) + DEP( 0xa5a5a431, 2047, 15, 12, 0xa3ffa431) + EXT( 0xa5a5a430, 15, 13, 0x00000b4b) + EXTU(0xa5a5a430, 15, 13, 0x00000b4b) + DEP( 0xa5a5a430, 4095, 15, 13, 0xa7ffa430) + EXT( 0xa5a5a42f, 15, 14, 0x00000b4b) + EXTU(0xa5a5a42f, 15, 14, 0x00000b4b) + DEP( 0xa5a5a42f, 8191, 15, 14, 0xafffa42f) + EXT( 0xa5a5a42e, 15, 15, 0xffffcb4b) + EXTU(0xa5a5a42e, 15, 15, 0x00004b4b) + DEP( 0xa5a5a42e, 16383, 15, 15, 0x9fffa42e) + EXT( 0xa5a5a42d, 15, 16, 0x00004b4b) + EXTU(0xa5a5a42d, 15, 16, 0x00004b4b) + DEP( 0xa5a5a42d, 32767, 15, 16, 0xbfffa42d) + EXT( 0xa5a5a42c, 16, 1, 0xffffffff) + EXTU(0xa5a5a42c, 16, 1, 0x00000001) + DEP( 0xa5a5a42c, 0, 16, 1, 0xa5a4a42c) + EXT( 0xa5a5a42b, 16, 2, 0x00000001) + EXTU(0xa5a5a42b, 16, 2, 0x00000001) + DEP( 0xa5a5a42b, 1, 16, 2, 0xa5a5a42b) + EXT( 0xa5a5a42a, 16, 3, 0xfffffffd) + EXTU(0xa5a5a42a, 16, 3, 0x00000005) + DEP( 0xa5a5a42a, 3, 16, 3, 0xa5a3a42a) + EXT( 0xa5a5a429, 16, 4, 0x00000005) + EXTU(0xa5a5a429, 16, 4, 0x00000005) + DEP( 0xa5a5a429, 7, 16, 4, 0xa5a7a429) + EXT( 0xa5a5a428, 16, 5, 0x00000005) + EXTU(0xa5a5a428, 16, 5, 0x00000005) + DEP( 0xa5a5a428, 15, 16, 5, 0xa5afa428) + EXT( 0xa5a5a427, 16, 6, 0xffffffe5) + EXTU(0xa5a5a427, 16, 6, 0x00000025) + DEP( 0xa5a5a427, 31, 16, 6, 0xa59fa427) + EXT( 0xa5a5a426, 16, 7, 0x00000025) + EXTU(0xa5a5a426, 16, 7, 0x00000025) + DEP( 0xa5a5a426, 63, 16, 7, 0xa5bfa426) + EXT( 0xa5a5a425, 16, 8, 0xffffffa5) + EXTU(0xa5a5a425, 16, 8, 0x000000a5) + DEP( 0xa5a5a425, 127, 16, 8, 0xa57fa425) + EXT( 0xa5a5a424, 16, 9, 0xffffffa5) + EXTU(0xa5a5a424, 16, 9, 0x000001a5) + DEP( 0xa5a5a424, 255, 16, 9, 0xa4ffa424) + EXT( 0xa5a5a423, 16, 10, 0x000001a5) + EXTU(0xa5a5a423, 16, 10, 0x000001a5) + DEP( 0xa5a5a423, 511, 16, 10, 0xa5ffa423) + EXT( 0xa5a5a422, 16, 11, 0xfffffda5) + EXTU(0xa5a5a422, 16, 11, 0x000005a5) + DEP( 0xa5a5a422, 1023, 16, 11, 0xa3ffa422) + EXT( 0xa5a5a421, 16, 12, 0x000005a5) + EXTU(0xa5a5a421, 16, 12, 0x000005a5) + DEP( 0xa5a5a421, 2047, 16, 12, 0xa7ffa421) + EXT( 0xa5a5a420, 16, 13, 0x000005a5) + EXTU(0xa5a5a420, 16, 13, 0x000005a5) + DEP( 0xa5a5a420, 4095, 16, 13, 0xafffa420) + EXT( 0xa5a5a41f, 16, 14, 0xffffe5a5) + EXTU(0xa5a5a41f, 16, 14, 0x000025a5) + DEP( 0xa5a5a41f, 8191, 16, 14, 0x9fffa41f) + EXT( 0xa5a5a41e, 16, 15, 0x000025a5) + EXTU(0xa5a5a41e, 16, 15, 0x000025a5) + DEP( 0xa5a5a41e, 16383, 16, 15, 0xbfffa41e) + EXT( 0xa5a5a41d, 17, 1, 0x00000000) + EXTU(0xa5a5a41d, 17, 1, 0x00000000) + DEP( 0xa5a5a41d, 0, 17, 1, 0xa5a5a41d) + EXT( 0xa5a5a41c, 17, 2, 0xfffffffe) + EXTU(0xa5a5a41c, 17, 2, 0x00000002) + DEP( 0xa5a5a41c, 1, 17, 2, 0xa5a3a41c) + EXT( 0xa5a5a41b, 17, 3, 0x00000002) + EXTU(0xa5a5a41b, 17, 3, 0x00000002) + DEP( 0xa5a5a41b, 3, 17, 3, 0xa5a7a41b) + EXT( 0xa5a5a41a, 17, 4, 0x00000002) + EXTU(0xa5a5a41a, 17, 4, 0x00000002) + DEP( 0xa5a5a41a, 7, 17, 4, 0xa5afa41a) + EXT( 0xa5a5a419, 17, 5, 0xfffffff2) + EXTU(0xa5a5a419, 17, 5, 0x00000012) + DEP( 0xa5a5a419, 15, 17, 5, 0xa59fa419) + EXT( 0xa5a5a418, 17, 6, 0x00000012) + EXTU(0xa5a5a418, 17, 6, 0x00000012) + DEP( 0xa5a5a418, 31, 17, 6, 0xa5bfa418) + EXT( 0xa5a5a417, 17, 7, 0xffffffd2) + EXTU(0xa5a5a417, 17, 7, 0x00000052) + DEP( 0xa5a5a417, 63, 17, 7, 0xa57fa417) + EXT( 0xa5a5a416, 17, 8, 0xffffffd2) + EXTU(0xa5a5a416, 17, 8, 0x000000d2) + DEP( 0xa5a5a416, 127, 17, 8, 0xa4ffa416) + EXT( 0xa5a5a415, 17, 9, 0x000000d2) + EXTU(0xa5a5a415, 17, 9, 0x000000d2) + DEP( 0xa5a5a415, 255, 17, 9, 0xa5ffa415) + EXT( 0xa5a5a414, 17, 10, 0xfffffed2) + EXTU(0xa5a5a414, 17, 10, 0x000002d2) + DEP( 0xa5a5a414, 511, 17, 10, 0xa3ffa414) + EXT( 0xa5a5a413, 17, 11, 0x000002d2) + EXTU(0xa5a5a413, 17, 11, 0x000002d2) + DEP( 0xa5a5a413, 1023, 17, 11, 0xa7ffa413) + EXT( 0xa5a5a412, 17, 12, 0x000002d2) + EXTU(0xa5a5a412, 17, 12, 0x000002d2) + DEP( 0xa5a5a412, 2047, 17, 12, 0xafffa412) + EXT( 0xa5a5a411, 17, 13, 0xfffff2d2) + EXTU(0xa5a5a411, 17, 13, 0x000012d2) + DEP( 0xa5a5a411, 4095, 17, 13, 0x9fffa411) + EXT( 0xa5a5a410, 17, 14, 0x000012d2) + EXTU(0xa5a5a410, 17, 14, 0x000012d2) + DEP( 0xa5a5a410, 8191, 17, 14, 0xbfffa410) + EXT( 0xa5a5a40f, 18, 1, 0xffffffff) + EXTU(0xa5a5a40f, 18, 1, 0x00000001) + DEP( 0xa5a5a40f, 0, 18, 1, 0xa5a1a40f) + EXT( 0xa5a5a40e, 18, 2, 0x00000001) + EXTU(0xa5a5a40e, 18, 2, 0x00000001) + DEP( 0xa5a5a40e, 1, 18, 2, 0xa5a5a40e) + EXT( 0xa5a5a40d, 18, 3, 0x00000001) + EXTU(0xa5a5a40d, 18, 3, 0x00000001) + DEP( 0xa5a5a40d, 3, 18, 3, 0xa5ada40d) + EXT( 0xa5a5a40c, 18, 4, 0xfffffff9) + EXTU(0xa5a5a40c, 18, 4, 0x00000009) + DEP( 0xa5a5a40c, 7, 18, 4, 0xa59da40c) + EXT( 0xa5a5a40b, 18, 5, 0x00000009) + EXTU(0xa5a5a40b, 18, 5, 0x00000009) + DEP( 0xa5a5a40b, 15, 18, 5, 0xa5bda40b) + EXT( 0xa5a5a40a, 18, 6, 0xffffffe9) + EXTU(0xa5a5a40a, 18, 6, 0x00000029) + DEP( 0xa5a5a40a, 31, 18, 6, 0xa57da40a) + EXT( 0xa5a5a409, 18, 7, 0xffffffe9) + EXTU(0xa5a5a409, 18, 7, 0x00000069) + DEP( 0xa5a5a409, 63, 18, 7, 0xa4fda409) + EXT( 0xa5a5a408, 18, 8, 0x00000069) + EXTU(0xa5a5a408, 18, 8, 0x00000069) + DEP( 0xa5a5a408, 127, 18, 8, 0xa5fda408) + EXT( 0xa5a5a407, 18, 9, 0xffffff69) + EXTU(0xa5a5a407, 18, 9, 0x00000169) + DEP( 0xa5a5a407, 255, 18, 9, 0xa3fda407) + EXT( 0xa5a5a406, 18, 10, 0x00000169) + EXTU(0xa5a5a406, 18, 10, 0x00000169) + DEP( 0xa5a5a406, 511, 18, 10, 0xa7fda406) + EXT( 0xa5a5a405, 18, 11, 0x00000169) + EXTU(0xa5a5a405, 18, 11, 0x00000169) + DEP( 0xa5a5a405, 1023, 18, 11, 0xaffda405) + EXT( 0xa5a5a404, 18, 12, 0xfffff969) + EXTU(0xa5a5a404, 18, 12, 0x00000969) + DEP( 0xa5a5a404, 2047, 18, 12, 0x9ffda404) + EXT( 0xa5a5a403, 18, 13, 0x00000969) + EXTU(0xa5a5a403, 18, 13, 0x00000969) + DEP( 0xa5a5a403, 4095, 18, 13, 0xbffda403) + EXT( 0xa5a5a402, 19, 1, 0x00000000) + EXTU(0xa5a5a402, 19, 1, 0x00000000) + DEP( 0xa5a5a402, 0, 19, 1, 0xa5a5a402) + EXT( 0xa5a5a401, 19, 2, 0x00000000) + EXTU(0xa5a5a401, 19, 2, 0x00000000) + DEP( 0xa5a5a401, 1, 19, 2, 0xa5ada401) + EXT( 0xa5a5a400, 19, 3, 0xfffffffc) + EXTU(0xa5a5a400, 19, 3, 0x00000004) + DEP( 0xa5a5a400, 3, 19, 3, 0xa59da400) + EXT( 0xa5a5a3ff, 19, 4, 0x00000004) + EXTU(0xa5a5a3ff, 19, 4, 0x00000004) + DEP( 0xa5a5a3ff, 7, 19, 4, 0xa5bda3ff) + EXT( 0xa5a5a3fe, 19, 5, 0xfffffff4) + EXTU(0xa5a5a3fe, 19, 5, 0x00000014) + DEP( 0xa5a5a3fe, 15, 19, 5, 0xa57da3fe) + EXT( 0xa5a5a3fd, 19, 6, 0xfffffff4) + EXTU(0xa5a5a3fd, 19, 6, 0x00000034) + DEP( 0xa5a5a3fd, 31, 19, 6, 0xa4fda3fd) + EXT( 0xa5a5a3fc, 19, 7, 0x00000034) + EXTU(0xa5a5a3fc, 19, 7, 0x00000034) + DEP( 0xa5a5a3fc, 63, 19, 7, 0xa5fda3fc) + EXT( 0xa5a5a3fb, 19, 8, 0xffffffb4) + EXTU(0xa5a5a3fb, 19, 8, 0x000000b4) + DEP( 0xa5a5a3fb, 127, 19, 8, 0xa3fda3fb) + EXT( 0xa5a5a3fa, 19, 9, 0x000000b4) + EXTU(0xa5a5a3fa, 19, 9, 0x000000b4) + DEP( 0xa5a5a3fa, 255, 19, 9, 0xa7fda3fa) + EXT( 0xa5a5a3f9, 19, 10, 0x000000b4) + EXTU(0xa5a5a3f9, 19, 10, 0x000000b4) + DEP( 0xa5a5a3f9, 511, 19, 10, 0xaffda3f9) + EXT( 0xa5a5a3f8, 19, 11, 0xfffffcb4) + EXTU(0xa5a5a3f8, 19, 11, 0x000004b4) + DEP( 0xa5a5a3f8, 1023, 19, 11, 0x9ffda3f8) + EXT( 0xa5a5a3f7, 19, 12, 0x000004b4) + EXTU(0xa5a5a3f7, 19, 12, 0x000004b4) + DEP( 0xa5a5a3f7, 2047, 19, 12, 0xbffda3f7) + EXT( 0xa5a5a3f6, 20, 1, 0x00000000) + EXTU(0xa5a5a3f6, 20, 1, 0x00000000) + DEP( 0xa5a5a3f6, 0, 20, 1, 0xa5a5a3f6) + EXT( 0xa5a5a3f5, 20, 2, 0xfffffffe) + EXTU(0xa5a5a3f5, 20, 2, 0x00000002) + DEP( 0xa5a5a3f5, 1, 20, 2, 0xa595a3f5) + EXT( 0xa5a5a3f4, 20, 3, 0x00000002) + EXTU(0xa5a5a3f4, 20, 3, 0x00000002) + DEP( 0xa5a5a3f4, 3, 20, 3, 0xa5b5a3f4) + EXT( 0xa5a5a3f3, 20, 4, 0xfffffffa) + EXTU(0xa5a5a3f3, 20, 4, 0x0000000a) + DEP( 0xa5a5a3f3, 7, 20, 4, 0xa575a3f3) + EXT( 0xa5a5a3f2, 20, 5, 0xfffffffa) + EXTU(0xa5a5a3f2, 20, 5, 0x0000001a) + DEP( 0xa5a5a3f2, 15, 20, 5, 0xa4f5a3f2) + EXT( 0xa5a5a3f1, 20, 6, 0x0000001a) + EXTU(0xa5a5a3f1, 20, 6, 0x0000001a) + DEP( 0xa5a5a3f1, 31, 20, 6, 0xa5f5a3f1) + EXT( 0xa5a5a3f0, 20, 7, 0xffffffda) + EXTU(0xa5a5a3f0, 20, 7, 0x0000005a) + DEP( 0xa5a5a3f0, 63, 20, 7, 0xa3f5a3f0) + EXT( 0xa5a5a3ef, 20, 8, 0x0000005a) + EXTU(0xa5a5a3ef, 20, 8, 0x0000005a) + DEP( 0xa5a5a3ef, 127, 20, 8, 0xa7f5a3ef) + EXT( 0xa5a5a3ee, 20, 9, 0x0000005a) + EXTU(0xa5a5a3ee, 20, 9, 0x0000005a) + DEP( 0xa5a5a3ee, 255, 20, 9, 0xaff5a3ee) + EXT( 0xa5a5a3ed, 20, 10, 0xfffffe5a) + EXTU(0xa5a5a3ed, 20, 10, 0x0000025a) + DEP( 0xa5a5a3ed, 511, 20, 10, 0x9ff5a3ed) + EXT( 0xa5a5a3ec, 20, 11, 0x0000025a) + EXTU(0xa5a5a3ec, 20, 11, 0x0000025a) + DEP( 0xa5a5a3ec, 1023, 20, 11, 0xbff5a3ec) + EXT( 0xa5a5a3eb, 21, 1, 0xffffffff) + EXTU(0xa5a5a3eb, 21, 1, 0x00000001) + DEP( 0xa5a5a3eb, 0, 21, 1, 0xa585a3eb) + EXT( 0xa5a5a3ea, 21, 2, 0x00000001) + EXTU(0xa5a5a3ea, 21, 2, 0x00000001) + DEP( 0xa5a5a3ea, 1, 21, 2, 0xa5a5a3ea) + EXT( 0xa5a5a3e9, 21, 3, 0xfffffffd) + EXTU(0xa5a5a3e9, 21, 3, 0x00000005) + DEP( 0xa5a5a3e9, 3, 21, 3, 0xa565a3e9) + EXT( 0xa5a5a3e8, 21, 4, 0xfffffffd) + EXTU(0xa5a5a3e8, 21, 4, 0x0000000d) + DEP( 0xa5a5a3e8, 7, 21, 4, 0xa4e5a3e8) + EXT( 0xa5a5a3e7, 21, 5, 0x0000000d) + EXTU(0xa5a5a3e7, 21, 5, 0x0000000d) + DEP( 0xa5a5a3e7, 15, 21, 5, 0xa5e5a3e7) + EXT( 0xa5a5a3e6, 21, 6, 0xffffffed) + EXTU(0xa5a5a3e6, 21, 6, 0x0000002d) + DEP( 0xa5a5a3e6, 31, 21, 6, 0xa3e5a3e6) + EXT( 0xa5a5a3e5, 21, 7, 0x0000002d) + EXTU(0xa5a5a3e5, 21, 7, 0x0000002d) + DEP( 0xa5a5a3e5, 63, 21, 7, 0xa7e5a3e5) + EXT( 0xa5a5a3e4, 21, 8, 0x0000002d) + EXTU(0xa5a5a3e4, 21, 8, 0x0000002d) + DEP( 0xa5a5a3e4, 127, 21, 8, 0xafe5a3e4) + EXT( 0xa5a5a3e3, 21, 9, 0xffffff2d) + EXTU(0xa5a5a3e3, 21, 9, 0x0000012d) + DEP( 0xa5a5a3e3, 255, 21, 9, 0x9fe5a3e3) + EXT( 0xa5a5a3e2, 21, 10, 0x0000012d) + EXTU(0xa5a5a3e2, 21, 10, 0x0000012d) + DEP( 0xa5a5a3e2, 511, 21, 10, 0xbfe5a3e2) + EXT( 0xa5a5a3e1, 22, 1, 0x00000000) + EXTU(0xa5a5a3e1, 22, 1, 0x00000000) + DEP( 0xa5a5a3e1, 0, 22, 1, 0xa5a5a3e1) + EXT( 0xa5a5a3e0, 22, 2, 0xfffffffe) + EXTU(0xa5a5a3e0, 22, 2, 0x00000002) + DEP( 0xa5a5a3e0, 1, 22, 2, 0xa565a3e0) + EXT( 0xa5a5a3df, 22, 3, 0xfffffffe) + EXTU(0xa5a5a3df, 22, 3, 0x00000006) + DEP( 0xa5a5a3df, 3, 22, 3, 0xa4e5a3df) + EXT( 0xa5a5a3de, 22, 4, 0x00000006) + EXTU(0xa5a5a3de, 22, 4, 0x00000006) + DEP( 0xa5a5a3de, 7, 22, 4, 0xa5e5a3de) + EXT( 0xa5a5a3dd, 22, 5, 0xfffffff6) + EXTU(0xa5a5a3dd, 22, 5, 0x00000016) + DEP( 0xa5a5a3dd, 15, 22, 5, 0xa3e5a3dd) + EXT( 0xa5a5a3dc, 22, 6, 0x00000016) + EXTU(0xa5a5a3dc, 22, 6, 0x00000016) + DEP( 0xa5a5a3dc, 31, 22, 6, 0xa7e5a3dc) + EXT( 0xa5a5a3db, 22, 7, 0x00000016) + EXTU(0xa5a5a3db, 22, 7, 0x00000016) + DEP( 0xa5a5a3db, 63, 22, 7, 0xafe5a3db) + EXT( 0xa5a5a3da, 22, 8, 0xffffff96) + EXTU(0xa5a5a3da, 22, 8, 0x00000096) + DEP( 0xa5a5a3da, 127, 22, 8, 0x9fe5a3da) + EXT( 0xa5a5a3d9, 22, 9, 0x00000096) + EXTU(0xa5a5a3d9, 22, 9, 0x00000096) + DEP( 0xa5a5a3d9, 255, 22, 9, 0xbfe5a3d9) + EXT( 0xa5a5a3d8, 23, 1, 0xffffffff) + EXTU(0xa5a5a3d8, 23, 1, 0x00000001) + DEP( 0xa5a5a3d8, 0, 23, 1, 0xa525a3d8) + EXT( 0xa5a5a3d7, 23, 2, 0xffffffff) + EXTU(0xa5a5a3d7, 23, 2, 0x00000003) + DEP( 0xa5a5a3d7, 1, 23, 2, 0xa4a5a3d7) + EXT( 0xa5a5a3d6, 23, 3, 0x00000003) + EXTU(0xa5a5a3d6, 23, 3, 0x00000003) + DEP( 0xa5a5a3d6, 3, 23, 3, 0xa5a5a3d6) + EXT( 0xa5a5a3d5, 23, 4, 0xfffffffb) + EXTU(0xa5a5a3d5, 23, 4, 0x0000000b) + DEP( 0xa5a5a3d5, 7, 23, 4, 0xa3a5a3d5) + EXT( 0xa5a5a3d4, 23, 5, 0x0000000b) + EXTU(0xa5a5a3d4, 23, 5, 0x0000000b) + DEP( 0xa5a5a3d4, 15, 23, 5, 0xa7a5a3d4) + EXT( 0xa5a5a3d3, 23, 6, 0x0000000b) + EXTU(0xa5a5a3d3, 23, 6, 0x0000000b) + DEP( 0xa5a5a3d3, 31, 23, 6, 0xafa5a3d3) + EXT( 0xa5a5a3d2, 23, 7, 0xffffffcb) + EXTU(0xa5a5a3d2, 23, 7, 0x0000004b) + DEP( 0xa5a5a3d2, 63, 23, 7, 0x9fa5a3d2) + EXT( 0xa5a5a3d1, 23, 8, 0x0000004b) + EXTU(0xa5a5a3d1, 23, 8, 0x0000004b) + DEP( 0xa5a5a3d1, 127, 23, 8, 0xbfa5a3d1) + EXT( 0xa5a5a3d0, 24, 1, 0xffffffff) + EXTU(0xa5a5a3d0, 24, 1, 0x00000001) + DEP( 0xa5a5a3d0, 0, 24, 1, 0xa4a5a3d0) + EXT( 0xa5a5a3cf, 24, 2, 0x00000001) + EXTU(0xa5a5a3cf, 24, 2, 0x00000001) + DEP( 0xa5a5a3cf, 1, 24, 2, 0xa5a5a3cf) + EXT( 0xa5a5a3ce, 24, 3, 0xfffffffd) + EXTU(0xa5a5a3ce, 24, 3, 0x00000005) + DEP( 0xa5a5a3ce, 3, 24, 3, 0xa3a5a3ce) + EXT( 0xa5a5a3cd, 24, 4, 0x00000005) + EXTU(0xa5a5a3cd, 24, 4, 0x00000005) + DEP( 0xa5a5a3cd, 7, 24, 4, 0xa7a5a3cd) + EXT( 0xa5a5a3cc, 24, 5, 0x00000005) + EXTU(0xa5a5a3cc, 24, 5, 0x00000005) + DEP( 0xa5a5a3cc, 15, 24, 5, 0xafa5a3cc) + EXT( 0xa5a5a3cb, 24, 6, 0xffffffe5) + EXTU(0xa5a5a3cb, 24, 6, 0x00000025) + DEP( 0xa5a5a3cb, 31, 24, 6, 0x9fa5a3cb) + EXT( 0xa5a5a3ca, 24, 7, 0x00000025) + EXTU(0xa5a5a3ca, 24, 7, 0x00000025) + DEP( 0xa5a5a3ca, 63, 24, 7, 0xbfa5a3ca) + EXT( 0xa5a5a3c9, 25, 1, 0x00000000) + EXTU(0xa5a5a3c9, 25, 1, 0x00000000) + DEP( 0xa5a5a3c9, 0, 25, 1, 0xa5a5a3c9) + EXT( 0xa5a5a3c8, 25, 2, 0xfffffffe) + EXTU(0xa5a5a3c8, 25, 2, 0x00000002) + DEP( 0xa5a5a3c8, 1, 25, 2, 0xa3a5a3c8) + EXT( 0xa5a5a3c7, 25, 3, 0x00000002) + EXTU(0xa5a5a3c7, 25, 3, 0x00000002) + DEP( 0xa5a5a3c7, 3, 25, 3, 0xa7a5a3c7) + EXT( 0xa5a5a3c6, 25, 4, 0x00000002) + EXTU(0xa5a5a3c6, 25, 4, 0x00000002) + DEP( 0xa5a5a3c6, 7, 25, 4, 0xafa5a3c6) + EXT( 0xa5a5a3c5, 25, 5, 0xfffffff2) + EXTU(0xa5a5a3c5, 25, 5, 0x00000012) + DEP( 0xa5a5a3c5, 15, 25, 5, 0x9fa5a3c5) + EXT( 0xa5a5a3c4, 25, 6, 0x00000012) + EXTU(0xa5a5a3c4, 25, 6, 0x00000012) + DEP( 0xa5a5a3c4, 31, 25, 6, 0xbfa5a3c4) + EXT( 0xa5a5a3c3, 26, 1, 0xffffffff) + EXTU(0xa5a5a3c3, 26, 1, 0x00000001) + DEP( 0xa5a5a3c3, 0, 26, 1, 0xa1a5a3c3) + EXT( 0xa5a5a3c2, 26, 2, 0x00000001) + EXTU(0xa5a5a3c2, 26, 2, 0x00000001) + DEP( 0xa5a5a3c2, 1, 26, 2, 0xa5a5a3c2) + EXT( 0xa5a5a3c1, 26, 3, 0x00000001) + EXTU(0xa5a5a3c1, 26, 3, 0x00000001) + DEP( 0xa5a5a3c1, 3, 26, 3, 0xada5a3c1) + EXT( 0xa5a5a3c0, 26, 4, 0xfffffff9) + EXTU(0xa5a5a3c0, 26, 4, 0x00000009) + DEP( 0xa5a5a3c0, 7, 26, 4, 0x9da5a3c0) + EXT( 0xa5a5a3bf, 26, 5, 0x00000009) + EXTU(0xa5a5a3bf, 26, 5, 0x00000009) + DEP( 0xa5a5a3bf, 15, 26, 5, 0xbda5a3bf) + EXT( 0xa5a5a3be, 27, 1, 0x00000000) + EXTU(0xa5a5a3be, 27, 1, 0x00000000) + DEP( 0xa5a5a3be, 0, 27, 1, 0xa5a5a3be) + EXT( 0xa5a5a3bd, 27, 2, 0x00000000) + EXTU(0xa5a5a3bd, 27, 2, 0x00000000) + DEP( 0xa5a5a3bd, 1, 27, 2, 0xada5a3bd) + EXT( 0xa5a5a3bc, 27, 3, 0xfffffffc) + EXTU(0xa5a5a3bc, 27, 3, 0x00000004) + DEP( 0xa5a5a3bc, 3, 27, 3, 0x9da5a3bc) + EXT( 0xa5a5a3bb, 27, 4, 0x00000004) + EXTU(0xa5a5a3bb, 27, 4, 0x00000004) + DEP( 0xa5a5a3bb, 7, 27, 4, 0xbda5a3bb) + EXT( 0xa5a5a3ba, 28, 1, 0x00000000) + EXTU(0xa5a5a3ba, 28, 1, 0x00000000) + DEP( 0xa5a5a3ba, 0, 28, 1, 0xa5a5a3ba) + EXT( 0xa5a5a3b9, 28, 2, 0xfffffffe) + EXTU(0xa5a5a3b9, 28, 2, 0x00000002) + DEP( 0xa5a5a3b9, 1, 28, 2, 0x95a5a3b9) + EXT( 0xa5a5a3b8, 28, 3, 0x00000002) + EXTU(0xa5a5a3b8, 28, 3, 0x00000002) + DEP( 0xa5a5a3b8, 3, 28, 3, 0xb5a5a3b8) + EXT( 0xa5a5a3b7, 29, 1, 0xffffffff) + EXTU(0xa5a5a3b7, 29, 1, 0x00000001) + DEP( 0xa5a5a3b7, 0, 29, 1, 0x85a5a3b7) + EXT( 0xa5a5a3b6, 29, 2, 0x00000001) + EXTU(0xa5a5a3b6, 29, 2, 0x00000001) + DEP( 0xa5a5a3b6, 1, 29, 2, 0xa5a5a3b6) + EXT( 0xa5a5a3b5, 30, 1, 0x00000000) + EXTU(0xa5a5a3b5, 30, 1, 0x00000000) + DEP( 0xa5a5a3b5, 0, 30, 1, 0xa5a5a3b5) + +# else + EXT( 0xa5a5a5a4, 0, 1, 0xffffffff) + EXTU(0xa5a5a5a4, 0, 1, 0x00000001) + DEP( 0xa5a5a5a4, 0, 0, 1, 0x25a5a5a4) + EXT( 0xa5a5a5a3, 0, 2, 0xfffffffe) + EXTU(0xa5a5a5a3, 0, 2, 0x00000002) + DEP( 0xa5a5a5a3, 1, 0, 2, 0x65a5a5a3) + EXT( 0xa5a5a5a2, 0, 3, 0xfffffffd) + EXTU(0xa5a5a5a2, 0, 3, 0x00000005) + DEP( 0xa5a5a5a2, 3, 0, 3, 0x65a5a5a2) + EXT( 0xa5a5a5a1, 0, 4, 0xfffffffa) + EXTU(0xa5a5a5a1, 0, 4, 0x0000000a) + DEP( 0xa5a5a5a1, 7, 0, 4, 0x75a5a5a1) + EXT( 0xa5a5a5a0, 0, 5, 0xfffffff4) + EXTU(0xa5a5a5a0, 0, 5, 0x00000014) + DEP( 0xa5a5a5a0, 15, 0, 5, 0x7da5a5a0) + EXT( 0xa5a5a59f, 0, 6, 0xffffffe9) + EXTU(0xa5a5a59f, 0, 6, 0x00000029) + DEP( 0xa5a5a59f, 31, 0, 6, 0x7da5a59f) + EXT( 0xa5a5a59e, 0, 7, 0xffffffd2) + EXTU(0xa5a5a59e, 0, 7, 0x00000052) + DEP( 0xa5a5a59e, 63, 0, 7, 0x7fa5a59e) + EXT( 0xa5a5a59d, 0, 8, 0xffffffa5) + EXTU(0xa5a5a59d, 0, 8, 0x000000a5) + DEP( 0xa5a5a59d, 127, 0, 8, 0x7fa5a59d) + EXT( 0xa5a5a59c, 0, 9, 0xffffff4b) + EXTU(0xa5a5a59c, 0, 9, 0x0000014b) + DEP( 0xa5a5a59c, 255, 0, 9, 0x7fa5a59c) + EXT( 0xa5a5a59b, 0, 10, 0xfffffe96) + EXTU(0xa5a5a59b, 0, 10, 0x00000296) + DEP( 0xa5a5a59b, 511, 0, 10, 0x7fe5a59b) + EXT( 0xa5a5a59a, 0, 11, 0xfffffd2d) + EXTU(0xa5a5a59a, 0, 11, 0x0000052d) + DEP( 0xa5a5a59a, 1023, 0, 11, 0x7fe5a59a) + EXT( 0xa5a5a599, 0, 12, 0xfffffa5a) + EXTU(0xa5a5a599, 0, 12, 0x00000a5a) + DEP( 0xa5a5a599, 2047, 0, 12, 0x7ff5a599) + EXT( 0xa5a5a598, 0, 13, 0xfffff4b4) + EXTU(0xa5a5a598, 0, 13, 0x000014b4) + DEP( 0xa5a5a598, 4095, 0, 13, 0x7ffda598) + EXT( 0xa5a5a597, 0, 14, 0xffffe969) + EXTU(0xa5a5a597, 0, 14, 0x00002969) + DEP( 0xa5a5a597, 8191, 0, 14, 0x7ffda597) + EXT( 0xa5a5a596, 0, 15, 0xffffd2d2) + EXTU(0xa5a5a596, 0, 15, 0x000052d2) + DEP( 0xa5a5a596, 16383, 0, 15, 0x7fffa596) + EXT( 0xa5a5a595, 0, 16, 0xffffa5a5) + EXTU(0xa5a5a595, 0, 16, 0x0000a5a5) + DEP( 0xa5a5a595, 32767, 0, 16, 0x7fffa595) + EXT( 0xa5a5a594, 0, 17, 0xffff4b4b) + EXTU(0xa5a5a594, 0, 17, 0x00014b4b) + DEP( 0xa5a5a594, 65535, 0, 17, 0x7fffa594) + EXT( 0xa5a5a593, 0, 18, 0xfffe9696) + EXTU(0xa5a5a593, 0, 18, 0x00029696) + DEP( 0xa5a5a593, 131071, 0, 18, 0x7fffe593) + EXT( 0xa5a5a592, 0, 19, 0xfffd2d2d) + EXTU(0xa5a5a592, 0, 19, 0x00052d2d) + DEP( 0xa5a5a592, 262143, 0, 19, 0x7fffe592) + EXT( 0xa5a5a591, 0, 20, 0xfffa5a5a) + EXTU(0xa5a5a591, 0, 20, 0x000a5a5a) + DEP( 0xa5a5a591, 524287, 0, 20, 0x7ffff591) + EXT( 0xa5a5a590, 0, 21, 0xfff4b4b4) + EXTU(0xa5a5a590, 0, 21, 0x0014b4b4) + DEP( 0xa5a5a590, 1048575, 0, 21, 0x7ffffd90) + EXT( 0xa5a5a58f, 0, 22, 0xffe96969) + EXTU(0xa5a5a58f, 0, 22, 0x00296969) + DEP( 0xa5a5a58f, 2097151, 0, 22, 0x7ffffd8f) + EXT( 0xa5a5a58e, 0, 23, 0xffd2d2d2) + EXTU(0xa5a5a58e, 0, 23, 0x0052d2d2) + DEP( 0xa5a5a58e, 4194303, 0, 23, 0x7fffff8e) + EXT( 0xa5a5a58d, 0, 24, 0xffa5a5a5) + EXTU(0xa5a5a58d, 0, 24, 0x00a5a5a5) + DEP( 0xa5a5a58d, 8388607, 0, 24, 0x7fffff8d) + EXT( 0xa5a5a58c, 0, 25, 0xff4b4b4b) + EXTU(0xa5a5a58c, 0, 25, 0x014b4b4b) + DEP( 0xa5a5a58c, 16777215, 0, 25, 0x7fffff8c) + EXT( 0xa5a5a58b, 0, 26, 0xfe969696) + EXTU(0xa5a5a58b, 0, 26, 0x02969696) + DEP( 0xa5a5a58b, 33554431, 0, 26, 0x7fffffcb) + EXT( 0xa5a5a58a, 0, 27, 0xfd2d2d2c) + EXTU(0xa5a5a58a, 0, 27, 0x052d2d2c) + DEP( 0xa5a5a58a, 67108863, 0, 27, 0x7fffffea) + EXT( 0xa5a5a589, 0, 28, 0xfa5a5a58) + EXTU(0xa5a5a589, 0, 28, 0x0a5a5a58) + DEP( 0xa5a5a589, 134217727, 0, 28, 0x7ffffff9) + EXT( 0xa5a5a588, 0, 29, 0xf4b4b4b1) + EXTU(0xa5a5a588, 0, 29, 0x14b4b4b1) + DEP( 0xa5a5a588, 268435455, 0, 29, 0x7ffffff8) + EXT( 0xa5a5a587, 0, 30, 0xe9696961) + EXTU(0xa5a5a587, 0, 30, 0x29696961) + DEP( 0xa5a5a587, 536870911, 0, 30, 0x7fffffff) + EXT( 0xa5a5a586, 0, 31, 0xd2d2d2c3) + EXTU(0xa5a5a586, 0, 31, 0x52d2d2c3) + DEP( 0xa5a5a586, 1073741823, 0, 31, 0x7ffffffe) + EXT( 0xa5a5a585, 1, 1, 0x00000000) + EXTU(0xa5a5a585, 1, 1, 0x00000000) + DEP( 0xa5a5a585, 0, 1, 1, 0xa5a5a585) + EXT( 0xa5a5a584, 1, 2, 0x00000001) + EXTU(0xa5a5a584, 1, 2, 0x00000001) + DEP( 0xa5a5a584, 1, 1, 2, 0xa5a5a584) + EXT( 0xa5a5a583, 1, 3, 0x00000002) + EXTU(0xa5a5a583, 1, 3, 0x00000002) + DEP( 0xa5a5a583, 3, 1, 3, 0xb5a5a583) + EXT( 0xa5a5a582, 1, 4, 0x00000004) + EXTU(0xa5a5a582, 1, 4, 0x00000004) + DEP( 0xa5a5a582, 7, 1, 4, 0xbda5a582) + EXT( 0xa5a5a581, 1, 5, 0x00000009) + EXTU(0xa5a5a581, 1, 5, 0x00000009) + DEP( 0xa5a5a581, 15, 1, 5, 0xbda5a581) + EXT( 0xa5a5a580, 1, 6, 0x00000012) + EXTU(0xa5a5a580, 1, 6, 0x00000012) + DEP( 0xa5a5a580, 31, 1, 6, 0xbfa5a580) + EXT( 0xa5a5a57f, 1, 7, 0x00000025) + EXTU(0xa5a5a57f, 1, 7, 0x00000025) + DEP( 0xa5a5a57f, 63, 1, 7, 0xbfa5a57f) + EXT( 0xa5a5a57e, 1, 8, 0x0000004b) + EXTU(0xa5a5a57e, 1, 8, 0x0000004b) + DEP( 0xa5a5a57e, 127, 1, 8, 0xbfa5a57e) + EXT( 0xa5a5a57d, 1, 9, 0x00000096) + EXTU(0xa5a5a57d, 1, 9, 0x00000096) + DEP( 0xa5a5a57d, 255, 1, 9, 0xbfe5a57d) + EXT( 0xa5a5a57c, 1, 10, 0x0000012d) + EXTU(0xa5a5a57c, 1, 10, 0x0000012d) + DEP( 0xa5a5a57c, 511, 1, 10, 0xbfe5a57c) + EXT( 0xa5a5a57b, 1, 11, 0x0000025a) + EXTU(0xa5a5a57b, 1, 11, 0x0000025a) + DEP( 0xa5a5a57b, 1023, 1, 11, 0xbff5a57b) + EXT( 0xa5a5a57a, 1, 12, 0x000004b4) + EXTU(0xa5a5a57a, 1, 12, 0x000004b4) + DEP( 0xa5a5a57a, 2047, 1, 12, 0xbffda57a) + EXT( 0xa5a5a579, 1, 13, 0x00000969) + EXTU(0xa5a5a579, 1, 13, 0x00000969) + DEP( 0xa5a5a579, 4095, 1, 13, 0xbffda579) + EXT( 0xa5a5a578, 1, 14, 0x000012d2) + EXTU(0xa5a5a578, 1, 14, 0x000012d2) + DEP( 0xa5a5a578, 8191, 1, 14, 0xbfffa578) + EXT( 0xa5a5a577, 1, 15, 0x000025a5) + EXTU(0xa5a5a577, 1, 15, 0x000025a5) + DEP( 0xa5a5a577, 16383, 1, 15, 0xbfffa577) + EXT( 0xa5a5a576, 1, 16, 0x00004b4b) + EXTU(0xa5a5a576, 1, 16, 0x00004b4b) + DEP( 0xa5a5a576, 32767, 1, 16, 0xbfffa576) + EXT( 0xa5a5a575, 1, 17, 0x00009696) + EXTU(0xa5a5a575, 1, 17, 0x00009696) + DEP( 0xa5a5a575, 65535, 1, 17, 0xbfffe575) + EXT( 0xa5a5a574, 1, 18, 0x00012d2d) + EXTU(0xa5a5a574, 1, 18, 0x00012d2d) + DEP( 0xa5a5a574, 131071, 1, 18, 0xbfffe574) + EXT( 0xa5a5a573, 1, 19, 0x00025a5a) + EXTU(0xa5a5a573, 1, 19, 0x00025a5a) + DEP( 0xa5a5a573, 262143, 1, 19, 0xbffff573) + EXT( 0xa5a5a572, 1, 20, 0x0004b4b4) + EXTU(0xa5a5a572, 1, 20, 0x0004b4b4) + DEP( 0xa5a5a572, 524287, 1, 20, 0xbffffd72) + EXT( 0xa5a5a571, 1, 21, 0x00096969) + EXTU(0xa5a5a571, 1, 21, 0x00096969) + DEP( 0xa5a5a571, 1048575, 1, 21, 0xbffffd71) + EXT( 0xa5a5a570, 1, 22, 0x0012d2d2) + EXTU(0xa5a5a570, 1, 22, 0x0012d2d2) + DEP( 0xa5a5a570, 2097151, 1, 22, 0xbfffff70) + EXT( 0xa5a5a56f, 1, 23, 0x0025a5a5) + EXTU(0xa5a5a56f, 1, 23, 0x0025a5a5) + DEP( 0xa5a5a56f, 4194303, 1, 23, 0xbfffff6f) + EXT( 0xa5a5a56e, 1, 24, 0x004b4b4a) + EXTU(0xa5a5a56e, 1, 24, 0x004b4b4a) + DEP( 0xa5a5a56e, 8388607, 1, 24, 0xbfffffee) + EXT( 0xa5a5a56d, 1, 25, 0x00969695) + EXTU(0xa5a5a56d, 1, 25, 0x00969695) + DEP( 0xa5a5a56d, 16777215, 1, 25, 0xbfffffed) + EXT( 0xa5a5a56c, 1, 26, 0x012d2d2b) + EXTU(0xa5a5a56c, 1, 26, 0x012d2d2b) + DEP( 0xa5a5a56c, 33554431, 1, 26, 0xbfffffec) + EXT( 0xa5a5a56b, 1, 27, 0x025a5a56) + EXTU(0xa5a5a56b, 1, 27, 0x025a5a56) + DEP( 0xa5a5a56b, 67108863, 1, 27, 0xbffffffb) + EXT( 0xa5a5a56a, 1, 28, 0x04b4b4ad) + EXTU(0xa5a5a56a, 1, 28, 0x04b4b4ad) + DEP( 0xa5a5a56a, 134217727, 1, 28, 0xbffffffa) + EXT( 0xa5a5a569, 1, 29, 0x0969695a) + EXTU(0xa5a5a569, 1, 29, 0x0969695a) + DEP( 0xa5a5a569, 268435455, 1, 29, 0xbffffffd) + EXT( 0xa5a5a568, 1, 30, 0x12d2d2b4) + EXTU(0xa5a5a568, 1, 30, 0x12d2d2b4) + DEP( 0xa5a5a568, 536870911, 1, 30, 0xbffffffe) + EXT( 0xa5a5a567, 2, 1, 0xffffffff) + EXTU(0xa5a5a567, 2, 1, 0x00000001) + DEP( 0xa5a5a567, 0, 2, 1, 0x85a5a567) + EXT( 0xa5a5a566, 2, 2, 0xfffffffe) + EXTU(0xa5a5a566, 2, 2, 0x00000002) + DEP( 0xa5a5a566, 1, 2, 2, 0x95a5a566) + EXT( 0xa5a5a565, 2, 3, 0xfffffffc) + EXTU(0xa5a5a565, 2, 3, 0x00000004) + DEP( 0xa5a5a565, 3, 2, 3, 0x9da5a565) + EXT( 0xa5a5a564, 2, 4, 0xfffffff9) + EXTU(0xa5a5a564, 2, 4, 0x00000009) + DEP( 0xa5a5a564, 7, 2, 4, 0x9da5a564) + EXT( 0xa5a5a563, 2, 5, 0xfffffff2) + EXTU(0xa5a5a563, 2, 5, 0x00000012) + DEP( 0xa5a5a563, 15, 2, 5, 0x9fa5a563) + EXT( 0xa5a5a562, 2, 6, 0xffffffe5) + EXTU(0xa5a5a562, 2, 6, 0x00000025) + DEP( 0xa5a5a562, 31, 2, 6, 0x9fa5a562) + EXT( 0xa5a5a561, 2, 7, 0xffffffcb) + EXTU(0xa5a5a561, 2, 7, 0x0000004b) + DEP( 0xa5a5a561, 63, 2, 7, 0x9fa5a561) + EXT( 0xa5a5a560, 2, 8, 0xffffff96) + EXTU(0xa5a5a560, 2, 8, 0x00000096) + DEP( 0xa5a5a560, 127, 2, 8, 0x9fe5a560) + EXT( 0xa5a5a55f, 2, 9, 0xffffff2d) + EXTU(0xa5a5a55f, 2, 9, 0x0000012d) + DEP( 0xa5a5a55f, 255, 2, 9, 0x9fe5a55f) + EXT( 0xa5a5a55e, 2, 10, 0xfffffe5a) + EXTU(0xa5a5a55e, 2, 10, 0x0000025a) + DEP( 0xa5a5a55e, 511, 2, 10, 0x9ff5a55e) + EXT( 0xa5a5a55d, 2, 11, 0xfffffcb4) + EXTU(0xa5a5a55d, 2, 11, 0x000004b4) + DEP( 0xa5a5a55d, 1023, 2, 11, 0x9ffda55d) + EXT( 0xa5a5a55c, 2, 12, 0xfffff969) + EXTU(0xa5a5a55c, 2, 12, 0x00000969) + DEP( 0xa5a5a55c, 2047, 2, 12, 0x9ffda55c) + EXT( 0xa5a5a55b, 2, 13, 0xfffff2d2) + EXTU(0xa5a5a55b, 2, 13, 0x000012d2) + DEP( 0xa5a5a55b, 4095, 2, 13, 0x9fffa55b) + EXT( 0xa5a5a55a, 2, 14, 0xffffe5a5) + EXTU(0xa5a5a55a, 2, 14, 0x000025a5) + DEP( 0xa5a5a55a, 8191, 2, 14, 0x9fffa55a) + EXT( 0xa5a5a559, 2, 15, 0xffffcb4b) + EXTU(0xa5a5a559, 2, 15, 0x00004b4b) + DEP( 0xa5a5a559, 16383, 2, 15, 0x9fffa559) + EXT( 0xa5a5a558, 2, 16, 0xffff9696) + EXTU(0xa5a5a558, 2, 16, 0x00009696) + DEP( 0xa5a5a558, 32767, 2, 16, 0x9fffe558) + EXT( 0xa5a5a557, 2, 17, 0xffff2d2d) + EXTU(0xa5a5a557, 2, 17, 0x00012d2d) + DEP( 0xa5a5a557, 65535, 2, 17, 0x9fffe557) + EXT( 0xa5a5a556, 2, 18, 0xfffe5a5a) + EXTU(0xa5a5a556, 2, 18, 0x00025a5a) + DEP( 0xa5a5a556, 131071, 2, 18, 0x9ffff556) + EXT( 0xa5a5a555, 2, 19, 0xfffcb4b4) + EXTU(0xa5a5a555, 2, 19, 0x0004b4b4) + DEP( 0xa5a5a555, 262143, 2, 19, 0x9ffffd55) + EXT( 0xa5a5a554, 2, 20, 0xfff96969) + EXTU(0xa5a5a554, 2, 20, 0x00096969) + DEP( 0xa5a5a554, 524287, 2, 20, 0x9ffffd54) + EXT( 0xa5a5a553, 2, 21, 0xfff2d2d2) + EXTU(0xa5a5a553, 2, 21, 0x0012d2d2) + DEP( 0xa5a5a553, 1048575, 2, 21, 0x9fffff53) + EXT( 0xa5a5a552, 2, 22, 0xffe5a5a5) + EXTU(0xa5a5a552, 2, 22, 0x0025a5a5) + DEP( 0xa5a5a552, 2097151, 2, 22, 0x9fffff52) + EXT( 0xa5a5a551, 2, 23, 0xffcb4b4a) + EXTU(0xa5a5a551, 2, 23, 0x004b4b4a) + DEP( 0xa5a5a551, 4194303, 2, 23, 0x9fffffd1) + EXT( 0xa5a5a550, 2, 24, 0xff969695) + EXTU(0xa5a5a550, 2, 24, 0x00969695) + DEP( 0xa5a5a550, 8388607, 2, 24, 0x9fffffd0) + EXT( 0xa5a5a54f, 2, 25, 0xff2d2d2a) + EXTU(0xa5a5a54f, 2, 25, 0x012d2d2a) + DEP( 0xa5a5a54f, 16777215, 2, 25, 0x9fffffef) + EXT( 0xa5a5a54e, 2, 26, 0xfe5a5a54) + EXTU(0xa5a5a54e, 2, 26, 0x025a5a54) + DEP( 0xa5a5a54e, 33554431, 2, 26, 0x9ffffffe) + EXT( 0xa5a5a54d, 2, 27, 0xfcb4b4a9) + EXTU(0xa5a5a54d, 2, 27, 0x04b4b4a9) + DEP( 0xa5a5a54d, 67108863, 2, 27, 0x9ffffffd) + EXT( 0xa5a5a54c, 2, 28, 0xf9696953) + EXTU(0xa5a5a54c, 2, 28, 0x09696953) + DEP( 0xa5a5a54c, 134217727, 2, 28, 0x9ffffffc) + EXT( 0xa5a5a54b, 2, 29, 0xf2d2d2a5) + EXTU(0xa5a5a54b, 2, 29, 0x12d2d2a5) + DEP( 0xa5a5a54b, 268435455, 2, 29, 0x9fffffff) + EXT( 0xa5a5a54a, 3, 1, 0x00000000) + EXTU(0xa5a5a54a, 3, 1, 0x00000000) + DEP( 0xa5a5a54a, 0, 3, 1, 0xa5a5a54a) + EXT( 0xa5a5a549, 3, 2, 0x00000000) + EXTU(0xa5a5a549, 3, 2, 0x00000000) + DEP( 0xa5a5a549, 1, 3, 2, 0xada5a549) + EXT( 0xa5a5a548, 3, 3, 0x00000001) + EXTU(0xa5a5a548, 3, 3, 0x00000001) + DEP( 0xa5a5a548, 3, 3, 3, 0xada5a548) + EXT( 0xa5a5a547, 3, 4, 0x00000002) + EXTU(0xa5a5a547, 3, 4, 0x00000002) + DEP( 0xa5a5a547, 7, 3, 4, 0xafa5a547) + EXT( 0xa5a5a546, 3, 5, 0x00000005) + EXTU(0xa5a5a546, 3, 5, 0x00000005) + DEP( 0xa5a5a546, 15, 3, 5, 0xafa5a546) + EXT( 0xa5a5a545, 3, 6, 0x0000000b) + EXTU(0xa5a5a545, 3, 6, 0x0000000b) + DEP( 0xa5a5a545, 31, 3, 6, 0xafa5a545) + EXT( 0xa5a5a544, 3, 7, 0x00000016) + EXTU(0xa5a5a544, 3, 7, 0x00000016) + DEP( 0xa5a5a544, 63, 3, 7, 0xafe5a544) + EXT( 0xa5a5a543, 3, 8, 0x0000002d) + EXTU(0xa5a5a543, 3, 8, 0x0000002d) + DEP( 0xa5a5a543, 127, 3, 8, 0xafe5a543) + EXT( 0xa5a5a542, 3, 9, 0x0000005a) + EXTU(0xa5a5a542, 3, 9, 0x0000005a) + DEP( 0xa5a5a542, 255, 3, 9, 0xaff5a542) + EXT( 0xa5a5a541, 3, 10, 0x000000b4) + EXTU(0xa5a5a541, 3, 10, 0x000000b4) + DEP( 0xa5a5a541, 511, 3, 10, 0xaffda541) + EXT( 0xa5a5a540, 3, 11, 0x00000169) + EXTU(0xa5a5a540, 3, 11, 0x00000169) + DEP( 0xa5a5a540, 1023, 3, 11, 0xaffda540) + EXT( 0xa5a5a53f, 3, 12, 0x000002d2) + EXTU(0xa5a5a53f, 3, 12, 0x000002d2) + DEP( 0xa5a5a53f, 2047, 3, 12, 0xafffa53f) + EXT( 0xa5a5a53e, 3, 13, 0x000005a5) + EXTU(0xa5a5a53e, 3, 13, 0x000005a5) + DEP( 0xa5a5a53e, 4095, 3, 13, 0xafffa53e) + EXT( 0xa5a5a53d, 3, 14, 0x00000b4b) + EXTU(0xa5a5a53d, 3, 14, 0x00000b4b) + DEP( 0xa5a5a53d, 8191, 3, 14, 0xafffa53d) + EXT( 0xa5a5a53c, 3, 15, 0x00001696) + EXTU(0xa5a5a53c, 3, 15, 0x00001696) + DEP( 0xa5a5a53c, 16383, 3, 15, 0xafffe53c) + EXT( 0xa5a5a53b, 3, 16, 0x00002d2d) + EXTU(0xa5a5a53b, 3, 16, 0x00002d2d) + DEP( 0xa5a5a53b, 32767, 3, 16, 0xafffe53b) + EXT( 0xa5a5a53a, 3, 17, 0x00005a5a) + EXTU(0xa5a5a53a, 3, 17, 0x00005a5a) + DEP( 0xa5a5a53a, 65535, 3, 17, 0xaffff53a) + EXT( 0xa5a5a539, 3, 18, 0x0000b4b4) + EXTU(0xa5a5a539, 3, 18, 0x0000b4b4) + DEP( 0xa5a5a539, 131071, 3, 18, 0xaffffd39) + EXT( 0xa5a5a538, 3, 19, 0x00016969) + EXTU(0xa5a5a538, 3, 19, 0x00016969) + DEP( 0xa5a5a538, 262143, 3, 19, 0xaffffd38) + EXT( 0xa5a5a537, 3, 20, 0x0002d2d2) + EXTU(0xa5a5a537, 3, 20, 0x0002d2d2) + DEP( 0xa5a5a537, 524287, 3, 20, 0xafffff37) + EXT( 0xa5a5a536, 3, 21, 0x0005a5a5) + EXTU(0xa5a5a536, 3, 21, 0x0005a5a5) + DEP( 0xa5a5a536, 1048575, 3, 21, 0xafffff36) + EXT( 0xa5a5a535, 3, 22, 0x000b4b4a) + EXTU(0xa5a5a535, 3, 22, 0x000b4b4a) + DEP( 0xa5a5a535, 2097151, 3, 22, 0xafffffb5) + EXT( 0xa5a5a534, 3, 23, 0x00169694) + EXTU(0xa5a5a534, 3, 23, 0x00169694) + DEP( 0xa5a5a534, 4194303, 3, 23, 0xaffffff4) + EXT( 0xa5a5a533, 3, 24, 0x002d2d29) + EXTU(0xa5a5a533, 3, 24, 0x002d2d29) + DEP( 0xa5a5a533, 8388607, 3, 24, 0xaffffff3) + EXT( 0xa5a5a532, 3, 25, 0x005a5a53) + EXTU(0xa5a5a532, 3, 25, 0x005a5a53) + DEP( 0xa5a5a532, 16777215, 3, 25, 0xaffffff2) + EXT( 0xa5a5a531, 3, 26, 0x00b4b4a6) + EXTU(0xa5a5a531, 3, 26, 0x00b4b4a6) + DEP( 0xa5a5a531, 33554431, 3, 26, 0xaffffff9) + EXT( 0xa5a5a530, 3, 27, 0x0169694c) + EXTU(0xa5a5a530, 3, 27, 0x0169694c) + DEP( 0xa5a5a530, 67108863, 3, 27, 0xaffffffc) + EXT( 0xa5a5a52f, 3, 28, 0x02d2d297) + EXTU(0xa5a5a52f, 3, 28, 0x02d2d297) + DEP( 0xa5a5a52f, 134217727, 3, 28, 0xafffffff) + EXT( 0xa5a5a52e, 4, 1, 0x00000000) + EXTU(0xa5a5a52e, 4, 1, 0x00000000) + DEP( 0xa5a5a52e, 0, 4, 1, 0xa5a5a52e) + EXT( 0xa5a5a52d, 4, 2, 0x00000001) + EXTU(0xa5a5a52d, 4, 2, 0x00000001) + DEP( 0xa5a5a52d, 1, 4, 2, 0xa5a5a52d) + EXT( 0xa5a5a52c, 4, 3, 0x00000002) + EXTU(0xa5a5a52c, 4, 3, 0x00000002) + DEP( 0xa5a5a52c, 3, 4, 3, 0xa7a5a52c) + EXT( 0xa5a5a52b, 4, 4, 0x00000005) + EXTU(0xa5a5a52b, 4, 4, 0x00000005) + DEP( 0xa5a5a52b, 7, 4, 4, 0xa7a5a52b) + EXT( 0xa5a5a52a, 4, 5, 0x0000000b) + EXTU(0xa5a5a52a, 4, 5, 0x0000000b) + DEP( 0xa5a5a52a, 15, 4, 5, 0xa7a5a52a) + EXT( 0xa5a5a529, 4, 6, 0x00000016) + EXTU(0xa5a5a529, 4, 6, 0x00000016) + DEP( 0xa5a5a529, 31, 4, 6, 0xa7e5a529) + EXT( 0xa5a5a528, 4, 7, 0x0000002d) + EXTU(0xa5a5a528, 4, 7, 0x0000002d) + DEP( 0xa5a5a528, 63, 4, 7, 0xa7e5a528) + EXT( 0xa5a5a527, 4, 8, 0x0000005a) + EXTU(0xa5a5a527, 4, 8, 0x0000005a) + DEP( 0xa5a5a527, 127, 4, 8, 0xa7f5a527) + EXT( 0xa5a5a526, 4, 9, 0x000000b4) + EXTU(0xa5a5a526, 4, 9, 0x000000b4) + DEP( 0xa5a5a526, 255, 4, 9, 0xa7fda526) + EXT( 0xa5a5a525, 4, 10, 0x00000169) + EXTU(0xa5a5a525, 4, 10, 0x00000169) + DEP( 0xa5a5a525, 511, 4, 10, 0xa7fda525) + EXT( 0xa5a5a524, 4, 11, 0x000002d2) + EXTU(0xa5a5a524, 4, 11, 0x000002d2) + DEP( 0xa5a5a524, 1023, 4, 11, 0xa7ffa524) + EXT( 0xa5a5a523, 4, 12, 0x000005a5) + EXTU(0xa5a5a523, 4, 12, 0x000005a5) + DEP( 0xa5a5a523, 2047, 4, 12, 0xa7ffa523) + EXT( 0xa5a5a522, 4, 13, 0x00000b4b) + EXTU(0xa5a5a522, 4, 13, 0x00000b4b) + DEP( 0xa5a5a522, 4095, 4, 13, 0xa7ffa522) + EXT( 0xa5a5a521, 4, 14, 0x00001696) + EXTU(0xa5a5a521, 4, 14, 0x00001696) + DEP( 0xa5a5a521, 8191, 4, 14, 0xa7ffe521) + EXT( 0xa5a5a520, 4, 15, 0x00002d2d) + EXTU(0xa5a5a520, 4, 15, 0x00002d2d) + DEP( 0xa5a5a520, 16383, 4, 15, 0xa7ffe520) + EXT( 0xa5a5a51f, 4, 16, 0x00005a5a) + EXTU(0xa5a5a51f, 4, 16, 0x00005a5a) + DEP( 0xa5a5a51f, 32767, 4, 16, 0xa7fff51f) + EXT( 0xa5a5a51e, 4, 17, 0x0000b4b4) + EXTU(0xa5a5a51e, 4, 17, 0x0000b4b4) + DEP( 0xa5a5a51e, 65535, 4, 17, 0xa7fffd1e) + EXT( 0xa5a5a51d, 4, 18, 0x00016969) + EXTU(0xa5a5a51d, 4, 18, 0x00016969) + DEP( 0xa5a5a51d, 131071, 4, 18, 0xa7fffd1d) + EXT( 0xa5a5a51c, 4, 19, 0x0002d2d2) + EXTU(0xa5a5a51c, 4, 19, 0x0002d2d2) + DEP( 0xa5a5a51c, 262143, 4, 19, 0xa7ffff1c) + EXT( 0xa5a5a51b, 4, 20, 0x0005a5a5) + EXTU(0xa5a5a51b, 4, 20, 0x0005a5a5) + DEP( 0xa5a5a51b, 524287, 4, 20, 0xa7ffff1b) + EXT( 0xa5a5a51a, 4, 21, 0x000b4b4a) + EXTU(0xa5a5a51a, 4, 21, 0x000b4b4a) + DEP( 0xa5a5a51a, 1048575, 4, 21, 0xa7ffff9a) + EXT( 0xa5a5a519, 4, 22, 0x00169694) + EXTU(0xa5a5a519, 4, 22, 0x00169694) + DEP( 0xa5a5a519, 2097151, 4, 22, 0xa7ffffd9) + EXT( 0xa5a5a518, 4, 23, 0x002d2d28) + EXTU(0xa5a5a518, 4, 23, 0x002d2d28) + DEP( 0xa5a5a518, 4194303, 4, 23, 0xa7fffff8) + EXT( 0xa5a5a517, 4, 24, 0x005a5a51) + EXTU(0xa5a5a517, 4, 24, 0x005a5a51) + DEP( 0xa5a5a517, 8388607, 4, 24, 0xa7fffff7) + EXT( 0xa5a5a516, 4, 25, 0x00b4b4a2) + EXTU(0xa5a5a516, 4, 25, 0x00b4b4a2) + DEP( 0xa5a5a516, 16777215, 4, 25, 0xa7fffffe) + EXT( 0xa5a5a515, 4, 26, 0x01696945) + EXTU(0xa5a5a515, 4, 26, 0x01696945) + DEP( 0xa5a5a515, 33554431, 4, 26, 0xa7fffffd) + EXT( 0xa5a5a514, 4, 27, 0x02d2d28a) + EXTU(0xa5a5a514, 4, 27, 0x02d2d28a) + DEP( 0xa5a5a514, 67108863, 4, 27, 0xa7fffffe) + EXT( 0xa5a5a513, 5, 1, 0xffffffff) + EXTU(0xa5a5a513, 5, 1, 0x00000001) + DEP( 0xa5a5a513, 0, 5, 1, 0xa1a5a513) + EXT( 0xa5a5a512, 5, 2, 0xfffffffe) + EXTU(0xa5a5a512, 5, 2, 0x00000002) + DEP( 0xa5a5a512, 1, 5, 2, 0xa3a5a512) + EXT( 0xa5a5a511, 5, 3, 0xfffffffd) + EXTU(0xa5a5a511, 5, 3, 0x00000005) + DEP( 0xa5a5a511, 3, 5, 3, 0xa3a5a511) + EXT( 0xa5a5a510, 5, 4, 0xfffffffb) + EXTU(0xa5a5a510, 5, 4, 0x0000000b) + DEP( 0xa5a5a510, 7, 5, 4, 0xa3a5a510) + EXT( 0xa5a5a50f, 5, 5, 0xfffffff6) + EXTU(0xa5a5a50f, 5, 5, 0x00000016) + DEP( 0xa5a5a50f, 15, 5, 5, 0xa3e5a50f) + EXT( 0xa5a5a50e, 5, 6, 0xffffffed) + EXTU(0xa5a5a50e, 5, 6, 0x0000002d) + DEP( 0xa5a5a50e, 31, 5, 6, 0xa3e5a50e) + EXT( 0xa5a5a50d, 5, 7, 0xffffffda) + EXTU(0xa5a5a50d, 5, 7, 0x0000005a) + DEP( 0xa5a5a50d, 63, 5, 7, 0xa3f5a50d) + EXT( 0xa5a5a50c, 5, 8, 0xffffffb4) + EXTU(0xa5a5a50c, 5, 8, 0x000000b4) + DEP( 0xa5a5a50c, 127, 5, 8, 0xa3fda50c) + EXT( 0xa5a5a50b, 5, 9, 0xffffff69) + EXTU(0xa5a5a50b, 5, 9, 0x00000169) + DEP( 0xa5a5a50b, 255, 5, 9, 0xa3fda50b) + EXT( 0xa5a5a50a, 5, 10, 0xfffffed2) + EXTU(0xa5a5a50a, 5, 10, 0x000002d2) + DEP( 0xa5a5a50a, 511, 5, 10, 0xa3ffa50a) + EXT( 0xa5a5a509, 5, 11, 0xfffffda5) + EXTU(0xa5a5a509, 5, 11, 0x000005a5) + DEP( 0xa5a5a509, 1023, 5, 11, 0xa3ffa509) + EXT( 0xa5a5a508, 5, 12, 0xfffffb4b) + EXTU(0xa5a5a508, 5, 12, 0x00000b4b) + DEP( 0xa5a5a508, 2047, 5, 12, 0xa3ffa508) + EXT( 0xa5a5a507, 5, 13, 0xfffff696) + EXTU(0xa5a5a507, 5, 13, 0x00001696) + DEP( 0xa5a5a507, 4095, 5, 13, 0xa3ffe507) + EXT( 0xa5a5a506, 5, 14, 0xffffed2d) + EXTU(0xa5a5a506, 5, 14, 0x00002d2d) + DEP( 0xa5a5a506, 8191, 5, 14, 0xa3ffe506) + EXT( 0xa5a5a505, 5, 15, 0xffffda5a) + EXTU(0xa5a5a505, 5, 15, 0x00005a5a) + DEP( 0xa5a5a505, 16383, 5, 15, 0xa3fff505) + EXT( 0xa5a5a504, 5, 16, 0xffffb4b4) + EXTU(0xa5a5a504, 5, 16, 0x0000b4b4) + DEP( 0xa5a5a504, 32767, 5, 16, 0xa3fffd04) + EXT( 0xa5a5a503, 5, 17, 0xffff6969) + EXTU(0xa5a5a503, 5, 17, 0x00016969) + DEP( 0xa5a5a503, 65535, 5, 17, 0xa3fffd03) + EXT( 0xa5a5a502, 5, 18, 0xfffed2d2) + EXTU(0xa5a5a502, 5, 18, 0x0002d2d2) + DEP( 0xa5a5a502, 131071, 5, 18, 0xa3ffff02) + EXT( 0xa5a5a501, 5, 19, 0xfffda5a5) + EXTU(0xa5a5a501, 5, 19, 0x0005a5a5) + DEP( 0xa5a5a501, 262143, 5, 19, 0xa3ffff01) + EXT( 0xa5a5a500, 5, 20, 0xfffb4b4a) + EXTU(0xa5a5a500, 5, 20, 0x000b4b4a) + DEP( 0xa5a5a500, 524287, 5, 20, 0xa3ffff80) + EXT( 0xa5a5a4ff, 5, 21, 0xfff69693) + EXTU(0xa5a5a4ff, 5, 21, 0x00169693) + DEP( 0xa5a5a4ff, 1048575, 5, 21, 0xa3ffffff) + EXT( 0xa5a5a4fe, 5, 22, 0xffed2d27) + EXTU(0xa5a5a4fe, 5, 22, 0x002d2d27) + DEP( 0xa5a5a4fe, 2097151, 5, 22, 0xa3fffffe) + EXT( 0xa5a5a4fd, 5, 23, 0xffda5a4f) + EXTU(0xa5a5a4fd, 5, 23, 0x005a5a4f) + DEP( 0xa5a5a4fd, 4194303, 5, 23, 0xa3fffffd) + EXT( 0xa5a5a4fc, 5, 24, 0xffb4b49f) + EXTU(0xa5a5a4fc, 5, 24, 0x00b4b49f) + DEP( 0xa5a5a4fc, 8388607, 5, 24, 0xa3fffffc) + EXT( 0xa5a5a4fb, 5, 25, 0xff69693e) + EXTU(0xa5a5a4fb, 5, 25, 0x0169693e) + DEP( 0xa5a5a4fb, 16777215, 5, 25, 0xa3ffffff) + EXT( 0xa5a5a4fa, 5, 26, 0xfed2d27d) + EXTU(0xa5a5a4fa, 5, 26, 0x02d2d27d) + DEP( 0xa5a5a4fa, 33554431, 5, 26, 0xa3fffffe) + EXT( 0xa5a5a4f9, 6, 1, 0x00000000) + EXTU(0xa5a5a4f9, 6, 1, 0x00000000) + DEP( 0xa5a5a4f9, 0, 6, 1, 0xa5a5a4f9) + EXT( 0xa5a5a4f8, 6, 2, 0x00000001) + EXTU(0xa5a5a4f8, 6, 2, 0x00000001) + DEP( 0xa5a5a4f8, 1, 6, 2, 0xa5a5a4f8) + EXT( 0xa5a5a4f7, 6, 3, 0x00000003) + EXTU(0xa5a5a4f7, 6, 3, 0x00000003) + DEP( 0xa5a5a4f7, 3, 6, 3, 0xa5a5a4f7) + EXT( 0xa5a5a4f6, 6, 4, 0x00000006) + EXTU(0xa5a5a4f6, 6, 4, 0x00000006) + DEP( 0xa5a5a4f6, 7, 6, 4, 0xa5e5a4f6) + EXT( 0xa5a5a4f5, 6, 5, 0x0000000d) + EXTU(0xa5a5a4f5, 6, 5, 0x0000000d) + DEP( 0xa5a5a4f5, 15, 6, 5, 0xa5e5a4f5) + EXT( 0xa5a5a4f4, 6, 6, 0x0000001a) + EXTU(0xa5a5a4f4, 6, 6, 0x0000001a) + DEP( 0xa5a5a4f4, 31, 6, 6, 0xa5f5a4f4) + EXT( 0xa5a5a4f3, 6, 7, 0x00000034) + EXTU(0xa5a5a4f3, 6, 7, 0x00000034) + DEP( 0xa5a5a4f3, 63, 6, 7, 0xa5fda4f3) + EXT( 0xa5a5a4f2, 6, 8, 0x00000069) + EXTU(0xa5a5a4f2, 6, 8, 0x00000069) + DEP( 0xa5a5a4f2, 127, 6, 8, 0xa5fda4f2) + EXT( 0xa5a5a4f1, 6, 9, 0x000000d2) + EXTU(0xa5a5a4f1, 6, 9, 0x000000d2) + DEP( 0xa5a5a4f1, 255, 6, 9, 0xa5ffa4f1) + EXT( 0xa5a5a4f0, 6, 10, 0x000001a5) + EXTU(0xa5a5a4f0, 6, 10, 0x000001a5) + DEP( 0xa5a5a4f0, 511, 6, 10, 0xa5ffa4f0) + EXT( 0xa5a5a4ef, 6, 11, 0x0000034b) + EXTU(0xa5a5a4ef, 6, 11, 0x0000034b) + DEP( 0xa5a5a4ef, 1023, 6, 11, 0xa5ffa4ef) + EXT( 0xa5a5a4ee, 6, 12, 0x00000696) + EXTU(0xa5a5a4ee, 6, 12, 0x00000696) + DEP( 0xa5a5a4ee, 2047, 6, 12, 0xa5ffe4ee) + EXT( 0xa5a5a4ed, 6, 13, 0x00000d2d) + EXTU(0xa5a5a4ed, 6, 13, 0x00000d2d) + DEP( 0xa5a5a4ed, 4095, 6, 13, 0xa5ffe4ed) + EXT( 0xa5a5a4ec, 6, 14, 0x00001a5a) + EXTU(0xa5a5a4ec, 6, 14, 0x00001a5a) + DEP( 0xa5a5a4ec, 8191, 6, 14, 0xa5fff4ec) + EXT( 0xa5a5a4eb, 6, 15, 0x000034b4) + EXTU(0xa5a5a4eb, 6, 15, 0x000034b4) + DEP( 0xa5a5a4eb, 16383, 6, 15, 0xa5fffceb) + EXT( 0xa5a5a4ea, 6, 16, 0x00006969) + EXTU(0xa5a5a4ea, 6, 16, 0x00006969) + DEP( 0xa5a5a4ea, 32767, 6, 16, 0xa5fffcea) + EXT( 0xa5a5a4e9, 6, 17, 0x0000d2d2) + EXTU(0xa5a5a4e9, 6, 17, 0x0000d2d2) + DEP( 0xa5a5a4e9, 65535, 6, 17, 0xa5fffee9) + EXT( 0xa5a5a4e8, 6, 18, 0x0001a5a4) + EXTU(0xa5a5a4e8, 6, 18, 0x0001a5a4) + DEP( 0xa5a5a4e8, 131071, 6, 18, 0xa5ffffe8) + EXT( 0xa5a5a4e7, 6, 19, 0x00034b49) + EXTU(0xa5a5a4e7, 6, 19, 0x00034b49) + DEP( 0xa5a5a4e7, 262143, 6, 19, 0xa5ffffe7) + EXT( 0xa5a5a4e6, 6, 20, 0x00069693) + EXTU(0xa5a5a4e6, 6, 20, 0x00069693) + DEP( 0xa5a5a4e6, 524287, 6, 20, 0xa5ffffe6) + EXT( 0xa5a5a4e5, 6, 21, 0x000d2d27) + EXTU(0xa5a5a4e5, 6, 21, 0x000d2d27) + DEP( 0xa5a5a4e5, 1048575, 6, 21, 0xa5ffffe5) + EXT( 0xa5a5a4e4, 6, 22, 0x001a5a4e) + EXTU(0xa5a5a4e4, 6, 22, 0x001a5a4e) + DEP( 0xa5a5a4e4, 2097151, 6, 22, 0xa5fffff4) + EXT( 0xa5a5a4e3, 6, 23, 0x0034b49c) + EXTU(0xa5a5a4e3, 6, 23, 0x0034b49c) + DEP( 0xa5a5a4e3, 4194303, 6, 23, 0xa5fffffb) + EXT( 0xa5a5a4e2, 6, 24, 0x00696938) + EXTU(0xa5a5a4e2, 6, 24, 0x00696938) + DEP( 0xa5a5a4e2, 8388607, 6, 24, 0xa5fffffe) + EXT( 0xa5a5a4e1, 6, 25, 0x00d2d270) + EXTU(0xa5a5a4e1, 6, 25, 0x00d2d270) + DEP( 0xa5a5a4e1, 16777215, 6, 25, 0xa5ffffff) + EXT( 0xa5a5a4e0, 7, 1, 0xffffffff) + EXTU(0xa5a5a4e0, 7, 1, 0x00000001) + DEP( 0xa5a5a4e0, 0, 7, 1, 0xa4a5a4e0) + EXT( 0xa5a5a4df, 7, 2, 0xffffffff) + EXTU(0xa5a5a4df, 7, 2, 0x00000003) + DEP( 0xa5a5a4df, 1, 7, 2, 0xa4a5a4df) + EXT( 0xa5a5a4de, 7, 3, 0xfffffffe) + EXTU(0xa5a5a4de, 7, 3, 0x00000006) + DEP( 0xa5a5a4de, 3, 7, 3, 0xa4e5a4de) + EXT( 0xa5a5a4dd, 7, 4, 0xfffffffd) + EXTU(0xa5a5a4dd, 7, 4, 0x0000000d) + DEP( 0xa5a5a4dd, 7, 7, 4, 0xa4e5a4dd) + EXT( 0xa5a5a4dc, 7, 5, 0xfffffffa) + EXTU(0xa5a5a4dc, 7, 5, 0x0000001a) + DEP( 0xa5a5a4dc, 15, 7, 5, 0xa4f5a4dc) + EXT( 0xa5a5a4db, 7, 6, 0xfffffff4) + EXTU(0xa5a5a4db, 7, 6, 0x00000034) + DEP( 0xa5a5a4db, 31, 7, 6, 0xa4fda4db) + EXT( 0xa5a5a4da, 7, 7, 0xffffffe9) + EXTU(0xa5a5a4da, 7, 7, 0x00000069) + DEP( 0xa5a5a4da, 63, 7, 7, 0xa4fda4da) + EXT( 0xa5a5a4d9, 7, 8, 0xffffffd2) + EXTU(0xa5a5a4d9, 7, 8, 0x000000d2) + DEP( 0xa5a5a4d9, 127, 7, 8, 0xa4ffa4d9) + EXT( 0xa5a5a4d8, 7, 9, 0xffffffa5) + EXTU(0xa5a5a4d8, 7, 9, 0x000001a5) + DEP( 0xa5a5a4d8, 255, 7, 9, 0xa4ffa4d8) + EXT( 0xa5a5a4d7, 7, 10, 0xffffff4b) + EXTU(0xa5a5a4d7, 7, 10, 0x0000034b) + DEP( 0xa5a5a4d7, 511, 7, 10, 0xa4ffa4d7) + EXT( 0xa5a5a4d6, 7, 11, 0xfffffe96) + EXTU(0xa5a5a4d6, 7, 11, 0x00000696) + DEP( 0xa5a5a4d6, 1023, 7, 11, 0xa4ffe4d6) + EXT( 0xa5a5a4d5, 7, 12, 0xfffffd2d) + EXTU(0xa5a5a4d5, 7, 12, 0x00000d2d) + DEP( 0xa5a5a4d5, 2047, 7, 12, 0xa4ffe4d5) + EXT( 0xa5a5a4d4, 7, 13, 0xfffffa5a) + EXTU(0xa5a5a4d4, 7, 13, 0x00001a5a) + DEP( 0xa5a5a4d4, 4095, 7, 13, 0xa4fff4d4) + EXT( 0xa5a5a4d3, 7, 14, 0xfffff4b4) + EXTU(0xa5a5a4d3, 7, 14, 0x000034b4) + DEP( 0xa5a5a4d3, 8191, 7, 14, 0xa4fffcd3) + EXT( 0xa5a5a4d2, 7, 15, 0xffffe969) + EXTU(0xa5a5a4d2, 7, 15, 0x00006969) + DEP( 0xa5a5a4d2, 16383, 7, 15, 0xa4fffcd2) + EXT( 0xa5a5a4d1, 7, 16, 0xffffd2d2) + EXTU(0xa5a5a4d1, 7, 16, 0x0000d2d2) + DEP( 0xa5a5a4d1, 32767, 7, 16, 0xa4fffed1) + EXT( 0xa5a5a4d0, 7, 17, 0xffffa5a4) + EXTU(0xa5a5a4d0, 7, 17, 0x0001a5a4) + DEP( 0xa5a5a4d0, 65535, 7, 17, 0xa4ffffd0) + EXT( 0xa5a5a4cf, 7, 18, 0xffff4b49) + EXTU(0xa5a5a4cf, 7, 18, 0x00034b49) + DEP( 0xa5a5a4cf, 131071, 7, 18, 0xa4ffffcf) + EXT( 0xa5a5a4ce, 7, 19, 0xfffe9693) + EXTU(0xa5a5a4ce, 7, 19, 0x00069693) + DEP( 0xa5a5a4ce, 262143, 7, 19, 0xa4ffffce) + EXT( 0xa5a5a4cd, 7, 20, 0xfffd2d26) + EXTU(0xa5a5a4cd, 7, 20, 0x000d2d26) + DEP( 0xa5a5a4cd, 524287, 7, 20, 0xa4ffffed) + EXT( 0xa5a5a4cc, 7, 21, 0xfffa5a4c) + EXTU(0xa5a5a4cc, 7, 21, 0x001a5a4c) + DEP( 0xa5a5a4cc, 1048575, 7, 21, 0xa4fffffc) + EXT( 0xa5a5a4cb, 7, 22, 0xfff4b499) + EXTU(0xa5a5a4cb, 7, 22, 0x0034b499) + DEP( 0xa5a5a4cb, 2097151, 7, 22, 0xa4fffffb) + EXT( 0xa5a5a4ca, 7, 23, 0xffe96932) + EXTU(0xa5a5a4ca, 7, 23, 0x00696932) + DEP( 0xa5a5a4ca, 4194303, 7, 23, 0xa4fffffe) + EXT( 0xa5a5a4c9, 7, 24, 0xffd2d264) + EXTU(0xa5a5a4c9, 7, 24, 0x00d2d264) + DEP( 0xa5a5a4c9, 8388607, 7, 24, 0xa4ffffff) + EXT( 0xa5a5a4c8, 8, 1, 0xffffffff) + EXTU(0xa5a5a4c8, 8, 1, 0x00000001) + DEP( 0xa5a5a4c8, 0, 8, 1, 0xa525a4c8) + EXT( 0xa5a5a4c7, 8, 2, 0xfffffffe) + EXTU(0xa5a5a4c7, 8, 2, 0x00000002) + DEP( 0xa5a5a4c7, 1, 8, 2, 0xa565a4c7) + EXT( 0xa5a5a4c6, 8, 3, 0xfffffffd) + EXTU(0xa5a5a4c6, 8, 3, 0x00000005) + DEP( 0xa5a5a4c6, 3, 8, 3, 0xa565a4c6) + EXT( 0xa5a5a4c5, 8, 4, 0xfffffffa) + EXTU(0xa5a5a4c5, 8, 4, 0x0000000a) + DEP( 0xa5a5a4c5, 7, 8, 4, 0xa575a4c5) + EXT( 0xa5a5a4c4, 8, 5, 0xfffffff4) + EXTU(0xa5a5a4c4, 8, 5, 0x00000014) + DEP( 0xa5a5a4c4, 15, 8, 5, 0xa57da4c4) + EXT( 0xa5a5a4c3, 8, 6, 0xffffffe9) + EXTU(0xa5a5a4c3, 8, 6, 0x00000029) + DEP( 0xa5a5a4c3, 31, 8, 6, 0xa57da4c3) + EXT( 0xa5a5a4c2, 8, 7, 0xffffffd2) + EXTU(0xa5a5a4c2, 8, 7, 0x00000052) + DEP( 0xa5a5a4c2, 63, 8, 7, 0xa57fa4c2) + EXT( 0xa5a5a4c1, 8, 8, 0xffffffa5) + EXTU(0xa5a5a4c1, 8, 8, 0x000000a5) + DEP( 0xa5a5a4c1, 127, 8, 8, 0xa57fa4c1) + EXT( 0xa5a5a4c0, 8, 9, 0xffffff4b) + EXTU(0xa5a5a4c0, 8, 9, 0x0000014b) + DEP( 0xa5a5a4c0, 255, 8, 9, 0xa57fa4c0) + EXT( 0xa5a5a4bf, 8, 10, 0xfffffe96) + EXTU(0xa5a5a4bf, 8, 10, 0x00000296) + DEP( 0xa5a5a4bf, 511, 8, 10, 0xa57fe4bf) + EXT( 0xa5a5a4be, 8, 11, 0xfffffd2d) + EXTU(0xa5a5a4be, 8, 11, 0x0000052d) + DEP( 0xa5a5a4be, 1023, 8, 11, 0xa57fe4be) + EXT( 0xa5a5a4bd, 8, 12, 0xfffffa5a) + EXTU(0xa5a5a4bd, 8, 12, 0x00000a5a) + DEP( 0xa5a5a4bd, 2047, 8, 12, 0xa57ff4bd) + EXT( 0xa5a5a4bc, 8, 13, 0xfffff4b4) + EXTU(0xa5a5a4bc, 8, 13, 0x000014b4) + DEP( 0xa5a5a4bc, 4095, 8, 13, 0xa57ffcbc) + EXT( 0xa5a5a4bb, 8, 14, 0xffffe969) + EXTU(0xa5a5a4bb, 8, 14, 0x00002969) + DEP( 0xa5a5a4bb, 8191, 8, 14, 0xa57ffcbb) + EXT( 0xa5a5a4ba, 8, 15, 0xffffd2d2) + EXTU(0xa5a5a4ba, 8, 15, 0x000052d2) + DEP( 0xa5a5a4ba, 16383, 8, 15, 0xa57ffeba) + EXT( 0xa5a5a4b9, 8, 16, 0xffffa5a4) + EXTU(0xa5a5a4b9, 8, 16, 0x0000a5a4) + DEP( 0xa5a5a4b9, 32767, 8, 16, 0xa57fffb9) + EXT( 0xa5a5a4b8, 8, 17, 0xffff4b49) + EXTU(0xa5a5a4b8, 8, 17, 0x00014b49) + DEP( 0xa5a5a4b8, 65535, 8, 17, 0xa57fffb8) + EXT( 0xa5a5a4b7, 8, 18, 0xfffe9692) + EXTU(0xa5a5a4b7, 8, 18, 0x00029692) + DEP( 0xa5a5a4b7, 131071, 8, 18, 0xa57ffff7) + EXT( 0xa5a5a4b6, 8, 19, 0xfffd2d25) + EXTU(0xa5a5a4b6, 8, 19, 0x00052d25) + DEP( 0xa5a5a4b6, 262143, 8, 19, 0xa57ffff6) + EXT( 0xa5a5a4b5, 8, 20, 0xfffa5a4b) + EXTU(0xa5a5a4b5, 8, 20, 0x000a5a4b) + DEP( 0xa5a5a4b5, 524287, 8, 20, 0xa57ffff5) + EXT( 0xa5a5a4b4, 8, 21, 0xfff4b496) + EXTU(0xa5a5a4b4, 8, 21, 0x0014b496) + DEP( 0xa5a5a4b4, 1048575, 8, 21, 0xa57ffffc) + EXT( 0xa5a5a4b3, 8, 22, 0xffe9692c) + EXTU(0xa5a5a4b3, 8, 22, 0x0029692c) + DEP( 0xa5a5a4b3, 2097151, 8, 22, 0xa57fffff) + EXT( 0xa5a5a4b2, 8, 23, 0xffd2d259) + EXTU(0xa5a5a4b2, 8, 23, 0x0052d259) + DEP( 0xa5a5a4b2, 4194303, 8, 23, 0xa57ffffe) + EXT( 0xa5a5a4b1, 9, 1, 0x00000000) + EXTU(0xa5a5a4b1, 9, 1, 0x00000000) + DEP( 0xa5a5a4b1, 0, 9, 1, 0xa5a5a4b1) + EXT( 0xa5a5a4b0, 9, 2, 0x00000001) + EXTU(0xa5a5a4b0, 9, 2, 0x00000001) + DEP( 0xa5a5a4b0, 1, 9, 2, 0xa5a5a4b0) + EXT( 0xa5a5a4af, 9, 3, 0x00000002) + EXTU(0xa5a5a4af, 9, 3, 0x00000002) + DEP( 0xa5a5a4af, 3, 9, 3, 0xa5b5a4af) + EXT( 0xa5a5a4ae, 9, 4, 0x00000004) + EXTU(0xa5a5a4ae, 9, 4, 0x00000004) + DEP( 0xa5a5a4ae, 7, 9, 4, 0xa5bda4ae) + EXT( 0xa5a5a4ad, 9, 5, 0x00000009) + EXTU(0xa5a5a4ad, 9, 5, 0x00000009) + DEP( 0xa5a5a4ad, 15, 9, 5, 0xa5bda4ad) + EXT( 0xa5a5a4ac, 9, 6, 0x00000012) + EXTU(0xa5a5a4ac, 9, 6, 0x00000012) + DEP( 0xa5a5a4ac, 31, 9, 6, 0xa5bfa4ac) + EXT( 0xa5a5a4ab, 9, 7, 0x00000025) + EXTU(0xa5a5a4ab, 9, 7, 0x00000025) + DEP( 0xa5a5a4ab, 63, 9, 7, 0xa5bfa4ab) + EXT( 0xa5a5a4aa, 9, 8, 0x0000004b) + EXTU(0xa5a5a4aa, 9, 8, 0x0000004b) + DEP( 0xa5a5a4aa, 127, 9, 8, 0xa5bfa4aa) + EXT( 0xa5a5a4a9, 9, 9, 0x00000096) + EXTU(0xa5a5a4a9, 9, 9, 0x00000096) + DEP( 0xa5a5a4a9, 255, 9, 9, 0xa5bfe4a9) + EXT( 0xa5a5a4a8, 9, 10, 0x0000012d) + EXTU(0xa5a5a4a8, 9, 10, 0x0000012d) + DEP( 0xa5a5a4a8, 511, 9, 10, 0xa5bfe4a8) + EXT( 0xa5a5a4a7, 9, 11, 0x0000025a) + EXTU(0xa5a5a4a7, 9, 11, 0x0000025a) + DEP( 0xa5a5a4a7, 1023, 9, 11, 0xa5bff4a7) + EXT( 0xa5a5a4a6, 9, 12, 0x000004b4) + EXTU(0xa5a5a4a6, 9, 12, 0x000004b4) + DEP( 0xa5a5a4a6, 2047, 9, 12, 0xa5bffca6) + EXT( 0xa5a5a4a5, 9, 13, 0x00000969) + EXTU(0xa5a5a4a5, 9, 13, 0x00000969) + DEP( 0xa5a5a4a5, 4095, 9, 13, 0xa5bffca5) + EXT( 0xa5a5a4a4, 9, 14, 0x000012d2) + EXTU(0xa5a5a4a4, 9, 14, 0x000012d2) + DEP( 0xa5a5a4a4, 8191, 9, 14, 0xa5bffea4) + EXT( 0xa5a5a4a3, 9, 15, 0x000025a4) + EXTU(0xa5a5a4a3, 9, 15, 0x000025a4) + DEP( 0xa5a5a4a3, 16383, 9, 15, 0xa5bfffa3) + EXT( 0xa5a5a4a2, 9, 16, 0x00004b49) + EXTU(0xa5a5a4a2, 9, 16, 0x00004b49) + DEP( 0xa5a5a4a2, 32767, 9, 16, 0xa5bfffa2) + EXT( 0xa5a5a4a1, 9, 17, 0x00009692) + EXTU(0xa5a5a4a1, 9, 17, 0x00009692) + DEP( 0xa5a5a4a1, 65535, 9, 17, 0xa5bfffe1) + EXT( 0xa5a5a4a0, 9, 18, 0x00012d25) + EXTU(0xa5a5a4a0, 9, 18, 0x00012d25) + DEP( 0xa5a5a4a0, 131071, 9, 18, 0xa5bfffe0) + EXT( 0xa5a5a49f, 9, 19, 0x00025a49) + EXTU(0xa5a5a49f, 9, 19, 0x00025a49) + DEP( 0xa5a5a49f, 262143, 9, 19, 0xa5bfffff) + EXT( 0xa5a5a49e, 9, 20, 0x0004b493) + EXTU(0xa5a5a49e, 9, 20, 0x0004b493) + DEP( 0xa5a5a49e, 524287, 9, 20, 0xa5bffffe) + EXT( 0xa5a5a49d, 9, 21, 0x00096927) + EXTU(0xa5a5a49d, 9, 21, 0x00096927) + DEP( 0xa5a5a49d, 1048575, 9, 21, 0xa5bffffd) + EXT( 0xa5a5a49c, 9, 22, 0x0012d24e) + EXTU(0xa5a5a49c, 9, 22, 0x0012d24e) + DEP( 0xa5a5a49c, 2097151, 9, 22, 0xa5bffffe) + EXT( 0xa5a5a49b, 10, 1, 0xffffffff) + EXTU(0xa5a5a49b, 10, 1, 0x00000001) + DEP( 0xa5a5a49b, 0, 10, 1, 0xa585a49b) + EXT( 0xa5a5a49a, 10, 2, 0xfffffffe) + EXTU(0xa5a5a49a, 10, 2, 0x00000002) + DEP( 0xa5a5a49a, 1, 10, 2, 0xa595a49a) + EXT( 0xa5a5a499, 10, 3, 0xfffffffc) + EXTU(0xa5a5a499, 10, 3, 0x00000004) + DEP( 0xa5a5a499, 3, 10, 3, 0xa59da499) + EXT( 0xa5a5a498, 10, 4, 0xfffffff9) + EXTU(0xa5a5a498, 10, 4, 0x00000009) + DEP( 0xa5a5a498, 7, 10, 4, 0xa59da498) + EXT( 0xa5a5a497, 10, 5, 0xfffffff2) + EXTU(0xa5a5a497, 10, 5, 0x00000012) + DEP( 0xa5a5a497, 15, 10, 5, 0xa59fa497) + EXT( 0xa5a5a496, 10, 6, 0xffffffe5) + EXTU(0xa5a5a496, 10, 6, 0x00000025) + DEP( 0xa5a5a496, 31, 10, 6, 0xa59fa496) + EXT( 0xa5a5a495, 10, 7, 0xffffffcb) + EXTU(0xa5a5a495, 10, 7, 0x0000004b) + DEP( 0xa5a5a495, 63, 10, 7, 0xa59fa495) + EXT( 0xa5a5a494, 10, 8, 0xffffff96) + EXTU(0xa5a5a494, 10, 8, 0x00000096) + DEP( 0xa5a5a494, 127, 10, 8, 0xa59fe494) + EXT( 0xa5a5a493, 10, 9, 0xffffff2d) + EXTU(0xa5a5a493, 10, 9, 0x0000012d) + DEP( 0xa5a5a493, 255, 10, 9, 0xa59fe493) + EXT( 0xa5a5a492, 10, 10, 0xfffffe5a) + EXTU(0xa5a5a492, 10, 10, 0x0000025a) + DEP( 0xa5a5a492, 511, 10, 10, 0xa59ff492) + EXT( 0xa5a5a491, 10, 11, 0xfffffcb4) + EXTU(0xa5a5a491, 10, 11, 0x000004b4) + DEP( 0xa5a5a491, 1023, 10, 11, 0xa59ffc91) + EXT( 0xa5a5a490, 10, 12, 0xfffff969) + EXTU(0xa5a5a490, 10, 12, 0x00000969) + DEP( 0xa5a5a490, 2047, 10, 12, 0xa59ffc90) + EXT( 0xa5a5a48f, 10, 13, 0xfffff2d2) + EXTU(0xa5a5a48f, 10, 13, 0x000012d2) + DEP( 0xa5a5a48f, 4095, 10, 13, 0xa59ffe8f) + EXT( 0xa5a5a48e, 10, 14, 0xffffe5a4) + EXTU(0xa5a5a48e, 10, 14, 0x000025a4) + DEP( 0xa5a5a48e, 8191, 10, 14, 0xa59fff8e) + EXT( 0xa5a5a48d, 10, 15, 0xffffcb49) + EXTU(0xa5a5a48d, 10, 15, 0x00004b49) + DEP( 0xa5a5a48d, 16383, 10, 15, 0xa59fff8d) + EXT( 0xa5a5a48c, 10, 16, 0xffff9692) + EXTU(0xa5a5a48c, 10, 16, 0x00009692) + DEP( 0xa5a5a48c, 32767, 10, 16, 0xa59fffcc) + EXT( 0xa5a5a48b, 10, 17, 0xffff2d24) + EXTU(0xa5a5a48b, 10, 17, 0x00012d24) + DEP( 0xa5a5a48b, 65535, 10, 17, 0xa59fffeb) + EXT( 0xa5a5a48a, 10, 18, 0xfffe5a48) + EXTU(0xa5a5a48a, 10, 18, 0x00025a48) + DEP( 0xa5a5a48a, 131071, 10, 18, 0xa59ffffa) + EXT( 0xa5a5a489, 10, 19, 0xfffcb491) + EXTU(0xa5a5a489, 10, 19, 0x0004b491) + DEP( 0xa5a5a489, 262143, 10, 19, 0xa59ffff9) + EXT( 0xa5a5a488, 10, 20, 0xfff96922) + EXTU(0xa5a5a488, 10, 20, 0x00096922) + DEP( 0xa5a5a488, 524287, 10, 20, 0xa59ffffc) + EXT( 0xa5a5a487, 10, 21, 0xfff2d243) + EXTU(0xa5a5a487, 10, 21, 0x0012d243) + DEP( 0xa5a5a487, 1048575, 10, 21, 0xa59fffff) + EXT( 0xa5a5a486, 11, 1, 0x00000000) + EXTU(0xa5a5a486, 11, 1, 0x00000000) + DEP( 0xa5a5a486, 0, 11, 1, 0xa5a5a486) + EXT( 0xa5a5a485, 11, 2, 0x00000000) + EXTU(0xa5a5a485, 11, 2, 0x00000000) + DEP( 0xa5a5a485, 1, 11, 2, 0xa5ada485) + EXT( 0xa5a5a484, 11, 3, 0x00000001) + EXTU(0xa5a5a484, 11, 3, 0x00000001) + DEP( 0xa5a5a484, 3, 11, 3, 0xa5ada484) + EXT( 0xa5a5a483, 11, 4, 0x00000002) + EXTU(0xa5a5a483, 11, 4, 0x00000002) + DEP( 0xa5a5a483, 7, 11, 4, 0xa5afa483) + EXT( 0xa5a5a482, 11, 5, 0x00000005) + EXTU(0xa5a5a482, 11, 5, 0x00000005) + DEP( 0xa5a5a482, 15, 11, 5, 0xa5afa482) + EXT( 0xa5a5a481, 11, 6, 0x0000000b) + EXTU(0xa5a5a481, 11, 6, 0x0000000b) + DEP( 0xa5a5a481, 31, 11, 6, 0xa5afa481) + EXT( 0xa5a5a480, 11, 7, 0x00000016) + EXTU(0xa5a5a480, 11, 7, 0x00000016) + DEP( 0xa5a5a480, 63, 11, 7, 0xa5afe480) + EXT( 0xa5a5a47f, 11, 8, 0x0000002d) + EXTU(0xa5a5a47f, 11, 8, 0x0000002d) + DEP( 0xa5a5a47f, 127, 11, 8, 0xa5afe47f) + EXT( 0xa5a5a47e, 11, 9, 0x0000005a) + EXTU(0xa5a5a47e, 11, 9, 0x0000005a) + DEP( 0xa5a5a47e, 255, 11, 9, 0xa5aff47e) + EXT( 0xa5a5a47d, 11, 10, 0x000000b4) + EXTU(0xa5a5a47d, 11, 10, 0x000000b4) + DEP( 0xa5a5a47d, 511, 11, 10, 0xa5affc7d) + EXT( 0xa5a5a47c, 11, 11, 0x00000169) + EXTU(0xa5a5a47c, 11, 11, 0x00000169) + DEP( 0xa5a5a47c, 1023, 11, 11, 0xa5affc7c) + EXT( 0xa5a5a47b, 11, 12, 0x000002d2) + EXTU(0xa5a5a47b, 11, 12, 0x000002d2) + DEP( 0xa5a5a47b, 2047, 11, 12, 0xa5affe7b) + EXT( 0xa5a5a47a, 11, 13, 0x000005a4) + EXTU(0xa5a5a47a, 11, 13, 0x000005a4) + DEP( 0xa5a5a47a, 4095, 11, 13, 0xa5afff7a) + EXT( 0xa5a5a479, 11, 14, 0x00000b48) + EXTU(0xa5a5a479, 11, 14, 0x00000b48) + DEP( 0xa5a5a479, 8191, 11, 14, 0xa5affff9) + EXT( 0xa5a5a478, 11, 15, 0x00001691) + EXTU(0xa5a5a478, 11, 15, 0x00001691) + DEP( 0xa5a5a478, 16383, 11, 15, 0xa5affff8) + EXT( 0xa5a5a477, 11, 16, 0x00002d23) + EXTU(0xa5a5a477, 11, 16, 0x00002d23) + DEP( 0xa5a5a477, 32767, 11, 16, 0xa5affff7) + EXT( 0xa5a5a476, 11, 17, 0x00005a47) + EXTU(0xa5a5a476, 11, 17, 0x00005a47) + DEP( 0xa5a5a476, 65535, 11, 17, 0xa5affff6) + EXT( 0xa5a5a475, 11, 18, 0x0000b48e) + EXTU(0xa5a5a475, 11, 18, 0x0000b48e) + DEP( 0xa5a5a475, 131071, 11, 18, 0xa5affffd) + EXT( 0xa5a5a474, 11, 19, 0x0001691d) + EXTU(0xa5a5a474, 11, 19, 0x0001691d) + DEP( 0xa5a5a474, 262143, 11, 19, 0xa5affffc) + EXT( 0xa5a5a473, 11, 20, 0x0002d239) + EXTU(0xa5a5a473, 11, 20, 0x0002d239) + DEP( 0xa5a5a473, 524287, 11, 20, 0xa5afffff) + EXT( 0xa5a5a472, 12, 1, 0x00000000) + EXTU(0xa5a5a472, 12, 1, 0x00000000) + DEP( 0xa5a5a472, 0, 12, 1, 0xa5a5a472) + EXT( 0xa5a5a471, 12, 2, 0x00000001) + EXTU(0xa5a5a471, 12, 2, 0x00000001) + DEP( 0xa5a5a471, 1, 12, 2, 0xa5a5a471) + EXT( 0xa5a5a470, 12, 3, 0x00000002) + EXTU(0xa5a5a470, 12, 3, 0x00000002) + DEP( 0xa5a5a470, 3, 12, 3, 0xa5a7a470) + EXT( 0xa5a5a46f, 12, 4, 0x00000005) + EXTU(0xa5a5a46f, 12, 4, 0x00000005) + DEP( 0xa5a5a46f, 7, 12, 4, 0xa5a7a46f) + EXT( 0xa5a5a46e, 12, 5, 0x0000000b) + EXTU(0xa5a5a46e, 12, 5, 0x0000000b) + DEP( 0xa5a5a46e, 15, 12, 5, 0xa5a7a46e) + EXT( 0xa5a5a46d, 12, 6, 0x00000016) + EXTU(0xa5a5a46d, 12, 6, 0x00000016) + DEP( 0xa5a5a46d, 31, 12, 6, 0xa5a7e46d) + EXT( 0xa5a5a46c, 12, 7, 0x0000002d) + EXTU(0xa5a5a46c, 12, 7, 0x0000002d) + DEP( 0xa5a5a46c, 63, 12, 7, 0xa5a7e46c) + EXT( 0xa5a5a46b, 12, 8, 0x0000005a) + EXTU(0xa5a5a46b, 12, 8, 0x0000005a) + DEP( 0xa5a5a46b, 127, 12, 8, 0xa5a7f46b) + EXT( 0xa5a5a46a, 12, 9, 0x000000b4) + EXTU(0xa5a5a46a, 12, 9, 0x000000b4) + DEP( 0xa5a5a46a, 255, 12, 9, 0xa5a7fc6a) + EXT( 0xa5a5a469, 12, 10, 0x00000169) + EXTU(0xa5a5a469, 12, 10, 0x00000169) + DEP( 0xa5a5a469, 511, 12, 10, 0xa5a7fc69) + EXT( 0xa5a5a468, 12, 11, 0x000002d2) + EXTU(0xa5a5a468, 12, 11, 0x000002d2) + DEP( 0xa5a5a468, 1023, 12, 11, 0xa5a7fe68) + EXT( 0xa5a5a467, 12, 12, 0x000005a4) + EXTU(0xa5a5a467, 12, 12, 0x000005a4) + DEP( 0xa5a5a467, 2047, 12, 12, 0xa5a7ff67) + EXT( 0xa5a5a466, 12, 13, 0x00000b48) + EXTU(0xa5a5a466, 12, 13, 0x00000b48) + DEP( 0xa5a5a466, 4095, 12, 13, 0xa5a7ffe6) + EXT( 0xa5a5a465, 12, 14, 0x00001691) + EXTU(0xa5a5a465, 12, 14, 0x00001691) + DEP( 0xa5a5a465, 8191, 12, 14, 0xa5a7ffe5) + EXT( 0xa5a5a464, 12, 15, 0x00002d23) + EXTU(0xa5a5a464, 12, 15, 0x00002d23) + DEP( 0xa5a5a464, 16383, 12, 15, 0xa5a7ffe4) + EXT( 0xa5a5a463, 12, 16, 0x00005a46) + EXTU(0xa5a5a463, 12, 16, 0x00005a46) + DEP( 0xa5a5a463, 32767, 12, 16, 0xa5a7fff3) + EXT( 0xa5a5a462, 12, 17, 0x0000b48c) + EXTU(0xa5a5a462, 12, 17, 0x0000b48c) + DEP( 0xa5a5a462, 65535, 12, 17, 0xa5a7fffa) + EXT( 0xa5a5a461, 12, 18, 0x00016918) + EXTU(0xa5a5a461, 12, 18, 0x00016918) + DEP( 0xa5a5a461, 131071, 12, 18, 0xa5a7fffd) + EXT( 0xa5a5a460, 12, 19, 0x0002d230) + EXTU(0xa5a5a460, 12, 19, 0x0002d230) + DEP( 0xa5a5a460, 262143, 12, 19, 0xa5a7fffe) + EXT( 0xa5a5a45f, 13, 1, 0xffffffff) + EXTU(0xa5a5a45f, 13, 1, 0x00000001) + DEP( 0xa5a5a45f, 0, 13, 1, 0xa5a1a45f) + EXT( 0xa5a5a45e, 13, 2, 0xfffffffe) + EXTU(0xa5a5a45e, 13, 2, 0x00000002) + DEP( 0xa5a5a45e, 1, 13, 2, 0xa5a3a45e) + EXT( 0xa5a5a45d, 13, 3, 0xfffffffd) + EXTU(0xa5a5a45d, 13, 3, 0x00000005) + DEP( 0xa5a5a45d, 3, 13, 3, 0xa5a3a45d) + EXT( 0xa5a5a45c, 13, 4, 0xfffffffb) + EXTU(0xa5a5a45c, 13, 4, 0x0000000b) + DEP( 0xa5a5a45c, 7, 13, 4, 0xa5a3a45c) + EXT( 0xa5a5a45b, 13, 5, 0xfffffff6) + EXTU(0xa5a5a45b, 13, 5, 0x00000016) + DEP( 0xa5a5a45b, 15, 13, 5, 0xa5a3e45b) + EXT( 0xa5a5a45a, 13, 6, 0xffffffed) + EXTU(0xa5a5a45a, 13, 6, 0x0000002d) + DEP( 0xa5a5a45a, 31, 13, 6, 0xa5a3e45a) + EXT( 0xa5a5a459, 13, 7, 0xffffffda) + EXTU(0xa5a5a459, 13, 7, 0x0000005a) + DEP( 0xa5a5a459, 63, 13, 7, 0xa5a3f459) + EXT( 0xa5a5a458, 13, 8, 0xffffffb4) + EXTU(0xa5a5a458, 13, 8, 0x000000b4) + DEP( 0xa5a5a458, 127, 13, 8, 0xa5a3fc58) + EXT( 0xa5a5a457, 13, 9, 0xffffff69) + EXTU(0xa5a5a457, 13, 9, 0x00000169) + DEP( 0xa5a5a457, 255, 13, 9, 0xa5a3fc57) + EXT( 0xa5a5a456, 13, 10, 0xfffffed2) + EXTU(0xa5a5a456, 13, 10, 0x000002d2) + DEP( 0xa5a5a456, 511, 13, 10, 0xa5a3fe56) + EXT( 0xa5a5a455, 13, 11, 0xfffffda4) + EXTU(0xa5a5a455, 13, 11, 0x000005a4) + DEP( 0xa5a5a455, 1023, 13, 11, 0xa5a3ff55) + EXT( 0xa5a5a454, 13, 12, 0xfffffb48) + EXTU(0xa5a5a454, 13, 12, 0x00000b48) + DEP( 0xa5a5a454, 2047, 13, 12, 0xa5a3ffd4) + EXT( 0xa5a5a453, 13, 13, 0xfffff691) + EXTU(0xa5a5a453, 13, 13, 0x00001691) + DEP( 0xa5a5a453, 4095, 13, 13, 0xa5a3ffd3) + EXT( 0xa5a5a452, 13, 14, 0xffffed22) + EXTU(0xa5a5a452, 13, 14, 0x00002d22) + DEP( 0xa5a5a452, 8191, 13, 14, 0xa5a3fff2) + EXT( 0xa5a5a451, 13, 15, 0xffffda45) + EXTU(0xa5a5a451, 13, 15, 0x00005a45) + DEP( 0xa5a5a451, 16383, 13, 15, 0xa5a3fff1) + EXT( 0xa5a5a450, 13, 16, 0xffffb48a) + EXTU(0xa5a5a450, 13, 16, 0x0000b48a) + DEP( 0xa5a5a450, 32767, 13, 16, 0xa5a3fff8) + EXT( 0xa5a5a44f, 13, 17, 0xffff6913) + EXTU(0xa5a5a44f, 13, 17, 0x00016913) + DEP( 0xa5a5a44f, 65535, 13, 17, 0xa5a3ffff) + EXT( 0xa5a5a44e, 13, 18, 0xfffed227) + EXTU(0xa5a5a44e, 13, 18, 0x0002d227) + DEP( 0xa5a5a44e, 131071, 13, 18, 0xa5a3fffe) + EXT( 0xa5a5a44d, 14, 1, 0x00000000) + EXTU(0xa5a5a44d, 14, 1, 0x00000000) + DEP( 0xa5a5a44d, 0, 14, 1, 0xa5a5a44d) + EXT( 0xa5a5a44c, 14, 2, 0x00000001) + EXTU(0xa5a5a44c, 14, 2, 0x00000001) + DEP( 0xa5a5a44c, 1, 14, 2, 0xa5a5a44c) + EXT( 0xa5a5a44b, 14, 3, 0x00000003) + EXTU(0xa5a5a44b, 14, 3, 0x00000003) + DEP( 0xa5a5a44b, 3, 14, 3, 0xa5a5a44b) + EXT( 0xa5a5a44a, 14, 4, 0x00000006) + EXTU(0xa5a5a44a, 14, 4, 0x00000006) + DEP( 0xa5a5a44a, 7, 14, 4, 0xa5a5e44a) + EXT( 0xa5a5a449, 14, 5, 0x0000000d) + EXTU(0xa5a5a449, 14, 5, 0x0000000d) + DEP( 0xa5a5a449, 15, 14, 5, 0xa5a5e449) + EXT( 0xa5a5a448, 14, 6, 0x0000001a) + EXTU(0xa5a5a448, 14, 6, 0x0000001a) + DEP( 0xa5a5a448, 31, 14, 6, 0xa5a5f448) + EXT( 0xa5a5a447, 14, 7, 0x00000034) + EXTU(0xa5a5a447, 14, 7, 0x00000034) + DEP( 0xa5a5a447, 63, 14, 7, 0xa5a5fc47) + EXT( 0xa5a5a446, 14, 8, 0x00000069) + EXTU(0xa5a5a446, 14, 8, 0x00000069) + DEP( 0xa5a5a446, 127, 14, 8, 0xa5a5fc46) + EXT( 0xa5a5a445, 14, 9, 0x000000d2) + EXTU(0xa5a5a445, 14, 9, 0x000000d2) + DEP( 0xa5a5a445, 255, 14, 9, 0xa5a5fe45) + EXT( 0xa5a5a444, 14, 10, 0x000001a4) + EXTU(0xa5a5a444, 14, 10, 0x000001a4) + DEP( 0xa5a5a444, 511, 14, 10, 0xa5a5ff44) + EXT( 0xa5a5a443, 14, 11, 0x00000348) + EXTU(0xa5a5a443, 14, 11, 0x00000348) + DEP( 0xa5a5a443, 1023, 14, 11, 0xa5a5ffc3) + EXT( 0xa5a5a442, 14, 12, 0x00000691) + EXTU(0xa5a5a442, 14, 12, 0x00000691) + DEP( 0xa5a5a442, 2047, 14, 12, 0xa5a5ffc2) + EXT( 0xa5a5a441, 14, 13, 0x00000d22) + EXTU(0xa5a5a441, 14, 13, 0x00000d22) + DEP( 0xa5a5a441, 4095, 14, 13, 0xa5a5ffe1) + EXT( 0xa5a5a440, 14, 14, 0x00001a44) + EXTU(0xa5a5a440, 14, 14, 0x00001a44) + DEP( 0xa5a5a440, 8191, 14, 14, 0xa5a5fff0) + EXT( 0xa5a5a43f, 14, 15, 0x00003487) + EXTU(0xa5a5a43f, 14, 15, 0x00003487) + DEP( 0xa5a5a43f, 16383, 14, 15, 0xa5a5ffff) + EXT( 0xa5a5a43e, 14, 16, 0x0000690f) + EXTU(0xa5a5a43e, 14, 16, 0x0000690f) + DEP( 0xa5a5a43e, 32767, 14, 16, 0xa5a5fffe) + EXT( 0xa5a5a43d, 14, 17, 0x0000d21e) + EXTU(0xa5a5a43d, 14, 17, 0x0000d21e) + DEP( 0xa5a5a43d, 65535, 14, 17, 0xa5a5ffff) + EXT( 0xa5a5a43c, 15, 1, 0xffffffff) + EXTU(0xa5a5a43c, 15, 1, 0x00000001) + DEP( 0xa5a5a43c, 0, 15, 1, 0xa5a4a43c) + EXT( 0xa5a5a43b, 15, 2, 0xffffffff) + EXTU(0xa5a5a43b, 15, 2, 0x00000003) + DEP( 0xa5a5a43b, 1, 15, 2, 0xa5a4a43b) + EXT( 0xa5a5a43a, 15, 3, 0xfffffffe) + EXTU(0xa5a5a43a, 15, 3, 0x00000006) + DEP( 0xa5a5a43a, 3, 15, 3, 0xa5a4e43a) + EXT( 0xa5a5a439, 15, 4, 0xfffffffd) + EXTU(0xa5a5a439, 15, 4, 0x0000000d) + DEP( 0xa5a5a439, 7, 15, 4, 0xa5a4e439) + EXT( 0xa5a5a438, 15, 5, 0xfffffffa) + EXTU(0xa5a5a438, 15, 5, 0x0000001a) + DEP( 0xa5a5a438, 15, 15, 5, 0xa5a4f438) + EXT( 0xa5a5a437, 15, 6, 0xfffffff4) + EXTU(0xa5a5a437, 15, 6, 0x00000034) + DEP( 0xa5a5a437, 31, 15, 6, 0xa5a4fc37) + EXT( 0xa5a5a436, 15, 7, 0xffffffe9) + EXTU(0xa5a5a436, 15, 7, 0x00000069) + DEP( 0xa5a5a436, 63, 15, 7, 0xa5a4fc36) + EXT( 0xa5a5a435, 15, 8, 0xffffffd2) + EXTU(0xa5a5a435, 15, 8, 0x000000d2) + DEP( 0xa5a5a435, 127, 15, 8, 0xa5a4fe35) + EXT( 0xa5a5a434, 15, 9, 0xffffffa4) + EXTU(0xa5a5a434, 15, 9, 0x000001a4) + DEP( 0xa5a5a434, 255, 15, 9, 0xa5a4ff34) + EXT( 0xa5a5a433, 15, 10, 0xffffff48) + EXTU(0xa5a5a433, 15, 10, 0x00000348) + DEP( 0xa5a5a433, 511, 15, 10, 0xa5a4ffb3) + EXT( 0xa5a5a432, 15, 11, 0xfffffe90) + EXTU(0xa5a5a432, 15, 11, 0x00000690) + DEP( 0xa5a5a432, 1023, 15, 11, 0xa5a4fff2) + EXT( 0xa5a5a431, 15, 12, 0xfffffd21) + EXTU(0xa5a5a431, 15, 12, 0x00000d21) + DEP( 0xa5a5a431, 2047, 15, 12, 0xa5a4fff1) + EXT( 0xa5a5a430, 15, 13, 0xfffffa43) + EXTU(0xa5a5a430, 15, 13, 0x00001a43) + DEP( 0xa5a5a430, 4095, 15, 13, 0xa5a4fff0) + EXT( 0xa5a5a42f, 15, 14, 0xfffff485) + EXTU(0xa5a5a42f, 15, 14, 0x00003485) + DEP( 0xa5a5a42f, 8191, 15, 14, 0xa5a4ffff) + EXT( 0xa5a5a42e, 15, 15, 0xffffe90b) + EXTU(0xa5a5a42e, 15, 15, 0x0000690b) + DEP( 0xa5a5a42e, 16383, 15, 15, 0xa5a4fffe) + EXT( 0xa5a5a42d, 15, 16, 0xffffd216) + EXTU(0xa5a5a42d, 15, 16, 0x0000d216) + DEP( 0xa5a5a42d, 32767, 15, 16, 0xa5a4ffff) + EXT( 0xa5a5a42c, 16, 1, 0xffffffff) + EXTU(0xa5a5a42c, 16, 1, 0x00000001) + DEP( 0xa5a5a42c, 0, 16, 1, 0xa5a5242c) + EXT( 0xa5a5a42b, 16, 2, 0xfffffffe) + EXTU(0xa5a5a42b, 16, 2, 0x00000002) + DEP( 0xa5a5a42b, 1, 16, 2, 0xa5a5642b) + EXT( 0xa5a5a42a, 16, 3, 0xfffffffd) + EXTU(0xa5a5a42a, 16, 3, 0x00000005) + DEP( 0xa5a5a42a, 3, 16, 3, 0xa5a5642a) + EXT( 0xa5a5a429, 16, 4, 0xfffffffa) + EXTU(0xa5a5a429, 16, 4, 0x0000000a) + DEP( 0xa5a5a429, 7, 16, 4, 0xa5a57429) + EXT( 0xa5a5a428, 16, 5, 0xfffffff4) + EXTU(0xa5a5a428, 16, 5, 0x00000014) + DEP( 0xa5a5a428, 15, 16, 5, 0xa5a57c28) + EXT( 0xa5a5a427, 16, 6, 0xffffffe9) + EXTU(0xa5a5a427, 16, 6, 0x00000029) + DEP( 0xa5a5a427, 31, 16, 6, 0xa5a57c27) + EXT( 0xa5a5a426, 16, 7, 0xffffffd2) + EXTU(0xa5a5a426, 16, 7, 0x00000052) + DEP( 0xa5a5a426, 63, 16, 7, 0xa5a57e26) + EXT( 0xa5a5a425, 16, 8, 0xffffffa4) + EXTU(0xa5a5a425, 16, 8, 0x000000a4) + DEP( 0xa5a5a425, 127, 16, 8, 0xa5a57f25) + EXT( 0xa5a5a424, 16, 9, 0xffffff48) + EXTU(0xa5a5a424, 16, 9, 0x00000148) + DEP( 0xa5a5a424, 255, 16, 9, 0xa5a57fa4) + EXT( 0xa5a5a423, 16, 10, 0xfffffe90) + EXTU(0xa5a5a423, 16, 10, 0x00000290) + DEP( 0xa5a5a423, 511, 16, 10, 0xa5a57fe3) + EXT( 0xa5a5a422, 16, 11, 0xfffffd21) + EXTU(0xa5a5a422, 16, 11, 0x00000521) + DEP( 0xa5a5a422, 1023, 16, 11, 0xa5a57fe2) + EXT( 0xa5a5a421, 16, 12, 0xfffffa42) + EXTU(0xa5a5a421, 16, 12, 0x00000a42) + DEP( 0xa5a5a421, 2047, 16, 12, 0xa5a57ff1) + EXT( 0xa5a5a420, 16, 13, 0xfffff484) + EXTU(0xa5a5a420, 16, 13, 0x00001484) + DEP( 0xa5a5a420, 4095, 16, 13, 0xa5a57ff8) + EXT( 0xa5a5a41f, 16, 14, 0xffffe907) + EXTU(0xa5a5a41f, 16, 14, 0x00002907) + DEP( 0xa5a5a41f, 8191, 16, 14, 0xa5a57fff) + EXT( 0xa5a5a41e, 16, 15, 0xffffd20f) + EXTU(0xa5a5a41e, 16, 15, 0x0000520f) + DEP( 0xa5a5a41e, 16383, 16, 15, 0xa5a57ffe) + EXT( 0xa5a5a41d, 17, 1, 0x00000000) + EXTU(0xa5a5a41d, 17, 1, 0x00000000) + DEP( 0xa5a5a41d, 0, 17, 1, 0xa5a5a41d) + EXT( 0xa5a5a41c, 17, 2, 0x00000001) + EXTU(0xa5a5a41c, 17, 2, 0x00000001) + DEP( 0xa5a5a41c, 1, 17, 2, 0xa5a5a41c) + EXT( 0xa5a5a41b, 17, 3, 0x00000002) + EXTU(0xa5a5a41b, 17, 3, 0x00000002) + DEP( 0xa5a5a41b, 3, 17, 3, 0xa5a5b41b) + EXT( 0xa5a5a41a, 17, 4, 0x00000004) + EXTU(0xa5a5a41a, 17, 4, 0x00000004) + DEP( 0xa5a5a41a, 7, 17, 4, 0xa5a5bc1a) + EXT( 0xa5a5a419, 17, 5, 0x00000009) + EXTU(0xa5a5a419, 17, 5, 0x00000009) + DEP( 0xa5a5a419, 15, 17, 5, 0xa5a5bc19) + EXT( 0xa5a5a418, 17, 6, 0x00000012) + EXTU(0xa5a5a418, 17, 6, 0x00000012) + DEP( 0xa5a5a418, 31, 17, 6, 0xa5a5be18) + EXT( 0xa5a5a417, 17, 7, 0x00000024) + EXTU(0xa5a5a417, 17, 7, 0x00000024) + DEP( 0xa5a5a417, 63, 17, 7, 0xa5a5bf17) + EXT( 0xa5a5a416, 17, 8, 0x00000048) + EXTU(0xa5a5a416, 17, 8, 0x00000048) + DEP( 0xa5a5a416, 127, 17, 8, 0xa5a5bf96) + EXT( 0xa5a5a415, 17, 9, 0x00000090) + EXTU(0xa5a5a415, 17, 9, 0x00000090) + DEP( 0xa5a5a415, 255, 17, 9, 0xa5a5bfd5) + EXT( 0xa5a5a414, 17, 10, 0x00000120) + EXTU(0xa5a5a414, 17, 10, 0x00000120) + DEP( 0xa5a5a414, 511, 17, 10, 0xa5a5bff4) + EXT( 0xa5a5a413, 17, 11, 0x00000241) + EXTU(0xa5a5a413, 17, 11, 0x00000241) + DEP( 0xa5a5a413, 1023, 17, 11, 0xa5a5bff3) + EXT( 0xa5a5a412, 17, 12, 0x00000482) + EXTU(0xa5a5a412, 17, 12, 0x00000482) + DEP( 0xa5a5a412, 2047, 17, 12, 0xa5a5bffa) + EXT( 0xa5a5a411, 17, 13, 0x00000904) + EXTU(0xa5a5a411, 17, 13, 0x00000904) + DEP( 0xa5a5a411, 4095, 17, 13, 0xa5a5bffd) + EXT( 0xa5a5a410, 17, 14, 0x00001208) + EXTU(0xa5a5a410, 17, 14, 0x00001208) + DEP( 0xa5a5a410, 8191, 17, 14, 0xa5a5bffe) + EXT( 0xa5a5a40f, 18, 1, 0xffffffff) + EXTU(0xa5a5a40f, 18, 1, 0x00000001) + DEP( 0xa5a5a40f, 0, 18, 1, 0xa5a5840f) + EXT( 0xa5a5a40e, 18, 2, 0xfffffffe) + EXTU(0xa5a5a40e, 18, 2, 0x00000002) + DEP( 0xa5a5a40e, 1, 18, 2, 0xa5a5940e) + EXT( 0xa5a5a40d, 18, 3, 0xfffffffc) + EXTU(0xa5a5a40d, 18, 3, 0x00000004) + DEP( 0xa5a5a40d, 3, 18, 3, 0xa5a59c0d) + EXT( 0xa5a5a40c, 18, 4, 0xfffffff9) + EXTU(0xa5a5a40c, 18, 4, 0x00000009) + DEP( 0xa5a5a40c, 7, 18, 4, 0xa5a59c0c) + EXT( 0xa5a5a40b, 18, 5, 0xfffffff2) + EXTU(0xa5a5a40b, 18, 5, 0x00000012) + DEP( 0xa5a5a40b, 15, 18, 5, 0xa5a59e0b) + EXT( 0xa5a5a40a, 18, 6, 0xffffffe4) + EXTU(0xa5a5a40a, 18, 6, 0x00000024) + DEP( 0xa5a5a40a, 31, 18, 6, 0xa5a59f0a) + EXT( 0xa5a5a409, 18, 7, 0xffffffc8) + EXTU(0xa5a5a409, 18, 7, 0x00000048) + DEP( 0xa5a5a409, 63, 18, 7, 0xa5a59f89) + EXT( 0xa5a5a408, 18, 8, 0xffffff90) + EXTU(0xa5a5a408, 18, 8, 0x00000090) + DEP( 0xa5a5a408, 127, 18, 8, 0xa5a59fc8) + EXT( 0xa5a5a407, 18, 9, 0xffffff20) + EXTU(0xa5a5a407, 18, 9, 0x00000120) + DEP( 0xa5a5a407, 255, 18, 9, 0xa5a59fe7) + EXT( 0xa5a5a406, 18, 10, 0xfffffe40) + EXTU(0xa5a5a406, 18, 10, 0x00000240) + DEP( 0xa5a5a406, 511, 18, 10, 0xa5a59ff6) + EXT( 0xa5a5a405, 18, 11, 0xfffffc80) + EXTU(0xa5a5a405, 18, 11, 0x00000480) + DEP( 0xa5a5a405, 1023, 18, 11, 0xa5a59ffd) + EXT( 0xa5a5a404, 18, 12, 0xfffff901) + EXTU(0xa5a5a404, 18, 12, 0x00000901) + DEP( 0xa5a5a404, 2047, 18, 12, 0xa5a59ffc) + EXT( 0xa5a5a403, 18, 13, 0xfffff201) + EXTU(0xa5a5a403, 18, 13, 0x00001201) + DEP( 0xa5a5a403, 4095, 18, 13, 0xa5a59fff) + EXT( 0xa5a5a402, 19, 1, 0x00000000) + EXTU(0xa5a5a402, 19, 1, 0x00000000) + DEP( 0xa5a5a402, 0, 19, 1, 0xa5a5a402) + EXT( 0xa5a5a401, 19, 2, 0x00000000) + EXTU(0xa5a5a401, 19, 2, 0x00000000) + DEP( 0xa5a5a401, 1, 19, 2, 0xa5a5ac01) + EXT( 0xa5a5a400, 19, 3, 0x00000001) + EXTU(0xa5a5a400, 19, 3, 0x00000001) + DEP( 0xa5a5a400, 3, 19, 3, 0xa5a5ac00) + EXT( 0xa5a5a3ff, 19, 4, 0x00000001) + EXTU(0xa5a5a3ff, 19, 4, 0x00000001) + DEP( 0xa5a5a3ff, 7, 19, 4, 0xa5a5afff) + EXT( 0xa5a5a3fe, 19, 5, 0x00000003) + EXTU(0xa5a5a3fe, 19, 5, 0x00000003) + DEP( 0xa5a5a3fe, 15, 19, 5, 0xa5a5affe) + EXT( 0xa5a5a3fd, 19, 6, 0x00000007) + EXTU(0xa5a5a3fd, 19, 6, 0x00000007) + DEP( 0xa5a5a3fd, 31, 19, 6, 0xa5a5affd) + EXT( 0xa5a5a3fc, 19, 7, 0x0000000f) + EXTU(0xa5a5a3fc, 19, 7, 0x0000000f) + DEP( 0xa5a5a3fc, 63, 19, 7, 0xa5a5affc) + EXT( 0xa5a5a3fb, 19, 8, 0x0000001f) + EXTU(0xa5a5a3fb, 19, 8, 0x0000001f) + DEP( 0xa5a5a3fb, 127, 19, 8, 0xa5a5affb) + EXT( 0xa5a5a3fa, 19, 9, 0x0000003f) + EXTU(0xa5a5a3fa, 19, 9, 0x0000003f) + DEP( 0xa5a5a3fa, 255, 19, 9, 0xa5a5affa) + EXT( 0xa5a5a3f9, 19, 10, 0x0000007f) + EXTU(0xa5a5a3f9, 19, 10, 0x0000007f) + DEP( 0xa5a5a3f9, 511, 19, 10, 0xa5a5aff9) + EXT( 0xa5a5a3f8, 19, 11, 0x000000fe) + EXTU(0xa5a5a3f8, 19, 11, 0x000000fe) + DEP( 0xa5a5a3f8, 1023, 19, 11, 0xa5a5affc) + EXT( 0xa5a5a3f7, 19, 12, 0x000001fb) + EXTU(0xa5a5a3f7, 19, 12, 0x000001fb) + DEP( 0xa5a5a3f7, 2047, 19, 12, 0xa5a5afff) + EXT( 0xa5a5a3f6, 20, 1, 0x00000000) + EXTU(0xa5a5a3f6, 20, 1, 0x00000000) + DEP( 0xa5a5a3f6, 0, 20, 1, 0xa5a5a3f6) + EXT( 0xa5a5a3f5, 20, 2, 0x00000000) + EXTU(0xa5a5a3f5, 20, 2, 0x00000000) + DEP( 0xa5a5a3f5, 1, 20, 2, 0xa5a5a7f5) + EXT( 0xa5a5a3f4, 20, 3, 0x00000001) + EXTU(0xa5a5a3f4, 20, 3, 0x00000001) + DEP( 0xa5a5a3f4, 3, 20, 3, 0xa5a5a7f4) + EXT( 0xa5a5a3f3, 20, 4, 0x00000003) + EXTU(0xa5a5a3f3, 20, 4, 0x00000003) + DEP( 0xa5a5a3f3, 7, 20, 4, 0xa5a5a7f3) + EXT( 0xa5a5a3f2, 20, 5, 0x00000007) + EXTU(0xa5a5a3f2, 20, 5, 0x00000007) + DEP( 0xa5a5a3f2, 15, 20, 5, 0xa5a5a7f2) + EXT( 0xa5a5a3f1, 20, 6, 0x0000000f) + EXTU(0xa5a5a3f1, 20, 6, 0x0000000f) + DEP( 0xa5a5a3f1, 31, 20, 6, 0xa5a5a7f1) + EXT( 0xa5a5a3f0, 20, 7, 0x0000001f) + EXTU(0xa5a5a3f0, 20, 7, 0x0000001f) + DEP( 0xa5a5a3f0, 63, 20, 7, 0xa5a5a7f0) + EXT( 0xa5a5a3ef, 20, 8, 0x0000003e) + EXTU(0xa5a5a3ef, 20, 8, 0x0000003e) + DEP( 0xa5a5a3ef, 127, 20, 8, 0xa5a5a7ff) + EXT( 0xa5a5a3ee, 20, 9, 0x0000007d) + EXTU(0xa5a5a3ee, 20, 9, 0x0000007d) + DEP( 0xa5a5a3ee, 255, 20, 9, 0xa5a5a7fe) + EXT( 0xa5a5a3ed, 20, 10, 0x000000fb) + EXTU(0xa5a5a3ed, 20, 10, 0x000000fb) + DEP( 0xa5a5a3ed, 511, 20, 10, 0xa5a5a7fd) + EXT( 0xa5a5a3ec, 20, 11, 0x000001f6) + EXTU(0xa5a5a3ec, 20, 11, 0x000001f6) + DEP( 0xa5a5a3ec, 1023, 20, 11, 0xa5a5a7fe) + EXT( 0xa5a5a3eb, 21, 1, 0x00000000) + EXTU(0xa5a5a3eb, 21, 1, 0x00000000) + DEP( 0xa5a5a3eb, 0, 21, 1, 0xa5a5a3eb) + EXT( 0xa5a5a3ea, 21, 2, 0x00000001) + EXTU(0xa5a5a3ea, 21, 2, 0x00000001) + DEP( 0xa5a5a3ea, 1, 21, 2, 0xa5a5a3ea) + EXT( 0xa5a5a3e9, 21, 3, 0x00000003) + EXTU(0xa5a5a3e9, 21, 3, 0x00000003) + DEP( 0xa5a5a3e9, 3, 21, 3, 0xa5a5a3e9) + EXT( 0xa5a5a3e8, 21, 4, 0x00000007) + EXTU(0xa5a5a3e8, 21, 4, 0x00000007) + DEP( 0xa5a5a3e8, 7, 21, 4, 0xa5a5a3e8) + EXT( 0xa5a5a3e7, 21, 5, 0x0000000f) + EXTU(0xa5a5a3e7, 21, 5, 0x0000000f) + DEP( 0xa5a5a3e7, 15, 21, 5, 0xa5a5a3e7) + EXT( 0xa5a5a3e6, 21, 6, 0x0000001f) + EXTU(0xa5a5a3e6, 21, 6, 0x0000001f) + DEP( 0xa5a5a3e6, 31, 21, 6, 0xa5a5a3e6) + EXT( 0xa5a5a3e5, 21, 7, 0x0000003e) + EXTU(0xa5a5a3e5, 21, 7, 0x0000003e) + DEP( 0xa5a5a3e5, 63, 21, 7, 0xa5a5a3f5) + EXT( 0xa5a5a3e4, 21, 8, 0x0000007c) + EXTU(0xa5a5a3e4, 21, 8, 0x0000007c) + DEP( 0xa5a5a3e4, 127, 21, 8, 0xa5a5a3fc) + EXT( 0xa5a5a3e3, 21, 9, 0x000000f8) + EXTU(0xa5a5a3e3, 21, 9, 0x000000f8) + DEP( 0xa5a5a3e3, 255, 21, 9, 0xa5a5a3ff) + EXT( 0xa5a5a3e2, 21, 10, 0x000001f1) + EXTU(0xa5a5a3e2, 21, 10, 0x000001f1) + DEP( 0xa5a5a3e2, 511, 21, 10, 0xa5a5a3fe) + EXT( 0xa5a5a3e1, 22, 1, 0xffffffff) + EXTU(0xa5a5a3e1, 22, 1, 0x00000001) + DEP( 0xa5a5a3e1, 0, 22, 1, 0xa5a5a1e1) + EXT( 0xa5a5a3e0, 22, 2, 0xffffffff) + EXTU(0xa5a5a3e0, 22, 2, 0x00000003) + DEP( 0xa5a5a3e0, 1, 22, 2, 0xa5a5a1e0) + EXT( 0xa5a5a3df, 22, 3, 0xffffffff) + EXTU(0xa5a5a3df, 22, 3, 0x00000007) + DEP( 0xa5a5a3df, 3, 22, 3, 0xa5a5a1df) + EXT( 0xa5a5a3de, 22, 4, 0xffffffff) + EXTU(0xa5a5a3de, 22, 4, 0x0000000f) + DEP( 0xa5a5a3de, 7, 22, 4, 0xa5a5a1de) + EXT( 0xa5a5a3dd, 22, 5, 0xfffffffe) + EXTU(0xa5a5a3dd, 22, 5, 0x0000001e) + DEP( 0xa5a5a3dd, 15, 22, 5, 0xa5a5a1fd) + EXT( 0xa5a5a3dc, 22, 6, 0xfffffffd) + EXTU(0xa5a5a3dc, 22, 6, 0x0000003d) + DEP( 0xa5a5a3dc, 31, 22, 6, 0xa5a5a1fc) + EXT( 0xa5a5a3db, 22, 7, 0xfffffffb) + EXTU(0xa5a5a3db, 22, 7, 0x0000007b) + DEP( 0xa5a5a3db, 63, 22, 7, 0xa5a5a1fb) + EXT( 0xa5a5a3da, 22, 8, 0xfffffff6) + EXTU(0xa5a5a3da, 22, 8, 0x000000f6) + DEP( 0xa5a5a3da, 127, 22, 8, 0xa5a5a1fe) + EXT( 0xa5a5a3d9, 22, 9, 0xffffffec) + EXTU(0xa5a5a3d9, 22, 9, 0x000001ec) + DEP( 0xa5a5a3d9, 255, 22, 9, 0xa5a5a1ff) + EXT( 0xa5a5a3d8, 23, 1, 0xffffffff) + EXTU(0xa5a5a3d8, 23, 1, 0x00000001) + DEP( 0xa5a5a3d8, 0, 23, 1, 0xa5a5a2d8) + EXT( 0xa5a5a3d7, 23, 2, 0xffffffff) + EXTU(0xa5a5a3d7, 23, 2, 0x00000003) + DEP( 0xa5a5a3d7, 1, 23, 2, 0xa5a5a2d7) + EXT( 0xa5a5a3d6, 23, 3, 0xffffffff) + EXTU(0xa5a5a3d6, 23, 3, 0x00000007) + DEP( 0xa5a5a3d6, 3, 23, 3, 0xa5a5a2d6) + EXT( 0xa5a5a3d5, 23, 4, 0xfffffffe) + EXTU(0xa5a5a3d5, 23, 4, 0x0000000e) + DEP( 0xa5a5a3d5, 7, 23, 4, 0xa5a5a2f5) + EXT( 0xa5a5a3d4, 23, 5, 0xfffffffd) + EXTU(0xa5a5a3d4, 23, 5, 0x0000001d) + DEP( 0xa5a5a3d4, 15, 23, 5, 0xa5a5a2f4) + EXT( 0xa5a5a3d3, 23, 6, 0xfffffffa) + EXTU(0xa5a5a3d3, 23, 6, 0x0000003a) + DEP( 0xa5a5a3d3, 31, 23, 6, 0xa5a5a2fb) + EXT( 0xa5a5a3d2, 23, 7, 0xfffffff4) + EXTU(0xa5a5a3d2, 23, 7, 0x00000074) + DEP( 0xa5a5a3d2, 63, 23, 7, 0xa5a5a2fe) + EXT( 0xa5a5a3d1, 23, 8, 0xffffffe8) + EXTU(0xa5a5a3d1, 23, 8, 0x000000e8) + DEP( 0xa5a5a3d1, 127, 23, 8, 0xa5a5a2ff) + EXT( 0xa5a5a3d0, 24, 1, 0xffffffff) + EXTU(0xa5a5a3d0, 24, 1, 0x00000001) + DEP( 0xa5a5a3d0, 0, 24, 1, 0xa5a5a350) + EXT( 0xa5a5a3cf, 24, 2, 0xffffffff) + EXTU(0xa5a5a3cf, 24, 2, 0x00000003) + DEP( 0xa5a5a3cf, 1, 24, 2, 0xa5a5a34f) + EXT( 0xa5a5a3ce, 24, 3, 0xfffffffe) + EXTU(0xa5a5a3ce, 24, 3, 0x00000006) + DEP( 0xa5a5a3ce, 3, 24, 3, 0xa5a5a36e) + EXT( 0xa5a5a3cd, 24, 4, 0xfffffffc) + EXTU(0xa5a5a3cd, 24, 4, 0x0000000c) + DEP( 0xa5a5a3cd, 7, 24, 4, 0xa5a5a37d) + EXT( 0xa5a5a3cc, 24, 5, 0xfffffff9) + EXTU(0xa5a5a3cc, 24, 5, 0x00000019) + DEP( 0xa5a5a3cc, 15, 24, 5, 0xa5a5a37c) + EXT( 0xa5a5a3cb, 24, 6, 0xfffffff2) + EXTU(0xa5a5a3cb, 24, 6, 0x00000032) + DEP( 0xa5a5a3cb, 31, 24, 6, 0xa5a5a37f) + EXT( 0xa5a5a3ca, 24, 7, 0xffffffe5) + EXTU(0xa5a5a3ca, 24, 7, 0x00000065) + DEP( 0xa5a5a3ca, 63, 24, 7, 0xa5a5a37e) + EXT( 0xa5a5a3c9, 25, 1, 0xffffffff) + EXTU(0xa5a5a3c9, 25, 1, 0x00000001) + DEP( 0xa5a5a3c9, 0, 25, 1, 0xa5a5a389) + EXT( 0xa5a5a3c8, 25, 2, 0xfffffffe) + EXTU(0xa5a5a3c8, 25, 2, 0x00000002) + DEP( 0xa5a5a3c8, 1, 25, 2, 0xa5a5a3a8) + EXT( 0xa5a5a3c7, 25, 3, 0xfffffffc) + EXTU(0xa5a5a3c7, 25, 3, 0x00000004) + DEP( 0xa5a5a3c7, 3, 25, 3, 0xa5a5a3b7) + EXT( 0xa5a5a3c6, 25, 4, 0xfffffff8) + EXTU(0xa5a5a3c6, 25, 4, 0x00000008) + DEP( 0xa5a5a3c6, 7, 25, 4, 0xa5a5a3be) + EXT( 0xa5a5a3c5, 25, 5, 0xfffffff1) + EXTU(0xa5a5a3c5, 25, 5, 0x00000011) + DEP( 0xa5a5a3c5, 15, 25, 5, 0xa5a5a3bd) + EXT( 0xa5a5a3c4, 25, 6, 0xffffffe2) + EXTU(0xa5a5a3c4, 25, 6, 0x00000022) + DEP( 0xa5a5a3c4, 31, 25, 6, 0xa5a5a3be) + EXT( 0xa5a5a3c3, 26, 1, 0x00000000) + EXTU(0xa5a5a3c3, 26, 1, 0x00000000) + DEP( 0xa5a5a3c3, 0, 26, 1, 0xa5a5a3c3) + EXT( 0xa5a5a3c2, 26, 2, 0x00000000) + EXTU(0xa5a5a3c2, 26, 2, 0x00000000) + DEP( 0xa5a5a3c2, 1, 26, 2, 0xa5a5a3d2) + EXT( 0xa5a5a3c1, 26, 3, 0x00000000) + EXTU(0xa5a5a3c1, 26, 3, 0x00000000) + DEP( 0xa5a5a3c1, 3, 26, 3, 0xa5a5a3d9) + EXT( 0xa5a5a3c0, 26, 4, 0x00000000) + EXTU(0xa5a5a3c0, 26, 4, 0x00000000) + DEP( 0xa5a5a3c0, 7, 26, 4, 0xa5a5a3dc) + EXT( 0xa5a5a3bf, 26, 5, 0xffffffff) + EXTU(0xa5a5a3bf, 26, 5, 0x0000001f) + DEP( 0xa5a5a3bf, 15, 26, 5, 0xa5a5a39f) + EXT( 0xa5a5a3be, 27, 1, 0xffffffff) + EXTU(0xa5a5a3be, 27, 1, 0x00000001) + DEP( 0xa5a5a3be, 0, 27, 1, 0xa5a5a3ae) + EXT( 0xa5a5a3bd, 27, 2, 0xffffffff) + EXTU(0xa5a5a3bd, 27, 2, 0x00000003) + DEP( 0xa5a5a3bd, 1, 27, 2, 0xa5a5a3ad) + EXT( 0xa5a5a3bc, 27, 3, 0xffffffff) + EXTU(0xa5a5a3bc, 27, 3, 0x00000007) + DEP( 0xa5a5a3bc, 3, 27, 3, 0xa5a5a3ac) + EXT( 0xa5a5a3bb, 27, 4, 0xfffffffd) + EXTU(0xa5a5a3bb, 27, 4, 0x0000000d) + DEP( 0xa5a5a3bb, 7, 27, 4, 0xa5a5a3af) + EXT( 0xa5a5a3ba, 28, 1, 0xffffffff) + EXTU(0xa5a5a3ba, 28, 1, 0x00000001) + DEP( 0xa5a5a3ba, 0, 28, 1, 0xa5a5a3b2) + EXT( 0xa5a5a3b9, 28, 2, 0xfffffffe) + EXTU(0xa5a5a3b9, 28, 2, 0x00000002) + DEP( 0xa5a5a3b9, 1, 28, 2, 0xa5a5a3b5) + EXT( 0xa5a5a3b8, 28, 3, 0xfffffffc) + EXTU(0xa5a5a3b8, 28, 3, 0x00000004) + DEP( 0xa5a5a3b8, 3, 28, 3, 0xa5a5a3b6) + EXT( 0xa5a5a3b7, 29, 1, 0xffffffff) + EXTU(0xa5a5a3b7, 29, 1, 0x00000001) + DEP( 0xa5a5a3b7, 0, 29, 1, 0xa5a5a3b3) + EXT( 0xa5a5a3b6, 29, 2, 0xffffffff) + EXTU(0xa5a5a3b6, 29, 2, 0x00000003) + DEP( 0xa5a5a3b6, 1, 29, 2, 0xa5a5a3b2) + EXT( 0xa5a5a3b5, 30, 1, 0x00000000) + EXTU(0xa5a5a3b5, 30, 1, 0x00000000) + DEP( 0xa5a5a3b5, 0, 30, 1, 0xa5a5a3b5) +# endif + +# else +# if __BYTE_ORDER == __LITTLE_ENDIAN + EXT( 0xa5a5a5a5a5a5a5a4, 0, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a5a4, 0, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a5a4, 0, 0, 1, 0xa5a5a5a5a5a5a5a4) + EXT( 0xa5a5a5a5a5a5a5a3, 0, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a5a3, 0, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a5a3, 1, 0, 2, 0xa5a5a5a5a5a5a5a1) + EXT( 0xa5a5a5a5a5a5a5a2, 0, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a5a2, 0, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a5a2, 3, 0, 3, 0xa5a5a5a5a5a5a5a3) + EXT( 0xa5a5a5a5a5a5a5a1, 0, 4, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a5a1, 0, 4, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a5a1, 7, 0, 4, 0xa5a5a5a5a5a5a5a7) + EXT( 0xa5a5a5a5a5a5a5a0, 0, 5, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a5a0, 0, 5, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a5a0, 15, 0, 5, 0xa5a5a5a5a5a5a5af) + EXT( 0xa5a5a5a5a5a5a59f, 0, 6, 0x000000000000001f) + EXTU(0xa5a5a5a5a5a5a59f, 0, 6, 0x000000000000001f) + DEP( 0xa5a5a5a5a5a5a59f, 31, 0, 6, 0xa5a5a5a5a5a5a59f) + EXT( 0xa5a5a5a5a5a5a59e, 0, 7, 0x000000000000001e) + EXTU(0xa5a5a5a5a5a5a59e, 0, 7, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a5a59e, 63, 0, 7, 0xa5a5a5a5a5a5a5bf) + EXT( 0xa5a5a5a5a5a5a59d, 0, 8, 0xffffffffffffff9d) + EXTU(0xa5a5a5a5a5a5a59d, 0, 8, 0x000000000000009d) + DEP( 0xa5a5a5a5a5a5a59d, 127, 0, 8, 0xa5a5a5a5a5a5a57f) + EXT( 0xa5a5a5a5a5a5a59c, 0, 9, 0xffffffffffffff9c) + EXTU(0xa5a5a5a5a5a5a59c, 0, 9, 0x000000000000019c) + DEP( 0xa5a5a5a5a5a5a59c, 255, 0, 9, 0xa5a5a5a5a5a5a4ff) + EXT( 0xa5a5a5a5a5a5a59b, 0, 10, 0x000000000000019b) + EXTU(0xa5a5a5a5a5a5a59b, 0, 10, 0x000000000000019b) + DEP( 0xa5a5a5a5a5a5a59b, 511, 0, 10, 0xa5a5a5a5a5a5a5ff) + EXT( 0xa5a5a5a5a5a5a59a, 0, 11, 0xfffffffffffffd9a) + EXTU(0xa5a5a5a5a5a5a59a, 0, 11, 0x000000000000059a) + DEP( 0xa5a5a5a5a5a5a59a, 1023, 0, 11, 0xa5a5a5a5a5a5a3ff) + EXT( 0xa5a5a5a5a5a5a599, 0, 12, 0x0000000000000599) + EXTU(0xa5a5a5a5a5a5a599, 0, 12, 0x0000000000000599) + DEP( 0xa5a5a5a5a5a5a599, 2047, 0, 12, 0xa5a5a5a5a5a5a7ff) + EXT( 0xa5a5a5a5a5a5a598, 0, 13, 0x0000000000000598) + EXTU(0xa5a5a5a5a5a5a598, 0, 13, 0x0000000000000598) + DEP( 0xa5a5a5a5a5a5a598, 4095, 0, 13, 0xa5a5a5a5a5a5afff) + EXT( 0xa5a5a5a5a5a5a597, 0, 14, 0xffffffffffffe597) + EXTU(0xa5a5a5a5a5a5a597, 0, 14, 0x0000000000002597) + DEP( 0xa5a5a5a5a5a5a597, 8191, 0, 14, 0xa5a5a5a5a5a59fff) + EXT( 0xa5a5a5a5a5a5a596, 0, 15, 0x0000000000002596) + EXTU(0xa5a5a5a5a5a5a596, 0, 15, 0x0000000000002596) + DEP( 0xa5a5a5a5a5a5a596, 16383, 0, 15, 0xa5a5a5a5a5a5bfff) + EXT( 0xa5a5a5a5a5a5a595, 0, 16, 0xffffffffffffa595) + EXTU(0xa5a5a5a5a5a5a595, 0, 16, 0x000000000000a595) + DEP( 0xa5a5a5a5a5a5a595, 32767, 0, 16, 0xa5a5a5a5a5a57fff) + EXT( 0xa5a5a5a5a5a5a594, 0, 17, 0xffffffffffffa594) + EXTU(0xa5a5a5a5a5a5a594, 0, 17, 0x000000000001a594) + DEP( 0xa5a5a5a5a5a5a594, 65535, 0, 17, 0xa5a5a5a5a5a4ffff) + EXT( 0xa5a5a5a5a5a5a593, 0, 18, 0x000000000001a593) + EXTU(0xa5a5a5a5a5a5a593, 0, 18, 0x000000000001a593) + DEP( 0xa5a5a5a5a5a5a593, 131071, 0, 18, 0xa5a5a5a5a5a5ffff) + EXT( 0xa5a5a5a5a5a5a592, 0, 19, 0xfffffffffffda592) + EXTU(0xa5a5a5a5a5a5a592, 0, 19, 0x000000000005a592) + DEP( 0xa5a5a5a5a5a5a592, 262143, 0, 19, 0xa5a5a5a5a5a3ffff) + EXT( 0xa5a5a5a5a5a5a591, 0, 20, 0x000000000005a591) + EXTU(0xa5a5a5a5a5a5a591, 0, 20, 0x000000000005a591) + DEP( 0xa5a5a5a5a5a5a591, 524287, 0, 20, 0xa5a5a5a5a5a7ffff) + EXT( 0xa5a5a5a5a5a5a590, 0, 21, 0x000000000005a590) + EXTU(0xa5a5a5a5a5a5a590, 0, 21, 0x000000000005a590) + DEP( 0xa5a5a5a5a5a5a590, 1048575, 0, 21, 0xa5a5a5a5a5afffff) + EXT( 0xa5a5a5a5a5a5a58f, 0, 22, 0xffffffffffe5a58f) + EXTU(0xa5a5a5a5a5a5a58f, 0, 22, 0x000000000025a58f) + DEP( 0xa5a5a5a5a5a5a58f, 2097151, 0, 22, 0xa5a5a5a5a59fffff) + EXT( 0xa5a5a5a5a5a5a58e, 0, 23, 0x000000000025a58e) + EXTU(0xa5a5a5a5a5a5a58e, 0, 23, 0x000000000025a58e) + DEP( 0xa5a5a5a5a5a5a58e, 4194303, 0, 23, 0xa5a5a5a5a5bfffff) + EXT( 0xa5a5a5a5a5a5a58d, 0, 24, 0xffffffffffa5a58d) + EXTU(0xa5a5a5a5a5a5a58d, 0, 24, 0x0000000000a5a58d) + DEP( 0xa5a5a5a5a5a5a58d, 8388607, 0, 24, 0xa5a5a5a5a57fffff) + EXT( 0xa5a5a5a5a5a5a58c, 0, 25, 0xffffffffffa5a58c) + EXTU(0xa5a5a5a5a5a5a58c, 0, 25, 0x0000000001a5a58c) + DEP( 0xa5a5a5a5a5a5a58c, 16777215, 0, 25, 0xa5a5a5a5a4ffffff) + EXT( 0xa5a5a5a5a5a5a58b, 0, 26, 0x0000000001a5a58b) + EXTU(0xa5a5a5a5a5a5a58b, 0, 26, 0x0000000001a5a58b) + DEP( 0xa5a5a5a5a5a5a58b, 33554431, 0, 26, 0xa5a5a5a5a5ffffff) + EXT( 0xa5a5a5a5a5a5a58a, 0, 27, 0xfffffffffda5a58a) + EXTU(0xa5a5a5a5a5a5a58a, 0, 27, 0x0000000005a5a58a) + DEP( 0xa5a5a5a5a5a5a58a, 67108863, 0, 27, 0xa5a5a5a5a3ffffff) + EXT( 0xa5a5a5a5a5a5a589, 0, 28, 0x0000000005a5a589) + EXTU(0xa5a5a5a5a5a5a589, 0, 28, 0x0000000005a5a589) + DEP( 0xa5a5a5a5a5a5a589, 134217727, 0, 28, 0xa5a5a5a5a7ffffff) + EXT( 0xa5a5a5a5a5a5a588, 0, 29, 0x0000000005a5a588) + EXTU(0xa5a5a5a5a5a5a588, 0, 29, 0x0000000005a5a588) + DEP( 0xa5a5a5a5a5a5a588, 268435455, 0, 29, 0xa5a5a5a5afffffff) + EXT( 0xa5a5a5a5a5a5a587, 0, 30, 0xffffffffe5a5a587) + EXTU(0xa5a5a5a5a5a5a587, 0, 30, 0x0000000025a5a587) + DEP( 0xa5a5a5a5a5a5a587, 536870911, 0, 30, 0xa5a5a5a59fffffff) + EXT( 0xa5a5a5a5a5a5a586, 0, 31, 0x0000000025a5a586) + EXTU(0xa5a5a5a5a5a5a586, 0, 31, 0x0000000025a5a586) + DEP( 0xa5a5a5a5a5a5a586, 1073741823, 0, 31, 0xa5a5a5a5bfffffff) + EXT( 0xa5a5a5a5a5a5a585, 0, 32, 0xffffffffa5a5a585) + EXTU(0xa5a5a5a5a5a5a585, 0, 32, 0x00000000a5a5a585) + DEP( 0xa5a5a5a5a5a5a585, 2147483647, 0, 32, 0xa5a5a5a57fffffff) + EXT( 0xa5a5a5a5a5a5a584, 0, 33, 0xffffffffa5a5a584) + EXTU(0xa5a5a5a5a5a5a584, 0, 33, 0x00000001a5a5a584) + DEP( 0xa5a5a5a5a5a5a584, 4294967295, 0, 33, 0xa5a5a5a4ffffffff) + EXT( 0xa5a5a5a5a5a5a583, 0, 34, 0x00000001a5a5a583) + EXTU(0xa5a5a5a5a5a5a583, 0, 34, 0x00000001a5a5a583) + DEP( 0xa5a5a5a5a5a5a583, 8589934591, 0, 34, 0xa5a5a5a5ffffffff) + EXT( 0xa5a5a5a5a5a5a582, 0, 35, 0xfffffffda5a5a582) + EXTU(0xa5a5a5a5a5a5a582, 0, 35, 0x00000005a5a5a582) + DEP( 0xa5a5a5a5a5a5a582, 17179869183, 0, 35, 0xa5a5a5a3ffffffff) + EXT( 0xa5a5a5a5a5a5a581, 0, 36, 0x00000005a5a5a581) + EXTU(0xa5a5a5a5a5a5a581, 0, 36, 0x00000005a5a5a581) + DEP( 0xa5a5a5a5a5a5a581, 34359738367, 0, 36, 0xa5a5a5a7ffffffff) + EXT( 0xa5a5a5a5a5a5a580, 0, 37, 0x00000005a5a5a580) + EXTU(0xa5a5a5a5a5a5a580, 0, 37, 0x00000005a5a5a580) + DEP( 0xa5a5a5a5a5a5a580, 68719476735, 0, 37, 0xa5a5a5afffffffff) + EXT( 0xa5a5a5a5a5a5a57f, 0, 38, 0xffffffe5a5a5a57f) + EXTU(0xa5a5a5a5a5a5a57f, 0, 38, 0x00000025a5a5a57f) + DEP( 0xa5a5a5a5a5a5a57f, 137438953471, 0, 38, 0xa5a5a59fffffffff) + EXT( 0xa5a5a5a5a5a5a57e, 0, 39, 0x00000025a5a5a57e) + EXTU(0xa5a5a5a5a5a5a57e, 0, 39, 0x00000025a5a5a57e) + DEP( 0xa5a5a5a5a5a5a57e, 274877906943, 0, 39, 0xa5a5a5bfffffffff) + EXT( 0xa5a5a5a5a5a5a57d, 0, 40, 0xffffffa5a5a5a57d) + EXTU(0xa5a5a5a5a5a5a57d, 0, 40, 0x000000a5a5a5a57d) + DEP( 0xa5a5a5a5a5a5a57d, 549755813887, 0, 40, 0xa5a5a57fffffffff) + EXT( 0xa5a5a5a5a5a5a57c, 0, 41, 0xffffffa5a5a5a57c) + EXTU(0xa5a5a5a5a5a5a57c, 0, 41, 0x000001a5a5a5a57c) + DEP( 0xa5a5a5a5a5a5a57c, 1099511627775, 0, 41, 0xa5a5a4ffffffffff) + EXT( 0xa5a5a5a5a5a5a57b, 0, 42, 0x000001a5a5a5a57b) + EXTU(0xa5a5a5a5a5a5a57b, 0, 42, 0x000001a5a5a5a57b) + DEP( 0xa5a5a5a5a5a5a57b, 2199023255551, 0, 42, 0xa5a5a5ffffffffff) + EXT( 0xa5a5a5a5a5a5a57a, 0, 43, 0xfffffda5a5a5a57a) + EXTU(0xa5a5a5a5a5a5a57a, 0, 43, 0x000005a5a5a5a57a) + DEP( 0xa5a5a5a5a5a5a57a, 4398046511103, 0, 43, 0xa5a5a3ffffffffff) + EXT( 0xa5a5a5a5a5a5a579, 0, 44, 0x000005a5a5a5a579) + EXTU(0xa5a5a5a5a5a5a579, 0, 44, 0x000005a5a5a5a579) + DEP( 0xa5a5a5a5a5a5a579, 8796093022207, 0, 44, 0xa5a5a7ffffffffff) + EXT( 0xa5a5a5a5a5a5a578, 0, 45, 0x000005a5a5a5a578) + EXTU(0xa5a5a5a5a5a5a578, 0, 45, 0x000005a5a5a5a578) + DEP( 0xa5a5a5a5a5a5a578, 17592186044415, 0, 45, 0xa5a5afffffffffff) + EXT( 0xa5a5a5a5a5a5a577, 0, 46, 0xffffe5a5a5a5a577) + EXTU(0xa5a5a5a5a5a5a577, 0, 46, 0x000025a5a5a5a577) + DEP( 0xa5a5a5a5a5a5a577, 35184372088831, 0, 46, 0xa5a59fffffffffff) + EXT( 0xa5a5a5a5a5a5a576, 0, 47, 0x000025a5a5a5a576) + EXTU(0xa5a5a5a5a5a5a576, 0, 47, 0x000025a5a5a5a576) + DEP( 0xa5a5a5a5a5a5a576, 70368744177663, 0, 47, 0xa5a5bfffffffffff) + EXT( 0xa5a5a5a5a5a5a575, 0, 48, 0xffffa5a5a5a5a575) + EXTU(0xa5a5a5a5a5a5a575, 0, 48, 0x0000a5a5a5a5a575) + DEP( 0xa5a5a5a5a5a5a575, 140737488355327, 0, 48, 0xa5a57fffffffffff) + EXT( 0xa5a5a5a5a5a5a574, 0, 49, 0xffffa5a5a5a5a574) + EXTU(0xa5a5a5a5a5a5a574, 0, 49, 0x0001a5a5a5a5a574) + DEP( 0xa5a5a5a5a5a5a574, 281474976710655, 0, 49, 0xa5a4ffffffffffff) + EXT( 0xa5a5a5a5a5a5a573, 0, 50, 0x0001a5a5a5a5a573) + EXTU(0xa5a5a5a5a5a5a573, 0, 50, 0x0001a5a5a5a5a573) + DEP( 0xa5a5a5a5a5a5a573, 562949953421311, 0, 50, 0xa5a5ffffffffffff) + EXT( 0xa5a5a5a5a5a5a572, 0, 51, 0xfffda5a5a5a5a572) + EXTU(0xa5a5a5a5a5a5a572, 0, 51, 0x0005a5a5a5a5a572) + DEP( 0xa5a5a5a5a5a5a572, 1125899906842623, 0, 51, 0xa5a3ffffffffffff) + EXT( 0xa5a5a5a5a5a5a571, 0, 52, 0x0005a5a5a5a5a571) + EXTU(0xa5a5a5a5a5a5a571, 0, 52, 0x0005a5a5a5a5a571) + DEP( 0xa5a5a5a5a5a5a571, 2251799813685247, 0, 52, 0xa5a7ffffffffffff) + EXT( 0xa5a5a5a5a5a5a570, 0, 53, 0x0005a5a5a5a5a570) + EXTU(0xa5a5a5a5a5a5a570, 0, 53, 0x0005a5a5a5a5a570) + DEP( 0xa5a5a5a5a5a5a570, 4503599627370495, 0, 53, 0xa5afffffffffffff) + EXT( 0xa5a5a5a5a5a5a56f, 0, 54, 0xffe5a5a5a5a5a56f) + EXTU(0xa5a5a5a5a5a5a56f, 0, 54, 0x0025a5a5a5a5a56f) + DEP( 0xa5a5a5a5a5a5a56f, 9007199254740991, 0, 54, 0xa59fffffffffffff) + EXT( 0xa5a5a5a5a5a5a56e, 0, 55, 0x0025a5a5a5a5a56e) + EXTU(0xa5a5a5a5a5a5a56e, 0, 55, 0x0025a5a5a5a5a56e) + DEP( 0xa5a5a5a5a5a5a56e, 18014398509481983, 0, 55, 0xa5bfffffffffffff) + EXT( 0xa5a5a5a5a5a5a56d, 0, 56, 0xffa5a5a5a5a5a56d) + EXTU(0xa5a5a5a5a5a5a56d, 0, 56, 0x00a5a5a5a5a5a56d) + DEP( 0xa5a5a5a5a5a5a56d, 36028797018963967, 0, 56, 0xa57fffffffffffff) + EXT( 0xa5a5a5a5a5a5a56c, 0, 57, 0xffa5a5a5a5a5a56c) + EXTU(0xa5a5a5a5a5a5a56c, 0, 57, 0x01a5a5a5a5a5a56c) + DEP( 0xa5a5a5a5a5a5a56c, 72057594037927935, 0, 57, 0xa4ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a56b, 0, 58, 0x01a5a5a5a5a5a56b) + EXTU(0xa5a5a5a5a5a5a56b, 0, 58, 0x01a5a5a5a5a5a56b) + DEP( 0xa5a5a5a5a5a5a56b, 144115188075855871, 0, 58, 0xa5ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a56a, 0, 59, 0xfda5a5a5a5a5a56a) + EXTU(0xa5a5a5a5a5a5a56a, 0, 59, 0x05a5a5a5a5a5a56a) + DEP( 0xa5a5a5a5a5a5a56a, 288230376151711743, 0, 59, 0xa3ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a569, 0, 60, 0x05a5a5a5a5a5a569) + EXTU(0xa5a5a5a5a5a5a569, 0, 60, 0x05a5a5a5a5a5a569) + DEP( 0xa5a5a5a5a5a5a569, 576460752303423487, 0, 60, 0xa7ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a568, 0, 61, 0x05a5a5a5a5a5a568) + EXTU(0xa5a5a5a5a5a5a568, 0, 61, 0x05a5a5a5a5a5a568) + DEP( 0xa5a5a5a5a5a5a568, 1152921504606846975, 0, 61, 0xafffffffffffffff) + EXT( 0xa5a5a5a5a5a5a567, 0, 62, 0xe5a5a5a5a5a5a567) + EXTU(0xa5a5a5a5a5a5a567, 0, 62, 0x25a5a5a5a5a5a567) + DEP( 0xa5a5a5a5a5a5a567, 2305843009213693951, 0, 62, 0x9fffffffffffffff) + EXT( 0xa5a5a5a5a5a5a566, 0, 63, 0x25a5a5a5a5a5a566) + EXTU(0xa5a5a5a5a5a5a566, 0, 63, 0x25a5a5a5a5a5a566) + DEP( 0xa5a5a5a5a5a5a566, 4611686018427387903, 0, 63, 0xbfffffffffffffff) + EXT( 0xa5a5a5a5a5a5a565, 1, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a565, 1, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a565, 0, 1, 1, 0xa5a5a5a5a5a5a565) + EXT( 0xa5a5a5a5a5a5a564, 1, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a564, 1, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a564, 1, 1, 2, 0xa5a5a5a5a5a5a562) + EXT( 0xa5a5a5a5a5a5a563, 1, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a563, 1, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a563, 3, 1, 3, 0xa5a5a5a5a5a5a567) + EXT( 0xa5a5a5a5a5a5a562, 1, 4, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a562, 1, 4, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a562, 7, 1, 4, 0xa5a5a5a5a5a5a56e) + EXT( 0xa5a5a5a5a5a5a561, 1, 5, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a5a561, 1, 5, 0x0000000000000010) + DEP( 0xa5a5a5a5a5a5a561, 15, 1, 5, 0xa5a5a5a5a5a5a55f) + EXT( 0xa5a5a5a5a5a5a560, 1, 6, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a5a560, 1, 6, 0x0000000000000030) + DEP( 0xa5a5a5a5a5a5a560, 31, 1, 6, 0xa5a5a5a5a5a5a53e) + EXT( 0xa5a5a5a5a5a5a55f, 1, 7, 0x000000000000002f) + EXTU(0xa5a5a5a5a5a5a55f, 1, 7, 0x000000000000002f) + DEP( 0xa5a5a5a5a5a5a55f, 63, 1, 7, 0xa5a5a5a5a5a5a57f) + EXT( 0xa5a5a5a5a5a5a55e, 1, 8, 0xffffffffffffffaf) + EXTU(0xa5a5a5a5a5a5a55e, 1, 8, 0x00000000000000af) + DEP( 0xa5a5a5a5a5a5a55e, 127, 1, 8, 0xa5a5a5a5a5a5a4fe) + EXT( 0xa5a5a5a5a5a5a55d, 1, 9, 0x00000000000000ae) + EXTU(0xa5a5a5a5a5a5a55d, 1, 9, 0x00000000000000ae) + DEP( 0xa5a5a5a5a5a5a55d, 255, 1, 9, 0xa5a5a5a5a5a5a5ff) + EXT( 0xa5a5a5a5a5a5a55c, 1, 10, 0xfffffffffffffeae) + EXTU(0xa5a5a5a5a5a5a55c, 1, 10, 0x00000000000002ae) + DEP( 0xa5a5a5a5a5a5a55c, 511, 1, 10, 0xa5a5a5a5a5a5a3fe) + EXT( 0xa5a5a5a5a5a5a55b, 1, 11, 0x00000000000002ad) + EXTU(0xa5a5a5a5a5a5a55b, 1, 11, 0x00000000000002ad) + DEP( 0xa5a5a5a5a5a5a55b, 1023, 1, 11, 0xa5a5a5a5a5a5a7ff) + EXT( 0xa5a5a5a5a5a5a55a, 1, 12, 0x00000000000002ad) + EXTU(0xa5a5a5a5a5a5a55a, 1, 12, 0x00000000000002ad) + DEP( 0xa5a5a5a5a5a5a55a, 2047, 1, 12, 0xa5a5a5a5a5a5affe) + EXT( 0xa5a5a5a5a5a5a559, 1, 13, 0xfffffffffffff2ac) + EXTU(0xa5a5a5a5a5a5a559, 1, 13, 0x00000000000012ac) + DEP( 0xa5a5a5a5a5a5a559, 4095, 1, 13, 0xa5a5a5a5a5a59fff) + EXT( 0xa5a5a5a5a5a5a558, 1, 14, 0x00000000000012ac) + EXTU(0xa5a5a5a5a5a5a558, 1, 14, 0x00000000000012ac) + DEP( 0xa5a5a5a5a5a5a558, 8191, 1, 14, 0xa5a5a5a5a5a5bffe) + EXT( 0xa5a5a5a5a5a5a557, 1, 15, 0xffffffffffffd2ab) + EXTU(0xa5a5a5a5a5a5a557, 1, 15, 0x00000000000052ab) + DEP( 0xa5a5a5a5a5a5a557, 16383, 1, 15, 0xa5a5a5a5a5a57fff) + EXT( 0xa5a5a5a5a5a5a556, 1, 16, 0xffffffffffffd2ab) + EXTU(0xa5a5a5a5a5a5a556, 1, 16, 0x000000000000d2ab) + DEP( 0xa5a5a5a5a5a5a556, 32767, 1, 16, 0xa5a5a5a5a5a4fffe) + EXT( 0xa5a5a5a5a5a5a555, 1, 17, 0x000000000000d2aa) + EXTU(0xa5a5a5a5a5a5a555, 1, 17, 0x000000000000d2aa) + DEP( 0xa5a5a5a5a5a5a555, 65535, 1, 17, 0xa5a5a5a5a5a5ffff) + EXT( 0xa5a5a5a5a5a5a554, 1, 18, 0xfffffffffffed2aa) + EXTU(0xa5a5a5a5a5a5a554, 1, 18, 0x000000000002d2aa) + DEP( 0xa5a5a5a5a5a5a554, 131071, 1, 18, 0xa5a5a5a5a5a3fffe) + EXT( 0xa5a5a5a5a5a5a553, 1, 19, 0x000000000002d2a9) + EXTU(0xa5a5a5a5a5a5a553, 1, 19, 0x000000000002d2a9) + DEP( 0xa5a5a5a5a5a5a553, 262143, 1, 19, 0xa5a5a5a5a5a7ffff) + EXT( 0xa5a5a5a5a5a5a552, 1, 20, 0x000000000002d2a9) + EXTU(0xa5a5a5a5a5a5a552, 1, 20, 0x000000000002d2a9) + DEP( 0xa5a5a5a5a5a5a552, 524287, 1, 20, 0xa5a5a5a5a5affffe) + EXT( 0xa5a5a5a5a5a5a551, 1, 21, 0xfffffffffff2d2a8) + EXTU(0xa5a5a5a5a5a5a551, 1, 21, 0x000000000012d2a8) + DEP( 0xa5a5a5a5a5a5a551, 1048575, 1, 21, 0xa5a5a5a5a59fffff) + EXT( 0xa5a5a5a5a5a5a550, 1, 22, 0x000000000012d2a8) + EXTU(0xa5a5a5a5a5a5a550, 1, 22, 0x000000000012d2a8) + DEP( 0xa5a5a5a5a5a5a550, 2097151, 1, 22, 0xa5a5a5a5a5bffffe) + EXT( 0xa5a5a5a5a5a5a54f, 1, 23, 0xffffffffffd2d2a7) + EXTU(0xa5a5a5a5a5a5a54f, 1, 23, 0x000000000052d2a7) + DEP( 0xa5a5a5a5a5a5a54f, 4194303, 1, 23, 0xa5a5a5a5a57fffff) + EXT( 0xa5a5a5a5a5a5a54e, 1, 24, 0xffffffffffd2d2a7) + EXTU(0xa5a5a5a5a5a5a54e, 1, 24, 0x0000000000d2d2a7) + DEP( 0xa5a5a5a5a5a5a54e, 8388607, 1, 24, 0xa5a5a5a5a4fffffe) + EXT( 0xa5a5a5a5a5a5a54d, 1, 25, 0x0000000000d2d2a6) + EXTU(0xa5a5a5a5a5a5a54d, 1, 25, 0x0000000000d2d2a6) + DEP( 0xa5a5a5a5a5a5a54d, 16777215, 1, 25, 0xa5a5a5a5a5ffffff) + EXT( 0xa5a5a5a5a5a5a54c, 1, 26, 0xfffffffffed2d2a6) + EXTU(0xa5a5a5a5a5a5a54c, 1, 26, 0x0000000002d2d2a6) + DEP( 0xa5a5a5a5a5a5a54c, 33554431, 1, 26, 0xa5a5a5a5a3fffffe) + EXT( 0xa5a5a5a5a5a5a54b, 1, 27, 0x0000000002d2d2a5) + EXTU(0xa5a5a5a5a5a5a54b, 1, 27, 0x0000000002d2d2a5) + DEP( 0xa5a5a5a5a5a5a54b, 67108863, 1, 27, 0xa5a5a5a5a7ffffff) + EXT( 0xa5a5a5a5a5a5a54a, 1, 28, 0x0000000002d2d2a5) + EXTU(0xa5a5a5a5a5a5a54a, 1, 28, 0x0000000002d2d2a5) + DEP( 0xa5a5a5a5a5a5a54a, 134217727, 1, 28, 0xa5a5a5a5affffffe) + EXT( 0xa5a5a5a5a5a5a549, 1, 29, 0xfffffffff2d2d2a4) + EXTU(0xa5a5a5a5a5a5a549, 1, 29, 0x0000000012d2d2a4) + DEP( 0xa5a5a5a5a5a5a549, 268435455, 1, 29, 0xa5a5a5a59fffffff) + EXT( 0xa5a5a5a5a5a5a548, 1, 30, 0x0000000012d2d2a4) + EXTU(0xa5a5a5a5a5a5a548, 1, 30, 0x0000000012d2d2a4) + DEP( 0xa5a5a5a5a5a5a548, 536870911, 1, 30, 0xa5a5a5a5bffffffe) + EXT( 0xa5a5a5a5a5a5a547, 1, 31, 0xffffffffd2d2d2a3) + EXTU(0xa5a5a5a5a5a5a547, 1, 31, 0x0000000052d2d2a3) + DEP( 0xa5a5a5a5a5a5a547, 1073741823, 1, 31, 0xa5a5a5a57fffffff) + EXT( 0xa5a5a5a5a5a5a546, 1, 32, 0xffffffffd2d2d2a3) + EXTU(0xa5a5a5a5a5a5a546, 1, 32, 0x00000000d2d2d2a3) + DEP( 0xa5a5a5a5a5a5a546, 2147483647, 1, 32, 0xa5a5a5a4fffffffe) + EXT( 0xa5a5a5a5a5a5a545, 1, 33, 0x00000000d2d2d2a2) + EXTU(0xa5a5a5a5a5a5a545, 1, 33, 0x00000000d2d2d2a2) + DEP( 0xa5a5a5a5a5a5a545, 4294967295, 1, 33, 0xa5a5a5a5ffffffff) + EXT( 0xa5a5a5a5a5a5a544, 1, 34, 0xfffffffed2d2d2a2) + EXTU(0xa5a5a5a5a5a5a544, 1, 34, 0x00000002d2d2d2a2) + DEP( 0xa5a5a5a5a5a5a544, 8589934591, 1, 34, 0xa5a5a5a3fffffffe) + EXT( 0xa5a5a5a5a5a5a543, 1, 35, 0x00000002d2d2d2a1) + EXTU(0xa5a5a5a5a5a5a543, 1, 35, 0x00000002d2d2d2a1) + DEP( 0xa5a5a5a5a5a5a543, 17179869183, 1, 35, 0xa5a5a5a7ffffffff) + EXT( 0xa5a5a5a5a5a5a542, 1, 36, 0x00000002d2d2d2a1) + EXTU(0xa5a5a5a5a5a5a542, 1, 36, 0x00000002d2d2d2a1) + DEP( 0xa5a5a5a5a5a5a542, 34359738367, 1, 36, 0xa5a5a5affffffffe) + EXT( 0xa5a5a5a5a5a5a541, 1, 37, 0xfffffff2d2d2d2a0) + EXTU(0xa5a5a5a5a5a5a541, 1, 37, 0x00000012d2d2d2a0) + DEP( 0xa5a5a5a5a5a5a541, 68719476735, 1, 37, 0xa5a5a59fffffffff) + EXT( 0xa5a5a5a5a5a5a540, 1, 38, 0x00000012d2d2d2a0) + EXTU(0xa5a5a5a5a5a5a540, 1, 38, 0x00000012d2d2d2a0) + DEP( 0xa5a5a5a5a5a5a540, 137438953471, 1, 38, 0xa5a5a5bffffffffe) + EXT( 0xa5a5a5a5a5a5a53f, 1, 39, 0xffffffd2d2d2d29f) + EXTU(0xa5a5a5a5a5a5a53f, 1, 39, 0x00000052d2d2d29f) + DEP( 0xa5a5a5a5a5a5a53f, 274877906943, 1, 39, 0xa5a5a57fffffffff) + EXT( 0xa5a5a5a5a5a5a53e, 1, 40, 0xffffffd2d2d2d29f) + EXTU(0xa5a5a5a5a5a5a53e, 1, 40, 0x000000d2d2d2d29f) + DEP( 0xa5a5a5a5a5a5a53e, 549755813887, 1, 40, 0xa5a5a4fffffffffe) + EXT( 0xa5a5a5a5a5a5a53d, 1, 41, 0x000000d2d2d2d29e) + EXTU(0xa5a5a5a5a5a5a53d, 1, 41, 0x000000d2d2d2d29e) + DEP( 0xa5a5a5a5a5a5a53d, 1099511627775, 1, 41, 0xa5a5a5ffffffffff) + EXT( 0xa5a5a5a5a5a5a53c, 1, 42, 0xfffffed2d2d2d29e) + EXTU(0xa5a5a5a5a5a5a53c, 1, 42, 0x000002d2d2d2d29e) + DEP( 0xa5a5a5a5a5a5a53c, 2199023255551, 1, 42, 0xa5a5a3fffffffffe) + EXT( 0xa5a5a5a5a5a5a53b, 1, 43, 0x000002d2d2d2d29d) + EXTU(0xa5a5a5a5a5a5a53b, 1, 43, 0x000002d2d2d2d29d) + DEP( 0xa5a5a5a5a5a5a53b, 4398046511103, 1, 43, 0xa5a5a7ffffffffff) + EXT( 0xa5a5a5a5a5a5a53a, 1, 44, 0x000002d2d2d2d29d) + EXTU(0xa5a5a5a5a5a5a53a, 1, 44, 0x000002d2d2d2d29d) + DEP( 0xa5a5a5a5a5a5a53a, 8796093022207, 1, 44, 0xa5a5affffffffffe) + EXT( 0xa5a5a5a5a5a5a539, 1, 45, 0xfffff2d2d2d2d29c) + EXTU(0xa5a5a5a5a5a5a539, 1, 45, 0x000012d2d2d2d29c) + DEP( 0xa5a5a5a5a5a5a539, 17592186044415, 1, 45, 0xa5a59fffffffffff) + EXT( 0xa5a5a5a5a5a5a538, 1, 46, 0x000012d2d2d2d29c) + EXTU(0xa5a5a5a5a5a5a538, 1, 46, 0x000012d2d2d2d29c) + DEP( 0xa5a5a5a5a5a5a538, 35184372088831, 1, 46, 0xa5a5bffffffffffe) + EXT( 0xa5a5a5a5a5a5a537, 1, 47, 0xffffd2d2d2d2d29b) + EXTU(0xa5a5a5a5a5a5a537, 1, 47, 0x000052d2d2d2d29b) + DEP( 0xa5a5a5a5a5a5a537, 70368744177663, 1, 47, 0xa5a57fffffffffff) + EXT( 0xa5a5a5a5a5a5a536, 1, 48, 0xffffd2d2d2d2d29b) + EXTU(0xa5a5a5a5a5a5a536, 1, 48, 0x0000d2d2d2d2d29b) + DEP( 0xa5a5a5a5a5a5a536, 140737488355327, 1, 48, 0xa5a4fffffffffffe) + EXT( 0xa5a5a5a5a5a5a535, 1, 49, 0x0000d2d2d2d2d29a) + EXTU(0xa5a5a5a5a5a5a535, 1, 49, 0x0000d2d2d2d2d29a) + DEP( 0xa5a5a5a5a5a5a535, 281474976710655, 1, 49, 0xa5a5ffffffffffff) + EXT( 0xa5a5a5a5a5a5a534, 1, 50, 0xfffed2d2d2d2d29a) + EXTU(0xa5a5a5a5a5a5a534, 1, 50, 0x0002d2d2d2d2d29a) + DEP( 0xa5a5a5a5a5a5a534, 562949953421311, 1, 50, 0xa5a3fffffffffffe) + EXT( 0xa5a5a5a5a5a5a533, 1, 51, 0x0002d2d2d2d2d299) + EXTU(0xa5a5a5a5a5a5a533, 1, 51, 0x0002d2d2d2d2d299) + DEP( 0xa5a5a5a5a5a5a533, 1125899906842623, 1, 51, 0xa5a7ffffffffffff) + EXT( 0xa5a5a5a5a5a5a532, 1, 52, 0x0002d2d2d2d2d299) + EXTU(0xa5a5a5a5a5a5a532, 1, 52, 0x0002d2d2d2d2d299) + DEP( 0xa5a5a5a5a5a5a532, 2251799813685247, 1, 52, 0xa5affffffffffffe) + EXT( 0xa5a5a5a5a5a5a531, 1, 53, 0xfff2d2d2d2d2d298) + EXTU(0xa5a5a5a5a5a5a531, 1, 53, 0x0012d2d2d2d2d298) + DEP( 0xa5a5a5a5a5a5a531, 4503599627370495, 1, 53, 0xa59fffffffffffff) + EXT( 0xa5a5a5a5a5a5a530, 1, 54, 0x0012d2d2d2d2d298) + EXTU(0xa5a5a5a5a5a5a530, 1, 54, 0x0012d2d2d2d2d298) + DEP( 0xa5a5a5a5a5a5a530, 9007199254740991, 1, 54, 0xa5bffffffffffffe) + EXT( 0xa5a5a5a5a5a5a52f, 1, 55, 0xffd2d2d2d2d2d297) + EXTU(0xa5a5a5a5a5a5a52f, 1, 55, 0x0052d2d2d2d2d297) + DEP( 0xa5a5a5a5a5a5a52f, 18014398509481983, 1, 55, 0xa57fffffffffffff) + EXT( 0xa5a5a5a5a5a5a52e, 1, 56, 0xffd2d2d2d2d2d297) + EXTU(0xa5a5a5a5a5a5a52e, 1, 56, 0x00d2d2d2d2d2d297) + DEP( 0xa5a5a5a5a5a5a52e, 36028797018963967, 1, 56, 0xa4fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a52d, 1, 57, 0x00d2d2d2d2d2d296) + EXTU(0xa5a5a5a5a5a5a52d, 1, 57, 0x00d2d2d2d2d2d296) + DEP( 0xa5a5a5a5a5a5a52d, 72057594037927935, 1, 57, 0xa5ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a52c, 1, 58, 0xfed2d2d2d2d2d296) + EXTU(0xa5a5a5a5a5a5a52c, 1, 58, 0x02d2d2d2d2d2d296) + DEP( 0xa5a5a5a5a5a5a52c, 144115188075855871, 1, 58, 0xa3fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a52b, 1, 59, 0x02d2d2d2d2d2d295) + EXTU(0xa5a5a5a5a5a5a52b, 1, 59, 0x02d2d2d2d2d2d295) + DEP( 0xa5a5a5a5a5a5a52b, 288230376151711743, 1, 59, 0xa7ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a52a, 1, 60, 0x02d2d2d2d2d2d295) + EXTU(0xa5a5a5a5a5a5a52a, 1, 60, 0x02d2d2d2d2d2d295) + DEP( 0xa5a5a5a5a5a5a52a, 576460752303423487, 1, 60, 0xaffffffffffffffe) + EXT( 0xa5a5a5a5a5a5a529, 1, 61, 0xf2d2d2d2d2d2d294) + EXTU(0xa5a5a5a5a5a5a529, 1, 61, 0x12d2d2d2d2d2d294) + DEP( 0xa5a5a5a5a5a5a529, 1152921504606846975, 1, 61, 0x9fffffffffffffff) + EXT( 0xa5a5a5a5a5a5a528, 1, 62, 0x12d2d2d2d2d2d294) + EXTU(0xa5a5a5a5a5a5a528, 1, 62, 0x12d2d2d2d2d2d294) + DEP( 0xa5a5a5a5a5a5a528, 2305843009213693951, 1, 62, 0xbffffffffffffffe) + EXT( 0xa5a5a5a5a5a5a527, 2, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a527, 2, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a527, 0, 2, 1, 0xa5a5a5a5a5a5a523) + EXT( 0xa5a5a5a5a5a5a526, 2, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a526, 2, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a526, 1, 2, 2, 0xa5a5a5a5a5a5a526) + EXT( 0xa5a5a5a5a5a5a525, 2, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a525, 2, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a525, 3, 2, 3, 0xa5a5a5a5a5a5a52d) + EXT( 0xa5a5a5a5a5a5a524, 2, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a524, 2, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a524, 7, 2, 4, 0xa5a5a5a5a5a5a51c) + EXT( 0xa5a5a5a5a5a5a523, 2, 5, 0x0000000000000008) + EXTU(0xa5a5a5a5a5a5a523, 2, 5, 0x0000000000000008) + DEP( 0xa5a5a5a5a5a5a523, 15, 2, 5, 0xa5a5a5a5a5a5a53f) + EXT( 0xa5a5a5a5a5a5a522, 2, 6, 0x0000000000000008) + EXTU(0xa5a5a5a5a5a5a522, 2, 6, 0x0000000000000008) + DEP( 0xa5a5a5a5a5a5a522, 31, 2, 6, 0xa5a5a5a5a5a5a57e) + EXT( 0xa5a5a5a5a5a5a521, 2, 7, 0xffffffffffffffc8) + EXTU(0xa5a5a5a5a5a5a521, 2, 7, 0x0000000000000048) + DEP( 0xa5a5a5a5a5a5a521, 63, 2, 7, 0xa5a5a5a5a5a5a4fd) + EXT( 0xa5a5a5a5a5a5a520, 2, 8, 0x0000000000000048) + EXTU(0xa5a5a5a5a5a5a520, 2, 8, 0x0000000000000048) + DEP( 0xa5a5a5a5a5a5a520, 127, 2, 8, 0xa5a5a5a5a5a5a5fc) + EXT( 0xa5a5a5a5a5a5a51f, 2, 9, 0xffffffffffffff47) + EXTU(0xa5a5a5a5a5a5a51f, 2, 9, 0x0000000000000147) + DEP( 0xa5a5a5a5a5a5a51f, 255, 2, 9, 0xa5a5a5a5a5a5a3ff) + EXT( 0xa5a5a5a5a5a5a51e, 2, 10, 0x0000000000000147) + EXTU(0xa5a5a5a5a5a5a51e, 2, 10, 0x0000000000000147) + DEP( 0xa5a5a5a5a5a5a51e, 511, 2, 10, 0xa5a5a5a5a5a5a7fe) + EXT( 0xa5a5a5a5a5a5a51d, 2, 11, 0x0000000000000147) + EXTU(0xa5a5a5a5a5a5a51d, 2, 11, 0x0000000000000147) + DEP( 0xa5a5a5a5a5a5a51d, 1023, 2, 11, 0xa5a5a5a5a5a5affd) + EXT( 0xa5a5a5a5a5a5a51c, 2, 12, 0xfffffffffffff947) + EXTU(0xa5a5a5a5a5a5a51c, 2, 12, 0x0000000000000947) + DEP( 0xa5a5a5a5a5a5a51c, 2047, 2, 12, 0xa5a5a5a5a5a59ffc) + EXT( 0xa5a5a5a5a5a5a51b, 2, 13, 0x0000000000000946) + EXTU(0xa5a5a5a5a5a5a51b, 2, 13, 0x0000000000000946) + DEP( 0xa5a5a5a5a5a5a51b, 4095, 2, 13, 0xa5a5a5a5a5a5bfff) + EXT( 0xa5a5a5a5a5a5a51a, 2, 14, 0xffffffffffffe946) + EXTU(0xa5a5a5a5a5a5a51a, 2, 14, 0x0000000000002946) + DEP( 0xa5a5a5a5a5a5a51a, 8191, 2, 14, 0xa5a5a5a5a5a57ffe) + EXT( 0xa5a5a5a5a5a5a519, 2, 15, 0xffffffffffffe946) + EXTU(0xa5a5a5a5a5a5a519, 2, 15, 0x0000000000006946) + DEP( 0xa5a5a5a5a5a5a519, 16383, 2, 15, 0xa5a5a5a5a5a4fffd) + EXT( 0xa5a5a5a5a5a5a518, 2, 16, 0x0000000000006946) + EXTU(0xa5a5a5a5a5a5a518, 2, 16, 0x0000000000006946) + DEP( 0xa5a5a5a5a5a5a518, 32767, 2, 16, 0xa5a5a5a5a5a5fffc) + EXT( 0xa5a5a5a5a5a5a517, 2, 17, 0xffffffffffff6945) + EXTU(0xa5a5a5a5a5a5a517, 2, 17, 0x0000000000016945) + DEP( 0xa5a5a5a5a5a5a517, 65535, 2, 17, 0xa5a5a5a5a5a3ffff) + EXT( 0xa5a5a5a5a5a5a516, 2, 18, 0x0000000000016945) + EXTU(0xa5a5a5a5a5a5a516, 2, 18, 0x0000000000016945) + DEP( 0xa5a5a5a5a5a5a516, 131071, 2, 18, 0xa5a5a5a5a5a7fffe) + EXT( 0xa5a5a5a5a5a5a515, 2, 19, 0x0000000000016945) + EXTU(0xa5a5a5a5a5a5a515, 2, 19, 0x0000000000016945) + DEP( 0xa5a5a5a5a5a5a515, 262143, 2, 19, 0xa5a5a5a5a5affffd) + EXT( 0xa5a5a5a5a5a5a514, 2, 20, 0xfffffffffff96945) + EXTU(0xa5a5a5a5a5a5a514, 2, 20, 0x0000000000096945) + DEP( 0xa5a5a5a5a5a5a514, 524287, 2, 20, 0xa5a5a5a5a59ffffc) + EXT( 0xa5a5a5a5a5a5a513, 2, 21, 0x0000000000096944) + EXTU(0xa5a5a5a5a5a5a513, 2, 21, 0x0000000000096944) + DEP( 0xa5a5a5a5a5a5a513, 1048575, 2, 21, 0xa5a5a5a5a5bfffff) + EXT( 0xa5a5a5a5a5a5a512, 2, 22, 0xffffffffffe96944) + EXTU(0xa5a5a5a5a5a5a512, 2, 22, 0x0000000000296944) + DEP( 0xa5a5a5a5a5a5a512, 2097151, 2, 22, 0xa5a5a5a5a57ffffe) + EXT( 0xa5a5a5a5a5a5a511, 2, 23, 0xffffffffffe96944) + EXTU(0xa5a5a5a5a5a5a511, 2, 23, 0x0000000000696944) + DEP( 0xa5a5a5a5a5a5a511, 4194303, 2, 23, 0xa5a5a5a5a4fffffd) + EXT( 0xa5a5a5a5a5a5a510, 2, 24, 0x0000000000696944) + EXTU(0xa5a5a5a5a5a5a510, 2, 24, 0x0000000000696944) + DEP( 0xa5a5a5a5a5a5a510, 8388607, 2, 24, 0xa5a5a5a5a5fffffc) + EXT( 0xa5a5a5a5a5a5a50f, 2, 25, 0xffffffffff696943) + EXTU(0xa5a5a5a5a5a5a50f, 2, 25, 0x0000000001696943) + DEP( 0xa5a5a5a5a5a5a50f, 16777215, 2, 25, 0xa5a5a5a5a3ffffff) + EXT( 0xa5a5a5a5a5a5a50e, 2, 26, 0x0000000001696943) + EXTU(0xa5a5a5a5a5a5a50e, 2, 26, 0x0000000001696943) + DEP( 0xa5a5a5a5a5a5a50e, 33554431, 2, 26, 0xa5a5a5a5a7fffffe) + EXT( 0xa5a5a5a5a5a5a50d, 2, 27, 0x0000000001696943) + EXTU(0xa5a5a5a5a5a5a50d, 2, 27, 0x0000000001696943) + DEP( 0xa5a5a5a5a5a5a50d, 67108863, 2, 27, 0xa5a5a5a5affffffd) + EXT( 0xa5a5a5a5a5a5a50c, 2, 28, 0xfffffffff9696943) + EXTU(0xa5a5a5a5a5a5a50c, 2, 28, 0x0000000009696943) + DEP( 0xa5a5a5a5a5a5a50c, 134217727, 2, 28, 0xa5a5a5a59ffffffc) + EXT( 0xa5a5a5a5a5a5a50b, 2, 29, 0x0000000009696942) + EXTU(0xa5a5a5a5a5a5a50b, 2, 29, 0x0000000009696942) + DEP( 0xa5a5a5a5a5a5a50b, 268435455, 2, 29, 0xa5a5a5a5bfffffff) + EXT( 0xa5a5a5a5a5a5a50a, 2, 30, 0xffffffffe9696942) + EXTU(0xa5a5a5a5a5a5a50a, 2, 30, 0x0000000029696942) + DEP( 0xa5a5a5a5a5a5a50a, 536870911, 2, 30, 0xa5a5a5a57ffffffe) + EXT( 0xa5a5a5a5a5a5a509, 2, 31, 0xffffffffe9696942) + EXTU(0xa5a5a5a5a5a5a509, 2, 31, 0x0000000069696942) + DEP( 0xa5a5a5a5a5a5a509, 1073741823, 2, 31, 0xa5a5a5a4fffffffd) + EXT( 0xa5a5a5a5a5a5a508, 2, 32, 0x0000000069696942) + EXTU(0xa5a5a5a5a5a5a508, 2, 32, 0x0000000069696942) + DEP( 0xa5a5a5a5a5a5a508, 2147483647, 2, 32, 0xa5a5a5a5fffffffc) + EXT( 0xa5a5a5a5a5a5a507, 2, 33, 0xffffffff69696941) + EXTU(0xa5a5a5a5a5a5a507, 2, 33, 0x0000000169696941) + DEP( 0xa5a5a5a5a5a5a507, 4294967295, 2, 33, 0xa5a5a5a3ffffffff) + EXT( 0xa5a5a5a5a5a5a506, 2, 34, 0x0000000169696941) + EXTU(0xa5a5a5a5a5a5a506, 2, 34, 0x0000000169696941) + DEP( 0xa5a5a5a5a5a5a506, 8589934591, 2, 34, 0xa5a5a5a7fffffffe) + EXT( 0xa5a5a5a5a5a5a505, 2, 35, 0x0000000169696941) + EXTU(0xa5a5a5a5a5a5a505, 2, 35, 0x0000000169696941) + DEP( 0xa5a5a5a5a5a5a505, 17179869183, 2, 35, 0xa5a5a5affffffffd) + EXT( 0xa5a5a5a5a5a5a504, 2, 36, 0xfffffff969696941) + EXTU(0xa5a5a5a5a5a5a504, 2, 36, 0x0000000969696941) + DEP( 0xa5a5a5a5a5a5a504, 34359738367, 2, 36, 0xa5a5a59ffffffffc) + EXT( 0xa5a5a5a5a5a5a503, 2, 37, 0x0000000969696940) + EXTU(0xa5a5a5a5a5a5a503, 2, 37, 0x0000000969696940) + DEP( 0xa5a5a5a5a5a5a503, 68719476735, 2, 37, 0xa5a5a5bfffffffff) + EXT( 0xa5a5a5a5a5a5a502, 2, 38, 0xffffffe969696940) + EXTU(0xa5a5a5a5a5a5a502, 2, 38, 0x0000002969696940) + DEP( 0xa5a5a5a5a5a5a502, 137438953471, 2, 38, 0xa5a5a57ffffffffe) + EXT( 0xa5a5a5a5a5a5a501, 2, 39, 0xffffffe969696940) + EXTU(0xa5a5a5a5a5a5a501, 2, 39, 0x0000006969696940) + DEP( 0xa5a5a5a5a5a5a501, 274877906943, 2, 39, 0xa5a5a4fffffffffd) + EXT( 0xa5a5a5a5a5a5a500, 2, 40, 0x0000006969696940) + EXTU(0xa5a5a5a5a5a5a500, 2, 40, 0x0000006969696940) + DEP( 0xa5a5a5a5a5a5a500, 549755813887, 2, 40, 0xa5a5a5fffffffffc) + EXT( 0xa5a5a5a5a5a5a4ff, 2, 41, 0xffffff696969693f) + EXTU(0xa5a5a5a5a5a5a4ff, 2, 41, 0x000001696969693f) + DEP( 0xa5a5a5a5a5a5a4ff, 1099511627775, 2, 41, 0xa5a5a3ffffffffff) + EXT( 0xa5a5a5a5a5a5a4fe, 2, 42, 0x000001696969693f) + EXTU(0xa5a5a5a5a5a5a4fe, 2, 42, 0x000001696969693f) + DEP( 0xa5a5a5a5a5a5a4fe, 2199023255551, 2, 42, 0xa5a5a7fffffffffe) + EXT( 0xa5a5a5a5a5a5a4fd, 2, 43, 0x000001696969693f) + EXTU(0xa5a5a5a5a5a5a4fd, 2, 43, 0x000001696969693f) + DEP( 0xa5a5a5a5a5a5a4fd, 4398046511103, 2, 43, 0xa5a5affffffffffd) + EXT( 0xa5a5a5a5a5a5a4fc, 2, 44, 0xfffff9696969693f) + EXTU(0xa5a5a5a5a5a5a4fc, 2, 44, 0x000009696969693f) + DEP( 0xa5a5a5a5a5a5a4fc, 8796093022207, 2, 44, 0xa5a59ffffffffffc) + EXT( 0xa5a5a5a5a5a5a4fb, 2, 45, 0x000009696969693e) + EXTU(0xa5a5a5a5a5a5a4fb, 2, 45, 0x000009696969693e) + DEP( 0xa5a5a5a5a5a5a4fb, 17592186044415, 2, 45, 0xa5a5bfffffffffff) + EXT( 0xa5a5a5a5a5a5a4fa, 2, 46, 0xffffe9696969693e) + EXTU(0xa5a5a5a5a5a5a4fa, 2, 46, 0x000029696969693e) + DEP( 0xa5a5a5a5a5a5a4fa, 35184372088831, 2, 46, 0xa5a57ffffffffffe) + EXT( 0xa5a5a5a5a5a5a4f9, 2, 47, 0xffffe9696969693e) + EXTU(0xa5a5a5a5a5a5a4f9, 2, 47, 0x000069696969693e) + DEP( 0xa5a5a5a5a5a5a4f9, 70368744177663, 2, 47, 0xa5a4fffffffffffd) + EXT( 0xa5a5a5a5a5a5a4f8, 2, 48, 0x000069696969693e) + EXTU(0xa5a5a5a5a5a5a4f8, 2, 48, 0x000069696969693e) + DEP( 0xa5a5a5a5a5a5a4f8, 140737488355327, 2, 48, 0xa5a5fffffffffffc) + EXT( 0xa5a5a5a5a5a5a4f7, 2, 49, 0xffff69696969693d) + EXTU(0xa5a5a5a5a5a5a4f7, 2, 49, 0x000169696969693d) + DEP( 0xa5a5a5a5a5a5a4f7, 281474976710655, 2, 49, 0xa5a3ffffffffffff) + EXT( 0xa5a5a5a5a5a5a4f6, 2, 50, 0x000169696969693d) + EXTU(0xa5a5a5a5a5a5a4f6, 2, 50, 0x000169696969693d) + DEP( 0xa5a5a5a5a5a5a4f6, 562949953421311, 2, 50, 0xa5a7fffffffffffe) + EXT( 0xa5a5a5a5a5a5a4f5, 2, 51, 0x000169696969693d) + EXTU(0xa5a5a5a5a5a5a4f5, 2, 51, 0x000169696969693d) + DEP( 0xa5a5a5a5a5a5a4f5, 1125899906842623, 2, 51, 0xa5affffffffffffd) + EXT( 0xa5a5a5a5a5a5a4f4, 2, 52, 0xfff969696969693d) + EXTU(0xa5a5a5a5a5a5a4f4, 2, 52, 0x000969696969693d) + DEP( 0xa5a5a5a5a5a5a4f4, 2251799813685247, 2, 52, 0xa59ffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4f3, 2, 53, 0x000969696969693c) + EXTU(0xa5a5a5a5a5a5a4f3, 2, 53, 0x000969696969693c) + DEP( 0xa5a5a5a5a5a5a4f3, 4503599627370495, 2, 53, 0xa5bfffffffffffff) + EXT( 0xa5a5a5a5a5a5a4f2, 2, 54, 0xffe969696969693c) + EXTU(0xa5a5a5a5a5a5a4f2, 2, 54, 0x002969696969693c) + DEP( 0xa5a5a5a5a5a5a4f2, 9007199254740991, 2, 54, 0xa57ffffffffffffe) + EXT( 0xa5a5a5a5a5a5a4f1, 2, 55, 0xffe969696969693c) + EXTU(0xa5a5a5a5a5a5a4f1, 2, 55, 0x006969696969693c) + DEP( 0xa5a5a5a5a5a5a4f1, 18014398509481983, 2, 55, 0xa4fffffffffffffd) + EXT( 0xa5a5a5a5a5a5a4f0, 2, 56, 0x006969696969693c) + EXTU(0xa5a5a5a5a5a5a4f0, 2, 56, 0x006969696969693c) + DEP( 0xa5a5a5a5a5a5a4f0, 36028797018963967, 2, 56, 0xa5fffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4ef, 2, 57, 0xff6969696969693b) + EXTU(0xa5a5a5a5a5a5a4ef, 2, 57, 0x016969696969693b) + DEP( 0xa5a5a5a5a5a5a4ef, 72057594037927935, 2, 57, 0xa3ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a4ee, 2, 58, 0x016969696969693b) + EXTU(0xa5a5a5a5a5a5a4ee, 2, 58, 0x016969696969693b) + DEP( 0xa5a5a5a5a5a5a4ee, 144115188075855871, 2, 58, 0xa7fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a4ed, 2, 59, 0x016969696969693b) + EXTU(0xa5a5a5a5a5a5a4ed, 2, 59, 0x016969696969693b) + DEP( 0xa5a5a5a5a5a5a4ed, 288230376151711743, 2, 59, 0xaffffffffffffffd) + EXT( 0xa5a5a5a5a5a5a4ec, 2, 60, 0xf96969696969693b) + EXTU(0xa5a5a5a5a5a5a4ec, 2, 60, 0x096969696969693b) + DEP( 0xa5a5a5a5a5a5a4ec, 576460752303423487, 2, 60, 0x9ffffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4eb, 2, 61, 0x096969696969693a) + EXTU(0xa5a5a5a5a5a5a4eb, 2, 61, 0x096969696969693a) + DEP( 0xa5a5a5a5a5a5a4eb, 1152921504606846975, 2, 61, 0xbfffffffffffffff) + EXT( 0xa5a5a5a5a5a5a4ea, 3, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a4ea, 3, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a4ea, 0, 3, 1, 0xa5a5a5a5a5a5a4e2) + EXT( 0xa5a5a5a5a5a5a4e9, 3, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a4e9, 3, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a4e9, 1, 3, 2, 0xa5a5a5a5a5a5a4e9) + EXT( 0xa5a5a5a5a5a5a4e8, 3, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a4e8, 3, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a4e8, 3, 3, 3, 0xa5a5a5a5a5a5a4d8) + EXT( 0xa5a5a5a5a5a5a4e7, 3, 4, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a4e7, 3, 4, 0x000000000000000c) + DEP( 0xa5a5a5a5a5a5a4e7, 7, 3, 4, 0xa5a5a5a5a5a5a4bf) + EXT( 0xa5a5a5a5a5a5a4e6, 3, 5, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a4e6, 3, 5, 0x000000000000001c) + DEP( 0xa5a5a5a5a5a5a4e6, 15, 3, 5, 0xa5a5a5a5a5a5a47e) + EXT( 0xa5a5a5a5a5a5a4e5, 3, 6, 0x000000000000001c) + EXTU(0xa5a5a5a5a5a5a4e5, 3, 6, 0x000000000000001c) + DEP( 0xa5a5a5a5a5a5a4e5, 31, 3, 6, 0xa5a5a5a5a5a5a4fd) + EXT( 0xa5a5a5a5a5a5a4e4, 3, 7, 0x000000000000001c) + EXTU(0xa5a5a5a5a5a5a4e4, 3, 7, 0x000000000000001c) + DEP( 0xa5a5a5a5a5a5a4e4, 63, 3, 7, 0xa5a5a5a5a5a5a5fc) + EXT( 0xa5a5a5a5a5a5a4e3, 3, 8, 0xffffffffffffff9c) + EXTU(0xa5a5a5a5a5a5a4e3, 3, 8, 0x000000000000009c) + DEP( 0xa5a5a5a5a5a5a4e3, 127, 3, 8, 0xa5a5a5a5a5a5a3fb) + EXT( 0xa5a5a5a5a5a5a4e2, 3, 9, 0x000000000000009c) + EXTU(0xa5a5a5a5a5a5a4e2, 3, 9, 0x000000000000009c) + DEP( 0xa5a5a5a5a5a5a4e2, 255, 3, 9, 0xa5a5a5a5a5a5a7fa) + EXT( 0xa5a5a5a5a5a5a4e1, 3, 10, 0x000000000000009c) + EXTU(0xa5a5a5a5a5a5a4e1, 3, 10, 0x000000000000009c) + DEP( 0xa5a5a5a5a5a5a4e1, 511, 3, 10, 0xa5a5a5a5a5a5aff9) + EXT( 0xa5a5a5a5a5a5a4e0, 3, 11, 0xfffffffffffffc9c) + EXTU(0xa5a5a5a5a5a5a4e0, 3, 11, 0x000000000000049c) + DEP( 0xa5a5a5a5a5a5a4e0, 1023, 3, 11, 0xa5a5a5a5a5a59ff8) + EXT( 0xa5a5a5a5a5a5a4df, 3, 12, 0x000000000000049b) + EXTU(0xa5a5a5a5a5a5a4df, 3, 12, 0x000000000000049b) + DEP( 0xa5a5a5a5a5a5a4df, 2047, 3, 12, 0xa5a5a5a5a5a5bfff) + EXT( 0xa5a5a5a5a5a5a4de, 3, 13, 0xfffffffffffff49b) + EXTU(0xa5a5a5a5a5a5a4de, 3, 13, 0x000000000000149b) + DEP( 0xa5a5a5a5a5a5a4de, 4095, 3, 13, 0xa5a5a5a5a5a57ffe) + EXT( 0xa5a5a5a5a5a5a4dd, 3, 14, 0xfffffffffffff49b) + EXTU(0xa5a5a5a5a5a5a4dd, 3, 14, 0x000000000000349b) + DEP( 0xa5a5a5a5a5a5a4dd, 8191, 3, 14, 0xa5a5a5a5a5a4fffd) + EXT( 0xa5a5a5a5a5a5a4dc, 3, 15, 0x000000000000349b) + EXTU(0xa5a5a5a5a5a5a4dc, 3, 15, 0x000000000000349b) + DEP( 0xa5a5a5a5a5a5a4dc, 16383, 3, 15, 0xa5a5a5a5a5a5fffc) + EXT( 0xa5a5a5a5a5a5a4db, 3, 16, 0xffffffffffffb49b) + EXTU(0xa5a5a5a5a5a5a4db, 3, 16, 0x000000000000b49b) + DEP( 0xa5a5a5a5a5a5a4db, 32767, 3, 16, 0xa5a5a5a5a5a3fffb) + EXT( 0xa5a5a5a5a5a5a4da, 3, 17, 0x000000000000b49b) + EXTU(0xa5a5a5a5a5a5a4da, 3, 17, 0x000000000000b49b) + DEP( 0xa5a5a5a5a5a5a4da, 65535, 3, 17, 0xa5a5a5a5a5a7fffa) + EXT( 0xa5a5a5a5a5a5a4d9, 3, 18, 0x000000000000b49b) + EXTU(0xa5a5a5a5a5a5a4d9, 3, 18, 0x000000000000b49b) + DEP( 0xa5a5a5a5a5a5a4d9, 131071, 3, 18, 0xa5a5a5a5a5affff9) + EXT( 0xa5a5a5a5a5a5a4d8, 3, 19, 0xfffffffffffcb49b) + EXTU(0xa5a5a5a5a5a5a4d8, 3, 19, 0x000000000004b49b) + DEP( 0xa5a5a5a5a5a5a4d8, 262143, 3, 19, 0xa5a5a5a5a59ffff8) + EXT( 0xa5a5a5a5a5a5a4d7, 3, 20, 0x000000000004b49a) + EXTU(0xa5a5a5a5a5a5a4d7, 3, 20, 0x000000000004b49a) + DEP( 0xa5a5a5a5a5a5a4d7, 524287, 3, 20, 0xa5a5a5a5a5bfffff) + EXT( 0xa5a5a5a5a5a5a4d6, 3, 21, 0xfffffffffff4b49a) + EXTU(0xa5a5a5a5a5a5a4d6, 3, 21, 0x000000000014b49a) + DEP( 0xa5a5a5a5a5a5a4d6, 1048575, 3, 21, 0xa5a5a5a5a57ffffe) + EXT( 0xa5a5a5a5a5a5a4d5, 3, 22, 0xfffffffffff4b49a) + EXTU(0xa5a5a5a5a5a5a4d5, 3, 22, 0x000000000034b49a) + DEP( 0xa5a5a5a5a5a5a4d5, 2097151, 3, 22, 0xa5a5a5a5a4fffffd) + EXT( 0xa5a5a5a5a5a5a4d4, 3, 23, 0x000000000034b49a) + EXTU(0xa5a5a5a5a5a5a4d4, 3, 23, 0x000000000034b49a) + DEP( 0xa5a5a5a5a5a5a4d4, 4194303, 3, 23, 0xa5a5a5a5a5fffffc) + EXT( 0xa5a5a5a5a5a5a4d3, 3, 24, 0xffffffffffb4b49a) + EXTU(0xa5a5a5a5a5a5a4d3, 3, 24, 0x0000000000b4b49a) + DEP( 0xa5a5a5a5a5a5a4d3, 8388607, 3, 24, 0xa5a5a5a5a3fffffb) + EXT( 0xa5a5a5a5a5a5a4d2, 3, 25, 0x0000000000b4b49a) + EXTU(0xa5a5a5a5a5a5a4d2, 3, 25, 0x0000000000b4b49a) + DEP( 0xa5a5a5a5a5a5a4d2, 16777215, 3, 25, 0xa5a5a5a5a7fffffa) + EXT( 0xa5a5a5a5a5a5a4d1, 3, 26, 0x0000000000b4b49a) + EXTU(0xa5a5a5a5a5a5a4d1, 3, 26, 0x0000000000b4b49a) + DEP( 0xa5a5a5a5a5a5a4d1, 33554431, 3, 26, 0xa5a5a5a5affffff9) + EXT( 0xa5a5a5a5a5a5a4d0, 3, 27, 0xfffffffffcb4b49a) + EXTU(0xa5a5a5a5a5a5a4d0, 3, 27, 0x0000000004b4b49a) + DEP( 0xa5a5a5a5a5a5a4d0, 67108863, 3, 27, 0xa5a5a5a59ffffff8) + EXT( 0xa5a5a5a5a5a5a4cf, 3, 28, 0x0000000004b4b499) + EXTU(0xa5a5a5a5a5a5a4cf, 3, 28, 0x0000000004b4b499) + DEP( 0xa5a5a5a5a5a5a4cf, 134217727, 3, 28, 0xa5a5a5a5bfffffff) + EXT( 0xa5a5a5a5a5a5a4ce, 3, 29, 0xfffffffff4b4b499) + EXTU(0xa5a5a5a5a5a5a4ce, 3, 29, 0x0000000014b4b499) + DEP( 0xa5a5a5a5a5a5a4ce, 268435455, 3, 29, 0xa5a5a5a57ffffffe) + EXT( 0xa5a5a5a5a5a5a4cd, 3, 30, 0xfffffffff4b4b499) + EXTU(0xa5a5a5a5a5a5a4cd, 3, 30, 0x0000000034b4b499) + DEP( 0xa5a5a5a5a5a5a4cd, 536870911, 3, 30, 0xa5a5a5a4fffffffd) + EXT( 0xa5a5a5a5a5a5a4cc, 3, 31, 0x0000000034b4b499) + EXTU(0xa5a5a5a5a5a5a4cc, 3, 31, 0x0000000034b4b499) + DEP( 0xa5a5a5a5a5a5a4cc, 1073741823, 3, 31, 0xa5a5a5a5fffffffc) + EXT( 0xa5a5a5a5a5a5a4cb, 3, 32, 0xffffffffb4b4b499) + EXTU(0xa5a5a5a5a5a5a4cb, 3, 32, 0x00000000b4b4b499) + DEP( 0xa5a5a5a5a5a5a4cb, 2147483647, 3, 32, 0xa5a5a5a3fffffffb) + EXT( 0xa5a5a5a5a5a5a4ca, 3, 33, 0x00000000b4b4b499) + EXTU(0xa5a5a5a5a5a5a4ca, 3, 33, 0x00000000b4b4b499) + DEP( 0xa5a5a5a5a5a5a4ca, 4294967295, 3, 33, 0xa5a5a5a7fffffffa) + EXT( 0xa5a5a5a5a5a5a4c9, 3, 34, 0x00000000b4b4b499) + EXTU(0xa5a5a5a5a5a5a4c9, 3, 34, 0x00000000b4b4b499) + DEP( 0xa5a5a5a5a5a5a4c9, 8589934591, 3, 34, 0xa5a5a5affffffff9) + EXT( 0xa5a5a5a5a5a5a4c8, 3, 35, 0xfffffffcb4b4b499) + EXTU(0xa5a5a5a5a5a5a4c8, 3, 35, 0x00000004b4b4b499) + DEP( 0xa5a5a5a5a5a5a4c8, 17179869183, 3, 35, 0xa5a5a59ffffffff8) + EXT( 0xa5a5a5a5a5a5a4c7, 3, 36, 0x00000004b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c7, 3, 36, 0x00000004b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c7, 34359738367, 3, 36, 0xa5a5a5bfffffffff) + EXT( 0xa5a5a5a5a5a5a4c6, 3, 37, 0xfffffff4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c6, 3, 37, 0x00000014b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c6, 68719476735, 3, 37, 0xa5a5a57ffffffffe) + EXT( 0xa5a5a5a5a5a5a4c5, 3, 38, 0xfffffff4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c5, 3, 38, 0x00000034b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c5, 137438953471, 3, 38, 0xa5a5a4fffffffffd) + EXT( 0xa5a5a5a5a5a5a4c4, 3, 39, 0x00000034b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c4, 3, 39, 0x00000034b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c4, 274877906943, 3, 39, 0xa5a5a5fffffffffc) + EXT( 0xa5a5a5a5a5a5a4c3, 3, 40, 0xffffffb4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c3, 3, 40, 0x000000b4b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c3, 549755813887, 3, 40, 0xa5a5a3fffffffffb) + EXT( 0xa5a5a5a5a5a5a4c2, 3, 41, 0x000000b4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c2, 3, 41, 0x000000b4b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c2, 1099511627775, 3, 41, 0xa5a5a7fffffffffa) + EXT( 0xa5a5a5a5a5a5a4c1, 3, 42, 0x000000b4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c1, 3, 42, 0x000000b4b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c1, 2199023255551, 3, 42, 0xa5a5affffffffff9) + EXT( 0xa5a5a5a5a5a5a4c0, 3, 43, 0xfffffcb4b4b4b498) + EXTU(0xa5a5a5a5a5a5a4c0, 3, 43, 0x000004b4b4b4b498) + DEP( 0xa5a5a5a5a5a5a4c0, 4398046511103, 3, 43, 0xa5a59ffffffffff8) + EXT( 0xa5a5a5a5a5a5a4bf, 3, 44, 0x000004b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4bf, 3, 44, 0x000004b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4bf, 8796093022207, 3, 44, 0xa5a5bfffffffffff) + EXT( 0xa5a5a5a5a5a5a4be, 3, 45, 0xfffff4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4be, 3, 45, 0x000014b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4be, 17592186044415, 3, 45, 0xa5a57ffffffffffe) + EXT( 0xa5a5a5a5a5a5a4bd, 3, 46, 0xfffff4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4bd, 3, 46, 0x000034b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4bd, 35184372088831, 3, 46, 0xa5a4fffffffffffd) + EXT( 0xa5a5a5a5a5a5a4bc, 3, 47, 0x000034b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4bc, 3, 47, 0x000034b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4bc, 70368744177663, 3, 47, 0xa5a5fffffffffffc) + EXT( 0xa5a5a5a5a5a5a4bb, 3, 48, 0xffffb4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4bb, 3, 48, 0x0000b4b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4bb, 140737488355327, 3, 48, 0xa5a3fffffffffffb) + EXT( 0xa5a5a5a5a5a5a4ba, 3, 49, 0x0000b4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4ba, 3, 49, 0x0000b4b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4ba, 281474976710655, 3, 49, 0xa5a7fffffffffffa) + EXT( 0xa5a5a5a5a5a5a4b9, 3, 50, 0x0000b4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4b9, 3, 50, 0x0000b4b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4b9, 562949953421311, 3, 50, 0xa5affffffffffff9) + EXT( 0xa5a5a5a5a5a5a4b8, 3, 51, 0xfffcb4b4b4b4b497) + EXTU(0xa5a5a5a5a5a5a4b8, 3, 51, 0x0004b4b4b4b4b497) + DEP( 0xa5a5a5a5a5a5a4b8, 1125899906842623, 3, 51, 0xa59ffffffffffff8) + EXT( 0xa5a5a5a5a5a5a4b7, 3, 52, 0x0004b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b7, 3, 52, 0x0004b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b7, 2251799813685247, 3, 52, 0xa5bfffffffffffff) + EXT( 0xa5a5a5a5a5a5a4b6, 3, 53, 0xfff4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b6, 3, 53, 0x0014b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b6, 4503599627370495, 3, 53, 0xa57ffffffffffffe) + EXT( 0xa5a5a5a5a5a5a4b5, 3, 54, 0xfff4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b5, 3, 54, 0x0034b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b5, 9007199254740991, 3, 54, 0xa4fffffffffffffd) + EXT( 0xa5a5a5a5a5a5a4b4, 3, 55, 0x0034b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b4, 3, 55, 0x0034b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b4, 18014398509481983, 3, 55, 0xa5fffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4b3, 3, 56, 0xffb4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b3, 3, 56, 0x00b4b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b3, 36028797018963967, 3, 56, 0xa3fffffffffffffb) + EXT( 0xa5a5a5a5a5a5a4b2, 3, 57, 0x00b4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b2, 3, 57, 0x00b4b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b2, 72057594037927935, 3, 57, 0xa7fffffffffffffa) + EXT( 0xa5a5a5a5a5a5a4b1, 3, 58, 0x00b4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b1, 3, 58, 0x00b4b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b1, 144115188075855871, 3, 58, 0xaffffffffffffff9) + EXT( 0xa5a5a5a5a5a5a4b0, 3, 59, 0xfcb4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b0, 3, 59, 0x04b4b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b0, 288230376151711743, 3, 59, 0x9ffffffffffffff8) + EXT( 0xa5a5a5a5a5a5a4af, 3, 60, 0x04b4b4b4b4b4b495) + EXTU(0xa5a5a5a5a5a5a4af, 3, 60, 0x04b4b4b4b4b4b495) + DEP( 0xa5a5a5a5a5a5a4af, 576460752303423487, 3, 60, 0xbfffffffffffffff) + EXT( 0xa5a5a5a5a5a5a4ae, 4, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a4ae, 4, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a4ae, 0, 4, 1, 0xa5a5a5a5a5a5a4ae) + EXT( 0xa5a5a5a5a5a5a4ad, 4, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a4ad, 4, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a4ad, 1, 4, 2, 0xa5a5a5a5a5a5a49d) + EXT( 0xa5a5a5a5a5a5a4ac, 4, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a4ac, 4, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a4ac, 3, 4, 3, 0xa5a5a5a5a5a5a4bc) + EXT( 0xa5a5a5a5a5a5a4ab, 4, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a4ab, 4, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a4ab, 7, 4, 4, 0xa5a5a5a5a5a5a47b) + EXT( 0xa5a5a5a5a5a5a4aa, 4, 5, 0x000000000000000a) + EXTU(0xa5a5a5a5a5a5a4aa, 4, 5, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a4aa, 15, 4, 5, 0xa5a5a5a5a5a5a4fa) + EXT( 0xa5a5a5a5a5a5a4a9, 4, 6, 0x000000000000000a) + EXTU(0xa5a5a5a5a5a5a4a9, 4, 6, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a4a9, 31, 4, 6, 0xa5a5a5a5a5a5a5f9) + EXT( 0xa5a5a5a5a5a5a4a8, 4, 7, 0xffffffffffffffca) + EXTU(0xa5a5a5a5a5a5a4a8, 4, 7, 0x000000000000004a) + DEP( 0xa5a5a5a5a5a5a4a8, 63, 4, 7, 0xa5a5a5a5a5a5a3f8) + EXT( 0xa5a5a5a5a5a5a4a7, 4, 8, 0x000000000000004a) + EXTU(0xa5a5a5a5a5a5a4a7, 4, 8, 0x000000000000004a) + DEP( 0xa5a5a5a5a5a5a4a7, 127, 4, 8, 0xa5a5a5a5a5a5a7f7) + EXT( 0xa5a5a5a5a5a5a4a6, 4, 9, 0x000000000000004a) + EXTU(0xa5a5a5a5a5a5a4a6, 4, 9, 0x000000000000004a) + DEP( 0xa5a5a5a5a5a5a4a6, 255, 4, 9, 0xa5a5a5a5a5a5aff6) + EXT( 0xa5a5a5a5a5a5a4a5, 4, 10, 0xfffffffffffffe4a) + EXTU(0xa5a5a5a5a5a5a4a5, 4, 10, 0x000000000000024a) + DEP( 0xa5a5a5a5a5a5a4a5, 511, 4, 10, 0xa5a5a5a5a5a59ff5) + EXT( 0xa5a5a5a5a5a5a4a4, 4, 11, 0x000000000000024a) + EXTU(0xa5a5a5a5a5a5a4a4, 4, 11, 0x000000000000024a) + DEP( 0xa5a5a5a5a5a5a4a4, 1023, 4, 11, 0xa5a5a5a5a5a5bff4) + EXT( 0xa5a5a5a5a5a5a4a3, 4, 12, 0xfffffffffffffa4a) + EXTU(0xa5a5a5a5a5a5a4a3, 4, 12, 0x0000000000000a4a) + DEP( 0xa5a5a5a5a5a5a4a3, 2047, 4, 12, 0xa5a5a5a5a5a57ff3) + EXT( 0xa5a5a5a5a5a5a4a2, 4, 13, 0xfffffffffffffa4a) + EXTU(0xa5a5a5a5a5a5a4a2, 4, 13, 0x0000000000001a4a) + DEP( 0xa5a5a5a5a5a5a4a2, 4095, 4, 13, 0xa5a5a5a5a5a4fff2) + EXT( 0xa5a5a5a5a5a5a4a1, 4, 14, 0x0000000000001a4a) + EXTU(0xa5a5a5a5a5a5a4a1, 4, 14, 0x0000000000001a4a) + DEP( 0xa5a5a5a5a5a5a4a1, 8191, 4, 14, 0xa5a5a5a5a5a5fff1) + EXT( 0xa5a5a5a5a5a5a4a0, 4, 15, 0xffffffffffffda4a) + EXTU(0xa5a5a5a5a5a5a4a0, 4, 15, 0x0000000000005a4a) + DEP( 0xa5a5a5a5a5a5a4a0, 16383, 4, 15, 0xa5a5a5a5a5a3fff0) + EXT( 0xa5a5a5a5a5a5a49f, 4, 16, 0x0000000000005a49) + EXTU(0xa5a5a5a5a5a5a49f, 4, 16, 0x0000000000005a49) + DEP( 0xa5a5a5a5a5a5a49f, 32767, 4, 16, 0xa5a5a5a5a5a7ffff) + EXT( 0xa5a5a5a5a5a5a49e, 4, 17, 0x0000000000005a49) + EXTU(0xa5a5a5a5a5a5a49e, 4, 17, 0x0000000000005a49) + DEP( 0xa5a5a5a5a5a5a49e, 65535, 4, 17, 0xa5a5a5a5a5affffe) + EXT( 0xa5a5a5a5a5a5a49d, 4, 18, 0xfffffffffffe5a49) + EXTU(0xa5a5a5a5a5a5a49d, 4, 18, 0x0000000000025a49) + DEP( 0xa5a5a5a5a5a5a49d, 131071, 4, 18, 0xa5a5a5a5a59ffffd) + EXT( 0xa5a5a5a5a5a5a49c, 4, 19, 0x0000000000025a49) + EXTU(0xa5a5a5a5a5a5a49c, 4, 19, 0x0000000000025a49) + DEP( 0xa5a5a5a5a5a5a49c, 262143, 4, 19, 0xa5a5a5a5a5bffffc) + EXT( 0xa5a5a5a5a5a5a49b, 4, 20, 0xfffffffffffa5a49) + EXTU(0xa5a5a5a5a5a5a49b, 4, 20, 0x00000000000a5a49) + DEP( 0xa5a5a5a5a5a5a49b, 524287, 4, 20, 0xa5a5a5a5a57ffffb) + EXT( 0xa5a5a5a5a5a5a49a, 4, 21, 0xfffffffffffa5a49) + EXTU(0xa5a5a5a5a5a5a49a, 4, 21, 0x00000000001a5a49) + DEP( 0xa5a5a5a5a5a5a49a, 1048575, 4, 21, 0xa5a5a5a5a4fffffa) + EXT( 0xa5a5a5a5a5a5a499, 4, 22, 0x00000000001a5a49) + EXTU(0xa5a5a5a5a5a5a499, 4, 22, 0x00000000001a5a49) + DEP( 0xa5a5a5a5a5a5a499, 2097151, 4, 22, 0xa5a5a5a5a5fffff9) + EXT( 0xa5a5a5a5a5a5a498, 4, 23, 0xffffffffffda5a49) + EXTU(0xa5a5a5a5a5a5a498, 4, 23, 0x00000000005a5a49) + DEP( 0xa5a5a5a5a5a5a498, 4194303, 4, 23, 0xa5a5a5a5a3fffff8) + EXT( 0xa5a5a5a5a5a5a497, 4, 24, 0x00000000005a5a49) + EXTU(0xa5a5a5a5a5a5a497, 4, 24, 0x00000000005a5a49) + DEP( 0xa5a5a5a5a5a5a497, 8388607, 4, 24, 0xa5a5a5a5a7fffff7) + EXT( 0xa5a5a5a5a5a5a496, 4, 25, 0x00000000005a5a49) + EXTU(0xa5a5a5a5a5a5a496, 4, 25, 0x00000000005a5a49) + DEP( 0xa5a5a5a5a5a5a496, 16777215, 4, 25, 0xa5a5a5a5affffff6) + EXT( 0xa5a5a5a5a5a5a495, 4, 26, 0xfffffffffe5a5a49) + EXTU(0xa5a5a5a5a5a5a495, 4, 26, 0x00000000025a5a49) + DEP( 0xa5a5a5a5a5a5a495, 33554431, 4, 26, 0xa5a5a5a59ffffff5) + EXT( 0xa5a5a5a5a5a5a494, 4, 27, 0x00000000025a5a49) + EXTU(0xa5a5a5a5a5a5a494, 4, 27, 0x00000000025a5a49) + DEP( 0xa5a5a5a5a5a5a494, 67108863, 4, 27, 0xa5a5a5a5bffffff4) + EXT( 0xa5a5a5a5a5a5a493, 4, 28, 0xfffffffffa5a5a49) + EXTU(0xa5a5a5a5a5a5a493, 4, 28, 0x000000000a5a5a49) + DEP( 0xa5a5a5a5a5a5a493, 134217727, 4, 28, 0xa5a5a5a57ffffff3) + EXT( 0xa5a5a5a5a5a5a492, 4, 29, 0xfffffffffa5a5a49) + EXTU(0xa5a5a5a5a5a5a492, 4, 29, 0x000000001a5a5a49) + DEP( 0xa5a5a5a5a5a5a492, 268435455, 4, 29, 0xa5a5a5a4fffffff2) + EXT( 0xa5a5a5a5a5a5a491, 4, 30, 0x000000001a5a5a49) + EXTU(0xa5a5a5a5a5a5a491, 4, 30, 0x000000001a5a5a49) + DEP( 0xa5a5a5a5a5a5a491, 536870911, 4, 30, 0xa5a5a5a5fffffff1) + EXT( 0xa5a5a5a5a5a5a490, 4, 31, 0xffffffffda5a5a49) + EXTU(0xa5a5a5a5a5a5a490, 4, 31, 0x000000005a5a5a49) + DEP( 0xa5a5a5a5a5a5a490, 1073741823, 4, 31, 0xa5a5a5a3fffffff0) + EXT( 0xa5a5a5a5a5a5a48f, 4, 32, 0x000000005a5a5a48) + EXTU(0xa5a5a5a5a5a5a48f, 4, 32, 0x000000005a5a5a48) + DEP( 0xa5a5a5a5a5a5a48f, 2147483647, 4, 32, 0xa5a5a5a7ffffffff) + EXT( 0xa5a5a5a5a5a5a48e, 4, 33, 0x000000005a5a5a48) + EXTU(0xa5a5a5a5a5a5a48e, 4, 33, 0x000000005a5a5a48) + DEP( 0xa5a5a5a5a5a5a48e, 4294967295, 4, 33, 0xa5a5a5affffffffe) + EXT( 0xa5a5a5a5a5a5a48d, 4, 34, 0xfffffffe5a5a5a48) + EXTU(0xa5a5a5a5a5a5a48d, 4, 34, 0x000000025a5a5a48) + DEP( 0xa5a5a5a5a5a5a48d, 8589934591, 4, 34, 0xa5a5a59ffffffffd) + EXT( 0xa5a5a5a5a5a5a48c, 4, 35, 0x000000025a5a5a48) + EXTU(0xa5a5a5a5a5a5a48c, 4, 35, 0x000000025a5a5a48) + DEP( 0xa5a5a5a5a5a5a48c, 17179869183, 4, 35, 0xa5a5a5bffffffffc) + EXT( 0xa5a5a5a5a5a5a48b, 4, 36, 0xfffffffa5a5a5a48) + EXTU(0xa5a5a5a5a5a5a48b, 4, 36, 0x0000000a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a48b, 34359738367, 4, 36, 0xa5a5a57ffffffffb) + EXT( 0xa5a5a5a5a5a5a48a, 4, 37, 0xfffffffa5a5a5a48) + EXTU(0xa5a5a5a5a5a5a48a, 4, 37, 0x0000001a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a48a, 68719476735, 4, 37, 0xa5a5a4fffffffffa) + EXT( 0xa5a5a5a5a5a5a489, 4, 38, 0x0000001a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a489, 4, 38, 0x0000001a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a489, 137438953471, 4, 38, 0xa5a5a5fffffffff9) + EXT( 0xa5a5a5a5a5a5a488, 4, 39, 0xffffffda5a5a5a48) + EXTU(0xa5a5a5a5a5a5a488, 4, 39, 0x0000005a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a488, 274877906943, 4, 39, 0xa5a5a3fffffffff8) + EXT( 0xa5a5a5a5a5a5a487, 4, 40, 0x0000005a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a487, 4, 40, 0x0000005a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a487, 549755813887, 4, 40, 0xa5a5a7fffffffff7) + EXT( 0xa5a5a5a5a5a5a486, 4, 41, 0x0000005a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a486, 4, 41, 0x0000005a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a486, 1099511627775, 4, 41, 0xa5a5affffffffff6) + EXT( 0xa5a5a5a5a5a5a485, 4, 42, 0xfffffe5a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a485, 4, 42, 0x0000025a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a485, 2199023255551, 4, 42, 0xa5a59ffffffffff5) + EXT( 0xa5a5a5a5a5a5a484, 4, 43, 0x0000025a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a484, 4, 43, 0x0000025a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a484, 4398046511103, 4, 43, 0xa5a5bffffffffff4) + EXT( 0xa5a5a5a5a5a5a483, 4, 44, 0xfffffa5a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a483, 4, 44, 0x00000a5a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a483, 8796093022207, 4, 44, 0xa5a57ffffffffff3) + EXT( 0xa5a5a5a5a5a5a482, 4, 45, 0xfffffa5a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a482, 4, 45, 0x00001a5a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a482, 17592186044415, 4, 45, 0xa5a4fffffffffff2) + EXT( 0xa5a5a5a5a5a5a481, 4, 46, 0x00001a5a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a481, 4, 46, 0x00001a5a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a481, 35184372088831, 4, 46, 0xa5a5fffffffffff1) + EXT( 0xa5a5a5a5a5a5a480, 4, 47, 0xffffda5a5a5a5a48) + EXTU(0xa5a5a5a5a5a5a480, 4, 47, 0x00005a5a5a5a5a48) + DEP( 0xa5a5a5a5a5a5a480, 70368744177663, 4, 47, 0xa5a3fffffffffff0) + EXT( 0xa5a5a5a5a5a5a47f, 4, 48, 0x00005a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47f, 4, 48, 0x00005a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47f, 140737488355327, 4, 48, 0xa5a7ffffffffffff) + EXT( 0xa5a5a5a5a5a5a47e, 4, 49, 0x00005a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47e, 4, 49, 0x00005a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47e, 281474976710655, 4, 49, 0xa5affffffffffffe) + EXT( 0xa5a5a5a5a5a5a47d, 4, 50, 0xfffe5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47d, 4, 50, 0x00025a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47d, 562949953421311, 4, 50, 0xa59ffffffffffffd) + EXT( 0xa5a5a5a5a5a5a47c, 4, 51, 0x00025a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47c, 4, 51, 0x00025a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47c, 1125899906842623, 4, 51, 0xa5bffffffffffffc) + EXT( 0xa5a5a5a5a5a5a47b, 4, 52, 0xfffa5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47b, 4, 52, 0x000a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47b, 2251799813685247, 4, 52, 0xa57ffffffffffffb) + EXT( 0xa5a5a5a5a5a5a47a, 4, 53, 0xfffa5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a47a, 4, 53, 0x001a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a47a, 4503599627370495, 4, 53, 0xa4fffffffffffffa) + EXT( 0xa5a5a5a5a5a5a479, 4, 54, 0x001a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a479, 4, 54, 0x001a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a479, 9007199254740991, 4, 54, 0xa5fffffffffffff9) + EXT( 0xa5a5a5a5a5a5a478, 4, 55, 0xffda5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a478, 4, 55, 0x005a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a478, 18014398509481983, 4, 55, 0xa3fffffffffffff8) + EXT( 0xa5a5a5a5a5a5a477, 4, 56, 0x005a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a477, 4, 56, 0x005a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a477, 36028797018963967, 4, 56, 0xa7fffffffffffff7) + EXT( 0xa5a5a5a5a5a5a476, 4, 57, 0x005a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a476, 4, 57, 0x005a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a476, 72057594037927935, 4, 57, 0xaffffffffffffff6) + EXT( 0xa5a5a5a5a5a5a475, 4, 58, 0xfe5a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a475, 4, 58, 0x025a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a475, 144115188075855871, 4, 58, 0x9ffffffffffffff5) + EXT( 0xa5a5a5a5a5a5a474, 4, 59, 0x025a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a474, 4, 59, 0x025a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a474, 288230376151711743, 4, 59, 0xbffffffffffffff4) + EXT( 0xa5a5a5a5a5a5a473, 5, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a473, 5, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a473, 0, 5, 1, 0xa5a5a5a5a5a5a453) + EXT( 0xa5a5a5a5a5a5a472, 5, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a472, 5, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a472, 1, 5, 2, 0xa5a5a5a5a5a5a432) + EXT( 0xa5a5a5a5a5a5a471, 5, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a471, 5, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a471, 3, 5, 3, 0xa5a5a5a5a5a5a471) + EXT( 0xa5a5a5a5a5a5a470, 5, 4, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a470, 5, 4, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a470, 7, 5, 4, 0xa5a5a5a5a5a5a4f0) + EXT( 0xa5a5a5a5a5a5a46f, 5, 5, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a46f, 5, 5, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a46f, 15, 5, 5, 0xa5a5a5a5a5a5a5ef) + EXT( 0xa5a5a5a5a5a5a46e, 5, 6, 0xffffffffffffffe3) + EXTU(0xa5a5a5a5a5a5a46e, 5, 6, 0x0000000000000023) + DEP( 0xa5a5a5a5a5a5a46e, 31, 5, 6, 0xa5a5a5a5a5a5a3ee) + EXT( 0xa5a5a5a5a5a5a46d, 5, 7, 0x0000000000000023) + EXTU(0xa5a5a5a5a5a5a46d, 5, 7, 0x0000000000000023) + DEP( 0xa5a5a5a5a5a5a46d, 63, 5, 7, 0xa5a5a5a5a5a5a7ed) + EXT( 0xa5a5a5a5a5a5a46c, 5, 8, 0x0000000000000023) + EXTU(0xa5a5a5a5a5a5a46c, 5, 8, 0x0000000000000023) + DEP( 0xa5a5a5a5a5a5a46c, 127, 5, 8, 0xa5a5a5a5a5a5afec) + EXT( 0xa5a5a5a5a5a5a46b, 5, 9, 0xffffffffffffff23) + EXTU(0xa5a5a5a5a5a5a46b, 5, 9, 0x0000000000000123) + DEP( 0xa5a5a5a5a5a5a46b, 255, 5, 9, 0xa5a5a5a5a5a59feb) + EXT( 0xa5a5a5a5a5a5a46a, 5, 10, 0x0000000000000123) + EXTU(0xa5a5a5a5a5a5a46a, 5, 10, 0x0000000000000123) + DEP( 0xa5a5a5a5a5a5a46a, 511, 5, 10, 0xa5a5a5a5a5a5bfea) + EXT( 0xa5a5a5a5a5a5a469, 5, 11, 0xfffffffffffffd23) + EXTU(0xa5a5a5a5a5a5a469, 5, 11, 0x0000000000000523) + DEP( 0xa5a5a5a5a5a5a469, 1023, 5, 11, 0xa5a5a5a5a5a57fe9) + EXT( 0xa5a5a5a5a5a5a468, 5, 12, 0xfffffffffffffd23) + EXTU(0xa5a5a5a5a5a5a468, 5, 12, 0x0000000000000d23) + DEP( 0xa5a5a5a5a5a5a468, 2047, 5, 12, 0xa5a5a5a5a5a4ffe8) + EXT( 0xa5a5a5a5a5a5a467, 5, 13, 0x0000000000000d23) + EXTU(0xa5a5a5a5a5a5a467, 5, 13, 0x0000000000000d23) + DEP( 0xa5a5a5a5a5a5a467, 4095, 5, 13, 0xa5a5a5a5a5a5ffe7) + EXT( 0xa5a5a5a5a5a5a466, 5, 14, 0xffffffffffffed23) + EXTU(0xa5a5a5a5a5a5a466, 5, 14, 0x0000000000002d23) + DEP( 0xa5a5a5a5a5a5a466, 8191, 5, 14, 0xa5a5a5a5a5a3ffe6) + EXT( 0xa5a5a5a5a5a5a465, 5, 15, 0x0000000000002d23) + EXTU(0xa5a5a5a5a5a5a465, 5, 15, 0x0000000000002d23) + DEP( 0xa5a5a5a5a5a5a465, 16383, 5, 15, 0xa5a5a5a5a5a7ffe5) + EXT( 0xa5a5a5a5a5a5a464, 5, 16, 0x0000000000002d23) + EXTU(0xa5a5a5a5a5a5a464, 5, 16, 0x0000000000002d23) + DEP( 0xa5a5a5a5a5a5a464, 32767, 5, 16, 0xa5a5a5a5a5afffe4) + EXT( 0xa5a5a5a5a5a5a463, 5, 17, 0xffffffffffff2d23) + EXTU(0xa5a5a5a5a5a5a463, 5, 17, 0x0000000000012d23) + DEP( 0xa5a5a5a5a5a5a463, 65535, 5, 17, 0xa5a5a5a5a59fffe3) + EXT( 0xa5a5a5a5a5a5a462, 5, 18, 0x0000000000012d23) + EXTU(0xa5a5a5a5a5a5a462, 5, 18, 0x0000000000012d23) + DEP( 0xa5a5a5a5a5a5a462, 131071, 5, 18, 0xa5a5a5a5a5bfffe2) + EXT( 0xa5a5a5a5a5a5a461, 5, 19, 0xfffffffffffd2d23) + EXTU(0xa5a5a5a5a5a5a461, 5, 19, 0x0000000000052d23) + DEP( 0xa5a5a5a5a5a5a461, 262143, 5, 19, 0xa5a5a5a5a57fffe1) + EXT( 0xa5a5a5a5a5a5a460, 5, 20, 0xfffffffffffd2d23) + EXTU(0xa5a5a5a5a5a5a460, 5, 20, 0x00000000000d2d23) + DEP( 0xa5a5a5a5a5a5a460, 524287, 5, 20, 0xa5a5a5a5a4ffffe0) + EXT( 0xa5a5a5a5a5a5a45f, 5, 21, 0x00000000000d2d22) + EXTU(0xa5a5a5a5a5a5a45f, 5, 21, 0x00000000000d2d22) + DEP( 0xa5a5a5a5a5a5a45f, 1048575, 5, 21, 0xa5a5a5a5a5ffffff) + EXT( 0xa5a5a5a5a5a5a45e, 5, 22, 0xffffffffffed2d22) + EXTU(0xa5a5a5a5a5a5a45e, 5, 22, 0x00000000002d2d22) + DEP( 0xa5a5a5a5a5a5a45e, 2097151, 5, 22, 0xa5a5a5a5a3fffffe) + EXT( 0xa5a5a5a5a5a5a45d, 5, 23, 0x00000000002d2d22) + EXTU(0xa5a5a5a5a5a5a45d, 5, 23, 0x00000000002d2d22) + DEP( 0xa5a5a5a5a5a5a45d, 4194303, 5, 23, 0xa5a5a5a5a7fffffd) + EXT( 0xa5a5a5a5a5a5a45c, 5, 24, 0x00000000002d2d22) + EXTU(0xa5a5a5a5a5a5a45c, 5, 24, 0x00000000002d2d22) + DEP( 0xa5a5a5a5a5a5a45c, 8388607, 5, 24, 0xa5a5a5a5affffffc) + EXT( 0xa5a5a5a5a5a5a45b, 5, 25, 0xffffffffff2d2d22) + EXTU(0xa5a5a5a5a5a5a45b, 5, 25, 0x00000000012d2d22) + DEP( 0xa5a5a5a5a5a5a45b, 16777215, 5, 25, 0xa5a5a5a59ffffffb) + EXT( 0xa5a5a5a5a5a5a45a, 5, 26, 0x00000000012d2d22) + EXTU(0xa5a5a5a5a5a5a45a, 5, 26, 0x00000000012d2d22) + DEP( 0xa5a5a5a5a5a5a45a, 33554431, 5, 26, 0xa5a5a5a5bffffffa) + EXT( 0xa5a5a5a5a5a5a459, 5, 27, 0xfffffffffd2d2d22) + EXTU(0xa5a5a5a5a5a5a459, 5, 27, 0x00000000052d2d22) + DEP( 0xa5a5a5a5a5a5a459, 67108863, 5, 27, 0xa5a5a5a57ffffff9) + EXT( 0xa5a5a5a5a5a5a458, 5, 28, 0xfffffffffd2d2d22) + EXTU(0xa5a5a5a5a5a5a458, 5, 28, 0x000000000d2d2d22) + DEP( 0xa5a5a5a5a5a5a458, 134217727, 5, 28, 0xa5a5a5a4fffffff8) + EXT( 0xa5a5a5a5a5a5a457, 5, 29, 0x000000000d2d2d22) + EXTU(0xa5a5a5a5a5a5a457, 5, 29, 0x000000000d2d2d22) + DEP( 0xa5a5a5a5a5a5a457, 268435455, 5, 29, 0xa5a5a5a5fffffff7) + EXT( 0xa5a5a5a5a5a5a456, 5, 30, 0xffffffffed2d2d22) + EXTU(0xa5a5a5a5a5a5a456, 5, 30, 0x000000002d2d2d22) + DEP( 0xa5a5a5a5a5a5a456, 536870911, 5, 30, 0xa5a5a5a3fffffff6) + EXT( 0xa5a5a5a5a5a5a455, 5, 31, 0x000000002d2d2d22) + EXTU(0xa5a5a5a5a5a5a455, 5, 31, 0x000000002d2d2d22) + DEP( 0xa5a5a5a5a5a5a455, 1073741823, 5, 31, 0xa5a5a5a7fffffff5) + EXT( 0xa5a5a5a5a5a5a454, 5, 32, 0x000000002d2d2d22) + EXTU(0xa5a5a5a5a5a5a454, 5, 32, 0x000000002d2d2d22) + DEP( 0xa5a5a5a5a5a5a454, 2147483647, 5, 32, 0xa5a5a5affffffff4) + EXT( 0xa5a5a5a5a5a5a453, 5, 33, 0xffffffff2d2d2d22) + EXTU(0xa5a5a5a5a5a5a453, 5, 33, 0x000000012d2d2d22) + DEP( 0xa5a5a5a5a5a5a453, 4294967295, 5, 33, 0xa5a5a59ffffffff3) + EXT( 0xa5a5a5a5a5a5a452, 5, 34, 0x000000012d2d2d22) + EXTU(0xa5a5a5a5a5a5a452, 5, 34, 0x000000012d2d2d22) + DEP( 0xa5a5a5a5a5a5a452, 8589934591, 5, 34, 0xa5a5a5bffffffff2) + EXT( 0xa5a5a5a5a5a5a451, 5, 35, 0xfffffffd2d2d2d22) + EXTU(0xa5a5a5a5a5a5a451, 5, 35, 0x000000052d2d2d22) + DEP( 0xa5a5a5a5a5a5a451, 17179869183, 5, 35, 0xa5a5a57ffffffff1) + EXT( 0xa5a5a5a5a5a5a450, 5, 36, 0xfffffffd2d2d2d22) + EXTU(0xa5a5a5a5a5a5a450, 5, 36, 0x0000000d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a450, 34359738367, 5, 36, 0xa5a5a4fffffffff0) + EXT( 0xa5a5a5a5a5a5a44f, 5, 37, 0x0000000d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44f, 5, 37, 0x0000000d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44f, 68719476735, 5, 37, 0xa5a5a5ffffffffef) + EXT( 0xa5a5a5a5a5a5a44e, 5, 38, 0xffffffed2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44e, 5, 38, 0x0000002d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44e, 137438953471, 5, 38, 0xa5a5a3ffffffffee) + EXT( 0xa5a5a5a5a5a5a44d, 5, 39, 0x0000002d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44d, 5, 39, 0x0000002d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44d, 274877906943, 5, 39, 0xa5a5a7ffffffffed) + EXT( 0xa5a5a5a5a5a5a44c, 5, 40, 0x0000002d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44c, 5, 40, 0x0000002d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44c, 549755813887, 5, 40, 0xa5a5afffffffffec) + EXT( 0xa5a5a5a5a5a5a44b, 5, 41, 0xffffff2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44b, 5, 41, 0x0000012d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44b, 1099511627775, 5, 41, 0xa5a59fffffffffeb) + EXT( 0xa5a5a5a5a5a5a44a, 5, 42, 0x0000012d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a44a, 5, 42, 0x0000012d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a44a, 2199023255551, 5, 42, 0xa5a5bfffffffffea) + EXT( 0xa5a5a5a5a5a5a449, 5, 43, 0xfffffd2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a449, 5, 43, 0x0000052d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a449, 4398046511103, 5, 43, 0xa5a57fffffffffe9) + EXT( 0xa5a5a5a5a5a5a448, 5, 44, 0xfffffd2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a448, 5, 44, 0x00000d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a448, 8796093022207, 5, 44, 0xa5a4ffffffffffe8) + EXT( 0xa5a5a5a5a5a5a447, 5, 45, 0x00000d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a447, 5, 45, 0x00000d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a447, 17592186044415, 5, 45, 0xa5a5ffffffffffe7) + EXT( 0xa5a5a5a5a5a5a446, 5, 46, 0xffffed2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a446, 5, 46, 0x00002d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a446, 35184372088831, 5, 46, 0xa5a3ffffffffffe6) + EXT( 0xa5a5a5a5a5a5a445, 5, 47, 0x00002d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a445, 5, 47, 0x00002d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a445, 70368744177663, 5, 47, 0xa5a7ffffffffffe5) + EXT( 0xa5a5a5a5a5a5a444, 5, 48, 0x00002d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a444, 5, 48, 0x00002d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a444, 140737488355327, 5, 48, 0xa5afffffffffffe4) + EXT( 0xa5a5a5a5a5a5a443, 5, 49, 0xffff2d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a443, 5, 49, 0x00012d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a443, 281474976710655, 5, 49, 0xa59fffffffffffe3) + EXT( 0xa5a5a5a5a5a5a442, 5, 50, 0x00012d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a442, 5, 50, 0x00012d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a442, 562949953421311, 5, 50, 0xa5bfffffffffffe2) + EXT( 0xa5a5a5a5a5a5a441, 5, 51, 0xfffd2d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a441, 5, 51, 0x00052d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a441, 1125899906842623, 5, 51, 0xa57fffffffffffe1) + EXT( 0xa5a5a5a5a5a5a440, 5, 52, 0xfffd2d2d2d2d2d22) + EXTU(0xa5a5a5a5a5a5a440, 5, 52, 0x000d2d2d2d2d2d22) + DEP( 0xa5a5a5a5a5a5a440, 2251799813685247, 5, 52, 0xa4ffffffffffffe0) + EXT( 0xa5a5a5a5a5a5a43f, 5, 53, 0x000d2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43f, 5, 53, 0x000d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43f, 4503599627370495, 5, 53, 0xa5ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a43e, 5, 54, 0xffed2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43e, 5, 54, 0x002d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43e, 9007199254740991, 5, 54, 0xa3fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a43d, 5, 55, 0x002d2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43d, 5, 55, 0x002d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43d, 18014398509481983, 5, 55, 0xa7fffffffffffffd) + EXT( 0xa5a5a5a5a5a5a43c, 5, 56, 0x002d2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43c, 5, 56, 0x002d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43c, 36028797018963967, 5, 56, 0xaffffffffffffffc) + EXT( 0xa5a5a5a5a5a5a43b, 5, 57, 0xff2d2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43b, 5, 57, 0x012d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43b, 72057594037927935, 5, 57, 0x9ffffffffffffffb) + EXT( 0xa5a5a5a5a5a5a43a, 5, 58, 0x012d2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43a, 5, 58, 0x012d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43a, 144115188075855871, 5, 58, 0xbffffffffffffffa) + EXT( 0xa5a5a5a5a5a5a439, 6, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a439, 6, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a439, 0, 6, 1, 0xa5a5a5a5a5a5a439) + EXT( 0xa5a5a5a5a5a5a438, 6, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a438, 6, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a438, 1, 6, 2, 0xa5a5a5a5a5a5a478) + EXT( 0xa5a5a5a5a5a5a437, 6, 3, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a437, 6, 3, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a437, 3, 6, 3, 0xa5a5a5a5a5a5a4f7) + EXT( 0xa5a5a5a5a5a5a436, 6, 4, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a436, 6, 4, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a436, 7, 6, 4, 0xa5a5a5a5a5a5a5f6) + EXT( 0xa5a5a5a5a5a5a435, 6, 5, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a5a435, 6, 5, 0x0000000000000010) + DEP( 0xa5a5a5a5a5a5a435, 15, 6, 5, 0xa5a5a5a5a5a5a3f5) + EXT( 0xa5a5a5a5a5a5a434, 6, 6, 0x0000000000000010) + EXTU(0xa5a5a5a5a5a5a434, 6, 6, 0x0000000000000010) + DEP( 0xa5a5a5a5a5a5a434, 31, 6, 6, 0xa5a5a5a5a5a5a7f4) + EXT( 0xa5a5a5a5a5a5a433, 6, 7, 0x0000000000000010) + EXTU(0xa5a5a5a5a5a5a433, 6, 7, 0x0000000000000010) + DEP( 0xa5a5a5a5a5a5a433, 63, 6, 7, 0xa5a5a5a5a5a5aff3) + EXT( 0xa5a5a5a5a5a5a432, 6, 8, 0xffffffffffffff90) + EXTU(0xa5a5a5a5a5a5a432, 6, 8, 0x0000000000000090) + DEP( 0xa5a5a5a5a5a5a432, 127, 6, 8, 0xa5a5a5a5a5a59ff2) + EXT( 0xa5a5a5a5a5a5a431, 6, 9, 0x0000000000000090) + EXTU(0xa5a5a5a5a5a5a431, 6, 9, 0x0000000000000090) + DEP( 0xa5a5a5a5a5a5a431, 255, 6, 9, 0xa5a5a5a5a5a5bff1) + EXT( 0xa5a5a5a5a5a5a430, 6, 10, 0xfffffffffffffe90) + EXTU(0xa5a5a5a5a5a5a430, 6, 10, 0x0000000000000290) + DEP( 0xa5a5a5a5a5a5a430, 511, 6, 10, 0xa5a5a5a5a5a57ff0) + EXT( 0xa5a5a5a5a5a5a42f, 6, 11, 0xfffffffffffffe90) + EXTU(0xa5a5a5a5a5a5a42f, 6, 11, 0x0000000000000690) + DEP( 0xa5a5a5a5a5a5a42f, 1023, 6, 11, 0xa5a5a5a5a5a4ffef) + EXT( 0xa5a5a5a5a5a5a42e, 6, 12, 0x0000000000000690) + EXTU(0xa5a5a5a5a5a5a42e, 6, 12, 0x0000000000000690) + DEP( 0xa5a5a5a5a5a5a42e, 2047, 6, 12, 0xa5a5a5a5a5a5ffee) + EXT( 0xa5a5a5a5a5a5a42d, 6, 13, 0xfffffffffffff690) + EXTU(0xa5a5a5a5a5a5a42d, 6, 13, 0x0000000000001690) + DEP( 0xa5a5a5a5a5a5a42d, 4095, 6, 13, 0xa5a5a5a5a5a3ffed) + EXT( 0xa5a5a5a5a5a5a42c, 6, 14, 0x0000000000001690) + EXTU(0xa5a5a5a5a5a5a42c, 6, 14, 0x0000000000001690) + DEP( 0xa5a5a5a5a5a5a42c, 8191, 6, 14, 0xa5a5a5a5a5a7ffec) + EXT( 0xa5a5a5a5a5a5a42b, 6, 15, 0x0000000000001690) + EXTU(0xa5a5a5a5a5a5a42b, 6, 15, 0x0000000000001690) + DEP( 0xa5a5a5a5a5a5a42b, 16383, 6, 15, 0xa5a5a5a5a5afffeb) + EXT( 0xa5a5a5a5a5a5a42a, 6, 16, 0xffffffffffff9690) + EXTU(0xa5a5a5a5a5a5a42a, 6, 16, 0x0000000000009690) + DEP( 0xa5a5a5a5a5a5a42a, 32767, 6, 16, 0xa5a5a5a5a59fffea) + EXT( 0xa5a5a5a5a5a5a429, 6, 17, 0x0000000000009690) + EXTU(0xa5a5a5a5a5a5a429, 6, 17, 0x0000000000009690) + DEP( 0xa5a5a5a5a5a5a429, 65535, 6, 17, 0xa5a5a5a5a5bfffe9) + EXT( 0xa5a5a5a5a5a5a428, 6, 18, 0xfffffffffffe9690) + EXTU(0xa5a5a5a5a5a5a428, 6, 18, 0x0000000000029690) + DEP( 0xa5a5a5a5a5a5a428, 131071, 6, 18, 0xa5a5a5a5a57fffe8) + EXT( 0xa5a5a5a5a5a5a427, 6, 19, 0xfffffffffffe9690) + EXTU(0xa5a5a5a5a5a5a427, 6, 19, 0x0000000000069690) + DEP( 0xa5a5a5a5a5a5a427, 262143, 6, 19, 0xa5a5a5a5a4ffffe7) + EXT( 0xa5a5a5a5a5a5a426, 6, 20, 0x0000000000069690) + EXTU(0xa5a5a5a5a5a5a426, 6, 20, 0x0000000000069690) + DEP( 0xa5a5a5a5a5a5a426, 524287, 6, 20, 0xa5a5a5a5a5ffffe6) + EXT( 0xa5a5a5a5a5a5a425, 6, 21, 0xfffffffffff69690) + EXTU(0xa5a5a5a5a5a5a425, 6, 21, 0x0000000000169690) + DEP( 0xa5a5a5a5a5a5a425, 1048575, 6, 21, 0xa5a5a5a5a3ffffe5) + EXT( 0xa5a5a5a5a5a5a424, 6, 22, 0x0000000000169690) + EXTU(0xa5a5a5a5a5a5a424, 6, 22, 0x0000000000169690) + DEP( 0xa5a5a5a5a5a5a424, 2097151, 6, 22, 0xa5a5a5a5a7ffffe4) + EXT( 0xa5a5a5a5a5a5a423, 6, 23, 0x0000000000169690) + EXTU(0xa5a5a5a5a5a5a423, 6, 23, 0x0000000000169690) + DEP( 0xa5a5a5a5a5a5a423, 4194303, 6, 23, 0xa5a5a5a5afffffe3) + EXT( 0xa5a5a5a5a5a5a422, 6, 24, 0xffffffffff969690) + EXTU(0xa5a5a5a5a5a5a422, 6, 24, 0x0000000000969690) + DEP( 0xa5a5a5a5a5a5a422, 8388607, 6, 24, 0xa5a5a5a59fffffe2) + EXT( 0xa5a5a5a5a5a5a421, 6, 25, 0x0000000000969690) + EXTU(0xa5a5a5a5a5a5a421, 6, 25, 0x0000000000969690) + DEP( 0xa5a5a5a5a5a5a421, 16777215, 6, 25, 0xa5a5a5a5bfffffe1) + EXT( 0xa5a5a5a5a5a5a420, 6, 26, 0xfffffffffe969690) + EXTU(0xa5a5a5a5a5a5a420, 6, 26, 0x0000000002969690) + DEP( 0xa5a5a5a5a5a5a420, 33554431, 6, 26, 0xa5a5a5a57fffffe0) + EXT( 0xa5a5a5a5a5a5a41f, 6, 27, 0xfffffffffe969690) + EXTU(0xa5a5a5a5a5a5a41f, 6, 27, 0x0000000006969690) + DEP( 0xa5a5a5a5a5a5a41f, 67108863, 6, 27, 0xa5a5a5a4ffffffdf) + EXT( 0xa5a5a5a5a5a5a41e, 6, 28, 0x0000000006969690) + EXTU(0xa5a5a5a5a5a5a41e, 6, 28, 0x0000000006969690) + DEP( 0xa5a5a5a5a5a5a41e, 134217727, 6, 28, 0xa5a5a5a5ffffffde) + EXT( 0xa5a5a5a5a5a5a41d, 6, 29, 0xfffffffff6969690) + EXTU(0xa5a5a5a5a5a5a41d, 6, 29, 0x0000000016969690) + DEP( 0xa5a5a5a5a5a5a41d, 268435455, 6, 29, 0xa5a5a5a3ffffffdd) + EXT( 0xa5a5a5a5a5a5a41c, 6, 30, 0x0000000016969690) + EXTU(0xa5a5a5a5a5a5a41c, 6, 30, 0x0000000016969690) + DEP( 0xa5a5a5a5a5a5a41c, 536870911, 6, 30, 0xa5a5a5a7ffffffdc) + EXT( 0xa5a5a5a5a5a5a41b, 6, 31, 0x0000000016969690) + EXTU(0xa5a5a5a5a5a5a41b, 6, 31, 0x0000000016969690) + DEP( 0xa5a5a5a5a5a5a41b, 1073741823, 6, 31, 0xa5a5a5afffffffdb) + EXT( 0xa5a5a5a5a5a5a41a, 6, 32, 0xffffffff96969690) + EXTU(0xa5a5a5a5a5a5a41a, 6, 32, 0x0000000096969690) + DEP( 0xa5a5a5a5a5a5a41a, 2147483647, 6, 32, 0xa5a5a59fffffffda) + EXT( 0xa5a5a5a5a5a5a419, 6, 33, 0x0000000096969690) + EXTU(0xa5a5a5a5a5a5a419, 6, 33, 0x0000000096969690) + DEP( 0xa5a5a5a5a5a5a419, 4294967295, 6, 33, 0xa5a5a5bfffffffd9) + EXT( 0xa5a5a5a5a5a5a418, 6, 34, 0xfffffffe96969690) + EXTU(0xa5a5a5a5a5a5a418, 6, 34, 0x0000000296969690) + DEP( 0xa5a5a5a5a5a5a418, 8589934591, 6, 34, 0xa5a5a57fffffffd8) + EXT( 0xa5a5a5a5a5a5a417, 6, 35, 0xfffffffe96969690) + EXTU(0xa5a5a5a5a5a5a417, 6, 35, 0x0000000696969690) + DEP( 0xa5a5a5a5a5a5a417, 17179869183, 6, 35, 0xa5a5a4ffffffffd7) + EXT( 0xa5a5a5a5a5a5a416, 6, 36, 0x0000000696969690) + EXTU(0xa5a5a5a5a5a5a416, 6, 36, 0x0000000696969690) + DEP( 0xa5a5a5a5a5a5a416, 34359738367, 6, 36, 0xa5a5a5ffffffffd6) + EXT( 0xa5a5a5a5a5a5a415, 6, 37, 0xfffffff696969690) + EXTU(0xa5a5a5a5a5a5a415, 6, 37, 0x0000001696969690) + DEP( 0xa5a5a5a5a5a5a415, 68719476735, 6, 37, 0xa5a5a3ffffffffd5) + EXT( 0xa5a5a5a5a5a5a414, 6, 38, 0x0000001696969690) + EXTU(0xa5a5a5a5a5a5a414, 6, 38, 0x0000001696969690) + DEP( 0xa5a5a5a5a5a5a414, 137438953471, 6, 38, 0xa5a5a7ffffffffd4) + EXT( 0xa5a5a5a5a5a5a413, 6, 39, 0x0000001696969690) + EXTU(0xa5a5a5a5a5a5a413, 6, 39, 0x0000001696969690) + DEP( 0xa5a5a5a5a5a5a413, 274877906943, 6, 39, 0xa5a5afffffffffd3) + EXT( 0xa5a5a5a5a5a5a412, 6, 40, 0xffffff9696969690) + EXTU(0xa5a5a5a5a5a5a412, 6, 40, 0x0000009696969690) + DEP( 0xa5a5a5a5a5a5a412, 549755813887, 6, 40, 0xa5a59fffffffffd2) + EXT( 0xa5a5a5a5a5a5a411, 6, 41, 0x0000009696969690) + EXTU(0xa5a5a5a5a5a5a411, 6, 41, 0x0000009696969690) + DEP( 0xa5a5a5a5a5a5a411, 1099511627775, 6, 41, 0xa5a5bfffffffffd1) + EXT( 0xa5a5a5a5a5a5a410, 6, 42, 0xfffffe9696969690) + EXTU(0xa5a5a5a5a5a5a410, 6, 42, 0x0000029696969690) + DEP( 0xa5a5a5a5a5a5a410, 2199023255551, 6, 42, 0xa5a57fffffffffd0) + EXT( 0xa5a5a5a5a5a5a40f, 6, 43, 0xfffffe9696969690) + EXTU(0xa5a5a5a5a5a5a40f, 6, 43, 0x0000069696969690) + DEP( 0xa5a5a5a5a5a5a40f, 4398046511103, 6, 43, 0xa5a4ffffffffffcf) + EXT( 0xa5a5a5a5a5a5a40e, 6, 44, 0x0000069696969690) + EXTU(0xa5a5a5a5a5a5a40e, 6, 44, 0x0000069696969690) + DEP( 0xa5a5a5a5a5a5a40e, 8796093022207, 6, 44, 0xa5a5ffffffffffce) + EXT( 0xa5a5a5a5a5a5a40d, 6, 45, 0xfffff69696969690) + EXTU(0xa5a5a5a5a5a5a40d, 6, 45, 0x0000169696969690) + DEP( 0xa5a5a5a5a5a5a40d, 17592186044415, 6, 45, 0xa5a3ffffffffffcd) + EXT( 0xa5a5a5a5a5a5a40c, 6, 46, 0x0000169696969690) + EXTU(0xa5a5a5a5a5a5a40c, 6, 46, 0x0000169696969690) + DEP( 0xa5a5a5a5a5a5a40c, 35184372088831, 6, 46, 0xa5a7ffffffffffcc) + EXT( 0xa5a5a5a5a5a5a40b, 6, 47, 0x0000169696969690) + EXTU(0xa5a5a5a5a5a5a40b, 6, 47, 0x0000169696969690) + DEP( 0xa5a5a5a5a5a5a40b, 70368744177663, 6, 47, 0xa5afffffffffffcb) + EXT( 0xa5a5a5a5a5a5a40a, 6, 48, 0xffff969696969690) + EXTU(0xa5a5a5a5a5a5a40a, 6, 48, 0x0000969696969690) + DEP( 0xa5a5a5a5a5a5a40a, 140737488355327, 6, 48, 0xa59fffffffffffca) + EXT( 0xa5a5a5a5a5a5a409, 6, 49, 0x0000969696969690) + EXTU(0xa5a5a5a5a5a5a409, 6, 49, 0x0000969696969690) + DEP( 0xa5a5a5a5a5a5a409, 281474976710655, 6, 49, 0xa5bfffffffffffc9) + EXT( 0xa5a5a5a5a5a5a408, 6, 50, 0xfffe969696969690) + EXTU(0xa5a5a5a5a5a5a408, 6, 50, 0x0002969696969690) + DEP( 0xa5a5a5a5a5a5a408, 562949953421311, 6, 50, 0xa57fffffffffffc8) + EXT( 0xa5a5a5a5a5a5a407, 6, 51, 0xfffe969696969690) + EXTU(0xa5a5a5a5a5a5a407, 6, 51, 0x0006969696969690) + DEP( 0xa5a5a5a5a5a5a407, 1125899906842623, 6, 51, 0xa4ffffffffffffc7) + EXT( 0xa5a5a5a5a5a5a406, 6, 52, 0x0006969696969690) + EXTU(0xa5a5a5a5a5a5a406, 6, 52, 0x0006969696969690) + DEP( 0xa5a5a5a5a5a5a406, 2251799813685247, 6, 52, 0xa5ffffffffffffc6) + EXT( 0xa5a5a5a5a5a5a405, 6, 53, 0xfff6969696969690) + EXTU(0xa5a5a5a5a5a5a405, 6, 53, 0x0016969696969690) + DEP( 0xa5a5a5a5a5a5a405, 4503599627370495, 6, 53, 0xa3ffffffffffffc5) + EXT( 0xa5a5a5a5a5a5a404, 6, 54, 0x0016969696969690) + EXTU(0xa5a5a5a5a5a5a404, 6, 54, 0x0016969696969690) + DEP( 0xa5a5a5a5a5a5a404, 9007199254740991, 6, 54, 0xa7ffffffffffffc4) + EXT( 0xa5a5a5a5a5a5a403, 6, 55, 0x0016969696969690) + EXTU(0xa5a5a5a5a5a5a403, 6, 55, 0x0016969696969690) + DEP( 0xa5a5a5a5a5a5a403, 18014398509481983, 6, 55, 0xafffffffffffffc3) + EXT( 0xa5a5a5a5a5a5a402, 6, 56, 0xff96969696969690) + EXTU(0xa5a5a5a5a5a5a402, 6, 56, 0x0096969696969690) + DEP( 0xa5a5a5a5a5a5a402, 36028797018963967, 6, 56, 0x9fffffffffffffc2) + EXT( 0xa5a5a5a5a5a5a401, 6, 57, 0x0096969696969690) + EXTU(0xa5a5a5a5a5a5a401, 6, 57, 0x0096969696969690) + DEP( 0xa5a5a5a5a5a5a401, 72057594037927935, 6, 57, 0xbfffffffffffffc1) + EXT( 0xa5a5a5a5a5a5a400, 7, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a400, 7, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a400, 0, 7, 1, 0xa5a5a5a5a5a5a400) + EXT( 0xa5a5a5a5a5a5a3ff, 7, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3ff, 7, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3ff, 1, 7, 2, 0xa5a5a5a5a5a5a2ff) + EXT( 0xa5a5a5a5a5a5a3fe, 7, 3, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3fe, 7, 3, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a5a3fe, 3, 7, 3, 0xa5a5a5a5a5a5a1fe) + EXT( 0xa5a5a5a5a5a5a3fd, 7, 4, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a5a3fd, 7, 4, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a5a3fd, 7, 7, 4, 0xa5a5a5a5a5a5a3fd) + EXT( 0xa5a5a5a5a5a5a3fc, 7, 5, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a5a3fc, 7, 5, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a5a3fc, 15, 7, 5, 0xa5a5a5a5a5a5a7fc) + EXT( 0xa5a5a5a5a5a5a3fb, 7, 6, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a5a3fb, 7, 6, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a5a3fb, 31, 7, 6, 0xa5a5a5a5a5a5affb) + EXT( 0xa5a5a5a5a5a5a3fa, 7, 7, 0xffffffffffffffc7) + EXTU(0xa5a5a5a5a5a5a3fa, 7, 7, 0x0000000000000047) + DEP( 0xa5a5a5a5a5a5a3fa, 63, 7, 7, 0xa5a5a5a5a5a59ffa) + EXT( 0xa5a5a5a5a5a5a3f9, 7, 8, 0x0000000000000047) + EXTU(0xa5a5a5a5a5a5a3f9, 7, 8, 0x0000000000000047) + DEP( 0xa5a5a5a5a5a5a3f9, 127, 7, 8, 0xa5a5a5a5a5a5bff9) + EXT( 0xa5a5a5a5a5a5a3f8, 7, 9, 0xffffffffffffff47) + EXTU(0xa5a5a5a5a5a5a3f8, 7, 9, 0x0000000000000147) + DEP( 0xa5a5a5a5a5a5a3f8, 255, 7, 9, 0xa5a5a5a5a5a57ff8) + EXT( 0xa5a5a5a5a5a5a3f7, 7, 10, 0xffffffffffffff47) + EXTU(0xa5a5a5a5a5a5a3f7, 7, 10, 0x0000000000000347) + DEP( 0xa5a5a5a5a5a5a3f7, 511, 7, 10, 0xa5a5a5a5a5a4fff7) + EXT( 0xa5a5a5a5a5a5a3f6, 7, 11, 0x0000000000000347) + EXTU(0xa5a5a5a5a5a5a3f6, 7, 11, 0x0000000000000347) + DEP( 0xa5a5a5a5a5a5a3f6, 1023, 7, 11, 0xa5a5a5a5a5a5fff6) + EXT( 0xa5a5a5a5a5a5a3f5, 7, 12, 0xfffffffffffffb47) + EXTU(0xa5a5a5a5a5a5a3f5, 7, 12, 0x0000000000000b47) + DEP( 0xa5a5a5a5a5a5a3f5, 2047, 7, 12, 0xa5a5a5a5a5a3fff5) + EXT( 0xa5a5a5a5a5a5a3f4, 7, 13, 0x0000000000000b47) + EXTU(0xa5a5a5a5a5a5a3f4, 7, 13, 0x0000000000000b47) + DEP( 0xa5a5a5a5a5a5a3f4, 4095, 7, 13, 0xa5a5a5a5a5a7fff4) + EXT( 0xa5a5a5a5a5a5a3f3, 7, 14, 0x0000000000000b47) + EXTU(0xa5a5a5a5a5a5a3f3, 7, 14, 0x0000000000000b47) + DEP( 0xa5a5a5a5a5a5a3f3, 8191, 7, 14, 0xa5a5a5a5a5affff3) + EXT( 0xa5a5a5a5a5a5a3f2, 7, 15, 0xffffffffffffcb47) + EXTU(0xa5a5a5a5a5a5a3f2, 7, 15, 0x0000000000004b47) + DEP( 0xa5a5a5a5a5a5a3f2, 16383, 7, 15, 0xa5a5a5a5a59ffff2) + EXT( 0xa5a5a5a5a5a5a3f1, 7, 16, 0x0000000000004b47) + EXTU(0xa5a5a5a5a5a5a3f1, 7, 16, 0x0000000000004b47) + DEP( 0xa5a5a5a5a5a5a3f1, 32767, 7, 16, 0xa5a5a5a5a5bffff1) + EXT( 0xa5a5a5a5a5a5a3f0, 7, 17, 0xffffffffffff4b47) + EXTU(0xa5a5a5a5a5a5a3f0, 7, 17, 0x0000000000014b47) + DEP( 0xa5a5a5a5a5a5a3f0, 65535, 7, 17, 0xa5a5a5a5a57ffff0) + EXT( 0xa5a5a5a5a5a5a3ef, 7, 18, 0xffffffffffff4b47) + EXTU(0xa5a5a5a5a5a5a3ef, 7, 18, 0x0000000000034b47) + DEP( 0xa5a5a5a5a5a5a3ef, 131071, 7, 18, 0xa5a5a5a5a4ffffef) + EXT( 0xa5a5a5a5a5a5a3ee, 7, 19, 0x0000000000034b47) + EXTU(0xa5a5a5a5a5a5a3ee, 7, 19, 0x0000000000034b47) + DEP( 0xa5a5a5a5a5a5a3ee, 262143, 7, 19, 0xa5a5a5a5a5ffffee) + EXT( 0xa5a5a5a5a5a5a3ed, 7, 20, 0xfffffffffffb4b47) + EXTU(0xa5a5a5a5a5a5a3ed, 7, 20, 0x00000000000b4b47) + DEP( 0xa5a5a5a5a5a5a3ed, 524287, 7, 20, 0xa5a5a5a5a3ffffed) + EXT( 0xa5a5a5a5a5a5a3ec, 7, 21, 0x00000000000b4b47) + EXTU(0xa5a5a5a5a5a5a3ec, 7, 21, 0x00000000000b4b47) + DEP( 0xa5a5a5a5a5a5a3ec, 1048575, 7, 21, 0xa5a5a5a5a7ffffec) + EXT( 0xa5a5a5a5a5a5a3eb, 7, 22, 0x00000000000b4b47) + EXTU(0xa5a5a5a5a5a5a3eb, 7, 22, 0x00000000000b4b47) + DEP( 0xa5a5a5a5a5a5a3eb, 2097151, 7, 22, 0xa5a5a5a5afffffeb) + EXT( 0xa5a5a5a5a5a5a3ea, 7, 23, 0xffffffffffcb4b47) + EXTU(0xa5a5a5a5a5a5a3ea, 7, 23, 0x00000000004b4b47) + DEP( 0xa5a5a5a5a5a5a3ea, 4194303, 7, 23, 0xa5a5a5a59fffffea) + EXT( 0xa5a5a5a5a5a5a3e9, 7, 24, 0x00000000004b4b47) + EXTU(0xa5a5a5a5a5a5a3e9, 7, 24, 0x00000000004b4b47) + DEP( 0xa5a5a5a5a5a5a3e9, 8388607, 7, 24, 0xa5a5a5a5bfffffe9) + EXT( 0xa5a5a5a5a5a5a3e8, 7, 25, 0xffffffffff4b4b47) + EXTU(0xa5a5a5a5a5a5a3e8, 7, 25, 0x00000000014b4b47) + DEP( 0xa5a5a5a5a5a5a3e8, 16777215, 7, 25, 0xa5a5a5a57fffffe8) + EXT( 0xa5a5a5a5a5a5a3e7, 7, 26, 0xffffffffff4b4b47) + EXTU(0xa5a5a5a5a5a5a3e7, 7, 26, 0x00000000034b4b47) + DEP( 0xa5a5a5a5a5a5a3e7, 33554431, 7, 26, 0xa5a5a5a4ffffffe7) + EXT( 0xa5a5a5a5a5a5a3e6, 7, 27, 0x00000000034b4b47) + EXTU(0xa5a5a5a5a5a5a3e6, 7, 27, 0x00000000034b4b47) + DEP( 0xa5a5a5a5a5a5a3e6, 67108863, 7, 27, 0xa5a5a5a5ffffffe6) + EXT( 0xa5a5a5a5a5a5a3e5, 7, 28, 0xfffffffffb4b4b47) + EXTU(0xa5a5a5a5a5a5a3e5, 7, 28, 0x000000000b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e5, 134217727, 7, 28, 0xa5a5a5a3ffffffe5) + EXT( 0xa5a5a5a5a5a5a3e4, 7, 29, 0x000000000b4b4b47) + EXTU(0xa5a5a5a5a5a5a3e4, 7, 29, 0x000000000b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e4, 268435455, 7, 29, 0xa5a5a5a7ffffffe4) + EXT( 0xa5a5a5a5a5a5a3e3, 7, 30, 0x000000000b4b4b47) + EXTU(0xa5a5a5a5a5a5a3e3, 7, 30, 0x000000000b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e3, 536870911, 7, 30, 0xa5a5a5afffffffe3) + EXT( 0xa5a5a5a5a5a5a3e2, 7, 31, 0xffffffffcb4b4b47) + EXTU(0xa5a5a5a5a5a5a3e2, 7, 31, 0x000000004b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e2, 1073741823, 7, 31, 0xa5a5a59fffffffe2) + EXT( 0xa5a5a5a5a5a5a3e1, 7, 32, 0x000000004b4b4b47) + EXTU(0xa5a5a5a5a5a5a3e1, 7, 32, 0x000000004b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e1, 2147483647, 7, 32, 0xa5a5a5bfffffffe1) + EXT( 0xa5a5a5a5a5a5a3e0, 7, 33, 0xffffffff4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3e0, 7, 33, 0x000000014b4b4b47) + DEP( 0xa5a5a5a5a5a5a3e0, 4294967295, 7, 33, 0xa5a5a57fffffffe0) + EXT( 0xa5a5a5a5a5a5a3df, 7, 34, 0xffffffff4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3df, 7, 34, 0x000000034b4b4b47) + DEP( 0xa5a5a5a5a5a5a3df, 8589934591, 7, 34, 0xa5a5a4ffffffffdf) + EXT( 0xa5a5a5a5a5a5a3de, 7, 35, 0x000000034b4b4b47) + EXTU(0xa5a5a5a5a5a5a3de, 7, 35, 0x000000034b4b4b47) + DEP( 0xa5a5a5a5a5a5a3de, 17179869183, 7, 35, 0xa5a5a5ffffffffde) + EXT( 0xa5a5a5a5a5a5a3dd, 7, 36, 0xfffffffb4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3dd, 7, 36, 0x0000000b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3dd, 34359738367, 7, 36, 0xa5a5a3ffffffffdd) + EXT( 0xa5a5a5a5a5a5a3dc, 7, 37, 0x0000000b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3dc, 7, 37, 0x0000000b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3dc, 68719476735, 7, 37, 0xa5a5a7ffffffffdc) + EXT( 0xa5a5a5a5a5a5a3db, 7, 38, 0x0000000b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3db, 7, 38, 0x0000000b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3db, 137438953471, 7, 38, 0xa5a5afffffffffdb) + EXT( 0xa5a5a5a5a5a5a3da, 7, 39, 0xffffffcb4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3da, 7, 39, 0x0000004b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3da, 274877906943, 7, 39, 0xa5a59fffffffffda) + EXT( 0xa5a5a5a5a5a5a3d9, 7, 40, 0x0000004b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d9, 7, 40, 0x0000004b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d9, 549755813887, 7, 40, 0xa5a5bfffffffffd9) + EXT( 0xa5a5a5a5a5a5a3d8, 7, 41, 0xffffff4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d8, 7, 41, 0x0000014b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d8, 1099511627775, 7, 41, 0xa5a57fffffffffd8) + EXT( 0xa5a5a5a5a5a5a3d7, 7, 42, 0xffffff4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d7, 7, 42, 0x0000034b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d7, 2199023255551, 7, 42, 0xa5a4ffffffffffd7) + EXT( 0xa5a5a5a5a5a5a3d6, 7, 43, 0x0000034b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d6, 7, 43, 0x0000034b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d6, 4398046511103, 7, 43, 0xa5a5ffffffffffd6) + EXT( 0xa5a5a5a5a5a5a3d5, 7, 44, 0xfffffb4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d5, 7, 44, 0x00000b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d5, 8796093022207, 7, 44, 0xa5a3ffffffffffd5) + EXT( 0xa5a5a5a5a5a5a3d4, 7, 45, 0x00000b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d4, 7, 45, 0x00000b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d4, 17592186044415, 7, 45, 0xa5a7ffffffffffd4) + EXT( 0xa5a5a5a5a5a5a3d3, 7, 46, 0x00000b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d3, 7, 46, 0x00000b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d3, 35184372088831, 7, 46, 0xa5afffffffffffd3) + EXT( 0xa5a5a5a5a5a5a3d2, 7, 47, 0xffffcb4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d2, 7, 47, 0x00004b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d2, 70368744177663, 7, 47, 0xa59fffffffffffd2) + EXT( 0xa5a5a5a5a5a5a3d1, 7, 48, 0x00004b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d1, 7, 48, 0x00004b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d1, 140737488355327, 7, 48, 0xa5bfffffffffffd1) + EXT( 0xa5a5a5a5a5a5a3d0, 7, 49, 0xffff4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3d0, 7, 49, 0x00014b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3d0, 281474976710655, 7, 49, 0xa57fffffffffffd0) + EXT( 0xa5a5a5a5a5a5a3cf, 7, 50, 0xffff4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3cf, 7, 50, 0x00034b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3cf, 562949953421311, 7, 50, 0xa4ffffffffffffcf) + EXT( 0xa5a5a5a5a5a5a3ce, 7, 51, 0x00034b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3ce, 7, 51, 0x00034b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3ce, 1125899906842623, 7, 51, 0xa5ffffffffffffce) + EXT( 0xa5a5a5a5a5a5a3cd, 7, 52, 0xfffb4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3cd, 7, 52, 0x000b4b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3cd, 2251799813685247, 7, 52, 0xa3ffffffffffffcd) + EXT( 0xa5a5a5a5a5a5a3cc, 7, 53, 0x000b4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3cc, 7, 53, 0x000b4b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3cc, 4503599627370495, 7, 53, 0xa7ffffffffffffcc) + EXT( 0xa5a5a5a5a5a5a3cb, 7, 54, 0x000b4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3cb, 7, 54, 0x000b4b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3cb, 9007199254740991, 7, 54, 0xafffffffffffffcb) + EXT( 0xa5a5a5a5a5a5a3ca, 7, 55, 0xffcb4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3ca, 7, 55, 0x004b4b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3ca, 18014398509481983, 7, 55, 0x9fffffffffffffca) + EXT( 0xa5a5a5a5a5a5a3c9, 7, 56, 0x004b4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3c9, 7, 56, 0x004b4b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3c9, 36028797018963967, 7, 56, 0xbfffffffffffffc9) + EXT( 0xa5a5a5a5a5a5a3c8, 8, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3c8, 8, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a3c8, 0, 8, 1, 0xa5a5a5a5a5a5a2c8) + EXT( 0xa5a5a5a5a5a5a3c7, 8, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3c7, 8, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3c7, 1, 8, 2, 0xa5a5a5a5a5a5a1c7) + EXT( 0xa5a5a5a5a5a5a3c6, 8, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a3c6, 8, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3c6, 3, 8, 3, 0xa5a5a5a5a5a5a3c6) + EXT( 0xa5a5a5a5a5a5a3c5, 8, 4, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a3c5, 8, 4, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3c5, 7, 8, 4, 0xa5a5a5a5a5a5a7c5) + EXT( 0xa5a5a5a5a5a5a3c4, 8, 5, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a3c4, 8, 5, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3c4, 15, 8, 5, 0xa5a5a5a5a5a5afc4) + EXT( 0xa5a5a5a5a5a5a3c3, 8, 6, 0xffffffffffffffe3) + EXTU(0xa5a5a5a5a5a5a3c3, 8, 6, 0x0000000000000023) + DEP( 0xa5a5a5a5a5a5a3c3, 31, 8, 6, 0xa5a5a5a5a5a59fc3) + EXT( 0xa5a5a5a5a5a5a3c2, 8, 7, 0x0000000000000023) + EXTU(0xa5a5a5a5a5a5a3c2, 8, 7, 0x0000000000000023) + DEP( 0xa5a5a5a5a5a5a3c2, 63, 8, 7, 0xa5a5a5a5a5a5bfc2) + EXT( 0xa5a5a5a5a5a5a3c1, 8, 8, 0xffffffffffffffa3) + EXTU(0xa5a5a5a5a5a5a3c1, 8, 8, 0x00000000000000a3) + DEP( 0xa5a5a5a5a5a5a3c1, 127, 8, 8, 0xa5a5a5a5a5a57fc1) + EXT( 0xa5a5a5a5a5a5a3c0, 8, 9, 0xffffffffffffffa3) + EXTU(0xa5a5a5a5a5a5a3c0, 8, 9, 0x00000000000001a3) + DEP( 0xa5a5a5a5a5a5a3c0, 255, 8, 9, 0xa5a5a5a5a5a4ffc0) + EXT( 0xa5a5a5a5a5a5a3bf, 8, 10, 0x00000000000001a3) + EXTU(0xa5a5a5a5a5a5a3bf, 8, 10, 0x00000000000001a3) + DEP( 0xa5a5a5a5a5a5a3bf, 511, 8, 10, 0xa5a5a5a5a5a5ffbf) + EXT( 0xa5a5a5a5a5a5a3be, 8, 11, 0xfffffffffffffda3) + EXTU(0xa5a5a5a5a5a5a3be, 8, 11, 0x00000000000005a3) + DEP( 0xa5a5a5a5a5a5a3be, 1023, 8, 11, 0xa5a5a5a5a5a3ffbe) + EXT( 0xa5a5a5a5a5a5a3bd, 8, 12, 0x00000000000005a3) + EXTU(0xa5a5a5a5a5a5a3bd, 8, 12, 0x00000000000005a3) + DEP( 0xa5a5a5a5a5a5a3bd, 2047, 8, 12, 0xa5a5a5a5a5a7ffbd) + EXT( 0xa5a5a5a5a5a5a3bc, 8, 13, 0x00000000000005a3) + EXTU(0xa5a5a5a5a5a5a3bc, 8, 13, 0x00000000000005a3) + DEP( 0xa5a5a5a5a5a5a3bc, 4095, 8, 13, 0xa5a5a5a5a5afffbc) + EXT( 0xa5a5a5a5a5a5a3bb, 8, 14, 0xffffffffffffe5a3) + EXTU(0xa5a5a5a5a5a5a3bb, 8, 14, 0x00000000000025a3) + DEP( 0xa5a5a5a5a5a5a3bb, 8191, 8, 14, 0xa5a5a5a5a59fffbb) + EXT( 0xa5a5a5a5a5a5a3ba, 8, 15, 0x00000000000025a3) + EXTU(0xa5a5a5a5a5a5a3ba, 8, 15, 0x00000000000025a3) + DEP( 0xa5a5a5a5a5a5a3ba, 16383, 8, 15, 0xa5a5a5a5a5bfffba) + EXT( 0xa5a5a5a5a5a5a3b9, 8, 16, 0xffffffffffffa5a3) + EXTU(0xa5a5a5a5a5a5a3b9, 8, 16, 0x000000000000a5a3) + DEP( 0xa5a5a5a5a5a5a3b9, 32767, 8, 16, 0xa5a5a5a5a57fffb9) + EXT( 0xa5a5a5a5a5a5a3b8, 8, 17, 0xffffffffffffa5a3) + EXTU(0xa5a5a5a5a5a5a3b8, 8, 17, 0x000000000001a5a3) + DEP( 0xa5a5a5a5a5a5a3b8, 65535, 8, 17, 0xa5a5a5a5a4ffffb8) + EXT( 0xa5a5a5a5a5a5a3b7, 8, 18, 0x000000000001a5a3) + EXTU(0xa5a5a5a5a5a5a3b7, 8, 18, 0x000000000001a5a3) + DEP( 0xa5a5a5a5a5a5a3b7, 131071, 8, 18, 0xa5a5a5a5a5ffffb7) + EXT( 0xa5a5a5a5a5a5a3b6, 8, 19, 0xfffffffffffda5a3) + EXTU(0xa5a5a5a5a5a5a3b6, 8, 19, 0x000000000005a5a3) + DEP( 0xa5a5a5a5a5a5a3b6, 262143, 8, 19, 0xa5a5a5a5a3ffffb6) + EXT( 0xa5a5a5a5a5a5a3b5, 8, 20, 0x000000000005a5a3) + EXTU(0xa5a5a5a5a5a5a3b5, 8, 20, 0x000000000005a5a3) + DEP( 0xa5a5a5a5a5a5a3b5, 524287, 8, 20, 0xa5a5a5a5a7ffffb5) + EXT( 0xa5a5a5a5a5a5a3b4, 8, 21, 0x000000000005a5a3) + EXTU(0xa5a5a5a5a5a5a3b4, 8, 21, 0x000000000005a5a3) + DEP( 0xa5a5a5a5a5a5a3b4, 1048575, 8, 21, 0xa5a5a5a5afffffb4) + EXT( 0xa5a5a5a5a5a5a3b3, 8, 22, 0xffffffffffe5a5a3) + EXTU(0xa5a5a5a5a5a5a3b3, 8, 22, 0x000000000025a5a3) + DEP( 0xa5a5a5a5a5a5a3b3, 2097151, 8, 22, 0xa5a5a5a59fffffb3) + EXT( 0xa5a5a5a5a5a5a3b2, 8, 23, 0x000000000025a5a3) + EXTU(0xa5a5a5a5a5a5a3b2, 8, 23, 0x000000000025a5a3) + DEP( 0xa5a5a5a5a5a5a3b2, 4194303, 8, 23, 0xa5a5a5a5bfffffb2) + EXT( 0xa5a5a5a5a5a5a3b1, 8, 24, 0xffffffffffa5a5a3) + EXTU(0xa5a5a5a5a5a5a3b1, 8, 24, 0x0000000000a5a5a3) + DEP( 0xa5a5a5a5a5a5a3b1, 8388607, 8, 24, 0xa5a5a5a57fffffb1) + EXT( 0xa5a5a5a5a5a5a3b0, 8, 25, 0xffffffffffa5a5a3) + EXTU(0xa5a5a5a5a5a5a3b0, 8, 25, 0x0000000001a5a5a3) + DEP( 0xa5a5a5a5a5a5a3b0, 16777215, 8, 25, 0xa5a5a5a4ffffffb0) + EXT( 0xa5a5a5a5a5a5a3af, 8, 26, 0x0000000001a5a5a3) + EXTU(0xa5a5a5a5a5a5a3af, 8, 26, 0x0000000001a5a5a3) + DEP( 0xa5a5a5a5a5a5a3af, 33554431, 8, 26, 0xa5a5a5a5ffffffaf) + EXT( 0xa5a5a5a5a5a5a3ae, 8, 27, 0xfffffffffda5a5a3) + EXTU(0xa5a5a5a5a5a5a3ae, 8, 27, 0x0000000005a5a5a3) + DEP( 0xa5a5a5a5a5a5a3ae, 67108863, 8, 27, 0xa5a5a5a3ffffffae) + EXT( 0xa5a5a5a5a5a5a3ad, 8, 28, 0x0000000005a5a5a3) + EXTU(0xa5a5a5a5a5a5a3ad, 8, 28, 0x0000000005a5a5a3) + DEP( 0xa5a5a5a5a5a5a3ad, 134217727, 8, 28, 0xa5a5a5a7ffffffad) + EXT( 0xa5a5a5a5a5a5a3ac, 8, 29, 0x0000000005a5a5a3) + EXTU(0xa5a5a5a5a5a5a3ac, 8, 29, 0x0000000005a5a5a3) + DEP( 0xa5a5a5a5a5a5a3ac, 268435455, 8, 29, 0xa5a5a5afffffffac) + EXT( 0xa5a5a5a5a5a5a3ab, 8, 30, 0xffffffffe5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3ab, 8, 30, 0x0000000025a5a5a3) + DEP( 0xa5a5a5a5a5a5a3ab, 536870911, 8, 30, 0xa5a5a59fffffffab) + EXT( 0xa5a5a5a5a5a5a3aa, 8, 31, 0x0000000025a5a5a3) + EXTU(0xa5a5a5a5a5a5a3aa, 8, 31, 0x0000000025a5a5a3) + DEP( 0xa5a5a5a5a5a5a3aa, 1073741823, 8, 31, 0xa5a5a5bfffffffaa) + EXT( 0xa5a5a5a5a5a5a3a9, 8, 32, 0xffffffffa5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a9, 8, 32, 0x00000000a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a9, 2147483647, 8, 32, 0xa5a5a57fffffffa9) + EXT( 0xa5a5a5a5a5a5a3a8, 8, 33, 0xffffffffa5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a8, 8, 33, 0x00000001a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a8, 4294967295, 8, 33, 0xa5a5a4ffffffffa8) + EXT( 0xa5a5a5a5a5a5a3a7, 8, 34, 0x00000001a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a7, 8, 34, 0x00000001a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a7, 8589934591, 8, 34, 0xa5a5a5ffffffffa7) + EXT( 0xa5a5a5a5a5a5a3a6, 8, 35, 0xfffffffda5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a6, 8, 35, 0x00000005a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a6, 17179869183, 8, 35, 0xa5a5a3ffffffffa6) + EXT( 0xa5a5a5a5a5a5a3a5, 8, 36, 0x00000005a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a5, 8, 36, 0x00000005a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a5, 34359738367, 8, 36, 0xa5a5a7ffffffffa5) + EXT( 0xa5a5a5a5a5a5a3a4, 8, 37, 0x00000005a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a4, 8, 37, 0x00000005a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a4, 68719476735, 8, 37, 0xa5a5afffffffffa4) + EXT( 0xa5a5a5a5a5a5a3a3, 8, 38, 0xffffffe5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a3, 8, 38, 0x00000025a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a3, 137438953471, 8, 38, 0xa5a59fffffffffa3) + EXT( 0xa5a5a5a5a5a5a3a2, 8, 39, 0x00000025a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a2, 8, 39, 0x00000025a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a2, 274877906943, 8, 39, 0xa5a5bfffffffffa2) + EXT( 0xa5a5a5a5a5a5a3a1, 8, 40, 0xffffffa5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a1, 8, 40, 0x000000a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a1, 549755813887, 8, 40, 0xa5a57fffffffffa1) + EXT( 0xa5a5a5a5a5a5a3a0, 8, 41, 0xffffffa5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3a0, 8, 41, 0x000001a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3a0, 1099511627775, 8, 41, 0xa5a4ffffffffffa0) + EXT( 0xa5a5a5a5a5a5a39f, 8, 42, 0x000001a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39f, 8, 42, 0x000001a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39f, 2199023255551, 8, 42, 0xa5a5ffffffffff9f) + EXT( 0xa5a5a5a5a5a5a39e, 8, 43, 0xfffffda5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39e, 8, 43, 0x000005a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39e, 4398046511103, 8, 43, 0xa5a3ffffffffff9e) + EXT( 0xa5a5a5a5a5a5a39d, 8, 44, 0x000005a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39d, 8, 44, 0x000005a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39d, 8796093022207, 8, 44, 0xa5a7ffffffffff9d) + EXT( 0xa5a5a5a5a5a5a39c, 8, 45, 0x000005a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39c, 8, 45, 0x000005a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39c, 17592186044415, 8, 45, 0xa5afffffffffff9c) + EXT( 0xa5a5a5a5a5a5a39b, 8, 46, 0xffffe5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39b, 8, 46, 0x000025a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39b, 35184372088831, 8, 46, 0xa59fffffffffff9b) + EXT( 0xa5a5a5a5a5a5a39a, 8, 47, 0x000025a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a39a, 8, 47, 0x000025a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a39a, 70368744177663, 8, 47, 0xa5bfffffffffff9a) + EXT( 0xa5a5a5a5a5a5a399, 8, 48, 0xffffa5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a399, 8, 48, 0x0000a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a399, 140737488355327, 8, 48, 0xa57fffffffffff99) + EXT( 0xa5a5a5a5a5a5a398, 8, 49, 0xffffa5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a398, 8, 49, 0x0001a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a398, 281474976710655, 8, 49, 0xa4ffffffffffff98) + EXT( 0xa5a5a5a5a5a5a397, 8, 50, 0x0001a5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a397, 8, 50, 0x0001a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a397, 562949953421311, 8, 50, 0xa5ffffffffffff97) + EXT( 0xa5a5a5a5a5a5a396, 8, 51, 0xfffda5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a396, 8, 51, 0x0005a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a396, 1125899906842623, 8, 51, 0xa3ffffffffffff96) + EXT( 0xa5a5a5a5a5a5a395, 8, 52, 0x0005a5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a395, 8, 52, 0x0005a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a395, 2251799813685247, 8, 52, 0xa7ffffffffffff95) + EXT( 0xa5a5a5a5a5a5a394, 8, 53, 0x0005a5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a394, 8, 53, 0x0005a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a394, 4503599627370495, 8, 53, 0xafffffffffffff94) + EXT( 0xa5a5a5a5a5a5a393, 8, 54, 0xffe5a5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a393, 8, 54, 0x0025a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a393, 9007199254740991, 8, 54, 0x9fffffffffffff93) + EXT( 0xa5a5a5a5a5a5a392, 8, 55, 0x0025a5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a392, 8, 55, 0x0025a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a392, 18014398509481983, 8, 55, 0xbfffffffffffff92) + EXT( 0xa5a5a5a5a5a5a391, 9, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a391, 9, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a391, 0, 9, 1, 0xa5a5a5a5a5a5a191) + EXT( 0xa5a5a5a5a5a5a390, 9, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a390, 9, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a390, 1, 9, 2, 0xa5a5a5a5a5a5a390) + EXT( 0xa5a5a5a5a5a5a38f, 9, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a38f, 9, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a38f, 3, 9, 3, 0xa5a5a5a5a5a5a78f) + EXT( 0xa5a5a5a5a5a5a38e, 9, 4, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a38e, 9, 4, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a38e, 7, 9, 4, 0xa5a5a5a5a5a5af8e) + EXT( 0xa5a5a5a5a5a5a38d, 9, 5, 0xfffffffffffffff1) + EXTU(0xa5a5a5a5a5a5a38d, 9, 5, 0x0000000000000011) + DEP( 0xa5a5a5a5a5a5a38d, 15, 9, 5, 0xa5a5a5a5a5a59f8d) + EXT( 0xa5a5a5a5a5a5a38c, 9, 6, 0x0000000000000011) + EXTU(0xa5a5a5a5a5a5a38c, 9, 6, 0x0000000000000011) + DEP( 0xa5a5a5a5a5a5a38c, 31, 9, 6, 0xa5a5a5a5a5a5bf8c) + EXT( 0xa5a5a5a5a5a5a38b, 9, 7, 0xffffffffffffffd1) + EXTU(0xa5a5a5a5a5a5a38b, 9, 7, 0x0000000000000051) + DEP( 0xa5a5a5a5a5a5a38b, 63, 9, 7, 0xa5a5a5a5a5a57f8b) + EXT( 0xa5a5a5a5a5a5a38a, 9, 8, 0xffffffffffffffd1) + EXTU(0xa5a5a5a5a5a5a38a, 9, 8, 0x00000000000000d1) + DEP( 0xa5a5a5a5a5a5a38a, 127, 9, 8, 0xa5a5a5a5a5a4ff8a) + EXT( 0xa5a5a5a5a5a5a389, 9, 9, 0x00000000000000d1) + EXTU(0xa5a5a5a5a5a5a389, 9, 9, 0x00000000000000d1) + DEP( 0xa5a5a5a5a5a5a389, 255, 9, 9, 0xa5a5a5a5a5a5ff89) + EXT( 0xa5a5a5a5a5a5a388, 9, 10, 0xfffffffffffffed1) + EXTU(0xa5a5a5a5a5a5a388, 9, 10, 0x00000000000002d1) + DEP( 0xa5a5a5a5a5a5a388, 511, 9, 10, 0xa5a5a5a5a5a3ff88) + EXT( 0xa5a5a5a5a5a5a387, 9, 11, 0x00000000000002d1) + EXTU(0xa5a5a5a5a5a5a387, 9, 11, 0x00000000000002d1) + DEP( 0xa5a5a5a5a5a5a387, 1023, 9, 11, 0xa5a5a5a5a5a7ff87) + EXT( 0xa5a5a5a5a5a5a386, 9, 12, 0x00000000000002d1) + EXTU(0xa5a5a5a5a5a5a386, 9, 12, 0x00000000000002d1) + DEP( 0xa5a5a5a5a5a5a386, 2047, 9, 12, 0xa5a5a5a5a5afff86) + EXT( 0xa5a5a5a5a5a5a385, 9, 13, 0xfffffffffffff2d1) + EXTU(0xa5a5a5a5a5a5a385, 9, 13, 0x00000000000012d1) + DEP( 0xa5a5a5a5a5a5a385, 4095, 9, 13, 0xa5a5a5a5a59fff85) + EXT( 0xa5a5a5a5a5a5a384, 9, 14, 0x00000000000012d1) + EXTU(0xa5a5a5a5a5a5a384, 9, 14, 0x00000000000012d1) + DEP( 0xa5a5a5a5a5a5a384, 8191, 9, 14, 0xa5a5a5a5a5bfff84) + EXT( 0xa5a5a5a5a5a5a383, 9, 15, 0xffffffffffffd2d1) + EXTU(0xa5a5a5a5a5a5a383, 9, 15, 0x00000000000052d1) + DEP( 0xa5a5a5a5a5a5a383, 16383, 9, 15, 0xa5a5a5a5a57fff83) + EXT( 0xa5a5a5a5a5a5a382, 9, 16, 0xffffffffffffd2d1) + EXTU(0xa5a5a5a5a5a5a382, 9, 16, 0x000000000000d2d1) + DEP( 0xa5a5a5a5a5a5a382, 32767, 9, 16, 0xa5a5a5a5a4ffff82) + EXT( 0xa5a5a5a5a5a5a381, 9, 17, 0x000000000000d2d1) + EXTU(0xa5a5a5a5a5a5a381, 9, 17, 0x000000000000d2d1) + DEP( 0xa5a5a5a5a5a5a381, 65535, 9, 17, 0xa5a5a5a5a5ffff81) + EXT( 0xa5a5a5a5a5a5a380, 9, 18, 0xfffffffffffed2d1) + EXTU(0xa5a5a5a5a5a5a380, 9, 18, 0x000000000002d2d1) + DEP( 0xa5a5a5a5a5a5a380, 131071, 9, 18, 0xa5a5a5a5a3ffff80) + EXT( 0xa5a5a5a5a5a5a37f, 9, 19, 0x000000000002d2d1) + EXTU(0xa5a5a5a5a5a5a37f, 9, 19, 0x000000000002d2d1) + DEP( 0xa5a5a5a5a5a5a37f, 262143, 9, 19, 0xa5a5a5a5a7ffff7f) + EXT( 0xa5a5a5a5a5a5a37e, 9, 20, 0x000000000002d2d1) + EXTU(0xa5a5a5a5a5a5a37e, 9, 20, 0x000000000002d2d1) + DEP( 0xa5a5a5a5a5a5a37e, 524287, 9, 20, 0xa5a5a5a5afffff7e) + EXT( 0xa5a5a5a5a5a5a37d, 9, 21, 0xfffffffffff2d2d1) + EXTU(0xa5a5a5a5a5a5a37d, 9, 21, 0x000000000012d2d1) + DEP( 0xa5a5a5a5a5a5a37d, 1048575, 9, 21, 0xa5a5a5a59fffff7d) + EXT( 0xa5a5a5a5a5a5a37c, 9, 22, 0x000000000012d2d1) + EXTU(0xa5a5a5a5a5a5a37c, 9, 22, 0x000000000012d2d1) + DEP( 0xa5a5a5a5a5a5a37c, 2097151, 9, 22, 0xa5a5a5a5bfffff7c) + EXT( 0xa5a5a5a5a5a5a37b, 9, 23, 0xffffffffffd2d2d1) + EXTU(0xa5a5a5a5a5a5a37b, 9, 23, 0x000000000052d2d1) + DEP( 0xa5a5a5a5a5a5a37b, 4194303, 9, 23, 0xa5a5a5a57fffff7b) + EXT( 0xa5a5a5a5a5a5a37a, 9, 24, 0xffffffffffd2d2d1) + EXTU(0xa5a5a5a5a5a5a37a, 9, 24, 0x0000000000d2d2d1) + DEP( 0xa5a5a5a5a5a5a37a, 8388607, 9, 24, 0xa5a5a5a4ffffff7a) + EXT( 0xa5a5a5a5a5a5a379, 9, 25, 0x0000000000d2d2d1) + EXTU(0xa5a5a5a5a5a5a379, 9, 25, 0x0000000000d2d2d1) + DEP( 0xa5a5a5a5a5a5a379, 16777215, 9, 25, 0xa5a5a5a5ffffff79) + EXT( 0xa5a5a5a5a5a5a378, 9, 26, 0xfffffffffed2d2d1) + EXTU(0xa5a5a5a5a5a5a378, 9, 26, 0x0000000002d2d2d1) + DEP( 0xa5a5a5a5a5a5a378, 33554431, 9, 26, 0xa5a5a5a3ffffff78) + EXT( 0xa5a5a5a5a5a5a377, 9, 27, 0x0000000002d2d2d1) + EXTU(0xa5a5a5a5a5a5a377, 9, 27, 0x0000000002d2d2d1) + DEP( 0xa5a5a5a5a5a5a377, 67108863, 9, 27, 0xa5a5a5a7ffffff77) + EXT( 0xa5a5a5a5a5a5a376, 9, 28, 0x0000000002d2d2d1) + EXTU(0xa5a5a5a5a5a5a376, 9, 28, 0x0000000002d2d2d1) + DEP( 0xa5a5a5a5a5a5a376, 134217727, 9, 28, 0xa5a5a5afffffff76) + EXT( 0xa5a5a5a5a5a5a375, 9, 29, 0xfffffffff2d2d2d1) + EXTU(0xa5a5a5a5a5a5a375, 9, 29, 0x0000000012d2d2d1) + DEP( 0xa5a5a5a5a5a5a375, 268435455, 9, 29, 0xa5a5a59fffffff75) + EXT( 0xa5a5a5a5a5a5a374, 9, 30, 0x0000000012d2d2d1) + EXTU(0xa5a5a5a5a5a5a374, 9, 30, 0x0000000012d2d2d1) + DEP( 0xa5a5a5a5a5a5a374, 536870911, 9, 30, 0xa5a5a5bfffffff74) + EXT( 0xa5a5a5a5a5a5a373, 9, 31, 0xffffffffd2d2d2d1) + EXTU(0xa5a5a5a5a5a5a373, 9, 31, 0x0000000052d2d2d1) + DEP( 0xa5a5a5a5a5a5a373, 1073741823, 9, 31, 0xa5a5a57fffffff73) + EXT( 0xa5a5a5a5a5a5a372, 9, 32, 0xffffffffd2d2d2d1) + EXTU(0xa5a5a5a5a5a5a372, 9, 32, 0x00000000d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a372, 2147483647, 9, 32, 0xa5a5a4ffffffff72) + EXT( 0xa5a5a5a5a5a5a371, 9, 33, 0x00000000d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a371, 9, 33, 0x00000000d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a371, 4294967295, 9, 33, 0xa5a5a5ffffffff71) + EXT( 0xa5a5a5a5a5a5a370, 9, 34, 0xfffffffed2d2d2d1) + EXTU(0xa5a5a5a5a5a5a370, 9, 34, 0x00000002d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a370, 8589934591, 9, 34, 0xa5a5a3ffffffff70) + EXT( 0xa5a5a5a5a5a5a36f, 9, 35, 0x00000002d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36f, 9, 35, 0x00000002d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36f, 17179869183, 9, 35, 0xa5a5a7ffffffff6f) + EXT( 0xa5a5a5a5a5a5a36e, 9, 36, 0x00000002d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36e, 9, 36, 0x00000002d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36e, 34359738367, 9, 36, 0xa5a5afffffffff6e) + EXT( 0xa5a5a5a5a5a5a36d, 9, 37, 0xfffffff2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36d, 9, 37, 0x00000012d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36d, 68719476735, 9, 37, 0xa5a59fffffffff6d) + EXT( 0xa5a5a5a5a5a5a36c, 9, 38, 0x00000012d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36c, 9, 38, 0x00000012d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36c, 137438953471, 9, 38, 0xa5a5bfffffffff6c) + EXT( 0xa5a5a5a5a5a5a36b, 9, 39, 0xffffffd2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36b, 9, 39, 0x00000052d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36b, 274877906943, 9, 39, 0xa5a57fffffffff6b) + EXT( 0xa5a5a5a5a5a5a36a, 9, 40, 0xffffffd2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a36a, 9, 40, 0x000000d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a36a, 549755813887, 9, 40, 0xa5a4ffffffffff6a) + EXT( 0xa5a5a5a5a5a5a369, 9, 41, 0x000000d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a369, 9, 41, 0x000000d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a369, 1099511627775, 9, 41, 0xa5a5ffffffffff69) + EXT( 0xa5a5a5a5a5a5a368, 9, 42, 0xfffffed2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a368, 9, 42, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a368, 2199023255551, 9, 42, 0xa5a3ffffffffff68) + EXT( 0xa5a5a5a5a5a5a367, 9, 43, 0x000002d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a367, 9, 43, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a367, 4398046511103, 9, 43, 0xa5a7ffffffffff67) + EXT( 0xa5a5a5a5a5a5a366, 9, 44, 0x000002d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a366, 9, 44, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a366, 8796093022207, 9, 44, 0xa5afffffffffff66) + EXT( 0xa5a5a5a5a5a5a365, 9, 45, 0xfffff2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a365, 9, 45, 0x000012d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a365, 17592186044415, 9, 45, 0xa59fffffffffff65) + EXT( 0xa5a5a5a5a5a5a364, 9, 46, 0x000012d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a364, 9, 46, 0x000012d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a364, 35184372088831, 9, 46, 0xa5bfffffffffff64) + EXT( 0xa5a5a5a5a5a5a363, 9, 47, 0xffffd2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a363, 9, 47, 0x000052d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a363, 70368744177663, 9, 47, 0xa57fffffffffff63) + EXT( 0xa5a5a5a5a5a5a362, 9, 48, 0xffffd2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a362, 9, 48, 0x0000d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a362, 140737488355327, 9, 48, 0xa4ffffffffffff62) + EXT( 0xa5a5a5a5a5a5a361, 9, 49, 0x0000d2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a361, 9, 49, 0x0000d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a361, 281474976710655, 9, 49, 0xa5ffffffffffff61) + EXT( 0xa5a5a5a5a5a5a360, 9, 50, 0xfffed2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a360, 9, 50, 0x0002d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a360, 562949953421311, 9, 50, 0xa3ffffffffffff60) + EXT( 0xa5a5a5a5a5a5a35f, 9, 51, 0x0002d2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a35f, 9, 51, 0x0002d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a35f, 1125899906842623, 9, 51, 0xa7ffffffffffff5f) + EXT( 0xa5a5a5a5a5a5a35e, 9, 52, 0x0002d2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a35e, 9, 52, 0x0002d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a35e, 2251799813685247, 9, 52, 0xafffffffffffff5e) + EXT( 0xa5a5a5a5a5a5a35d, 9, 53, 0xfff2d2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a35d, 9, 53, 0x0012d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a35d, 4503599627370495, 9, 53, 0x9fffffffffffff5d) + EXT( 0xa5a5a5a5a5a5a35c, 9, 54, 0x0012d2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a35c, 9, 54, 0x0012d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a35c, 9007199254740991, 9, 54, 0xbfffffffffffff5c) + EXT( 0xa5a5a5a5a5a5a35b, 10, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a35b, 10, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a35b, 0, 10, 1, 0xa5a5a5a5a5a5a35b) + EXT( 0xa5a5a5a5a5a5a35a, 10, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a35a, 10, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a35a, 1, 10, 2, 0xa5a5a5a5a5a5a75a) + EXT( 0xa5a5a5a5a5a5a359, 10, 3, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a359, 10, 3, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a359, 3, 10, 3, 0xa5a5a5a5a5a5af59) + EXT( 0xa5a5a5a5a5a5a358, 10, 4, 0xfffffffffffffff8) + EXTU(0xa5a5a5a5a5a5a358, 10, 4, 0x0000000000000008) + DEP( 0xa5a5a5a5a5a5a358, 7, 10, 4, 0xa5a5a5a5a5a59f58) + EXT( 0xa5a5a5a5a5a5a357, 10, 5, 0x0000000000000008) + EXTU(0xa5a5a5a5a5a5a357, 10, 5, 0x0000000000000008) + DEP( 0xa5a5a5a5a5a5a357, 15, 10, 5, 0xa5a5a5a5a5a5bf57) + EXT( 0xa5a5a5a5a5a5a356, 10, 6, 0xffffffffffffffe8) + EXTU(0xa5a5a5a5a5a5a356, 10, 6, 0x0000000000000028) + DEP( 0xa5a5a5a5a5a5a356, 31, 10, 6, 0xa5a5a5a5a5a57f56) + EXT( 0xa5a5a5a5a5a5a355, 10, 7, 0xffffffffffffffe8) + EXTU(0xa5a5a5a5a5a5a355, 10, 7, 0x0000000000000068) + DEP( 0xa5a5a5a5a5a5a355, 63, 10, 7, 0xa5a5a5a5a5a4ff55) + EXT( 0xa5a5a5a5a5a5a354, 10, 8, 0x0000000000000068) + EXTU(0xa5a5a5a5a5a5a354, 10, 8, 0x0000000000000068) + DEP( 0xa5a5a5a5a5a5a354, 127, 10, 8, 0xa5a5a5a5a5a5ff54) + EXT( 0xa5a5a5a5a5a5a353, 10, 9, 0xffffffffffffff68) + EXTU(0xa5a5a5a5a5a5a353, 10, 9, 0x0000000000000168) + DEP( 0xa5a5a5a5a5a5a353, 255, 10, 9, 0xa5a5a5a5a5a3ff53) + EXT( 0xa5a5a5a5a5a5a352, 10, 10, 0x0000000000000168) + EXTU(0xa5a5a5a5a5a5a352, 10, 10, 0x0000000000000168) + DEP( 0xa5a5a5a5a5a5a352, 511, 10, 10, 0xa5a5a5a5a5a7ff52) + EXT( 0xa5a5a5a5a5a5a351, 10, 11, 0x0000000000000168) + EXTU(0xa5a5a5a5a5a5a351, 10, 11, 0x0000000000000168) + DEP( 0xa5a5a5a5a5a5a351, 1023, 10, 11, 0xa5a5a5a5a5afff51) + EXT( 0xa5a5a5a5a5a5a350, 10, 12, 0xfffffffffffff968) + EXTU(0xa5a5a5a5a5a5a350, 10, 12, 0x0000000000000968) + DEP( 0xa5a5a5a5a5a5a350, 2047, 10, 12, 0xa5a5a5a5a59fff50) + EXT( 0xa5a5a5a5a5a5a34f, 10, 13, 0x0000000000000968) + EXTU(0xa5a5a5a5a5a5a34f, 10, 13, 0x0000000000000968) + DEP( 0xa5a5a5a5a5a5a34f, 4095, 10, 13, 0xa5a5a5a5a5bfff4f) + EXT( 0xa5a5a5a5a5a5a34e, 10, 14, 0xffffffffffffe968) + EXTU(0xa5a5a5a5a5a5a34e, 10, 14, 0x0000000000002968) + DEP( 0xa5a5a5a5a5a5a34e, 8191, 10, 14, 0xa5a5a5a5a57fff4e) + EXT( 0xa5a5a5a5a5a5a34d, 10, 15, 0xffffffffffffe968) + EXTU(0xa5a5a5a5a5a5a34d, 10, 15, 0x0000000000006968) + DEP( 0xa5a5a5a5a5a5a34d, 16383, 10, 15, 0xa5a5a5a5a4ffff4d) + EXT( 0xa5a5a5a5a5a5a34c, 10, 16, 0x0000000000006968) + EXTU(0xa5a5a5a5a5a5a34c, 10, 16, 0x0000000000006968) + DEP( 0xa5a5a5a5a5a5a34c, 32767, 10, 16, 0xa5a5a5a5a5ffff4c) + EXT( 0xa5a5a5a5a5a5a34b, 10, 17, 0xffffffffffff6968) + EXTU(0xa5a5a5a5a5a5a34b, 10, 17, 0x0000000000016968) + DEP( 0xa5a5a5a5a5a5a34b, 65535, 10, 17, 0xa5a5a5a5a3ffff4b) + EXT( 0xa5a5a5a5a5a5a34a, 10, 18, 0x0000000000016968) + EXTU(0xa5a5a5a5a5a5a34a, 10, 18, 0x0000000000016968) + DEP( 0xa5a5a5a5a5a5a34a, 131071, 10, 18, 0xa5a5a5a5a7ffff4a) + EXT( 0xa5a5a5a5a5a5a349, 10, 19, 0x0000000000016968) + EXTU(0xa5a5a5a5a5a5a349, 10, 19, 0x0000000000016968) + DEP( 0xa5a5a5a5a5a5a349, 262143, 10, 19, 0xa5a5a5a5afffff49) + EXT( 0xa5a5a5a5a5a5a348, 10, 20, 0xfffffffffff96968) + EXTU(0xa5a5a5a5a5a5a348, 10, 20, 0x0000000000096968) + DEP( 0xa5a5a5a5a5a5a348, 524287, 10, 20, 0xa5a5a5a59fffff48) + EXT( 0xa5a5a5a5a5a5a347, 10, 21, 0x0000000000096968) + EXTU(0xa5a5a5a5a5a5a347, 10, 21, 0x0000000000096968) + DEP( 0xa5a5a5a5a5a5a347, 1048575, 10, 21, 0xa5a5a5a5bfffff47) + EXT( 0xa5a5a5a5a5a5a346, 10, 22, 0xffffffffffe96968) + EXTU(0xa5a5a5a5a5a5a346, 10, 22, 0x0000000000296968) + DEP( 0xa5a5a5a5a5a5a346, 2097151, 10, 22, 0xa5a5a5a57fffff46) + EXT( 0xa5a5a5a5a5a5a345, 10, 23, 0xffffffffffe96968) + EXTU(0xa5a5a5a5a5a5a345, 10, 23, 0x0000000000696968) + DEP( 0xa5a5a5a5a5a5a345, 4194303, 10, 23, 0xa5a5a5a4ffffff45) + EXT( 0xa5a5a5a5a5a5a344, 10, 24, 0x0000000000696968) + EXTU(0xa5a5a5a5a5a5a344, 10, 24, 0x0000000000696968) + DEP( 0xa5a5a5a5a5a5a344, 8388607, 10, 24, 0xa5a5a5a5ffffff44) + EXT( 0xa5a5a5a5a5a5a343, 10, 25, 0xffffffffff696968) + EXTU(0xa5a5a5a5a5a5a343, 10, 25, 0x0000000001696968) + DEP( 0xa5a5a5a5a5a5a343, 16777215, 10, 25, 0xa5a5a5a3ffffff43) + EXT( 0xa5a5a5a5a5a5a342, 10, 26, 0x0000000001696968) + EXTU(0xa5a5a5a5a5a5a342, 10, 26, 0x0000000001696968) + DEP( 0xa5a5a5a5a5a5a342, 33554431, 10, 26, 0xa5a5a5a7ffffff42) + EXT( 0xa5a5a5a5a5a5a341, 10, 27, 0x0000000001696968) + EXTU(0xa5a5a5a5a5a5a341, 10, 27, 0x0000000001696968) + DEP( 0xa5a5a5a5a5a5a341, 67108863, 10, 27, 0xa5a5a5afffffff41) + EXT( 0xa5a5a5a5a5a5a340, 10, 28, 0xfffffffff9696968) + EXTU(0xa5a5a5a5a5a5a340, 10, 28, 0x0000000009696968) + DEP( 0xa5a5a5a5a5a5a340, 134217727, 10, 28, 0xa5a5a59fffffff40) + EXT( 0xa5a5a5a5a5a5a33f, 10, 29, 0x0000000009696968) + EXTU(0xa5a5a5a5a5a5a33f, 10, 29, 0x0000000009696968) + DEP( 0xa5a5a5a5a5a5a33f, 268435455, 10, 29, 0xa5a5a5bfffffff3f) + EXT( 0xa5a5a5a5a5a5a33e, 10, 30, 0xffffffffe9696968) + EXTU(0xa5a5a5a5a5a5a33e, 10, 30, 0x0000000029696968) + DEP( 0xa5a5a5a5a5a5a33e, 536870911, 10, 30, 0xa5a5a57fffffff3e) + EXT( 0xa5a5a5a5a5a5a33d, 10, 31, 0xffffffffe9696968) + EXTU(0xa5a5a5a5a5a5a33d, 10, 31, 0x0000000069696968) + DEP( 0xa5a5a5a5a5a5a33d, 1073741823, 10, 31, 0xa5a5a4ffffffff3d) + EXT( 0xa5a5a5a5a5a5a33c, 10, 32, 0x0000000069696968) + EXTU(0xa5a5a5a5a5a5a33c, 10, 32, 0x0000000069696968) + DEP( 0xa5a5a5a5a5a5a33c, 2147483647, 10, 32, 0xa5a5a5ffffffff3c) + EXT( 0xa5a5a5a5a5a5a33b, 10, 33, 0xffffffff69696968) + EXTU(0xa5a5a5a5a5a5a33b, 10, 33, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a33b, 4294967295, 10, 33, 0xa5a5a3ffffffff3b) + EXT( 0xa5a5a5a5a5a5a33a, 10, 34, 0x0000000169696968) + EXTU(0xa5a5a5a5a5a5a33a, 10, 34, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a33a, 8589934591, 10, 34, 0xa5a5a7ffffffff3a) + EXT( 0xa5a5a5a5a5a5a339, 10, 35, 0x0000000169696968) + EXTU(0xa5a5a5a5a5a5a339, 10, 35, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a339, 17179869183, 10, 35, 0xa5a5afffffffff39) + EXT( 0xa5a5a5a5a5a5a338, 10, 36, 0xfffffff969696968) + EXTU(0xa5a5a5a5a5a5a338, 10, 36, 0x0000000969696968) + DEP( 0xa5a5a5a5a5a5a338, 34359738367, 10, 36, 0xa5a59fffffffff38) + EXT( 0xa5a5a5a5a5a5a337, 10, 37, 0x0000000969696968) + EXTU(0xa5a5a5a5a5a5a337, 10, 37, 0x0000000969696968) + DEP( 0xa5a5a5a5a5a5a337, 68719476735, 10, 37, 0xa5a5bfffffffff37) + EXT( 0xa5a5a5a5a5a5a336, 10, 38, 0xffffffe969696968) + EXTU(0xa5a5a5a5a5a5a336, 10, 38, 0x0000002969696968) + DEP( 0xa5a5a5a5a5a5a336, 137438953471, 10, 38, 0xa5a57fffffffff36) + EXT( 0xa5a5a5a5a5a5a335, 10, 39, 0xffffffe969696968) + EXTU(0xa5a5a5a5a5a5a335, 10, 39, 0x0000006969696968) + DEP( 0xa5a5a5a5a5a5a335, 274877906943, 10, 39, 0xa5a4ffffffffff35) + EXT( 0xa5a5a5a5a5a5a334, 10, 40, 0x0000006969696968) + EXTU(0xa5a5a5a5a5a5a334, 10, 40, 0x0000006969696968) + DEP( 0xa5a5a5a5a5a5a334, 549755813887, 10, 40, 0xa5a5ffffffffff34) + EXT( 0xa5a5a5a5a5a5a333, 10, 41, 0xffffff6969696968) + EXTU(0xa5a5a5a5a5a5a333, 10, 41, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a333, 1099511627775, 10, 41, 0xa5a3ffffffffff33) + EXT( 0xa5a5a5a5a5a5a332, 10, 42, 0x0000016969696968) + EXTU(0xa5a5a5a5a5a5a332, 10, 42, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a332, 2199023255551, 10, 42, 0xa5a7ffffffffff32) + EXT( 0xa5a5a5a5a5a5a331, 10, 43, 0x0000016969696968) + EXTU(0xa5a5a5a5a5a5a331, 10, 43, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a331, 4398046511103, 10, 43, 0xa5afffffffffff31) + EXT( 0xa5a5a5a5a5a5a330, 10, 44, 0xfffff96969696968) + EXTU(0xa5a5a5a5a5a5a330, 10, 44, 0x0000096969696968) + DEP( 0xa5a5a5a5a5a5a330, 8796093022207, 10, 44, 0xa59fffffffffff30) + EXT( 0xa5a5a5a5a5a5a32f, 10, 45, 0x0000096969696968) + EXTU(0xa5a5a5a5a5a5a32f, 10, 45, 0x0000096969696968) + DEP( 0xa5a5a5a5a5a5a32f, 17592186044415, 10, 45, 0xa5bfffffffffff2f) + EXT( 0xa5a5a5a5a5a5a32e, 10, 46, 0xffffe96969696968) + EXTU(0xa5a5a5a5a5a5a32e, 10, 46, 0x0000296969696968) + DEP( 0xa5a5a5a5a5a5a32e, 35184372088831, 10, 46, 0xa57fffffffffff2e) + EXT( 0xa5a5a5a5a5a5a32d, 10, 47, 0xffffe96969696968) + EXTU(0xa5a5a5a5a5a5a32d, 10, 47, 0x0000696969696968) + DEP( 0xa5a5a5a5a5a5a32d, 70368744177663, 10, 47, 0xa4ffffffffffff2d) + EXT( 0xa5a5a5a5a5a5a32c, 10, 48, 0x0000696969696968) + EXTU(0xa5a5a5a5a5a5a32c, 10, 48, 0x0000696969696968) + DEP( 0xa5a5a5a5a5a5a32c, 140737488355327, 10, 48, 0xa5ffffffffffff2c) + EXT( 0xa5a5a5a5a5a5a32b, 10, 49, 0xffff696969696968) + EXTU(0xa5a5a5a5a5a5a32b, 10, 49, 0x0001696969696968) + DEP( 0xa5a5a5a5a5a5a32b, 281474976710655, 10, 49, 0xa3ffffffffffff2b) + EXT( 0xa5a5a5a5a5a5a32a, 10, 50, 0x0001696969696968) + EXTU(0xa5a5a5a5a5a5a32a, 10, 50, 0x0001696969696968) + DEP( 0xa5a5a5a5a5a5a32a, 562949953421311, 10, 50, 0xa7ffffffffffff2a) + EXT( 0xa5a5a5a5a5a5a329, 10, 51, 0x0001696969696968) + EXTU(0xa5a5a5a5a5a5a329, 10, 51, 0x0001696969696968) + DEP( 0xa5a5a5a5a5a5a329, 1125899906842623, 10, 51, 0xafffffffffffff29) + EXT( 0xa5a5a5a5a5a5a328, 10, 52, 0xfff9696969696968) + EXTU(0xa5a5a5a5a5a5a328, 10, 52, 0x0009696969696968) + DEP( 0xa5a5a5a5a5a5a328, 2251799813685247, 10, 52, 0x9fffffffffffff28) + EXT( 0xa5a5a5a5a5a5a327, 10, 53, 0x0009696969696968) + EXTU(0xa5a5a5a5a5a5a327, 10, 53, 0x0009696969696968) + DEP( 0xa5a5a5a5a5a5a327, 4503599627370495, 10, 53, 0xbfffffffffffff27) + EXT( 0xa5a5a5a5a5a5a326, 11, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a326, 11, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a326, 0, 11, 1, 0xa5a5a5a5a5a5a326) + EXT( 0xa5a5a5a5a5a5a325, 11, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a325, 11, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a325, 1, 11, 2, 0xa5a5a5a5a5a5ab25) + EXT( 0xa5a5a5a5a5a5a324, 11, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a324, 11, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a324, 3, 11, 3, 0xa5a5a5a5a5a59b24) + EXT( 0xa5a5a5a5a5a5a323, 11, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a323, 11, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a323, 7, 11, 4, 0xa5a5a5a5a5a5bb23) + EXT( 0xa5a5a5a5a5a5a322, 11, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a322, 11, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a322, 15, 11, 5, 0xa5a5a5a5a5a57b22) + EXT( 0xa5a5a5a5a5a5a321, 11, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a321, 11, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a321, 31, 11, 6, 0xa5a5a5a5a5a4fb21) + EXT( 0xa5a5a5a5a5a5a320, 11, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a320, 11, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a320, 63, 11, 7, 0xa5a5a5a5a5a5fb20) + EXT( 0xa5a5a5a5a5a5a31f, 11, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a31f, 11, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a31f, 127, 11, 8, 0xa5a5a5a5a5a3fb1f) + EXT( 0xa5a5a5a5a5a5a31e, 11, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a31e, 11, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a31e, 255, 11, 9, 0xa5a5a5a5a5a7fb1e) + EXT( 0xa5a5a5a5a5a5a31d, 11, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a31d, 11, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a31d, 511, 11, 10, 0xa5a5a5a5a5affb1d) + EXT( 0xa5a5a5a5a5a5a31c, 11, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a31c, 11, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a31c, 1023, 11, 11, 0xa5a5a5a5a59ffb1c) + EXT( 0xa5a5a5a5a5a5a31b, 11, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a31b, 11, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a31b, 2047, 11, 12, 0xa5a5a5a5a5bffb1b) + EXT( 0xa5a5a5a5a5a5a31a, 11, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a31a, 11, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a31a, 4095, 11, 13, 0xa5a5a5a5a57ffb1a) + EXT( 0xa5a5a5a5a5a5a319, 11, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a319, 11, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a319, 8191, 11, 14, 0xa5a5a5a5a4fffb19) + EXT( 0xa5a5a5a5a5a5a318, 11, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a318, 11, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a318, 16383, 11, 15, 0xa5a5a5a5a5fffb18) + EXT( 0xa5a5a5a5a5a5a317, 11, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a317, 11, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a317, 32767, 11, 16, 0xa5a5a5a5a3fffb17) + EXT( 0xa5a5a5a5a5a5a316, 11, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a316, 11, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a316, 65535, 11, 17, 0xa5a5a5a5a7fffb16) + EXT( 0xa5a5a5a5a5a5a315, 11, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a315, 11, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a315, 131071, 11, 18, 0xa5a5a5a5affffb15) + EXT( 0xa5a5a5a5a5a5a314, 11, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a314, 11, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a314, 262143, 11, 19, 0xa5a5a5a59ffffb14) + EXT( 0xa5a5a5a5a5a5a313, 11, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a313, 11, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a313, 524287, 11, 20, 0xa5a5a5a5bffffb13) + EXT( 0xa5a5a5a5a5a5a312, 11, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a312, 11, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a312, 1048575, 11, 21, 0xa5a5a5a57ffffb12) + EXT( 0xa5a5a5a5a5a5a311, 11, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a311, 11, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a311, 2097151, 11, 22, 0xa5a5a5a4fffffb11) + EXT( 0xa5a5a5a5a5a5a310, 11, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a310, 11, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a310, 4194303, 11, 23, 0xa5a5a5a5fffffb10) + EXT( 0xa5a5a5a5a5a5a30f, 11, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a30f, 11, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a30f, 8388607, 11, 24, 0xa5a5a5a3fffffb0f) + EXT( 0xa5a5a5a5a5a5a30e, 11, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a30e, 11, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a30e, 16777215, 11, 25, 0xa5a5a5a7fffffb0e) + EXT( 0xa5a5a5a5a5a5a30d, 11, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a30d, 11, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a30d, 33554431, 11, 26, 0xa5a5a5affffffb0d) + EXT( 0xa5a5a5a5a5a5a30c, 11, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a30c, 11, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a30c, 67108863, 11, 27, 0xa5a5a59ffffffb0c) + EXT( 0xa5a5a5a5a5a5a30b, 11, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a30b, 11, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a30b, 134217727, 11, 28, 0xa5a5a5bffffffb0b) + EXT( 0xa5a5a5a5a5a5a30a, 11, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a30a, 11, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a30a, 268435455, 11, 29, 0xa5a5a57ffffffb0a) + EXT( 0xa5a5a5a5a5a5a309, 11, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a309, 11, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a309, 536870911, 11, 30, 0xa5a5a4fffffffb09) + EXT( 0xa5a5a5a5a5a5a308, 11, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a308, 11, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a308, 1073741823, 11, 31, 0xa5a5a5fffffffb08) + EXT( 0xa5a5a5a5a5a5a307, 11, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a307, 11, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a307, 2147483647, 11, 32, 0xa5a5a3fffffffb07) + EXT( 0xa5a5a5a5a5a5a306, 11, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a306, 11, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a306, 4294967295, 11, 33, 0xa5a5a7fffffffb06) + EXT( 0xa5a5a5a5a5a5a305, 11, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a305, 11, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a305, 8589934591, 11, 34, 0xa5a5affffffffb05) + EXT( 0xa5a5a5a5a5a5a304, 11, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a304, 11, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a304, 17179869183, 11, 35, 0xa5a59ffffffffb04) + EXT( 0xa5a5a5a5a5a5a303, 11, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a303, 11, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a303, 34359738367, 11, 36, 0xa5a5bffffffffb03) + EXT( 0xa5a5a5a5a5a5a302, 11, 37, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a302, 11, 37, 0x00000014b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a302, 68719476735, 11, 37, 0xa5a57ffffffffb02) + EXT( 0xa5a5a5a5a5a5a301, 11, 38, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a301, 11, 38, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a301, 137438953471, 11, 38, 0xa5a4fffffffffb01) + EXT( 0xa5a5a5a5a5a5a300, 11, 39, 0x00000034b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a300, 11, 39, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a300, 274877906943, 11, 39, 0xa5a5fffffffffb00) + EXT( 0xa5a5a5a5a5a5a2ff, 11, 40, 0xffffffb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2ff, 11, 40, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2ff, 549755813887, 11, 40, 0xa5a3fffffffffaff) + EXT( 0xa5a5a5a5a5a5a2fe, 11, 41, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fe, 11, 41, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fe, 1099511627775, 11, 41, 0xa5a7fffffffffafe) + EXT( 0xa5a5a5a5a5a5a2fd, 11, 42, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fd, 11, 42, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fd, 2199023255551, 11, 42, 0xa5affffffffffafd) + EXT( 0xa5a5a5a5a5a5a2fc, 11, 43, 0xfffffcb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fc, 11, 43, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fc, 4398046511103, 11, 43, 0xa59ffffffffffafc) + EXT( 0xa5a5a5a5a5a5a2fb, 11, 44, 0x000004b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fb, 11, 44, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fb, 8796093022207, 11, 44, 0xa5bffffffffffafb) + EXT( 0xa5a5a5a5a5a5a2fa, 11, 45, 0xfffff4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fa, 11, 45, 0x000014b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fa, 17592186044415, 11, 45, 0xa57ffffffffffafa) + EXT( 0xa5a5a5a5a5a5a2f9, 11, 46, 0xfffff4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f9, 11, 46, 0x000034b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f9, 35184372088831, 11, 46, 0xa4fffffffffffaf9) + EXT( 0xa5a5a5a5a5a5a2f8, 11, 47, 0x000034b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f8, 11, 47, 0x000034b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f8, 70368744177663, 11, 47, 0xa5fffffffffffaf8) + EXT( 0xa5a5a5a5a5a5a2f7, 11, 48, 0xffffb4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f7, 11, 48, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f7, 140737488355327, 11, 48, 0xa3fffffffffffaf7) + EXT( 0xa5a5a5a5a5a5a2f6, 11, 49, 0x0000b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f6, 11, 49, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f6, 281474976710655, 11, 49, 0xa7fffffffffffaf6) + EXT( 0xa5a5a5a5a5a5a2f5, 11, 50, 0x0000b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f5, 11, 50, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f5, 562949953421311, 11, 50, 0xaffffffffffffaf5) + EXT( 0xa5a5a5a5a5a5a2f4, 11, 51, 0xfffcb4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f4, 11, 51, 0x0004b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f4, 1125899906842623, 11, 51, 0x9ffffffffffffaf4) + EXT( 0xa5a5a5a5a5a5a2f3, 11, 52, 0x0004b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2f3, 11, 52, 0x0004b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2f3, 2251799813685247, 11, 52, 0xbffffffffffffaf3) + EXT( 0xa5a5a5a5a5a5a2f2, 12, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a2f2, 12, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a2f2, 0, 12, 1, 0xa5a5a5a5a5a5a2f2) + EXT( 0xa5a5a5a5a5a5a2f1, 12, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a2f1, 12, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a2f1, 1, 12, 2, 0xa5a5a5a5a5a592f1) + EXT( 0xa5a5a5a5a5a5a2f0, 12, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a2f0, 12, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a2f0, 3, 12, 3, 0xa5a5a5a5a5a5b2f0) + EXT( 0xa5a5a5a5a5a5a2ef, 12, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a2ef, 12, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a2ef, 7, 12, 4, 0xa5a5a5a5a5a572ef) + EXT( 0xa5a5a5a5a5a5a2ee, 12, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a2ee, 12, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a2ee, 15, 12, 5, 0xa5a5a5a5a5a4f2ee) + EXT( 0xa5a5a5a5a5a5a2ed, 12, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a2ed, 12, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a2ed, 31, 12, 6, 0xa5a5a5a5a5a5f2ed) + EXT( 0xa5a5a5a5a5a5a2ec, 12, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a2ec, 12, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a2ec, 63, 12, 7, 0xa5a5a5a5a5a3f2ec) + EXT( 0xa5a5a5a5a5a5a2eb, 12, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a2eb, 12, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a2eb, 127, 12, 8, 0xa5a5a5a5a5a7f2eb) + EXT( 0xa5a5a5a5a5a5a2ea, 12, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a2ea, 12, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a2ea, 255, 12, 9, 0xa5a5a5a5a5aff2ea) + EXT( 0xa5a5a5a5a5a5a2e9, 12, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a2e9, 12, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a2e9, 511, 12, 10, 0xa5a5a5a5a59ff2e9) + EXT( 0xa5a5a5a5a5a5a2e8, 12, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a2e8, 12, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a2e8, 1023, 12, 11, 0xa5a5a5a5a5bff2e8) + EXT( 0xa5a5a5a5a5a5a2e7, 12, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a2e7, 12, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a2e7, 2047, 12, 12, 0xa5a5a5a5a57ff2e7) + EXT( 0xa5a5a5a5a5a5a2e6, 12, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a2e6, 12, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a2e6, 4095, 12, 13, 0xa5a5a5a5a4fff2e6) + EXT( 0xa5a5a5a5a5a5a2e5, 12, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a2e5, 12, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a2e5, 8191, 12, 14, 0xa5a5a5a5a5fff2e5) + EXT( 0xa5a5a5a5a5a5a2e4, 12, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a2e4, 12, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a2e4, 16383, 12, 15, 0xa5a5a5a5a3fff2e4) + EXT( 0xa5a5a5a5a5a5a2e3, 12, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a2e3, 12, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a2e3, 32767, 12, 16, 0xa5a5a5a5a7fff2e3) + EXT( 0xa5a5a5a5a5a5a2e2, 12, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a2e2, 12, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a2e2, 65535, 12, 17, 0xa5a5a5a5affff2e2) + EXT( 0xa5a5a5a5a5a5a2e1, 12, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a2e1, 12, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a2e1, 131071, 12, 18, 0xa5a5a5a59ffff2e1) + EXT( 0xa5a5a5a5a5a5a2e0, 12, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a2e0, 12, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a2e0, 262143, 12, 19, 0xa5a5a5a5bffff2e0) + EXT( 0xa5a5a5a5a5a5a2df, 12, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a2df, 12, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a2df, 524287, 12, 20, 0xa5a5a5a57ffff2df) + EXT( 0xa5a5a5a5a5a5a2de, 12, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a2de, 12, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a2de, 1048575, 12, 21, 0xa5a5a5a4fffff2de) + EXT( 0xa5a5a5a5a5a5a2dd, 12, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a2dd, 12, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a2dd, 2097151, 12, 22, 0xa5a5a5a5fffff2dd) + EXT( 0xa5a5a5a5a5a5a2dc, 12, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a2dc, 12, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a2dc, 4194303, 12, 23, 0xa5a5a5a3fffff2dc) + EXT( 0xa5a5a5a5a5a5a2db, 12, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a2db, 12, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a2db, 8388607, 12, 24, 0xa5a5a5a7fffff2db) + EXT( 0xa5a5a5a5a5a5a2da, 12, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a2da, 12, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a2da, 16777215, 12, 25, 0xa5a5a5affffff2da) + EXT( 0xa5a5a5a5a5a5a2d9, 12, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d9, 12, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a2d9, 33554431, 12, 26, 0xa5a5a59ffffff2d9) + EXT( 0xa5a5a5a5a5a5a2d8, 12, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a2d8, 12, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a2d8, 67108863, 12, 27, 0xa5a5a5bffffff2d8) + EXT( 0xa5a5a5a5a5a5a2d7, 12, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d7, 12, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d7, 134217727, 12, 28, 0xa5a5a57ffffff2d7) + EXT( 0xa5a5a5a5a5a5a2d6, 12, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d6, 12, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d6, 268435455, 12, 29, 0xa5a5a4fffffff2d6) + EXT( 0xa5a5a5a5a5a5a2d5, 12, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d5, 12, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d5, 536870911, 12, 30, 0xa5a5a5fffffff2d5) + EXT( 0xa5a5a5a5a5a5a2d4, 12, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d4, 12, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d4, 1073741823, 12, 31, 0xa5a5a3fffffff2d4) + EXT( 0xa5a5a5a5a5a5a2d3, 12, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d3, 12, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d3, 2147483647, 12, 32, 0xa5a5a7fffffff2d3) + EXT( 0xa5a5a5a5a5a5a2d2, 12, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d2, 12, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d2, 4294967295, 12, 33, 0xa5a5affffffff2d2) + EXT( 0xa5a5a5a5a5a5a2d1, 12, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d1, 12, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d1, 8589934591, 12, 34, 0xa5a59ffffffff2d1) + EXT( 0xa5a5a5a5a5a5a2d0, 12, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d0, 12, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d0, 17179869183, 12, 35, 0xa5a5bffffffff2d0) + EXT( 0xa5a5a5a5a5a5a2cf, 12, 36, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2cf, 12, 36, 0x0000000a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2cf, 34359738367, 12, 36, 0xa5a57ffffffff2cf) + EXT( 0xa5a5a5a5a5a5a2ce, 12, 37, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2ce, 12, 37, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2ce, 68719476735, 12, 37, 0xa5a4fffffffff2ce) + EXT( 0xa5a5a5a5a5a5a2cd, 12, 38, 0x0000001a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2cd, 12, 38, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2cd, 137438953471, 12, 38, 0xa5a5fffffffff2cd) + EXT( 0xa5a5a5a5a5a5a2cc, 12, 39, 0xffffffda5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2cc, 12, 39, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2cc, 274877906943, 12, 39, 0xa5a3fffffffff2cc) + EXT( 0xa5a5a5a5a5a5a2cb, 12, 40, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2cb, 12, 40, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2cb, 549755813887, 12, 40, 0xa5a7fffffffff2cb) + EXT( 0xa5a5a5a5a5a5a2ca, 12, 41, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2ca, 12, 41, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2ca, 1099511627775, 12, 41, 0xa5affffffffff2ca) + EXT( 0xa5a5a5a5a5a5a2c9, 12, 42, 0xfffffe5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c9, 12, 42, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c9, 2199023255551, 12, 42, 0xa59ffffffffff2c9) + EXT( 0xa5a5a5a5a5a5a2c8, 12, 43, 0x0000025a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c8, 12, 43, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c8, 4398046511103, 12, 43, 0xa5bffffffffff2c8) + EXT( 0xa5a5a5a5a5a5a2c7, 12, 44, 0xfffffa5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c7, 12, 44, 0x00000a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c7, 8796093022207, 12, 44, 0xa57ffffffffff2c7) + EXT( 0xa5a5a5a5a5a5a2c6, 12, 45, 0xfffffa5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c6, 12, 45, 0x00001a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c6, 17592186044415, 12, 45, 0xa4fffffffffff2c6) + EXT( 0xa5a5a5a5a5a5a2c5, 12, 46, 0x00001a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c5, 12, 46, 0x00001a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c5, 35184372088831, 12, 46, 0xa5fffffffffff2c5) + EXT( 0xa5a5a5a5a5a5a2c4, 12, 47, 0xffffda5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c4, 12, 47, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c4, 70368744177663, 12, 47, 0xa3fffffffffff2c4) + EXT( 0xa5a5a5a5a5a5a2c3, 12, 48, 0x00005a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c3, 12, 48, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c3, 140737488355327, 12, 48, 0xa7fffffffffff2c3) + EXT( 0xa5a5a5a5a5a5a2c2, 12, 49, 0x00005a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c2, 12, 49, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c2, 281474976710655, 12, 49, 0xaffffffffffff2c2) + EXT( 0xa5a5a5a5a5a5a2c1, 12, 50, 0xfffe5a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c1, 12, 50, 0x00025a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c1, 562949953421311, 12, 50, 0x9ffffffffffff2c1) + EXT( 0xa5a5a5a5a5a5a2c0, 12, 51, 0x00025a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2c0, 12, 51, 0x00025a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2c0, 1125899906842623, 12, 51, 0xbffffffffffff2c0) + EXT( 0xa5a5a5a5a5a5a2bf, 13, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a2bf, 13, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a2bf, 0, 13, 1, 0xa5a5a5a5a5a582bf) + EXT( 0xa5a5a5a5a5a5a2be, 13, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a2be, 13, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a2be, 1, 13, 2, 0xa5a5a5a5a5a5a2be) + EXT( 0xa5a5a5a5a5a5a2bd, 13, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a2bd, 13, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a2bd, 3, 13, 3, 0xa5a5a5a5a5a562bd) + EXT( 0xa5a5a5a5a5a5a2bc, 13, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a2bc, 13, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a2bc, 7, 13, 4, 0xa5a5a5a5a5a4e2bc) + EXT( 0xa5a5a5a5a5a5a2bb, 13, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a2bb, 13, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a2bb, 15, 13, 5, 0xa5a5a5a5a5a5e2bb) + EXT( 0xa5a5a5a5a5a5a2ba, 13, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a2ba, 13, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a2ba, 31, 13, 6, 0xa5a5a5a5a5a3e2ba) + EXT( 0xa5a5a5a5a5a5a2b9, 13, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a2b9, 13, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a2b9, 63, 13, 7, 0xa5a5a5a5a5a7e2b9) + EXT( 0xa5a5a5a5a5a5a2b8, 13, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a2b8, 13, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a2b8, 127, 13, 8, 0xa5a5a5a5a5afe2b8) + EXT( 0xa5a5a5a5a5a5a2b7, 13, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a2b7, 13, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a2b7, 255, 13, 9, 0xa5a5a5a5a59fe2b7) + EXT( 0xa5a5a5a5a5a5a2b6, 13, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a2b6, 13, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a2b6, 511, 13, 10, 0xa5a5a5a5a5bfe2b6) + EXT( 0xa5a5a5a5a5a5a2b5, 13, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a2b5, 13, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a2b5, 1023, 13, 11, 0xa5a5a5a5a57fe2b5) + EXT( 0xa5a5a5a5a5a5a2b4, 13, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a2b4, 13, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a2b4, 2047, 13, 12, 0xa5a5a5a5a4ffe2b4) + EXT( 0xa5a5a5a5a5a5a2b3, 13, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a2b3, 13, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a2b3, 4095, 13, 13, 0xa5a5a5a5a5ffe2b3) + EXT( 0xa5a5a5a5a5a5a2b2, 13, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a2b2, 13, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a2b2, 8191, 13, 14, 0xa5a5a5a5a3ffe2b2) + EXT( 0xa5a5a5a5a5a5a2b1, 13, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a2b1, 13, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a2b1, 16383, 13, 15, 0xa5a5a5a5a7ffe2b1) + EXT( 0xa5a5a5a5a5a5a2b0, 13, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a2b0, 13, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a2b0, 32767, 13, 16, 0xa5a5a5a5afffe2b0) + EXT( 0xa5a5a5a5a5a5a2af, 13, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a2af, 13, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a2af, 65535, 13, 17, 0xa5a5a5a59fffe2af) + EXT( 0xa5a5a5a5a5a5a2ae, 13, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a2ae, 13, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a2ae, 131071, 13, 18, 0xa5a5a5a5bfffe2ae) + EXT( 0xa5a5a5a5a5a5a2ad, 13, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a2ad, 13, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a2ad, 262143, 13, 19, 0xa5a5a5a57fffe2ad) + EXT( 0xa5a5a5a5a5a5a2ac, 13, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a2ac, 13, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a2ac, 524287, 13, 20, 0xa5a5a5a4ffffe2ac) + EXT( 0xa5a5a5a5a5a5a2ab, 13, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a2ab, 13, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a2ab, 1048575, 13, 21, 0xa5a5a5a5ffffe2ab) + EXT( 0xa5a5a5a5a5a5a2aa, 13, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a2aa, 13, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a2aa, 2097151, 13, 22, 0xa5a5a5a3ffffe2aa) + EXT( 0xa5a5a5a5a5a5a2a9, 13, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a2a9, 13, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a2a9, 4194303, 13, 23, 0xa5a5a5a7ffffe2a9) + EXT( 0xa5a5a5a5a5a5a2a8, 13, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a2a8, 13, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a2a8, 8388607, 13, 24, 0xa5a5a5afffffe2a8) + EXT( 0xa5a5a5a5a5a5a2a7, 13, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a7, 13, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a2a7, 16777215, 13, 25, 0xa5a5a59fffffe2a7) + EXT( 0xa5a5a5a5a5a5a2a6, 13, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a2a6, 13, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a2a6, 33554431, 13, 26, 0xa5a5a5bfffffe2a6) + EXT( 0xa5a5a5a5a5a5a2a5, 13, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a5, 13, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a2a5, 67108863, 13, 27, 0xa5a5a57fffffe2a5) + EXT( 0xa5a5a5a5a5a5a2a4, 13, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a4, 13, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a4, 134217727, 13, 28, 0xa5a5a4ffffffe2a4) + EXT( 0xa5a5a5a5a5a5a2a3, 13, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a3, 13, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a3, 268435455, 13, 29, 0xa5a5a5ffffffe2a3) + EXT( 0xa5a5a5a5a5a5a2a2, 13, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a2, 13, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a2, 536870911, 13, 30, 0xa5a5a3ffffffe2a2) + EXT( 0xa5a5a5a5a5a5a2a1, 13, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a1, 13, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a1, 1073741823, 13, 31, 0xa5a5a7ffffffe2a1) + EXT( 0xa5a5a5a5a5a5a2a0, 13, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a0, 13, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a0, 2147483647, 13, 32, 0xa5a5afffffffe2a0) + EXT( 0xa5a5a5a5a5a5a29f, 13, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29f, 13, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29f, 4294967295, 13, 33, 0xa5a59fffffffe29f) + EXT( 0xa5a5a5a5a5a5a29e, 13, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29e, 13, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29e, 8589934591, 13, 34, 0xa5a5bfffffffe29e) + EXT( 0xa5a5a5a5a5a5a29d, 13, 35, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29d, 13, 35, 0x000000052d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29d, 17179869183, 13, 35, 0xa5a57fffffffe29d) + EXT( 0xa5a5a5a5a5a5a29c, 13, 36, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29c, 13, 36, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29c, 34359738367, 13, 36, 0xa5a4ffffffffe29c) + EXT( 0xa5a5a5a5a5a5a29b, 13, 37, 0x0000000d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29b, 13, 37, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29b, 68719476735, 13, 37, 0xa5a5ffffffffe29b) + EXT( 0xa5a5a5a5a5a5a29a, 13, 38, 0xffffffed2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29a, 13, 38, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29a, 137438953471, 13, 38, 0xa5a3ffffffffe29a) + EXT( 0xa5a5a5a5a5a5a299, 13, 39, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a299, 13, 39, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a299, 274877906943, 13, 39, 0xa5a7ffffffffe299) + EXT( 0xa5a5a5a5a5a5a298, 13, 40, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a298, 13, 40, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a298, 549755813887, 13, 40, 0xa5afffffffffe298) + EXT( 0xa5a5a5a5a5a5a297, 13, 41, 0xffffff2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a297, 13, 41, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a297, 1099511627775, 13, 41, 0xa59fffffffffe297) + EXT( 0xa5a5a5a5a5a5a296, 13, 42, 0x0000012d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a296, 13, 42, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a296, 2199023255551, 13, 42, 0xa5bfffffffffe296) + EXT( 0xa5a5a5a5a5a5a295, 13, 43, 0xfffffd2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a295, 13, 43, 0x0000052d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a295, 4398046511103, 13, 43, 0xa57fffffffffe295) + EXT( 0xa5a5a5a5a5a5a294, 13, 44, 0xfffffd2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a294, 13, 44, 0x00000d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a294, 8796093022207, 13, 44, 0xa4ffffffffffe294) + EXT( 0xa5a5a5a5a5a5a293, 13, 45, 0x00000d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a293, 13, 45, 0x00000d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a293, 17592186044415, 13, 45, 0xa5ffffffffffe293) + EXT( 0xa5a5a5a5a5a5a292, 13, 46, 0xffffed2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a292, 13, 46, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a292, 35184372088831, 13, 46, 0xa3ffffffffffe292) + EXT( 0xa5a5a5a5a5a5a291, 13, 47, 0x00002d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a291, 13, 47, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a291, 70368744177663, 13, 47, 0xa7ffffffffffe291) + EXT( 0xa5a5a5a5a5a5a290, 13, 48, 0x00002d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a290, 13, 48, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a290, 140737488355327, 13, 48, 0xafffffffffffe290) + EXT( 0xa5a5a5a5a5a5a28f, 13, 49, 0xffff2d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a28f, 13, 49, 0x00012d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a28f, 281474976710655, 13, 49, 0x9fffffffffffe28f) + EXT( 0xa5a5a5a5a5a5a28e, 13, 50, 0x00012d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a28e, 13, 50, 0x00012d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a28e, 562949953421311, 13, 50, 0xbfffffffffffe28e) + EXT( 0xa5a5a5a5a5a5a28d, 14, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a28d, 14, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a28d, 0, 14, 1, 0xa5a5a5a5a5a5a28d) + EXT( 0xa5a5a5a5a5a5a28c, 14, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a28c, 14, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a28c, 1, 14, 2, 0xa5a5a5a5a5a5628c) + EXT( 0xa5a5a5a5a5a5a28b, 14, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a28b, 14, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a28b, 3, 14, 3, 0xa5a5a5a5a5a4e28b) + EXT( 0xa5a5a5a5a5a5a28a, 14, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a5a28a, 14, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a28a, 7, 14, 4, 0xa5a5a5a5a5a5e28a) + EXT( 0xa5a5a5a5a5a5a289, 14, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a289, 14, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a289, 15, 14, 5, 0xa5a5a5a5a5a3e289) + EXT( 0xa5a5a5a5a5a5a288, 14, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a288, 14, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a288, 31, 14, 6, 0xa5a5a5a5a5a7e288) + EXT( 0xa5a5a5a5a5a5a287, 14, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a287, 14, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a287, 63, 14, 7, 0xa5a5a5a5a5afe287) + EXT( 0xa5a5a5a5a5a5a286, 14, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a286, 14, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a286, 127, 14, 8, 0xa5a5a5a5a59fe286) + EXT( 0xa5a5a5a5a5a5a285, 14, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a285, 14, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a285, 255, 14, 9, 0xa5a5a5a5a5bfe285) + EXT( 0xa5a5a5a5a5a5a284, 14, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a284, 14, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a284, 511, 14, 10, 0xa5a5a5a5a57fe284) + EXT( 0xa5a5a5a5a5a5a283, 14, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a283, 14, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a283, 1023, 14, 11, 0xa5a5a5a5a4ffe283) + EXT( 0xa5a5a5a5a5a5a282, 14, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a5a282, 14, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a282, 2047, 14, 12, 0xa5a5a5a5a5ffe282) + EXT( 0xa5a5a5a5a5a5a281, 14, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a281, 14, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a281, 4095, 14, 13, 0xa5a5a5a5a3ffe281) + EXT( 0xa5a5a5a5a5a5a280, 14, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a280, 14, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a280, 8191, 14, 14, 0xa5a5a5a5a7ffe280) + EXT( 0xa5a5a5a5a5a5a27f, 14, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a27f, 14, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a27f, 16383, 14, 15, 0xa5a5a5a5afffe27f) + EXT( 0xa5a5a5a5a5a5a27e, 14, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a27e, 14, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a27e, 32767, 14, 16, 0xa5a5a5a59fffe27e) + EXT( 0xa5a5a5a5a5a5a27d, 14, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a27d, 14, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a27d, 65535, 14, 17, 0xa5a5a5a5bfffe27d) + EXT( 0xa5a5a5a5a5a5a27c, 14, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a27c, 14, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a27c, 131071, 14, 18, 0xa5a5a5a57fffe27c) + EXT( 0xa5a5a5a5a5a5a27b, 14, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a27b, 14, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a27b, 262143, 14, 19, 0xa5a5a5a4ffffe27b) + EXT( 0xa5a5a5a5a5a5a27a, 14, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a5a27a, 14, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a27a, 524287, 14, 20, 0xa5a5a5a5ffffe27a) + EXT( 0xa5a5a5a5a5a5a279, 14, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a279, 14, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a279, 1048575, 14, 21, 0xa5a5a5a3ffffe279) + EXT( 0xa5a5a5a5a5a5a278, 14, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a278, 14, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a278, 2097151, 14, 22, 0xa5a5a5a7ffffe278) + EXT( 0xa5a5a5a5a5a5a277, 14, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a277, 14, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a277, 4194303, 14, 23, 0xa5a5a5afffffe277) + EXT( 0xa5a5a5a5a5a5a276, 14, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a276, 14, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a276, 8388607, 14, 24, 0xa5a5a59fffffe276) + EXT( 0xa5a5a5a5a5a5a275, 14, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a275, 14, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a275, 16777215, 14, 25, 0xa5a5a5bfffffe275) + EXT( 0xa5a5a5a5a5a5a274, 14, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a274, 14, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a274, 33554431, 14, 26, 0xa5a5a57fffffe274) + EXT( 0xa5a5a5a5a5a5a273, 14, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a273, 14, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a273, 67108863, 14, 27, 0xa5a5a4ffffffe273) + EXT( 0xa5a5a5a5a5a5a272, 14, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a5a272, 14, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a272, 134217727, 14, 28, 0xa5a5a5ffffffe272) + EXT( 0xa5a5a5a5a5a5a271, 14, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a5a271, 14, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a271, 268435455, 14, 29, 0xa5a5a3ffffffe271) + EXT( 0xa5a5a5a5a5a5a270, 14, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a270, 14, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a270, 536870911, 14, 30, 0xa5a5a7ffffffe270) + EXT( 0xa5a5a5a5a5a5a26f, 14, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a26f, 14, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a26f, 1073741823, 14, 31, 0xa5a5afffffffe26f) + EXT( 0xa5a5a5a5a5a5a26e, 14, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a5a26e, 14, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a26e, 2147483647, 14, 32, 0xa5a59fffffffe26e) + EXT( 0xa5a5a5a5a5a5a26d, 14, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a5a26d, 14, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a26d, 4294967295, 14, 33, 0xa5a5bfffffffe26d) + EXT( 0xa5a5a5a5a5a5a26c, 14, 34, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a26c, 14, 34, 0x0000000296969696) + DEP( 0xa5a5a5a5a5a5a26c, 8589934591, 14, 34, 0xa5a57fffffffe26c) + EXT( 0xa5a5a5a5a5a5a26b, 14, 35, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a26b, 14, 35, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a26b, 17179869183, 14, 35, 0xa5a4ffffffffe26b) + EXT( 0xa5a5a5a5a5a5a26a, 14, 36, 0x0000000696969696) + EXTU(0xa5a5a5a5a5a5a26a, 14, 36, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a26a, 34359738367, 14, 36, 0xa5a5ffffffffe26a) + EXT( 0xa5a5a5a5a5a5a269, 14, 37, 0xfffffff696969696) + EXTU(0xa5a5a5a5a5a5a269, 14, 37, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a269, 68719476735, 14, 37, 0xa5a3ffffffffe269) + EXT( 0xa5a5a5a5a5a5a268, 14, 38, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a268, 14, 38, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a268, 137438953471, 14, 38, 0xa5a7ffffffffe268) + EXT( 0xa5a5a5a5a5a5a267, 14, 39, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a267, 14, 39, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a267, 274877906943, 14, 39, 0xa5afffffffffe267) + EXT( 0xa5a5a5a5a5a5a266, 14, 40, 0xffffff9696969696) + EXTU(0xa5a5a5a5a5a5a266, 14, 40, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a266, 549755813887, 14, 40, 0xa59fffffffffe266) + EXT( 0xa5a5a5a5a5a5a265, 14, 41, 0x0000009696969696) + EXTU(0xa5a5a5a5a5a5a265, 14, 41, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a265, 1099511627775, 14, 41, 0xa5bfffffffffe265) + EXT( 0xa5a5a5a5a5a5a264, 14, 42, 0xfffffe9696969696) + EXTU(0xa5a5a5a5a5a5a264, 14, 42, 0x0000029696969696) + DEP( 0xa5a5a5a5a5a5a264, 2199023255551, 14, 42, 0xa57fffffffffe264) + EXT( 0xa5a5a5a5a5a5a263, 14, 43, 0xfffffe9696969696) + EXTU(0xa5a5a5a5a5a5a263, 14, 43, 0x0000069696969696) + DEP( 0xa5a5a5a5a5a5a263, 4398046511103, 14, 43, 0xa4ffffffffffe263) + EXT( 0xa5a5a5a5a5a5a262, 14, 44, 0x0000069696969696) + EXTU(0xa5a5a5a5a5a5a262, 14, 44, 0x0000069696969696) + DEP( 0xa5a5a5a5a5a5a262, 8796093022207, 14, 44, 0xa5ffffffffffe262) + EXT( 0xa5a5a5a5a5a5a261, 14, 45, 0xfffff69696969696) + EXTU(0xa5a5a5a5a5a5a261, 14, 45, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a261, 17592186044415, 14, 45, 0xa3ffffffffffe261) + EXT( 0xa5a5a5a5a5a5a260, 14, 46, 0x0000169696969696) + EXTU(0xa5a5a5a5a5a5a260, 14, 46, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a260, 35184372088831, 14, 46, 0xa7ffffffffffe260) + EXT( 0xa5a5a5a5a5a5a25f, 14, 47, 0x0000169696969696) + EXTU(0xa5a5a5a5a5a5a25f, 14, 47, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a25f, 70368744177663, 14, 47, 0xafffffffffffe25f) + EXT( 0xa5a5a5a5a5a5a25e, 14, 48, 0xffff969696969696) + EXTU(0xa5a5a5a5a5a5a25e, 14, 48, 0x0000969696969696) + DEP( 0xa5a5a5a5a5a5a25e, 140737488355327, 14, 48, 0x9fffffffffffe25e) + EXT( 0xa5a5a5a5a5a5a25d, 14, 49, 0x0000969696969696) + EXTU(0xa5a5a5a5a5a5a25d, 14, 49, 0x0000969696969696) + DEP( 0xa5a5a5a5a5a5a25d, 281474976710655, 14, 49, 0xbfffffffffffe25d) + EXT( 0xa5a5a5a5a5a5a25c, 15, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a25c, 15, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a25c, 0, 15, 1, 0xa5a5a5a5a5a5225c) + EXT( 0xa5a5a5a5a5a5a25b, 15, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a25b, 15, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a25b, 1, 15, 2, 0xa5a5a5a5a5a4a25b) + EXT( 0xa5a5a5a5a5a5a25a, 15, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a25a, 15, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a25a, 3, 15, 3, 0xa5a5a5a5a5a5a25a) + EXT( 0xa5a5a5a5a5a5a259, 15, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a259, 15, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a259, 7, 15, 4, 0xa5a5a5a5a5a3a259) + EXT( 0xa5a5a5a5a5a5a258, 15, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a258, 15, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a258, 15, 15, 5, 0xa5a5a5a5a5a7a258) + EXT( 0xa5a5a5a5a5a5a257, 15, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a257, 15, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a257, 31, 15, 6, 0xa5a5a5a5a5afa257) + EXT( 0xa5a5a5a5a5a5a256, 15, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a256, 15, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a256, 63, 15, 7, 0xa5a5a5a5a59fa256) + EXT( 0xa5a5a5a5a5a5a255, 15, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a255, 15, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a255, 127, 15, 8, 0xa5a5a5a5a5bfa255) + EXT( 0xa5a5a5a5a5a5a254, 15, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a254, 15, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a254, 255, 15, 9, 0xa5a5a5a5a57fa254) + EXT( 0xa5a5a5a5a5a5a253, 15, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a253, 15, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a253, 511, 15, 10, 0xa5a5a5a5a4ffa253) + EXT( 0xa5a5a5a5a5a5a252, 15, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a5a252, 15, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a252, 1023, 15, 11, 0xa5a5a5a5a5ffa252) + EXT( 0xa5a5a5a5a5a5a251, 15, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a251, 15, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a251, 2047, 15, 12, 0xa5a5a5a5a3ffa251) + EXT( 0xa5a5a5a5a5a5a250, 15, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a250, 15, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a250, 4095, 15, 13, 0xa5a5a5a5a7ffa250) + EXT( 0xa5a5a5a5a5a5a24f, 15, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a24f, 15, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a24f, 8191, 15, 14, 0xa5a5a5a5afffa24f) + EXT( 0xa5a5a5a5a5a5a24e, 15, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a24e, 15, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a24e, 16383, 15, 15, 0xa5a5a5a59fffa24e) + EXT( 0xa5a5a5a5a5a5a24d, 15, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a24d, 15, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a24d, 32767, 15, 16, 0xa5a5a5a5bfffa24d) + EXT( 0xa5a5a5a5a5a5a24c, 15, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a24c, 15, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a24c, 65535, 15, 17, 0xa5a5a5a57fffa24c) + EXT( 0xa5a5a5a5a5a5a24b, 15, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a24b, 15, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a24b, 131071, 15, 18, 0xa5a5a5a4ffffa24b) + EXT( 0xa5a5a5a5a5a5a24a, 15, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a5a24a, 15, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a24a, 262143, 15, 19, 0xa5a5a5a5ffffa24a) + EXT( 0xa5a5a5a5a5a5a249, 15, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a249, 15, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a249, 524287, 15, 20, 0xa5a5a5a3ffffa249) + EXT( 0xa5a5a5a5a5a5a248, 15, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a248, 15, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a248, 1048575, 15, 21, 0xa5a5a5a7ffffa248) + EXT( 0xa5a5a5a5a5a5a247, 15, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a247, 15, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a247, 2097151, 15, 22, 0xa5a5a5afffffa247) + EXT( 0xa5a5a5a5a5a5a246, 15, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a246, 15, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a246, 4194303, 15, 23, 0xa5a5a59fffffa246) + EXT( 0xa5a5a5a5a5a5a245, 15, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a245, 15, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a245, 8388607, 15, 24, 0xa5a5a5bfffffa245) + EXT( 0xa5a5a5a5a5a5a244, 15, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a244, 15, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a244, 16777215, 15, 25, 0xa5a5a57fffffa244) + EXT( 0xa5a5a5a5a5a5a243, 15, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a243, 15, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a243, 33554431, 15, 26, 0xa5a5a4ffffffa243) + EXT( 0xa5a5a5a5a5a5a242, 15, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a5a242, 15, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a242, 67108863, 15, 27, 0xa5a5a5ffffffa242) + EXT( 0xa5a5a5a5a5a5a241, 15, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a5a241, 15, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a241, 134217727, 15, 28, 0xa5a5a3ffffffa241) + EXT( 0xa5a5a5a5a5a5a240, 15, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a240, 15, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a240, 268435455, 15, 29, 0xa5a5a7ffffffa240) + EXT( 0xa5a5a5a5a5a5a23f, 15, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23f, 15, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23f, 536870911, 15, 30, 0xa5a5afffffffa23f) + EXT( 0xa5a5a5a5a5a5a23e, 15, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a5a23e, 15, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23e, 1073741823, 15, 31, 0xa5a59fffffffa23e) + EXT( 0xa5a5a5a5a5a5a23d, 15, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23d, 15, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23d, 2147483647, 15, 32, 0xa5a5bfffffffa23d) + EXT( 0xa5a5a5a5a5a5a23c, 15, 33, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23c, 15, 33, 0x000000014b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23c, 4294967295, 15, 33, 0xa5a57fffffffa23c) + EXT( 0xa5a5a5a5a5a5a23b, 15, 34, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23b, 15, 34, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23b, 8589934591, 15, 34, 0xa5a4ffffffffa23b) + EXT( 0xa5a5a5a5a5a5a23a, 15, 35, 0x000000034b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23a, 15, 35, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23a, 17179869183, 15, 35, 0xa5a5ffffffffa23a) + EXT( 0xa5a5a5a5a5a5a239, 15, 36, 0xfffffffb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a239, 15, 36, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a239, 34359738367, 15, 36, 0xa5a3ffffffffa239) + EXT( 0xa5a5a5a5a5a5a238, 15, 37, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a238, 15, 37, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a238, 68719476735, 15, 37, 0xa5a7ffffffffa238) + EXT( 0xa5a5a5a5a5a5a237, 15, 38, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a237, 15, 38, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a237, 137438953471, 15, 38, 0xa5afffffffffa237) + EXT( 0xa5a5a5a5a5a5a236, 15, 39, 0xffffffcb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a236, 15, 39, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a236, 274877906943, 15, 39, 0xa59fffffffffa236) + EXT( 0xa5a5a5a5a5a5a235, 15, 40, 0x0000004b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a235, 15, 40, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a235, 549755813887, 15, 40, 0xa5bfffffffffa235) + EXT( 0xa5a5a5a5a5a5a234, 15, 41, 0xffffff4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a234, 15, 41, 0x0000014b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a234, 1099511627775, 15, 41, 0xa57fffffffffa234) + EXT( 0xa5a5a5a5a5a5a233, 15, 42, 0xffffff4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a233, 15, 42, 0x0000034b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a233, 2199023255551, 15, 42, 0xa4ffffffffffa233) + EXT( 0xa5a5a5a5a5a5a232, 15, 43, 0x0000034b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a232, 15, 43, 0x0000034b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a232, 4398046511103, 15, 43, 0xa5ffffffffffa232) + EXT( 0xa5a5a5a5a5a5a231, 15, 44, 0xfffffb4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a231, 15, 44, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a231, 8796093022207, 15, 44, 0xa3ffffffffffa231) + EXT( 0xa5a5a5a5a5a5a230, 15, 45, 0x00000b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a230, 15, 45, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a230, 17592186044415, 15, 45, 0xa7ffffffffffa230) + EXT( 0xa5a5a5a5a5a5a22f, 15, 46, 0x00000b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a22f, 15, 46, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a22f, 35184372088831, 15, 46, 0xafffffffffffa22f) + EXT( 0xa5a5a5a5a5a5a22e, 15, 47, 0xffffcb4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a22e, 15, 47, 0x00004b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a22e, 70368744177663, 15, 47, 0x9fffffffffffa22e) + EXT( 0xa5a5a5a5a5a5a22d, 15, 48, 0x00004b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a22d, 15, 48, 0x00004b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a22d, 140737488355327, 15, 48, 0xbfffffffffffa22d) + EXT( 0xa5a5a5a5a5a5a22c, 16, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a22c, 16, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a22c, 0, 16, 1, 0xa5a5a5a5a5a4a22c) + EXT( 0xa5a5a5a5a5a5a22b, 16, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a22b, 16, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a22b, 1, 16, 2, 0xa5a5a5a5a5a5a22b) + EXT( 0xa5a5a5a5a5a5a22a, 16, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a22a, 16, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a22a, 3, 16, 3, 0xa5a5a5a5a5a3a22a) + EXT( 0xa5a5a5a5a5a5a229, 16, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a229, 16, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a229, 7, 16, 4, 0xa5a5a5a5a5a7a229) + EXT( 0xa5a5a5a5a5a5a228, 16, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a228, 16, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a228, 15, 16, 5, 0xa5a5a5a5a5afa228) + EXT( 0xa5a5a5a5a5a5a227, 16, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a227, 16, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a227, 31, 16, 6, 0xa5a5a5a5a59fa227) + EXT( 0xa5a5a5a5a5a5a226, 16, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a226, 16, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a226, 63, 16, 7, 0xa5a5a5a5a5bfa226) + EXT( 0xa5a5a5a5a5a5a225, 16, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a225, 16, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a225, 127, 16, 8, 0xa5a5a5a5a57fa225) + EXT( 0xa5a5a5a5a5a5a224, 16, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a224, 16, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a224, 255, 16, 9, 0xa5a5a5a5a4ffa224) + EXT( 0xa5a5a5a5a5a5a223, 16, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a5a223, 16, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a223, 511, 16, 10, 0xa5a5a5a5a5ffa223) + EXT( 0xa5a5a5a5a5a5a222, 16, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a222, 16, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a222, 1023, 16, 11, 0xa5a5a5a5a3ffa222) + EXT( 0xa5a5a5a5a5a5a221, 16, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a221, 16, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a221, 2047, 16, 12, 0xa5a5a5a5a7ffa221) + EXT( 0xa5a5a5a5a5a5a220, 16, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a220, 16, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a220, 4095, 16, 13, 0xa5a5a5a5afffa220) + EXT( 0xa5a5a5a5a5a5a21f, 16, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a21f, 16, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a21f, 8191, 16, 14, 0xa5a5a5a59fffa21f) + EXT( 0xa5a5a5a5a5a5a21e, 16, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a21e, 16, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a21e, 16383, 16, 15, 0xa5a5a5a5bfffa21e) + EXT( 0xa5a5a5a5a5a5a21d, 16, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a21d, 16, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a21d, 32767, 16, 16, 0xa5a5a5a57fffa21d) + EXT( 0xa5a5a5a5a5a5a21c, 16, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a21c, 16, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a21c, 65535, 16, 17, 0xa5a5a5a4ffffa21c) + EXT( 0xa5a5a5a5a5a5a21b, 16, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a5a21b, 16, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a21b, 131071, 16, 18, 0xa5a5a5a5ffffa21b) + EXT( 0xa5a5a5a5a5a5a21a, 16, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a21a, 16, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a21a, 262143, 16, 19, 0xa5a5a5a3ffffa21a) + EXT( 0xa5a5a5a5a5a5a219, 16, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a219, 16, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a219, 524287, 16, 20, 0xa5a5a5a7ffffa219) + EXT( 0xa5a5a5a5a5a5a218, 16, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a218, 16, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a218, 1048575, 16, 21, 0xa5a5a5afffffa218) + EXT( 0xa5a5a5a5a5a5a217, 16, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a217, 16, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a217, 2097151, 16, 22, 0xa5a5a59fffffa217) + EXT( 0xa5a5a5a5a5a5a216, 16, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a216, 16, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a216, 4194303, 16, 23, 0xa5a5a5bfffffa216) + EXT( 0xa5a5a5a5a5a5a215, 16, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a215, 16, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a215, 8388607, 16, 24, 0xa5a5a57fffffa215) + EXT( 0xa5a5a5a5a5a5a214, 16, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a214, 16, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a214, 16777215, 16, 25, 0xa5a5a4ffffffa214) + EXT( 0xa5a5a5a5a5a5a213, 16, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a5a213, 16, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a213, 33554431, 16, 26, 0xa5a5a5ffffffa213) + EXT( 0xa5a5a5a5a5a5a212, 16, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a5a212, 16, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a212, 67108863, 16, 27, 0xa5a5a3ffffffa212) + EXT( 0xa5a5a5a5a5a5a211, 16, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a211, 16, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a211, 134217727, 16, 28, 0xa5a5a7ffffffa211) + EXT( 0xa5a5a5a5a5a5a210, 16, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a210, 16, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a210, 268435455, 16, 29, 0xa5a5afffffffa210) + EXT( 0xa5a5a5a5a5a5a20f, 16, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20f, 16, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a20f, 536870911, 16, 30, 0xa5a59fffffffa20f) + EXT( 0xa5a5a5a5a5a5a20e, 16, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a5a20e, 16, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a20e, 1073741823, 16, 31, 0xa5a5bfffffffa20e) + EXT( 0xa5a5a5a5a5a5a20d, 16, 32, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20d, 16, 32, 0x00000000a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a20d, 2147483647, 16, 32, 0xa5a57fffffffa20d) + EXT( 0xa5a5a5a5a5a5a20c, 16, 33, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20c, 16, 33, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a20c, 4294967295, 16, 33, 0xa5a4ffffffffa20c) + EXT( 0xa5a5a5a5a5a5a20b, 16, 34, 0x00000001a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20b, 16, 34, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a20b, 8589934591, 16, 34, 0xa5a5ffffffffa20b) + EXT( 0xa5a5a5a5a5a5a20a, 16, 35, 0xfffffffda5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20a, 16, 35, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a20a, 17179869183, 16, 35, 0xa5a3ffffffffa20a) + EXT( 0xa5a5a5a5a5a5a209, 16, 36, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a209, 16, 36, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a209, 34359738367, 16, 36, 0xa5a7ffffffffa209) + EXT( 0xa5a5a5a5a5a5a208, 16, 37, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a208, 16, 37, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a208, 68719476735, 16, 37, 0xa5afffffffffa208) + EXT( 0xa5a5a5a5a5a5a207, 16, 38, 0xffffffe5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a207, 16, 38, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a207, 137438953471, 16, 38, 0xa59fffffffffa207) + EXT( 0xa5a5a5a5a5a5a206, 16, 39, 0x00000025a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a206, 16, 39, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a206, 274877906943, 16, 39, 0xa5bfffffffffa206) + EXT( 0xa5a5a5a5a5a5a205, 16, 40, 0xffffffa5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a205, 16, 40, 0x000000a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a205, 549755813887, 16, 40, 0xa57fffffffffa205) + EXT( 0xa5a5a5a5a5a5a204, 16, 41, 0xffffffa5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a204, 16, 41, 0x000001a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a204, 1099511627775, 16, 41, 0xa4ffffffffffa204) + EXT( 0xa5a5a5a5a5a5a203, 16, 42, 0x000001a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a203, 16, 42, 0x000001a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a203, 2199023255551, 16, 42, 0xa5ffffffffffa203) + EXT( 0xa5a5a5a5a5a5a202, 16, 43, 0xfffffda5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a202, 16, 43, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a202, 4398046511103, 16, 43, 0xa3ffffffffffa202) + EXT( 0xa5a5a5a5a5a5a201, 16, 44, 0x000005a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a201, 16, 44, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a201, 8796093022207, 16, 44, 0xa7ffffffffffa201) + EXT( 0xa5a5a5a5a5a5a200, 16, 45, 0x000005a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a200, 16, 45, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a200, 17592186044415, 16, 45, 0xafffffffffffa200) + EXT( 0xa5a5a5a5a5a5a1ff, 16, 46, 0xffffe5a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a1ff, 16, 46, 0x000025a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a1ff, 35184372088831, 16, 46, 0x9fffffffffffa1ff) + EXT( 0xa5a5a5a5a5a5a1fe, 16, 47, 0x000025a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a1fe, 16, 47, 0x000025a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a1fe, 70368744177663, 16, 47, 0xbfffffffffffa1fe) + EXT( 0xa5a5a5a5a5a5a1fd, 17, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1fd, 17, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1fd, 0, 17, 1, 0xa5a5a5a5a5a5a1fd) + EXT( 0xa5a5a5a5a5a5a1fc, 17, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a1fc, 17, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a1fc, 1, 17, 2, 0xa5a5a5a5a5a3a1fc) + EXT( 0xa5a5a5a5a5a5a1fb, 17, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a1fb, 17, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a1fb, 3, 17, 3, 0xa5a5a5a5a5a7a1fb) + EXT( 0xa5a5a5a5a5a5a1fa, 17, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a1fa, 17, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a1fa, 7, 17, 4, 0xa5a5a5a5a5afa1fa) + EXT( 0xa5a5a5a5a5a5a1f9, 17, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a1f9, 17, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a1f9, 15, 17, 5, 0xa5a5a5a5a59fa1f9) + EXT( 0xa5a5a5a5a5a5a1f8, 17, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a1f8, 17, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a1f8, 31, 17, 6, 0xa5a5a5a5a5bfa1f8) + EXT( 0xa5a5a5a5a5a5a1f7, 17, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a1f7, 17, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a1f7, 63, 17, 7, 0xa5a5a5a5a57fa1f7) + EXT( 0xa5a5a5a5a5a5a1f6, 17, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a1f6, 17, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a1f6, 127, 17, 8, 0xa5a5a5a5a4ffa1f6) + EXT( 0xa5a5a5a5a5a5a1f5, 17, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a5a1f5, 17, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a1f5, 255, 17, 9, 0xa5a5a5a5a5ffa1f5) + EXT( 0xa5a5a5a5a5a5a1f4, 17, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a1f4, 17, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a1f4, 511, 17, 10, 0xa5a5a5a5a3ffa1f4) + EXT( 0xa5a5a5a5a5a5a1f3, 17, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a1f3, 17, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a1f3, 1023, 17, 11, 0xa5a5a5a5a7ffa1f3) + EXT( 0xa5a5a5a5a5a5a1f2, 17, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a1f2, 17, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a1f2, 2047, 17, 12, 0xa5a5a5a5afffa1f2) + EXT( 0xa5a5a5a5a5a5a1f1, 17, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a1f1, 17, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a1f1, 4095, 17, 13, 0xa5a5a5a59fffa1f1) + EXT( 0xa5a5a5a5a5a5a1f0, 17, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a1f0, 17, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a1f0, 8191, 17, 14, 0xa5a5a5a5bfffa1f0) + EXT( 0xa5a5a5a5a5a5a1ef, 17, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a1ef, 17, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a1ef, 16383, 17, 15, 0xa5a5a5a57fffa1ef) + EXT( 0xa5a5a5a5a5a5a1ee, 17, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a1ee, 17, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a1ee, 32767, 17, 16, 0xa5a5a5a4ffffa1ee) + EXT( 0xa5a5a5a5a5a5a1ed, 17, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a5a1ed, 17, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a1ed, 65535, 17, 17, 0xa5a5a5a5ffffa1ed) + EXT( 0xa5a5a5a5a5a5a1ec, 17, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a1ec, 17, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a1ec, 131071, 17, 18, 0xa5a5a5a3ffffa1ec) + EXT( 0xa5a5a5a5a5a5a1eb, 17, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a1eb, 17, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a1eb, 262143, 17, 19, 0xa5a5a5a7ffffa1eb) + EXT( 0xa5a5a5a5a5a5a1ea, 17, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a1ea, 17, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a1ea, 524287, 17, 20, 0xa5a5a5afffffa1ea) + EXT( 0xa5a5a5a5a5a5a1e9, 17, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a1e9, 17, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a1e9, 1048575, 17, 21, 0xa5a5a59fffffa1e9) + EXT( 0xa5a5a5a5a5a5a1e8, 17, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a1e8, 17, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a1e8, 2097151, 17, 22, 0xa5a5a5bfffffa1e8) + EXT( 0xa5a5a5a5a5a5a1e7, 17, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a1e7, 17, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a1e7, 4194303, 17, 23, 0xa5a5a57fffffa1e7) + EXT( 0xa5a5a5a5a5a5a1e6, 17, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a1e6, 17, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e6, 8388607, 17, 24, 0xa5a5a4ffffffa1e6) + EXT( 0xa5a5a5a5a5a5a1e5, 17, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e5, 17, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e5, 16777215, 17, 25, 0xa5a5a5ffffffa1e5) + EXT( 0xa5a5a5a5a5a5a1e4, 17, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a5a1e4, 17, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e4, 33554431, 17, 26, 0xa5a5a3ffffffa1e4) + EXT( 0xa5a5a5a5a5a5a1e3, 17, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e3, 17, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e3, 67108863, 17, 27, 0xa5a5a7ffffffa1e3) + EXT( 0xa5a5a5a5a5a5a1e2, 17, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e2, 17, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e2, 134217727, 17, 28, 0xa5a5afffffffa1e2) + EXT( 0xa5a5a5a5a5a5a1e1, 17, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e1, 17, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e1, 268435455, 17, 29, 0xa5a59fffffffa1e1) + EXT( 0xa5a5a5a5a5a5a1e0, 17, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e0, 17, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e0, 536870911, 17, 30, 0xa5a5bfffffffa1e0) + EXT( 0xa5a5a5a5a5a5a1df, 17, 31, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1df, 17, 31, 0x0000000052d2d2d2) + DEP( 0xa5a5a5a5a5a5a1df, 1073741823, 17, 31, 0xa5a57fffffffa1df) + EXT( 0xa5a5a5a5a5a5a1de, 17, 32, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1de, 17, 32, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1de, 2147483647, 17, 32, 0xa5a4ffffffffa1de) + EXT( 0xa5a5a5a5a5a5a1dd, 17, 33, 0x00000000d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1dd, 17, 33, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1dd, 4294967295, 17, 33, 0xa5a5ffffffffa1dd) + EXT( 0xa5a5a5a5a5a5a1dc, 17, 34, 0xfffffffed2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1dc, 17, 34, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1dc, 8589934591, 17, 34, 0xa5a3ffffffffa1dc) + EXT( 0xa5a5a5a5a5a5a1db, 17, 35, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1db, 17, 35, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1db, 17179869183, 17, 35, 0xa5a7ffffffffa1db) + EXT( 0xa5a5a5a5a5a5a1da, 17, 36, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1da, 17, 36, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1da, 34359738367, 17, 36, 0xa5afffffffffa1da) + EXT( 0xa5a5a5a5a5a5a1d9, 17, 37, 0xfffffff2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d9, 17, 37, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d9, 68719476735, 17, 37, 0xa59fffffffffa1d9) + EXT( 0xa5a5a5a5a5a5a1d8, 17, 38, 0x00000012d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d8, 17, 38, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d8, 137438953471, 17, 38, 0xa5bfffffffffa1d8) + EXT( 0xa5a5a5a5a5a5a1d7, 17, 39, 0xffffffd2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d7, 17, 39, 0x00000052d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d7, 274877906943, 17, 39, 0xa57fffffffffa1d7) + EXT( 0xa5a5a5a5a5a5a1d6, 17, 40, 0xffffffd2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d6, 17, 40, 0x000000d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d6, 549755813887, 17, 40, 0xa4ffffffffffa1d6) + EXT( 0xa5a5a5a5a5a5a1d5, 17, 41, 0x000000d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d5, 17, 41, 0x000000d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d5, 1099511627775, 17, 41, 0xa5ffffffffffa1d5) + EXT( 0xa5a5a5a5a5a5a1d4, 17, 42, 0xfffffed2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d4, 17, 42, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d4, 2199023255551, 17, 42, 0xa3ffffffffffa1d4) + EXT( 0xa5a5a5a5a5a5a1d3, 17, 43, 0x000002d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d3, 17, 43, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d3, 4398046511103, 17, 43, 0xa7ffffffffffa1d3) + EXT( 0xa5a5a5a5a5a5a1d2, 17, 44, 0x000002d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d2, 17, 44, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d2, 8796093022207, 17, 44, 0xafffffffffffa1d2) + EXT( 0xa5a5a5a5a5a5a1d1, 17, 45, 0xfffff2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d1, 17, 45, 0x000012d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d1, 17592186044415, 17, 45, 0x9fffffffffffa1d1) + EXT( 0xa5a5a5a5a5a5a1d0, 17, 46, 0x000012d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1d0, 17, 46, 0x000012d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a1d0, 35184372088831, 17, 46, 0xbfffffffffffa1d0) + EXT( 0xa5a5a5a5a5a5a1cf, 18, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a1cf, 18, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1cf, 0, 18, 1, 0xa5a5a5a5a5a1a1cf) + EXT( 0xa5a5a5a5a5a5a1ce, 18, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a1ce, 18, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1ce, 1, 18, 2, 0xa5a5a5a5a5a5a1ce) + EXT( 0xa5a5a5a5a5a5a1cd, 18, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a1cd, 18, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1cd, 3, 18, 3, 0xa5a5a5a5a5ada1cd) + EXT( 0xa5a5a5a5a5a5a1cc, 18, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a1cc, 18, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a1cc, 7, 18, 4, 0xa5a5a5a5a59da1cc) + EXT( 0xa5a5a5a5a5a5a1cb, 18, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a1cb, 18, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a1cb, 15, 18, 5, 0xa5a5a5a5a5bda1cb) + EXT( 0xa5a5a5a5a5a5a1ca, 18, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a1ca, 18, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a1ca, 31, 18, 6, 0xa5a5a5a5a57da1ca) + EXT( 0xa5a5a5a5a5a5a1c9, 18, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a1c9, 18, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a1c9, 63, 18, 7, 0xa5a5a5a5a4fda1c9) + EXT( 0xa5a5a5a5a5a5a1c8, 18, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a5a1c8, 18, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a1c8, 127, 18, 8, 0xa5a5a5a5a5fda1c8) + EXT( 0xa5a5a5a5a5a5a1c7, 18, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a1c7, 18, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a1c7, 255, 18, 9, 0xa5a5a5a5a3fda1c7) + EXT( 0xa5a5a5a5a5a5a1c6, 18, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a1c6, 18, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a1c6, 511, 18, 10, 0xa5a5a5a5a7fda1c6) + EXT( 0xa5a5a5a5a5a5a1c5, 18, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a1c5, 18, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a1c5, 1023, 18, 11, 0xa5a5a5a5affda1c5) + EXT( 0xa5a5a5a5a5a5a1c4, 18, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a1c4, 18, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a1c4, 2047, 18, 12, 0xa5a5a5a59ffda1c4) + EXT( 0xa5a5a5a5a5a5a1c3, 18, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a1c3, 18, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a1c3, 4095, 18, 13, 0xa5a5a5a5bffda1c3) + EXT( 0xa5a5a5a5a5a5a1c2, 18, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a1c2, 18, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a1c2, 8191, 18, 14, 0xa5a5a5a57ffda1c2) + EXT( 0xa5a5a5a5a5a5a1c1, 18, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a1c1, 18, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a1c1, 16383, 18, 15, 0xa5a5a5a4fffda1c1) + EXT( 0xa5a5a5a5a5a5a1c0, 18, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a5a1c0, 18, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a1c0, 32767, 18, 16, 0xa5a5a5a5fffda1c0) + EXT( 0xa5a5a5a5a5a5a1bf, 18, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a1bf, 18, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a1bf, 65535, 18, 17, 0xa5a5a5a3fffda1bf) + EXT( 0xa5a5a5a5a5a5a1be, 18, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a1be, 18, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a1be, 131071, 18, 18, 0xa5a5a5a7fffda1be) + EXT( 0xa5a5a5a5a5a5a1bd, 18, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a1bd, 18, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a1bd, 262143, 18, 19, 0xa5a5a5affffda1bd) + EXT( 0xa5a5a5a5a5a5a1bc, 18, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a1bc, 18, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a1bc, 524287, 18, 20, 0xa5a5a59ffffda1bc) + EXT( 0xa5a5a5a5a5a5a1bb, 18, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a1bb, 18, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a1bb, 1048575, 18, 21, 0xa5a5a5bffffda1bb) + EXT( 0xa5a5a5a5a5a5a1ba, 18, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a1ba, 18, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a1ba, 2097151, 18, 22, 0xa5a5a57ffffda1ba) + EXT( 0xa5a5a5a5a5a5a1b9, 18, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a1b9, 18, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a1b9, 4194303, 18, 23, 0xa5a5a4fffffda1b9) + EXT( 0xa5a5a5a5a5a5a1b8, 18, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a5a1b8, 18, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a1b8, 8388607, 18, 24, 0xa5a5a5fffffda1b8) + EXT( 0xa5a5a5a5a5a5a1b7, 18, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a5a1b7, 18, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a1b7, 16777215, 18, 25, 0xa5a5a3fffffda1b7) + EXT( 0xa5a5a5a5a5a5a1b6, 18, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a1b6, 18, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a1b6, 33554431, 18, 26, 0xa5a5a7fffffda1b6) + EXT( 0xa5a5a5a5a5a5a1b5, 18, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a1b5, 18, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a1b5, 67108863, 18, 27, 0xa5a5affffffda1b5) + EXT( 0xa5a5a5a5a5a5a1b4, 18, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a5a1b4, 18, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a1b4, 134217727, 18, 28, 0xa5a59ffffffda1b4) + EXT( 0xa5a5a5a5a5a5a1b3, 18, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a5a1b3, 18, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a1b3, 268435455, 18, 29, 0xa5a5bffffffda1b3) + EXT( 0xa5a5a5a5a5a5a1b2, 18, 30, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a1b2, 18, 30, 0x0000000029696969) + DEP( 0xa5a5a5a5a5a5a1b2, 536870911, 18, 30, 0xa5a57ffffffda1b2) + EXT( 0xa5a5a5a5a5a5a1b1, 18, 31, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a1b1, 18, 31, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a1b1, 1073741823, 18, 31, 0xa5a4fffffffda1b1) + EXT( 0xa5a5a5a5a5a5a1b0, 18, 32, 0x0000000069696969) + EXTU(0xa5a5a5a5a5a5a1b0, 18, 32, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a1b0, 2147483647, 18, 32, 0xa5a5fffffffda1b0) + EXT( 0xa5a5a5a5a5a5a1af, 18, 33, 0xffffffff69696969) + EXTU(0xa5a5a5a5a5a5a1af, 18, 33, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a1af, 4294967295, 18, 33, 0xa5a3fffffffda1af) + EXT( 0xa5a5a5a5a5a5a1ae, 18, 34, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a1ae, 18, 34, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a1ae, 8589934591, 18, 34, 0xa5a7fffffffda1ae) + EXT( 0xa5a5a5a5a5a5a1ad, 18, 35, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a1ad, 18, 35, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a1ad, 17179869183, 18, 35, 0xa5affffffffda1ad) + EXT( 0xa5a5a5a5a5a5a1ac, 18, 36, 0xfffffff969696969) + EXTU(0xa5a5a5a5a5a5a1ac, 18, 36, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a1ac, 34359738367, 18, 36, 0xa59ffffffffda1ac) + EXT( 0xa5a5a5a5a5a5a1ab, 18, 37, 0x0000000969696969) + EXTU(0xa5a5a5a5a5a5a1ab, 18, 37, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a1ab, 68719476735, 18, 37, 0xa5bffffffffda1ab) + EXT( 0xa5a5a5a5a5a5a1aa, 18, 38, 0xffffffe969696969) + EXTU(0xa5a5a5a5a5a5a1aa, 18, 38, 0x0000002969696969) + DEP( 0xa5a5a5a5a5a5a1aa, 137438953471, 18, 38, 0xa57ffffffffda1aa) + EXT( 0xa5a5a5a5a5a5a1a9, 18, 39, 0xffffffe969696969) + EXTU(0xa5a5a5a5a5a5a1a9, 18, 39, 0x0000006969696969) + DEP( 0xa5a5a5a5a5a5a1a9, 274877906943, 18, 39, 0xa4fffffffffda1a9) + EXT( 0xa5a5a5a5a5a5a1a8, 18, 40, 0x0000006969696969) + EXTU(0xa5a5a5a5a5a5a1a8, 18, 40, 0x0000006969696969) + DEP( 0xa5a5a5a5a5a5a1a8, 549755813887, 18, 40, 0xa5fffffffffda1a8) + EXT( 0xa5a5a5a5a5a5a1a7, 18, 41, 0xffffff6969696969) + EXTU(0xa5a5a5a5a5a5a1a7, 18, 41, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a1a7, 1099511627775, 18, 41, 0xa3fffffffffda1a7) + EXT( 0xa5a5a5a5a5a5a1a6, 18, 42, 0x0000016969696969) + EXTU(0xa5a5a5a5a5a5a1a6, 18, 42, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a1a6, 2199023255551, 18, 42, 0xa7fffffffffda1a6) + EXT( 0xa5a5a5a5a5a5a1a5, 18, 43, 0x0000016969696969) + EXTU(0xa5a5a5a5a5a5a1a5, 18, 43, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a1a5, 4398046511103, 18, 43, 0xaffffffffffda1a5) + EXT( 0xa5a5a5a5a5a5a1a4, 18, 44, 0xfffff96969696969) + EXTU(0xa5a5a5a5a5a5a1a4, 18, 44, 0x0000096969696969) + DEP( 0xa5a5a5a5a5a5a1a4, 8796093022207, 18, 44, 0x9ffffffffffda1a4) + EXT( 0xa5a5a5a5a5a5a1a3, 18, 45, 0x0000096969696969) + EXTU(0xa5a5a5a5a5a5a1a3, 18, 45, 0x0000096969696969) + DEP( 0xa5a5a5a5a5a5a1a3, 17592186044415, 18, 45, 0xbffffffffffda1a3) + EXT( 0xa5a5a5a5a5a5a1a2, 19, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1a2, 19, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1a2, 0, 19, 1, 0xa5a5a5a5a5a5a1a2) + EXT( 0xa5a5a5a5a5a5a1a1, 19, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1a1, 19, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1a1, 1, 19, 2, 0xa5a5a5a5a5ada1a1) + EXT( 0xa5a5a5a5a5a5a1a0, 19, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a1a0, 19, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a1a0, 3, 19, 3, 0xa5a5a5a5a59da1a0) + EXT( 0xa5a5a5a5a5a5a19f, 19, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a19f, 19, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a19f, 7, 19, 4, 0xa5a5a5a5a5bda19f) + EXT( 0xa5a5a5a5a5a5a19e, 19, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a19e, 19, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a19e, 15, 19, 5, 0xa5a5a5a5a57da19e) + EXT( 0xa5a5a5a5a5a5a19d, 19, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a19d, 19, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a19d, 31, 19, 6, 0xa5a5a5a5a4fda19d) + EXT( 0xa5a5a5a5a5a5a19c, 19, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a19c, 19, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a19c, 63, 19, 7, 0xa5a5a5a5a5fda19c) + EXT( 0xa5a5a5a5a5a5a19b, 19, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a19b, 19, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a19b, 127, 19, 8, 0xa5a5a5a5a3fda19b) + EXT( 0xa5a5a5a5a5a5a19a, 19, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a19a, 19, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a19a, 255, 19, 9, 0xa5a5a5a5a7fda19a) + EXT( 0xa5a5a5a5a5a5a199, 19, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a199, 19, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a199, 511, 19, 10, 0xa5a5a5a5affda199) + EXT( 0xa5a5a5a5a5a5a198, 19, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a198, 19, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a198, 1023, 19, 11, 0xa5a5a5a59ffda198) + EXT( 0xa5a5a5a5a5a5a197, 19, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a197, 19, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a197, 2047, 19, 12, 0xa5a5a5a5bffda197) + EXT( 0xa5a5a5a5a5a5a196, 19, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a196, 19, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a196, 4095, 19, 13, 0xa5a5a5a57ffda196) + EXT( 0xa5a5a5a5a5a5a195, 19, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a195, 19, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a195, 8191, 19, 14, 0xa5a5a5a4fffda195) + EXT( 0xa5a5a5a5a5a5a194, 19, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a194, 19, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a194, 16383, 19, 15, 0xa5a5a5a5fffda194) + EXT( 0xa5a5a5a5a5a5a193, 19, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a193, 19, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a193, 32767, 19, 16, 0xa5a5a5a3fffda193) + EXT( 0xa5a5a5a5a5a5a192, 19, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a192, 19, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a192, 65535, 19, 17, 0xa5a5a5a7fffda192) + EXT( 0xa5a5a5a5a5a5a191, 19, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a191, 19, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a191, 131071, 19, 18, 0xa5a5a5affffda191) + EXT( 0xa5a5a5a5a5a5a190, 19, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a190, 19, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a190, 262143, 19, 19, 0xa5a5a59ffffda190) + EXT( 0xa5a5a5a5a5a5a18f, 19, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a18f, 19, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a18f, 524287, 19, 20, 0xa5a5a5bffffda18f) + EXT( 0xa5a5a5a5a5a5a18e, 19, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a18e, 19, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a18e, 1048575, 19, 21, 0xa5a5a57ffffda18e) + EXT( 0xa5a5a5a5a5a5a18d, 19, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a18d, 19, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a18d, 2097151, 19, 22, 0xa5a5a4fffffda18d) + EXT( 0xa5a5a5a5a5a5a18c, 19, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a18c, 19, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a18c, 4194303, 19, 23, 0xa5a5a5fffffda18c) + EXT( 0xa5a5a5a5a5a5a18b, 19, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a18b, 19, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a18b, 8388607, 19, 24, 0xa5a5a3fffffda18b) + EXT( 0xa5a5a5a5a5a5a18a, 19, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a18a, 19, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a18a, 16777215, 19, 25, 0xa5a5a7fffffda18a) + EXT( 0xa5a5a5a5a5a5a189, 19, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a189, 19, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a189, 33554431, 19, 26, 0xa5a5affffffda189) + EXT( 0xa5a5a5a5a5a5a188, 19, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a188, 19, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a188, 67108863, 19, 27, 0xa5a59ffffffda188) + EXT( 0xa5a5a5a5a5a5a187, 19, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a187, 19, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a187, 134217727, 19, 28, 0xa5a5bffffffda187) + EXT( 0xa5a5a5a5a5a5a186, 19, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a186, 19, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a186, 268435455, 19, 29, 0xa5a57ffffffda186) + EXT( 0xa5a5a5a5a5a5a185, 19, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a185, 19, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a185, 536870911, 19, 30, 0xa5a4fffffffda185) + EXT( 0xa5a5a5a5a5a5a184, 19, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a184, 19, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a184, 1073741823, 19, 31, 0xa5a5fffffffda184) + EXT( 0xa5a5a5a5a5a5a183, 19, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a183, 19, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a183, 2147483647, 19, 32, 0xa5a3fffffffda183) + EXT( 0xa5a5a5a5a5a5a182, 19, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a182, 19, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a182, 4294967295, 19, 33, 0xa5a7fffffffda182) + EXT( 0xa5a5a5a5a5a5a181, 19, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a181, 19, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a181, 8589934591, 19, 34, 0xa5affffffffda181) + EXT( 0xa5a5a5a5a5a5a180, 19, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a180, 19, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a180, 17179869183, 19, 35, 0xa59ffffffffda180) + EXT( 0xa5a5a5a5a5a5a17f, 19, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17f, 19, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17f, 34359738367, 19, 36, 0xa5bffffffffda17f) + EXT( 0xa5a5a5a5a5a5a17e, 19, 37, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17e, 19, 37, 0x00000014b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17e, 68719476735, 19, 37, 0xa57ffffffffda17e) + EXT( 0xa5a5a5a5a5a5a17d, 19, 38, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17d, 19, 38, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17d, 137438953471, 19, 38, 0xa4fffffffffda17d) + EXT( 0xa5a5a5a5a5a5a17c, 19, 39, 0x00000034b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17c, 19, 39, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17c, 274877906943, 19, 39, 0xa5fffffffffda17c) + EXT( 0xa5a5a5a5a5a5a17b, 19, 40, 0xffffffb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17b, 19, 40, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17b, 549755813887, 19, 40, 0xa3fffffffffda17b) + EXT( 0xa5a5a5a5a5a5a17a, 19, 41, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a17a, 19, 41, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a17a, 1099511627775, 19, 41, 0xa7fffffffffda17a) + EXT( 0xa5a5a5a5a5a5a179, 19, 42, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a179, 19, 42, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a179, 2199023255551, 19, 42, 0xaffffffffffda179) + EXT( 0xa5a5a5a5a5a5a178, 19, 43, 0xfffffcb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a178, 19, 43, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a178, 4398046511103, 19, 43, 0x9ffffffffffda178) + EXT( 0xa5a5a5a5a5a5a177, 19, 44, 0x000004b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a177, 19, 44, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a177, 8796093022207, 19, 44, 0xbffffffffffda177) + EXT( 0xa5a5a5a5a5a5a176, 20, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a176, 20, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a176, 0, 20, 1, 0xa5a5a5a5a5a5a176) + EXT( 0xa5a5a5a5a5a5a175, 20, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a175, 20, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a175, 1, 20, 2, 0xa5a5a5a5a595a175) + EXT( 0xa5a5a5a5a5a5a174, 20, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a174, 20, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a174, 3, 20, 3, 0xa5a5a5a5a5b5a174) + EXT( 0xa5a5a5a5a5a5a173, 20, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a173, 20, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a173, 7, 20, 4, 0xa5a5a5a5a575a173) + EXT( 0xa5a5a5a5a5a5a172, 20, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a172, 20, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a172, 15, 20, 5, 0xa5a5a5a5a4f5a172) + EXT( 0xa5a5a5a5a5a5a171, 20, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a171, 20, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a171, 31, 20, 6, 0xa5a5a5a5a5f5a171) + EXT( 0xa5a5a5a5a5a5a170, 20, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a170, 20, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a170, 63, 20, 7, 0xa5a5a5a5a3f5a170) + EXT( 0xa5a5a5a5a5a5a16f, 20, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a16f, 20, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a16f, 127, 20, 8, 0xa5a5a5a5a7f5a16f) + EXT( 0xa5a5a5a5a5a5a16e, 20, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a16e, 20, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a16e, 255, 20, 9, 0xa5a5a5a5aff5a16e) + EXT( 0xa5a5a5a5a5a5a16d, 20, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a16d, 20, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a16d, 511, 20, 10, 0xa5a5a5a59ff5a16d) + EXT( 0xa5a5a5a5a5a5a16c, 20, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a16c, 20, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a16c, 1023, 20, 11, 0xa5a5a5a5bff5a16c) + EXT( 0xa5a5a5a5a5a5a16b, 20, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a16b, 20, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a16b, 2047, 20, 12, 0xa5a5a5a57ff5a16b) + EXT( 0xa5a5a5a5a5a5a16a, 20, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a16a, 20, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a16a, 4095, 20, 13, 0xa5a5a5a4fff5a16a) + EXT( 0xa5a5a5a5a5a5a169, 20, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a169, 20, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a169, 8191, 20, 14, 0xa5a5a5a5fff5a169) + EXT( 0xa5a5a5a5a5a5a168, 20, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a168, 20, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a168, 16383, 20, 15, 0xa5a5a5a3fff5a168) + EXT( 0xa5a5a5a5a5a5a167, 20, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a167, 20, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a167, 32767, 20, 16, 0xa5a5a5a7fff5a167) + EXT( 0xa5a5a5a5a5a5a166, 20, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a166, 20, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a166, 65535, 20, 17, 0xa5a5a5affff5a166) + EXT( 0xa5a5a5a5a5a5a165, 20, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a165, 20, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a165, 131071, 20, 18, 0xa5a5a59ffff5a165) + EXT( 0xa5a5a5a5a5a5a164, 20, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a164, 20, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a164, 262143, 20, 19, 0xa5a5a5bffff5a164) + EXT( 0xa5a5a5a5a5a5a163, 20, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a163, 20, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a163, 524287, 20, 20, 0xa5a5a57ffff5a163) + EXT( 0xa5a5a5a5a5a5a162, 20, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a162, 20, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a162, 1048575, 20, 21, 0xa5a5a4fffff5a162) + EXT( 0xa5a5a5a5a5a5a161, 20, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a161, 20, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a161, 2097151, 20, 22, 0xa5a5a5fffff5a161) + EXT( 0xa5a5a5a5a5a5a160, 20, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a160, 20, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a160, 4194303, 20, 23, 0xa5a5a3fffff5a160) + EXT( 0xa5a5a5a5a5a5a15f, 20, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a15f, 20, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a15f, 8388607, 20, 24, 0xa5a5a7fffff5a15f) + EXT( 0xa5a5a5a5a5a5a15e, 20, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a15e, 20, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a15e, 16777215, 20, 25, 0xa5a5affffff5a15e) + EXT( 0xa5a5a5a5a5a5a15d, 20, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a15d, 20, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a15d, 33554431, 20, 26, 0xa5a59ffffff5a15d) + EXT( 0xa5a5a5a5a5a5a15c, 20, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a15c, 20, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a15c, 67108863, 20, 27, 0xa5a5bffffff5a15c) + EXT( 0xa5a5a5a5a5a5a15b, 20, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a15b, 20, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a15b, 134217727, 20, 28, 0xa5a57ffffff5a15b) + EXT( 0xa5a5a5a5a5a5a15a, 20, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a15a, 20, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a15a, 268435455, 20, 29, 0xa5a4fffffff5a15a) + EXT( 0xa5a5a5a5a5a5a159, 20, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a159, 20, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a159, 536870911, 20, 30, 0xa5a5fffffff5a159) + EXT( 0xa5a5a5a5a5a5a158, 20, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a158, 20, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a158, 1073741823, 20, 31, 0xa5a3fffffff5a158) + EXT( 0xa5a5a5a5a5a5a157, 20, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a157, 20, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a157, 2147483647, 20, 32, 0xa5a7fffffff5a157) + EXT( 0xa5a5a5a5a5a5a156, 20, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a156, 20, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a156, 4294967295, 20, 33, 0xa5affffffff5a156) + EXT( 0xa5a5a5a5a5a5a155, 20, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a155, 20, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a155, 8589934591, 20, 34, 0xa59ffffffff5a155) + EXT( 0xa5a5a5a5a5a5a154, 20, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a154, 20, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a154, 17179869183, 20, 35, 0xa5bffffffff5a154) + EXT( 0xa5a5a5a5a5a5a153, 20, 36, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a153, 20, 36, 0x0000000a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a153, 34359738367, 20, 36, 0xa57ffffffff5a153) + EXT( 0xa5a5a5a5a5a5a152, 20, 37, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a152, 20, 37, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a152, 68719476735, 20, 37, 0xa4fffffffff5a152) + EXT( 0xa5a5a5a5a5a5a151, 20, 38, 0x0000001a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a151, 20, 38, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a151, 137438953471, 20, 38, 0xa5fffffffff5a151) + EXT( 0xa5a5a5a5a5a5a150, 20, 39, 0xffffffda5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a150, 20, 39, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a150, 274877906943, 20, 39, 0xa3fffffffff5a150) + EXT( 0xa5a5a5a5a5a5a14f, 20, 40, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a14f, 20, 40, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a14f, 549755813887, 20, 40, 0xa7fffffffff5a14f) + EXT( 0xa5a5a5a5a5a5a14e, 20, 41, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a14e, 20, 41, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a14e, 1099511627775, 20, 41, 0xaffffffffff5a14e) + EXT( 0xa5a5a5a5a5a5a14d, 20, 42, 0xfffffe5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a14d, 20, 42, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a14d, 2199023255551, 20, 42, 0x9ffffffffff5a14d) + EXT( 0xa5a5a5a5a5a5a14c, 20, 43, 0x0000025a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a14c, 20, 43, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a14c, 4398046511103, 20, 43, 0xbffffffffff5a14c) + EXT( 0xa5a5a5a5a5a5a14b, 21, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a14b, 21, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a14b, 0, 21, 1, 0xa5a5a5a5a585a14b) + EXT( 0xa5a5a5a5a5a5a14a, 21, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a14a, 21, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a14a, 1, 21, 2, 0xa5a5a5a5a5a5a14a) + EXT( 0xa5a5a5a5a5a5a149, 21, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a149, 21, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a149, 3, 21, 3, 0xa5a5a5a5a565a149) + EXT( 0xa5a5a5a5a5a5a148, 21, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a148, 21, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a148, 7, 21, 4, 0xa5a5a5a5a4e5a148) + EXT( 0xa5a5a5a5a5a5a147, 21, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a147, 21, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a147, 15, 21, 5, 0xa5a5a5a5a5e5a147) + EXT( 0xa5a5a5a5a5a5a146, 21, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a146, 21, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a146, 31, 21, 6, 0xa5a5a5a5a3e5a146) + EXT( 0xa5a5a5a5a5a5a145, 21, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a145, 21, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a145, 63, 21, 7, 0xa5a5a5a5a7e5a145) + EXT( 0xa5a5a5a5a5a5a144, 21, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a144, 21, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a144, 127, 21, 8, 0xa5a5a5a5afe5a144) + EXT( 0xa5a5a5a5a5a5a143, 21, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a143, 21, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a143, 255, 21, 9, 0xa5a5a5a59fe5a143) + EXT( 0xa5a5a5a5a5a5a142, 21, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a142, 21, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a142, 511, 21, 10, 0xa5a5a5a5bfe5a142) + EXT( 0xa5a5a5a5a5a5a141, 21, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a141, 21, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a141, 1023, 21, 11, 0xa5a5a5a57fe5a141) + EXT( 0xa5a5a5a5a5a5a140, 21, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a140, 21, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a140, 2047, 21, 12, 0xa5a5a5a4ffe5a140) + EXT( 0xa5a5a5a5a5a5a13f, 21, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a13f, 21, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a13f, 4095, 21, 13, 0xa5a5a5a5ffe5a13f) + EXT( 0xa5a5a5a5a5a5a13e, 21, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a13e, 21, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a13e, 8191, 21, 14, 0xa5a5a5a3ffe5a13e) + EXT( 0xa5a5a5a5a5a5a13d, 21, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a13d, 21, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a13d, 16383, 21, 15, 0xa5a5a5a7ffe5a13d) + EXT( 0xa5a5a5a5a5a5a13c, 21, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a13c, 21, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a13c, 32767, 21, 16, 0xa5a5a5afffe5a13c) + EXT( 0xa5a5a5a5a5a5a13b, 21, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a13b, 21, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a13b, 65535, 21, 17, 0xa5a5a59fffe5a13b) + EXT( 0xa5a5a5a5a5a5a13a, 21, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a13a, 21, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a13a, 131071, 21, 18, 0xa5a5a5bfffe5a13a) + EXT( 0xa5a5a5a5a5a5a139, 21, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a139, 21, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a139, 262143, 21, 19, 0xa5a5a57fffe5a139) + EXT( 0xa5a5a5a5a5a5a138, 21, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a138, 21, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a138, 524287, 21, 20, 0xa5a5a4ffffe5a138) + EXT( 0xa5a5a5a5a5a5a137, 21, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a137, 21, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a137, 1048575, 21, 21, 0xa5a5a5ffffe5a137) + EXT( 0xa5a5a5a5a5a5a136, 21, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a136, 21, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a136, 2097151, 21, 22, 0xa5a5a3ffffe5a136) + EXT( 0xa5a5a5a5a5a5a135, 21, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a135, 21, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a135, 4194303, 21, 23, 0xa5a5a7ffffe5a135) + EXT( 0xa5a5a5a5a5a5a134, 21, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a134, 21, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a134, 8388607, 21, 24, 0xa5a5afffffe5a134) + EXT( 0xa5a5a5a5a5a5a133, 21, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a133, 21, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a133, 16777215, 21, 25, 0xa5a59fffffe5a133) + EXT( 0xa5a5a5a5a5a5a132, 21, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a132, 21, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a132, 33554431, 21, 26, 0xa5a5bfffffe5a132) + EXT( 0xa5a5a5a5a5a5a131, 21, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a131, 21, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a131, 67108863, 21, 27, 0xa5a57fffffe5a131) + EXT( 0xa5a5a5a5a5a5a130, 21, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a130, 21, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a130, 134217727, 21, 28, 0xa5a4ffffffe5a130) + EXT( 0xa5a5a5a5a5a5a12f, 21, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a5a12f, 21, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12f, 268435455, 21, 29, 0xa5a5ffffffe5a12f) + EXT( 0xa5a5a5a5a5a5a12e, 21, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a5a12e, 21, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12e, 536870911, 21, 30, 0xa5a3ffffffe5a12e) + EXT( 0xa5a5a5a5a5a5a12d, 21, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a12d, 21, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12d, 1073741823, 21, 31, 0xa5a7ffffffe5a12d) + EXT( 0xa5a5a5a5a5a5a12c, 21, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a12c, 21, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12c, 2147483647, 21, 32, 0xa5afffffffe5a12c) + EXT( 0xa5a5a5a5a5a5a12b, 21, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a12b, 21, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12b, 4294967295, 21, 33, 0xa59fffffffe5a12b) + EXT( 0xa5a5a5a5a5a5a12a, 21, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a5a12a, 21, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12a, 8589934591, 21, 34, 0xa5bfffffffe5a12a) + EXT( 0xa5a5a5a5a5a5a129, 21, 35, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a129, 21, 35, 0x000000052d2d2d2d) + DEP( 0xa5a5a5a5a5a5a129, 17179869183, 21, 35, 0xa57fffffffe5a129) + EXT( 0xa5a5a5a5a5a5a128, 21, 36, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a128, 21, 36, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a128, 34359738367, 21, 36, 0xa4ffffffffe5a128) + EXT( 0xa5a5a5a5a5a5a127, 21, 37, 0x0000000d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a127, 21, 37, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a127, 68719476735, 21, 37, 0xa5ffffffffe5a127) + EXT( 0xa5a5a5a5a5a5a126, 21, 38, 0xffffffed2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a126, 21, 38, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a126, 137438953471, 21, 38, 0xa3ffffffffe5a126) + EXT( 0xa5a5a5a5a5a5a125, 21, 39, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a125, 21, 39, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a125, 274877906943, 21, 39, 0xa7ffffffffe5a125) + EXT( 0xa5a5a5a5a5a5a124, 21, 40, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a124, 21, 40, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a124, 549755813887, 21, 40, 0xafffffffffe5a124) + EXT( 0xa5a5a5a5a5a5a123, 21, 41, 0xffffff2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a123, 21, 41, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a123, 1099511627775, 21, 41, 0x9fffffffffe5a123) + EXT( 0xa5a5a5a5a5a5a122, 21, 42, 0x0000012d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a122, 21, 42, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a122, 2199023255551, 21, 42, 0xbfffffffffe5a122) + EXT( 0xa5a5a5a5a5a5a121, 22, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a121, 22, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a121, 0, 22, 1, 0xa5a5a5a5a5a5a121) + EXT( 0xa5a5a5a5a5a5a120, 22, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a120, 22, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a120, 1, 22, 2, 0xa5a5a5a5a565a120) + EXT( 0xa5a5a5a5a5a5a11f, 22, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a11f, 22, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a11f, 3, 22, 3, 0xa5a5a5a5a4e5a11f) + EXT( 0xa5a5a5a5a5a5a11e, 22, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a5a11e, 22, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a11e, 7, 22, 4, 0xa5a5a5a5a5e5a11e) + EXT( 0xa5a5a5a5a5a5a11d, 22, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a11d, 22, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a11d, 15, 22, 5, 0xa5a5a5a5a3e5a11d) + EXT( 0xa5a5a5a5a5a5a11c, 22, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a11c, 22, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a11c, 31, 22, 6, 0xa5a5a5a5a7e5a11c) + EXT( 0xa5a5a5a5a5a5a11b, 22, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a11b, 22, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a11b, 63, 22, 7, 0xa5a5a5a5afe5a11b) + EXT( 0xa5a5a5a5a5a5a11a, 22, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a11a, 22, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a11a, 127, 22, 8, 0xa5a5a5a59fe5a11a) + EXT( 0xa5a5a5a5a5a5a119, 22, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a119, 22, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a119, 255, 22, 9, 0xa5a5a5a5bfe5a119) + EXT( 0xa5a5a5a5a5a5a118, 22, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a118, 22, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a118, 511, 22, 10, 0xa5a5a5a57fe5a118) + EXT( 0xa5a5a5a5a5a5a117, 22, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a117, 22, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a117, 1023, 22, 11, 0xa5a5a5a4ffe5a117) + EXT( 0xa5a5a5a5a5a5a116, 22, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a5a116, 22, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a116, 2047, 22, 12, 0xa5a5a5a5ffe5a116) + EXT( 0xa5a5a5a5a5a5a115, 22, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a115, 22, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a115, 4095, 22, 13, 0xa5a5a5a3ffe5a115) + EXT( 0xa5a5a5a5a5a5a114, 22, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a114, 22, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a114, 8191, 22, 14, 0xa5a5a5a7ffe5a114) + EXT( 0xa5a5a5a5a5a5a113, 22, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a113, 22, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a113, 16383, 22, 15, 0xa5a5a5afffe5a113) + EXT( 0xa5a5a5a5a5a5a112, 22, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a112, 22, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a112, 32767, 22, 16, 0xa5a5a59fffe5a112) + EXT( 0xa5a5a5a5a5a5a111, 22, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a111, 22, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a111, 65535, 22, 17, 0xa5a5a5bfffe5a111) + EXT( 0xa5a5a5a5a5a5a110, 22, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a110, 22, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a110, 131071, 22, 18, 0xa5a5a57fffe5a110) + EXT( 0xa5a5a5a5a5a5a10f, 22, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a10f, 22, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a10f, 262143, 22, 19, 0xa5a5a4ffffe5a10f) + EXT( 0xa5a5a5a5a5a5a10e, 22, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a5a10e, 22, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a10e, 524287, 22, 20, 0xa5a5a5ffffe5a10e) + EXT( 0xa5a5a5a5a5a5a10d, 22, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a10d, 22, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a10d, 1048575, 22, 21, 0xa5a5a3ffffe5a10d) + EXT( 0xa5a5a5a5a5a5a10c, 22, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a10c, 22, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a10c, 2097151, 22, 22, 0xa5a5a7ffffe5a10c) + EXT( 0xa5a5a5a5a5a5a10b, 22, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a10b, 22, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a10b, 4194303, 22, 23, 0xa5a5afffffe5a10b) + EXT( 0xa5a5a5a5a5a5a10a, 22, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a10a, 22, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a10a, 8388607, 22, 24, 0xa5a59fffffe5a10a) + EXT( 0xa5a5a5a5a5a5a109, 22, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a109, 22, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a109, 16777215, 22, 25, 0xa5a5bfffffe5a109) + EXT( 0xa5a5a5a5a5a5a108, 22, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a108, 22, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a108, 33554431, 22, 26, 0xa5a57fffffe5a108) + EXT( 0xa5a5a5a5a5a5a107, 22, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a107, 22, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a107, 67108863, 22, 27, 0xa5a4ffffffe5a107) + EXT( 0xa5a5a5a5a5a5a106, 22, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a5a106, 22, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a106, 134217727, 22, 28, 0xa5a5ffffffe5a106) + EXT( 0xa5a5a5a5a5a5a105, 22, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a5a105, 22, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a105, 268435455, 22, 29, 0xa5a3ffffffe5a105) + EXT( 0xa5a5a5a5a5a5a104, 22, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a104, 22, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a104, 536870911, 22, 30, 0xa5a7ffffffe5a104) + EXT( 0xa5a5a5a5a5a5a103, 22, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a103, 22, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a103, 1073741823, 22, 31, 0xa5afffffffe5a103) + EXT( 0xa5a5a5a5a5a5a102, 22, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a5a102, 22, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a102, 2147483647, 22, 32, 0xa59fffffffe5a102) + EXT( 0xa5a5a5a5a5a5a101, 22, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a5a101, 22, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a101, 4294967295, 22, 33, 0xa5bfffffffe5a101) + EXT( 0xa5a5a5a5a5a5a100, 22, 34, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a100, 22, 34, 0x0000000296969696) + DEP( 0xa5a5a5a5a5a5a100, 8589934591, 22, 34, 0xa57fffffffe5a100) + EXT( 0xa5a5a5a5a5a5a0ff, 22, 35, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a0ff, 22, 35, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a0ff, 17179869183, 22, 35, 0xa4ffffffffe5a0ff) + EXT( 0xa5a5a5a5a5a5a0fe, 22, 36, 0x0000000696969696) + EXTU(0xa5a5a5a5a5a5a0fe, 22, 36, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a0fe, 34359738367, 22, 36, 0xa5ffffffffe5a0fe) + EXT( 0xa5a5a5a5a5a5a0fd, 22, 37, 0xfffffff696969696) + EXTU(0xa5a5a5a5a5a5a0fd, 22, 37, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a0fd, 68719476735, 22, 37, 0xa3ffffffffe5a0fd) + EXT( 0xa5a5a5a5a5a5a0fc, 22, 38, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a0fc, 22, 38, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a0fc, 137438953471, 22, 38, 0xa7ffffffffe5a0fc) + EXT( 0xa5a5a5a5a5a5a0fb, 22, 39, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a0fb, 22, 39, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a0fb, 274877906943, 22, 39, 0xafffffffffe5a0fb) + EXT( 0xa5a5a5a5a5a5a0fa, 22, 40, 0xffffff9696969696) + EXTU(0xa5a5a5a5a5a5a0fa, 22, 40, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a0fa, 549755813887, 22, 40, 0x9fffffffffe5a0fa) + EXT( 0xa5a5a5a5a5a5a0f9, 22, 41, 0x0000009696969696) + EXTU(0xa5a5a5a5a5a5a0f9, 22, 41, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a0f9, 1099511627775, 22, 41, 0xbfffffffffe5a0f9) + EXT( 0xa5a5a5a5a5a5a0f8, 23, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0f8, 23, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0f8, 0, 23, 1, 0xa5a5a5a5a525a0f8) + EXT( 0xa5a5a5a5a5a5a0f7, 23, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0f7, 23, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a0f7, 1, 23, 2, 0xa5a5a5a5a4a5a0f7) + EXT( 0xa5a5a5a5a5a5a0f6, 23, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a0f6, 23, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a0f6, 3, 23, 3, 0xa5a5a5a5a5a5a0f6) + EXT( 0xa5a5a5a5a5a5a0f5, 23, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a0f5, 23, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a0f5, 7, 23, 4, 0xa5a5a5a5a3a5a0f5) + EXT( 0xa5a5a5a5a5a5a0f4, 23, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a0f4, 23, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a0f4, 15, 23, 5, 0xa5a5a5a5a7a5a0f4) + EXT( 0xa5a5a5a5a5a5a0f3, 23, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a0f3, 23, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a0f3, 31, 23, 6, 0xa5a5a5a5afa5a0f3) + EXT( 0xa5a5a5a5a5a5a0f2, 23, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a0f2, 23, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a0f2, 63, 23, 7, 0xa5a5a5a59fa5a0f2) + EXT( 0xa5a5a5a5a5a5a0f1, 23, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a0f1, 23, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a0f1, 127, 23, 8, 0xa5a5a5a5bfa5a0f1) + EXT( 0xa5a5a5a5a5a5a0f0, 23, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a0f0, 23, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a0f0, 255, 23, 9, 0xa5a5a5a57fa5a0f0) + EXT( 0xa5a5a5a5a5a5a0ef, 23, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a0ef, 23, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a0ef, 511, 23, 10, 0xa5a5a5a4ffa5a0ef) + EXT( 0xa5a5a5a5a5a5a0ee, 23, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a5a0ee, 23, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a0ee, 1023, 23, 11, 0xa5a5a5a5ffa5a0ee) + EXT( 0xa5a5a5a5a5a5a0ed, 23, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a0ed, 23, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a0ed, 2047, 23, 12, 0xa5a5a5a3ffa5a0ed) + EXT( 0xa5a5a5a5a5a5a0ec, 23, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a0ec, 23, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a0ec, 4095, 23, 13, 0xa5a5a5a7ffa5a0ec) + EXT( 0xa5a5a5a5a5a5a0eb, 23, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a0eb, 23, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a0eb, 8191, 23, 14, 0xa5a5a5afffa5a0eb) + EXT( 0xa5a5a5a5a5a5a0ea, 23, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a0ea, 23, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a0ea, 16383, 23, 15, 0xa5a5a59fffa5a0ea) + EXT( 0xa5a5a5a5a5a5a0e9, 23, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a0e9, 23, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a0e9, 32767, 23, 16, 0xa5a5a5bfffa5a0e9) + EXT( 0xa5a5a5a5a5a5a0e8, 23, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a0e8, 23, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a0e8, 65535, 23, 17, 0xa5a5a57fffa5a0e8) + EXT( 0xa5a5a5a5a5a5a0e7, 23, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a0e7, 23, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a0e7, 131071, 23, 18, 0xa5a5a4ffffa5a0e7) + EXT( 0xa5a5a5a5a5a5a0e6, 23, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a5a0e6, 23, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a0e6, 262143, 23, 19, 0xa5a5a5ffffa5a0e6) + EXT( 0xa5a5a5a5a5a5a0e5, 23, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a0e5, 23, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a0e5, 524287, 23, 20, 0xa5a5a3ffffa5a0e5) + EXT( 0xa5a5a5a5a5a5a0e4, 23, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a0e4, 23, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a0e4, 1048575, 23, 21, 0xa5a5a7ffffa5a0e4) + EXT( 0xa5a5a5a5a5a5a0e3, 23, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a0e3, 23, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a0e3, 2097151, 23, 22, 0xa5a5afffffa5a0e3) + EXT( 0xa5a5a5a5a5a5a0e2, 23, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a0e2, 23, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a0e2, 4194303, 23, 23, 0xa5a59fffffa5a0e2) + EXT( 0xa5a5a5a5a5a5a0e1, 23, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a0e1, 23, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a0e1, 8388607, 23, 24, 0xa5a5bfffffa5a0e1) + EXT( 0xa5a5a5a5a5a5a0e0, 23, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a0e0, 23, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a0e0, 16777215, 23, 25, 0xa5a57fffffa5a0e0) + EXT( 0xa5a5a5a5a5a5a0df, 23, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a0df, 23, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a0df, 33554431, 23, 26, 0xa5a4ffffffa5a0df) + EXT( 0xa5a5a5a5a5a5a0de, 23, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a5a0de, 23, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a0de, 67108863, 23, 27, 0xa5a5ffffffa5a0de) + EXT( 0xa5a5a5a5a5a5a0dd, 23, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a5a0dd, 23, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0dd, 134217727, 23, 28, 0xa5a3ffffffa5a0dd) + EXT( 0xa5a5a5a5a5a5a0dc, 23, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0dc, 23, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0dc, 268435455, 23, 29, 0xa5a7ffffffa5a0dc) + EXT( 0xa5a5a5a5a5a5a0db, 23, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0db, 23, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0db, 536870911, 23, 30, 0xa5afffffffa5a0db) + EXT( 0xa5a5a5a5a5a5a0da, 23, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a5a0da, 23, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0da, 1073741823, 23, 31, 0xa59fffffffa5a0da) + EXT( 0xa5a5a5a5a5a5a0d9, 23, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d9, 23, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d9, 2147483647, 23, 32, 0xa5bfffffffa5a0d9) + EXT( 0xa5a5a5a5a5a5a0d8, 23, 33, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d8, 23, 33, 0x000000014b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d8, 4294967295, 23, 33, 0xa57fffffffa5a0d8) + EXT( 0xa5a5a5a5a5a5a0d7, 23, 34, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d7, 23, 34, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d7, 8589934591, 23, 34, 0xa4ffffffffa5a0d7) + EXT( 0xa5a5a5a5a5a5a0d6, 23, 35, 0x000000034b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d6, 23, 35, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d6, 17179869183, 23, 35, 0xa5ffffffffa5a0d6) + EXT( 0xa5a5a5a5a5a5a0d5, 23, 36, 0xfffffffb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d5, 23, 36, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d5, 34359738367, 23, 36, 0xa3ffffffffa5a0d5) + EXT( 0xa5a5a5a5a5a5a0d4, 23, 37, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d4, 23, 37, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d4, 68719476735, 23, 37, 0xa7ffffffffa5a0d4) + EXT( 0xa5a5a5a5a5a5a0d3, 23, 38, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d3, 23, 38, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d3, 137438953471, 23, 38, 0xafffffffffa5a0d3) + EXT( 0xa5a5a5a5a5a5a0d2, 23, 39, 0xffffffcb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d2, 23, 39, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d2, 274877906943, 23, 39, 0x9fffffffffa5a0d2) + EXT( 0xa5a5a5a5a5a5a0d1, 23, 40, 0x0000004b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a0d1, 23, 40, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a0d1, 549755813887, 23, 40, 0xbfffffffffa5a0d1) + EXT( 0xa5a5a5a5a5a5a0d0, 24, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0d0, 24, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0d0, 0, 24, 1, 0xa5a5a5a5a4a5a0d0) + EXT( 0xa5a5a5a5a5a5a0cf, 24, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a0cf, 24, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0cf, 1, 24, 2, 0xa5a5a5a5a5a5a0cf) + EXT( 0xa5a5a5a5a5a5a0ce, 24, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a0ce, 24, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a0ce, 3, 24, 3, 0xa5a5a5a5a3a5a0ce) + EXT( 0xa5a5a5a5a5a5a0cd, 24, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a0cd, 24, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a0cd, 7, 24, 4, 0xa5a5a5a5a7a5a0cd) + EXT( 0xa5a5a5a5a5a5a0cc, 24, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a0cc, 24, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a0cc, 15, 24, 5, 0xa5a5a5a5afa5a0cc) + EXT( 0xa5a5a5a5a5a5a0cb, 24, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a0cb, 24, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a0cb, 31, 24, 6, 0xa5a5a5a59fa5a0cb) + EXT( 0xa5a5a5a5a5a5a0ca, 24, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a0ca, 24, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a0ca, 63, 24, 7, 0xa5a5a5a5bfa5a0ca) + EXT( 0xa5a5a5a5a5a5a0c9, 24, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a0c9, 24, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a0c9, 127, 24, 8, 0xa5a5a5a57fa5a0c9) + EXT( 0xa5a5a5a5a5a5a0c8, 24, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a0c8, 24, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a0c8, 255, 24, 9, 0xa5a5a5a4ffa5a0c8) + EXT( 0xa5a5a5a5a5a5a0c7, 24, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a5a0c7, 24, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a0c7, 511, 24, 10, 0xa5a5a5a5ffa5a0c7) + EXT( 0xa5a5a5a5a5a5a0c6, 24, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a0c6, 24, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a0c6, 1023, 24, 11, 0xa5a5a5a3ffa5a0c6) + EXT( 0xa5a5a5a5a5a5a0c5, 24, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a0c5, 24, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a0c5, 2047, 24, 12, 0xa5a5a5a7ffa5a0c5) + EXT( 0xa5a5a5a5a5a5a0c4, 24, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a0c4, 24, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a0c4, 4095, 24, 13, 0xa5a5a5afffa5a0c4) + EXT( 0xa5a5a5a5a5a5a0c3, 24, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a0c3, 24, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a0c3, 8191, 24, 14, 0xa5a5a59fffa5a0c3) + EXT( 0xa5a5a5a5a5a5a0c2, 24, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a0c2, 24, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a0c2, 16383, 24, 15, 0xa5a5a5bfffa5a0c2) + EXT( 0xa5a5a5a5a5a5a0c1, 24, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a0c1, 24, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a0c1, 32767, 24, 16, 0xa5a5a57fffa5a0c1) + EXT( 0xa5a5a5a5a5a5a0c0, 24, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a0c0, 24, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a0c0, 65535, 24, 17, 0xa5a5a4ffffa5a0c0) + EXT( 0xa5a5a5a5a5a5a0bf, 24, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a5a0bf, 24, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a0bf, 131071, 24, 18, 0xa5a5a5ffffa5a0bf) + EXT( 0xa5a5a5a5a5a5a0be, 24, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a0be, 24, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a0be, 262143, 24, 19, 0xa5a5a3ffffa5a0be) + EXT( 0xa5a5a5a5a5a5a0bd, 24, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a0bd, 24, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a0bd, 524287, 24, 20, 0xa5a5a7ffffa5a0bd) + EXT( 0xa5a5a5a5a5a5a0bc, 24, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a0bc, 24, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a0bc, 1048575, 24, 21, 0xa5a5afffffa5a0bc) + EXT( 0xa5a5a5a5a5a5a0bb, 24, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a0bb, 24, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a0bb, 2097151, 24, 22, 0xa5a59fffffa5a0bb) + EXT( 0xa5a5a5a5a5a5a0ba, 24, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a0ba, 24, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a0ba, 4194303, 24, 23, 0xa5a5bfffffa5a0ba) + EXT( 0xa5a5a5a5a5a5a0b9, 24, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a0b9, 24, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b9, 8388607, 24, 24, 0xa5a57fffffa5a0b9) + EXT( 0xa5a5a5a5a5a5a0b8, 24, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a0b8, 24, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b8, 16777215, 24, 25, 0xa5a4ffffffa5a0b8) + EXT( 0xa5a5a5a5a5a5a0b7, 24, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b7, 24, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b7, 33554431, 24, 26, 0xa5a5ffffffa5a0b7) + EXT( 0xa5a5a5a5a5a5a0b6, 24, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a5a0b6, 24, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b6, 67108863, 24, 27, 0xa5a3ffffffa5a0b6) + EXT( 0xa5a5a5a5a5a5a0b5, 24, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b5, 24, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b5, 134217727, 24, 28, 0xa5a7ffffffa5a0b5) + EXT( 0xa5a5a5a5a5a5a0b4, 24, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b4, 24, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b4, 268435455, 24, 29, 0xa5afffffffa5a0b4) + EXT( 0xa5a5a5a5a5a5a0b3, 24, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b3, 24, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b3, 536870911, 24, 30, 0xa59fffffffa5a0b3) + EXT( 0xa5a5a5a5a5a5a0b2, 24, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b2, 24, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b2, 1073741823, 24, 31, 0xa5bfffffffa5a0b2) + EXT( 0xa5a5a5a5a5a5a0b1, 24, 32, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b1, 24, 32, 0x00000000a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b1, 2147483647, 24, 32, 0xa57fffffffa5a0b1) + EXT( 0xa5a5a5a5a5a5a0b0, 24, 33, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0b0, 24, 33, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b0, 4294967295, 24, 33, 0xa4ffffffffa5a0b0) + EXT( 0xa5a5a5a5a5a5a0af, 24, 34, 0x00000001a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0af, 24, 34, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0af, 8589934591, 24, 34, 0xa5ffffffffa5a0af) + EXT( 0xa5a5a5a5a5a5a0ae, 24, 35, 0xfffffffda5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0ae, 24, 35, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0ae, 17179869183, 24, 35, 0xa3ffffffffa5a0ae) + EXT( 0xa5a5a5a5a5a5a0ad, 24, 36, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0ad, 24, 36, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0ad, 34359738367, 24, 36, 0xa7ffffffffa5a0ad) + EXT( 0xa5a5a5a5a5a5a0ac, 24, 37, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0ac, 24, 37, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0ac, 68719476735, 24, 37, 0xafffffffffa5a0ac) + EXT( 0xa5a5a5a5a5a5a0ab, 24, 38, 0xffffffe5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0ab, 24, 38, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0ab, 137438953471, 24, 38, 0x9fffffffffa5a0ab) + EXT( 0xa5a5a5a5a5a5a0aa, 24, 39, 0x00000025a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a0aa, 24, 39, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a0aa, 274877906943, 24, 39, 0xbfffffffffa5a0aa) + EXT( 0xa5a5a5a5a5a5a0a9, 25, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a0a9, 25, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a0a9, 0, 25, 1, 0xa5a5a5a5a5a5a0a9) + EXT( 0xa5a5a5a5a5a5a0a8, 25, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a0a8, 25, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a0a8, 1, 25, 2, 0xa5a5a5a5a3a5a0a8) + EXT( 0xa5a5a5a5a5a5a0a7, 25, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a0a7, 25, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a0a7, 3, 25, 3, 0xa5a5a5a5a7a5a0a7) + EXT( 0xa5a5a5a5a5a5a0a6, 25, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a0a6, 25, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a0a6, 7, 25, 4, 0xa5a5a5a5afa5a0a6) + EXT( 0xa5a5a5a5a5a5a0a5, 25, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a0a5, 25, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a0a5, 15, 25, 5, 0xa5a5a5a59fa5a0a5) + EXT( 0xa5a5a5a5a5a5a0a4, 25, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a0a4, 25, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a0a4, 31, 25, 6, 0xa5a5a5a5bfa5a0a4) + EXT( 0xa5a5a5a5a5a5a0a3, 25, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a0a3, 25, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a0a3, 63, 25, 7, 0xa5a5a5a57fa5a0a3) + EXT( 0xa5a5a5a5a5a5a0a2, 25, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a0a2, 25, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a0a2, 127, 25, 8, 0xa5a5a5a4ffa5a0a2) + EXT( 0xa5a5a5a5a5a5a0a1, 25, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a5a0a1, 25, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a0a1, 255, 25, 9, 0xa5a5a5a5ffa5a0a1) + EXT( 0xa5a5a5a5a5a5a0a0, 25, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a0a0, 25, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a0a0, 511, 25, 10, 0xa5a5a5a3ffa5a0a0) + EXT( 0xa5a5a5a5a5a5a09f, 25, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a09f, 25, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a09f, 1023, 25, 11, 0xa5a5a5a7ffa5a09f) + EXT( 0xa5a5a5a5a5a5a09e, 25, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a09e, 25, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a09e, 2047, 25, 12, 0xa5a5a5afffa5a09e) + EXT( 0xa5a5a5a5a5a5a09d, 25, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a09d, 25, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a09d, 4095, 25, 13, 0xa5a5a59fffa5a09d) + EXT( 0xa5a5a5a5a5a5a09c, 25, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a09c, 25, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a09c, 8191, 25, 14, 0xa5a5a5bfffa5a09c) + EXT( 0xa5a5a5a5a5a5a09b, 25, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a09b, 25, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a09b, 16383, 25, 15, 0xa5a5a57fffa5a09b) + EXT( 0xa5a5a5a5a5a5a09a, 25, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a09a, 25, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a09a, 32767, 25, 16, 0xa5a5a4ffffa5a09a) + EXT( 0xa5a5a5a5a5a5a099, 25, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a5a099, 25, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a099, 65535, 25, 17, 0xa5a5a5ffffa5a099) + EXT( 0xa5a5a5a5a5a5a098, 25, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a098, 25, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a098, 131071, 25, 18, 0xa5a5a3ffffa5a098) + EXT( 0xa5a5a5a5a5a5a097, 25, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a097, 25, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a097, 262143, 25, 19, 0xa5a5a7ffffa5a097) + EXT( 0xa5a5a5a5a5a5a096, 25, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a096, 25, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a096, 524287, 25, 20, 0xa5a5afffffa5a096) + EXT( 0xa5a5a5a5a5a5a095, 25, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a095, 25, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a095, 1048575, 25, 21, 0xa5a59fffffa5a095) + EXT( 0xa5a5a5a5a5a5a094, 25, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a094, 25, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a094, 2097151, 25, 22, 0xa5a5bfffffa5a094) + EXT( 0xa5a5a5a5a5a5a093, 25, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a093, 25, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a093, 4194303, 25, 23, 0xa5a57fffffa5a093) + EXT( 0xa5a5a5a5a5a5a092, 25, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a092, 25, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a092, 8388607, 25, 24, 0xa5a4ffffffa5a092) + EXT( 0xa5a5a5a5a5a5a091, 25, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a5a091, 25, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a091, 16777215, 25, 25, 0xa5a5ffffffa5a091) + EXT( 0xa5a5a5a5a5a5a090, 25, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a5a090, 25, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a090, 33554431, 25, 26, 0xa5a3ffffffa5a090) + EXT( 0xa5a5a5a5a5a5a08f, 25, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a08f, 25, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a08f, 67108863, 25, 27, 0xa5a7ffffffa5a08f) + EXT( 0xa5a5a5a5a5a5a08e, 25, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a08e, 25, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a08e, 134217727, 25, 28, 0xa5afffffffa5a08e) + EXT( 0xa5a5a5a5a5a5a08d, 25, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a5a08d, 25, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a08d, 268435455, 25, 29, 0xa59fffffffa5a08d) + EXT( 0xa5a5a5a5a5a5a08c, 25, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a5a08c, 25, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a08c, 536870911, 25, 30, 0xa5bfffffffa5a08c) + EXT( 0xa5a5a5a5a5a5a08b, 25, 31, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a08b, 25, 31, 0x0000000052d2d2d2) + DEP( 0xa5a5a5a5a5a5a08b, 1073741823, 25, 31, 0xa57fffffffa5a08b) + EXT( 0xa5a5a5a5a5a5a08a, 25, 32, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a08a, 25, 32, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a08a, 2147483647, 25, 32, 0xa4ffffffffa5a08a) + EXT( 0xa5a5a5a5a5a5a089, 25, 33, 0x00000000d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a089, 25, 33, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a089, 4294967295, 25, 33, 0xa5ffffffffa5a089) + EXT( 0xa5a5a5a5a5a5a088, 25, 34, 0xfffffffed2d2d2d2) + EXTU(0xa5a5a5a5a5a5a088, 25, 34, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a088, 8589934591, 25, 34, 0xa3ffffffffa5a088) + EXT( 0xa5a5a5a5a5a5a087, 25, 35, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a087, 25, 35, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a087, 17179869183, 25, 35, 0xa7ffffffffa5a087) + EXT( 0xa5a5a5a5a5a5a086, 25, 36, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a086, 25, 36, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a086, 34359738367, 25, 36, 0xafffffffffa5a086) + EXT( 0xa5a5a5a5a5a5a085, 25, 37, 0xfffffff2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a085, 25, 37, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a085, 68719476735, 25, 37, 0x9fffffffffa5a085) + EXT( 0xa5a5a5a5a5a5a084, 25, 38, 0x00000012d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a084, 25, 38, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a084, 137438953471, 25, 38, 0xbfffffffffa5a084) + EXT( 0xa5a5a5a5a5a5a083, 26, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a083, 26, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a083, 0, 26, 1, 0xa5a5a5a5a1a5a083) + EXT( 0xa5a5a5a5a5a5a082, 26, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a082, 26, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a082, 1, 26, 2, 0xa5a5a5a5a5a5a082) + EXT( 0xa5a5a5a5a5a5a081, 26, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a081, 26, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a081, 3, 26, 3, 0xa5a5a5a5ada5a081) + EXT( 0xa5a5a5a5a5a5a080, 26, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a080, 26, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a080, 7, 26, 4, 0xa5a5a5a59da5a080) + EXT( 0xa5a5a5a5a5a5a07f, 26, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a07f, 26, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a07f, 15, 26, 5, 0xa5a5a5a5bda5a07f) + EXT( 0xa5a5a5a5a5a5a07e, 26, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a07e, 26, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a07e, 31, 26, 6, 0xa5a5a5a57da5a07e) + EXT( 0xa5a5a5a5a5a5a07d, 26, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a07d, 26, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a07d, 63, 26, 7, 0xa5a5a5a4fda5a07d) + EXT( 0xa5a5a5a5a5a5a07c, 26, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a5a07c, 26, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a07c, 127, 26, 8, 0xa5a5a5a5fda5a07c) + EXT( 0xa5a5a5a5a5a5a07b, 26, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a07b, 26, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a07b, 255, 26, 9, 0xa5a5a5a3fda5a07b) + EXT( 0xa5a5a5a5a5a5a07a, 26, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a07a, 26, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a07a, 511, 26, 10, 0xa5a5a5a7fda5a07a) + EXT( 0xa5a5a5a5a5a5a079, 26, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a079, 26, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a079, 1023, 26, 11, 0xa5a5a5affda5a079) + EXT( 0xa5a5a5a5a5a5a078, 26, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a078, 26, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a078, 2047, 26, 12, 0xa5a5a59ffda5a078) + EXT( 0xa5a5a5a5a5a5a077, 26, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a077, 26, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a077, 4095, 26, 13, 0xa5a5a5bffda5a077) + EXT( 0xa5a5a5a5a5a5a076, 26, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a076, 26, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a076, 8191, 26, 14, 0xa5a5a57ffda5a076) + EXT( 0xa5a5a5a5a5a5a075, 26, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a075, 26, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a075, 16383, 26, 15, 0xa5a5a4fffda5a075) + EXT( 0xa5a5a5a5a5a5a074, 26, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a5a074, 26, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a074, 32767, 26, 16, 0xa5a5a5fffda5a074) + EXT( 0xa5a5a5a5a5a5a073, 26, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a073, 26, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a073, 65535, 26, 17, 0xa5a5a3fffda5a073) + EXT( 0xa5a5a5a5a5a5a072, 26, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a072, 26, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a072, 131071, 26, 18, 0xa5a5a7fffda5a072) + EXT( 0xa5a5a5a5a5a5a071, 26, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a071, 26, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a071, 262143, 26, 19, 0xa5a5affffda5a071) + EXT( 0xa5a5a5a5a5a5a070, 26, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a070, 26, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a070, 524287, 26, 20, 0xa5a59ffffda5a070) + EXT( 0xa5a5a5a5a5a5a06f, 26, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a06f, 26, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a06f, 1048575, 26, 21, 0xa5a5bffffda5a06f) + EXT( 0xa5a5a5a5a5a5a06e, 26, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a06e, 26, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a06e, 2097151, 26, 22, 0xa5a57ffffda5a06e) + EXT( 0xa5a5a5a5a5a5a06d, 26, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a06d, 26, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a06d, 4194303, 26, 23, 0xa5a4fffffda5a06d) + EXT( 0xa5a5a5a5a5a5a06c, 26, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a5a06c, 26, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a06c, 8388607, 26, 24, 0xa5a5fffffda5a06c) + EXT( 0xa5a5a5a5a5a5a06b, 26, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a5a06b, 26, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a06b, 16777215, 26, 25, 0xa5a3fffffda5a06b) + EXT( 0xa5a5a5a5a5a5a06a, 26, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a06a, 26, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a06a, 33554431, 26, 26, 0xa5a7fffffda5a06a) + EXT( 0xa5a5a5a5a5a5a069, 26, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a069, 26, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a069, 67108863, 26, 27, 0xa5affffffda5a069) + EXT( 0xa5a5a5a5a5a5a068, 26, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a5a068, 26, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a068, 134217727, 26, 28, 0xa59ffffffda5a068) + EXT( 0xa5a5a5a5a5a5a067, 26, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a5a067, 26, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a067, 268435455, 26, 29, 0xa5bffffffda5a067) + EXT( 0xa5a5a5a5a5a5a066, 26, 30, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a066, 26, 30, 0x0000000029696969) + DEP( 0xa5a5a5a5a5a5a066, 536870911, 26, 30, 0xa57ffffffda5a066) + EXT( 0xa5a5a5a5a5a5a065, 26, 31, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a065, 26, 31, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a065, 1073741823, 26, 31, 0xa4fffffffda5a065) + EXT( 0xa5a5a5a5a5a5a064, 26, 32, 0x0000000069696969) + EXTU(0xa5a5a5a5a5a5a064, 26, 32, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a064, 2147483647, 26, 32, 0xa5fffffffda5a064) + EXT( 0xa5a5a5a5a5a5a063, 26, 33, 0xffffffff69696969) + EXTU(0xa5a5a5a5a5a5a063, 26, 33, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a063, 4294967295, 26, 33, 0xa3fffffffda5a063) + EXT( 0xa5a5a5a5a5a5a062, 26, 34, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a062, 26, 34, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a062, 8589934591, 26, 34, 0xa7fffffffda5a062) + EXT( 0xa5a5a5a5a5a5a061, 26, 35, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a061, 26, 35, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a061, 17179869183, 26, 35, 0xaffffffffda5a061) + EXT( 0xa5a5a5a5a5a5a060, 26, 36, 0xfffffff969696969) + EXTU(0xa5a5a5a5a5a5a060, 26, 36, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a060, 34359738367, 26, 36, 0x9ffffffffda5a060) + EXT( 0xa5a5a5a5a5a5a05f, 26, 37, 0x0000000969696969) + EXTU(0xa5a5a5a5a5a5a05f, 26, 37, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a05f, 68719476735, 26, 37, 0xbffffffffda5a05f) + EXT( 0xa5a5a5a5a5a5a05e, 27, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a05e, 27, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a05e, 0, 27, 1, 0xa5a5a5a5a5a5a05e) + EXT( 0xa5a5a5a5a5a5a05d, 27, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a05d, 27, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a05d, 1, 27, 2, 0xa5a5a5a5ada5a05d) + EXT( 0xa5a5a5a5a5a5a05c, 27, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a05c, 27, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a05c, 3, 27, 3, 0xa5a5a5a59da5a05c) + EXT( 0xa5a5a5a5a5a5a05b, 27, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a05b, 27, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a05b, 7, 27, 4, 0xa5a5a5a5bda5a05b) + EXT( 0xa5a5a5a5a5a5a05a, 27, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a05a, 27, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a05a, 15, 27, 5, 0xa5a5a5a57da5a05a) + EXT( 0xa5a5a5a5a5a5a059, 27, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a059, 27, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a059, 31, 27, 6, 0xa5a5a5a4fda5a059) + EXT( 0xa5a5a5a5a5a5a058, 27, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a058, 27, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a058, 63, 27, 7, 0xa5a5a5a5fda5a058) + EXT( 0xa5a5a5a5a5a5a057, 27, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a057, 27, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a057, 127, 27, 8, 0xa5a5a5a3fda5a057) + EXT( 0xa5a5a5a5a5a5a056, 27, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a056, 27, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a056, 255, 27, 9, 0xa5a5a5a7fda5a056) + EXT( 0xa5a5a5a5a5a5a055, 27, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a055, 27, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a055, 511, 27, 10, 0xa5a5a5affda5a055) + EXT( 0xa5a5a5a5a5a5a054, 27, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a054, 27, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a054, 1023, 27, 11, 0xa5a5a59ffda5a054) + EXT( 0xa5a5a5a5a5a5a053, 27, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a053, 27, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a053, 2047, 27, 12, 0xa5a5a5bffda5a053) + EXT( 0xa5a5a5a5a5a5a052, 27, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a052, 27, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a052, 4095, 27, 13, 0xa5a5a57ffda5a052) + EXT( 0xa5a5a5a5a5a5a051, 27, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a051, 27, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a051, 8191, 27, 14, 0xa5a5a4fffda5a051) + EXT( 0xa5a5a5a5a5a5a050, 27, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a050, 27, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a050, 16383, 27, 15, 0xa5a5a5fffda5a050) + EXT( 0xa5a5a5a5a5a5a04f, 27, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a04f, 27, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a04f, 32767, 27, 16, 0xa5a5a3fffda5a04f) + EXT( 0xa5a5a5a5a5a5a04e, 27, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a04e, 27, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a04e, 65535, 27, 17, 0xa5a5a7fffda5a04e) + EXT( 0xa5a5a5a5a5a5a04d, 27, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a04d, 27, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a04d, 131071, 27, 18, 0xa5a5affffda5a04d) + EXT( 0xa5a5a5a5a5a5a04c, 27, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a04c, 27, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a04c, 262143, 27, 19, 0xa5a59ffffda5a04c) + EXT( 0xa5a5a5a5a5a5a04b, 27, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a04b, 27, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a04b, 524287, 27, 20, 0xa5a5bffffda5a04b) + EXT( 0xa5a5a5a5a5a5a04a, 27, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a04a, 27, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a04a, 1048575, 27, 21, 0xa5a57ffffda5a04a) + EXT( 0xa5a5a5a5a5a5a049, 27, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a049, 27, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a049, 2097151, 27, 22, 0xa5a4fffffda5a049) + EXT( 0xa5a5a5a5a5a5a048, 27, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a048, 27, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a048, 4194303, 27, 23, 0xa5a5fffffda5a048) + EXT( 0xa5a5a5a5a5a5a047, 27, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a047, 27, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a047, 8388607, 27, 24, 0xa5a3fffffda5a047) + EXT( 0xa5a5a5a5a5a5a046, 27, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a046, 27, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a046, 16777215, 27, 25, 0xa5a7fffffda5a046) + EXT( 0xa5a5a5a5a5a5a045, 27, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a045, 27, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a045, 33554431, 27, 26, 0xa5affffffda5a045) + EXT( 0xa5a5a5a5a5a5a044, 27, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a044, 27, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a044, 67108863, 27, 27, 0xa59ffffffda5a044) + EXT( 0xa5a5a5a5a5a5a043, 27, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a043, 27, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a043, 134217727, 27, 28, 0xa5bffffffda5a043) + EXT( 0xa5a5a5a5a5a5a042, 27, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a042, 27, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a042, 268435455, 27, 29, 0xa57ffffffda5a042) + EXT( 0xa5a5a5a5a5a5a041, 27, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a041, 27, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a041, 536870911, 27, 30, 0xa4fffffffda5a041) + EXT( 0xa5a5a5a5a5a5a040, 27, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a040, 27, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a040, 1073741823, 27, 31, 0xa5fffffffda5a040) + EXT( 0xa5a5a5a5a5a5a03f, 27, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a03f, 27, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a03f, 2147483647, 27, 32, 0xa3fffffffda5a03f) + EXT( 0xa5a5a5a5a5a5a03e, 27, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a03e, 27, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a03e, 4294967295, 27, 33, 0xa7fffffffda5a03e) + EXT( 0xa5a5a5a5a5a5a03d, 27, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a03d, 27, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a03d, 8589934591, 27, 34, 0xaffffffffda5a03d) + EXT( 0xa5a5a5a5a5a5a03c, 27, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a03c, 27, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a03c, 17179869183, 27, 35, 0x9ffffffffda5a03c) + EXT( 0xa5a5a5a5a5a5a03b, 27, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a03b, 27, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a03b, 34359738367, 27, 36, 0xbffffffffda5a03b) + EXT( 0xa5a5a5a5a5a5a03a, 28, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a03a, 28, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a03a, 0, 28, 1, 0xa5a5a5a5a5a5a03a) + EXT( 0xa5a5a5a5a5a5a039, 28, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a039, 28, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a039, 1, 28, 2, 0xa5a5a5a595a5a039) + EXT( 0xa5a5a5a5a5a5a038, 28, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a038, 28, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a038, 3, 28, 3, 0xa5a5a5a5b5a5a038) + EXT( 0xa5a5a5a5a5a5a037, 28, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a037, 28, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a037, 7, 28, 4, 0xa5a5a5a575a5a037) + EXT( 0xa5a5a5a5a5a5a036, 28, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a036, 28, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a036, 15, 28, 5, 0xa5a5a5a4f5a5a036) + EXT( 0xa5a5a5a5a5a5a035, 28, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a035, 28, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a035, 31, 28, 6, 0xa5a5a5a5f5a5a035) + EXT( 0xa5a5a5a5a5a5a034, 28, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a034, 28, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a034, 63, 28, 7, 0xa5a5a5a3f5a5a034) + EXT( 0xa5a5a5a5a5a5a033, 28, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a033, 28, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a033, 127, 28, 8, 0xa5a5a5a7f5a5a033) + EXT( 0xa5a5a5a5a5a5a032, 28, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a032, 28, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a032, 255, 28, 9, 0xa5a5a5aff5a5a032) + EXT( 0xa5a5a5a5a5a5a031, 28, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a031, 28, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a031, 511, 28, 10, 0xa5a5a59ff5a5a031) + EXT( 0xa5a5a5a5a5a5a030, 28, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a030, 28, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a030, 1023, 28, 11, 0xa5a5a5bff5a5a030) + EXT( 0xa5a5a5a5a5a5a02f, 28, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a02f, 28, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a02f, 2047, 28, 12, 0xa5a5a57ff5a5a02f) + EXT( 0xa5a5a5a5a5a5a02e, 28, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a02e, 28, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a02e, 4095, 28, 13, 0xa5a5a4fff5a5a02e) + EXT( 0xa5a5a5a5a5a5a02d, 28, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a02d, 28, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a02d, 8191, 28, 14, 0xa5a5a5fff5a5a02d) + EXT( 0xa5a5a5a5a5a5a02c, 28, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a02c, 28, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a02c, 16383, 28, 15, 0xa5a5a3fff5a5a02c) + EXT( 0xa5a5a5a5a5a5a02b, 28, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a02b, 28, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a02b, 32767, 28, 16, 0xa5a5a7fff5a5a02b) + EXT( 0xa5a5a5a5a5a5a02a, 28, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a02a, 28, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a02a, 65535, 28, 17, 0xa5a5affff5a5a02a) + EXT( 0xa5a5a5a5a5a5a029, 28, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a029, 28, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a029, 131071, 28, 18, 0xa5a59ffff5a5a029) + EXT( 0xa5a5a5a5a5a5a028, 28, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a028, 28, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a028, 262143, 28, 19, 0xa5a5bffff5a5a028) + EXT( 0xa5a5a5a5a5a5a027, 28, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a027, 28, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a027, 524287, 28, 20, 0xa5a57ffff5a5a027) + EXT( 0xa5a5a5a5a5a5a026, 28, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a026, 28, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a026, 1048575, 28, 21, 0xa5a4fffff5a5a026) + EXT( 0xa5a5a5a5a5a5a025, 28, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a025, 28, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a025, 2097151, 28, 22, 0xa5a5fffff5a5a025) + EXT( 0xa5a5a5a5a5a5a024, 28, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a024, 28, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a024, 4194303, 28, 23, 0xa5a3fffff5a5a024) + EXT( 0xa5a5a5a5a5a5a023, 28, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a023, 28, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a023, 8388607, 28, 24, 0xa5a7fffff5a5a023) + EXT( 0xa5a5a5a5a5a5a022, 28, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a022, 28, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a022, 16777215, 28, 25, 0xa5affffff5a5a022) + EXT( 0xa5a5a5a5a5a5a021, 28, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a021, 28, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a021, 33554431, 28, 26, 0xa59ffffff5a5a021) + EXT( 0xa5a5a5a5a5a5a020, 28, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a020, 28, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a020, 67108863, 28, 27, 0xa5bffffff5a5a020) + EXT( 0xa5a5a5a5a5a5a01f, 28, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a01f, 28, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01f, 134217727, 28, 28, 0xa57ffffff5a5a01f) + EXT( 0xa5a5a5a5a5a5a01e, 28, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a01e, 28, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01e, 268435455, 28, 29, 0xa4fffffff5a5a01e) + EXT( 0xa5a5a5a5a5a5a01d, 28, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a01d, 28, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01d, 536870911, 28, 30, 0xa5fffffff5a5a01d) + EXT( 0xa5a5a5a5a5a5a01c, 28, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a01c, 28, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01c, 1073741823, 28, 31, 0xa3fffffff5a5a01c) + EXT( 0xa5a5a5a5a5a5a01b, 28, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a01b, 28, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01b, 2147483647, 28, 32, 0xa7fffffff5a5a01b) + EXT( 0xa5a5a5a5a5a5a01a, 28, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a01a, 28, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a01a, 4294967295, 28, 33, 0xaffffffff5a5a01a) + EXT( 0xa5a5a5a5a5a5a019, 28, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a019, 28, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a019, 8589934591, 28, 34, 0x9ffffffff5a5a019) + EXT( 0xa5a5a5a5a5a5a018, 28, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a018, 28, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a018, 17179869183, 28, 35, 0xbffffffff5a5a018) + EXT( 0xa5a5a5a5a5a5a017, 29, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a017, 29, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a017, 0, 29, 1, 0xa5a5a5a585a5a017) + EXT( 0xa5a5a5a5a5a5a016, 29, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a016, 29, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a016, 1, 29, 2, 0xa5a5a5a5a5a5a016) + EXT( 0xa5a5a5a5a5a5a015, 29, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a015, 29, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a015, 3, 29, 3, 0xa5a5a5a565a5a015) + EXT( 0xa5a5a5a5a5a5a014, 29, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a014, 29, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a014, 7, 29, 4, 0xa5a5a5a4e5a5a014) + EXT( 0xa5a5a5a5a5a5a013, 29, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a013, 29, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a013, 15, 29, 5, 0xa5a5a5a5e5a5a013) + EXT( 0xa5a5a5a5a5a5a012, 29, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a012, 29, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a012, 31, 29, 6, 0xa5a5a5a3e5a5a012) + EXT( 0xa5a5a5a5a5a5a011, 29, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a011, 29, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a011, 63, 29, 7, 0xa5a5a5a7e5a5a011) + EXT( 0xa5a5a5a5a5a5a010, 29, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a010, 29, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a010, 127, 29, 8, 0xa5a5a5afe5a5a010) + EXT( 0xa5a5a5a5a5a5a00f, 29, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a00f, 29, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a00f, 255, 29, 9, 0xa5a5a59fe5a5a00f) + EXT( 0xa5a5a5a5a5a5a00e, 29, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a00e, 29, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a00e, 511, 29, 10, 0xa5a5a5bfe5a5a00e) + EXT( 0xa5a5a5a5a5a5a00d, 29, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a00d, 29, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a00d, 1023, 29, 11, 0xa5a5a57fe5a5a00d) + EXT( 0xa5a5a5a5a5a5a00c, 29, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a00c, 29, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a00c, 2047, 29, 12, 0xa5a5a4ffe5a5a00c) + EXT( 0xa5a5a5a5a5a5a00b, 29, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a00b, 29, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a00b, 4095, 29, 13, 0xa5a5a5ffe5a5a00b) + EXT( 0xa5a5a5a5a5a5a00a, 29, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a00a, 29, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a00a, 8191, 29, 14, 0xa5a5a3ffe5a5a00a) + EXT( 0xa5a5a5a5a5a5a009, 29, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a009, 29, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a009, 16383, 29, 15, 0xa5a5a7ffe5a5a009) + EXT( 0xa5a5a5a5a5a5a008, 29, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a008, 29, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a008, 32767, 29, 16, 0xa5a5afffe5a5a008) + EXT( 0xa5a5a5a5a5a5a007, 29, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a007, 29, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a007, 65535, 29, 17, 0xa5a59fffe5a5a007) + EXT( 0xa5a5a5a5a5a5a006, 29, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a006, 29, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a006, 131071, 29, 18, 0xa5a5bfffe5a5a006) + EXT( 0xa5a5a5a5a5a5a005, 29, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a005, 29, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a005, 262143, 29, 19, 0xa5a57fffe5a5a005) + EXT( 0xa5a5a5a5a5a5a004, 29, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a004, 29, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a004, 524287, 29, 20, 0xa5a4ffffe5a5a004) + EXT( 0xa5a5a5a5a5a5a003, 29, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a003, 29, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a003, 1048575, 29, 21, 0xa5a5ffffe5a5a003) + EXT( 0xa5a5a5a5a5a5a002, 29, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a002, 29, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a002, 2097151, 29, 22, 0xa5a3ffffe5a5a002) + EXT( 0xa5a5a5a5a5a5a001, 29, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a001, 29, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a001, 4194303, 29, 23, 0xa5a7ffffe5a5a001) + EXT( 0xa5a5a5a5a5a5a000, 29, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a000, 29, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a000, 8388607, 29, 24, 0xa5afffffe5a5a000) + EXT( 0xa5a5a5a5a5a59fff, 29, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a59fff, 29, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a59fff, 16777215, 29, 25, 0xa59fffffe5a59fff) + EXT( 0xa5a5a5a5a5a59ffe, 29, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a59ffe, 29, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a59ffe, 33554431, 29, 26, 0xa5bfffffe5a59ffe) + EXT( 0xa5a5a5a5a5a59ffd, 29, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a59ffd, 29, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a59ffd, 67108863, 29, 27, 0xa57fffffe5a59ffd) + EXT( 0xa5a5a5a5a5a59ffc, 29, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a59ffc, 29, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a59ffc, 134217727, 29, 28, 0xa4ffffffe5a59ffc) + EXT( 0xa5a5a5a5a5a59ffb, 29, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a59ffb, 29, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a59ffb, 268435455, 29, 29, 0xa5ffffffe5a59ffb) + EXT( 0xa5a5a5a5a5a59ffa, 29, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a59ffa, 29, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a59ffa, 536870911, 29, 30, 0xa3ffffffe5a59ffa) + EXT( 0xa5a5a5a5a5a59ff9, 29, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a59ff9, 29, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a59ff9, 1073741823, 29, 31, 0xa7ffffffe5a59ff9) + EXT( 0xa5a5a5a5a5a59ff8, 29, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a59ff8, 29, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a59ff8, 2147483647, 29, 32, 0xafffffffe5a59ff8) + EXT( 0xa5a5a5a5a5a59ff7, 29, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a59ff7, 29, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a59ff7, 4294967295, 29, 33, 0x9fffffffe5a59ff7) + EXT( 0xa5a5a5a5a5a59ff6, 29, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a59ff6, 29, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a59ff6, 8589934591, 29, 34, 0xbfffffffe5a59ff6) + EXT( 0xa5a5a5a5a5a59ff5, 30, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59ff5, 30, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59ff5, 0, 30, 1, 0xa5a5a5a5a5a59ff5) + EXT( 0xa5a5a5a5a5a59ff4, 30, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59ff4, 30, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ff4, 1, 30, 2, 0xa5a5a5a565a59ff4) + EXT( 0xa5a5a5a5a5a59ff3, 30, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59ff3, 30, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59ff3, 3, 30, 3, 0xa5a5a5a4e5a59ff3) + EXT( 0xa5a5a5a5a5a59ff2, 30, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59ff2, 30, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59ff2, 7, 30, 4, 0xa5a5a5a5e5a59ff2) + EXT( 0xa5a5a5a5a5a59ff1, 30, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59ff1, 30, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59ff1, 15, 30, 5, 0xa5a5a5a3e5a59ff1) + EXT( 0xa5a5a5a5a5a59ff0, 30, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59ff0, 30, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59ff0, 31, 30, 6, 0xa5a5a5a7e5a59ff0) + EXT( 0xa5a5a5a5a5a59fef, 30, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59fef, 30, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59fef, 63, 30, 7, 0xa5a5a5afe5a59fef) + EXT( 0xa5a5a5a5a5a59fee, 30, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59fee, 30, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59fee, 127, 30, 8, 0xa5a5a59fe5a59fee) + EXT( 0xa5a5a5a5a5a59fed, 30, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59fed, 30, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59fed, 255, 30, 9, 0xa5a5a5bfe5a59fed) + EXT( 0xa5a5a5a5a5a59fec, 30, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59fec, 30, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a59fec, 511, 30, 10, 0xa5a5a57fe5a59fec) + EXT( 0xa5a5a5a5a5a59feb, 30, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59feb, 30, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59feb, 1023, 30, 11, 0xa5a5a4ffe5a59feb) + EXT( 0xa5a5a5a5a5a59fea, 30, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a59fea, 30, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59fea, 2047, 30, 12, 0xa5a5a5ffe5a59fea) + EXT( 0xa5a5a5a5a5a59fe9, 30, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a59fe9, 30, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59fe9, 4095, 30, 13, 0xa5a5a3ffe5a59fe9) + EXT( 0xa5a5a5a5a5a59fe8, 30, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59fe8, 30, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59fe8, 8191, 30, 14, 0xa5a5a7ffe5a59fe8) + EXT( 0xa5a5a5a5a5a59fe7, 30, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59fe7, 30, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59fe7, 16383, 30, 15, 0xa5a5afffe5a59fe7) + EXT( 0xa5a5a5a5a5a59fe6, 30, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a59fe6, 30, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59fe6, 32767, 30, 16, 0xa5a59fffe5a59fe6) + EXT( 0xa5a5a5a5a5a59fe5, 30, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a59fe5, 30, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59fe5, 65535, 30, 17, 0xa5a5bfffe5a59fe5) + EXT( 0xa5a5a5a5a5a59fe4, 30, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59fe4, 30, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a59fe4, 131071, 30, 18, 0xa5a57fffe5a59fe4) + EXT( 0xa5a5a5a5a5a59fe3, 30, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59fe3, 30, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59fe3, 262143, 30, 19, 0xa5a4ffffe5a59fe3) + EXT( 0xa5a5a5a5a5a59fe2, 30, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a59fe2, 30, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59fe2, 524287, 30, 20, 0xa5a5ffffe5a59fe2) + EXT( 0xa5a5a5a5a5a59fe1, 30, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a59fe1, 30, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59fe1, 1048575, 30, 21, 0xa5a3ffffe5a59fe1) + EXT( 0xa5a5a5a5a5a59fe0, 30, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a59fe0, 30, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59fe0, 2097151, 30, 22, 0xa5a7ffffe5a59fe0) + EXT( 0xa5a5a5a5a5a59fdf, 30, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a59fdf, 30, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59fdf, 4194303, 30, 23, 0xa5afffffe5a59fdf) + EXT( 0xa5a5a5a5a5a59fde, 30, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a59fde, 30, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a59fde, 8388607, 30, 24, 0xa59fffffe5a59fde) + EXT( 0xa5a5a5a5a5a59fdd, 30, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a59fdd, 30, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a59fdd, 16777215, 30, 25, 0xa5bfffffe5a59fdd) + EXT( 0xa5a5a5a5a5a59fdc, 30, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a59fdc, 30, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a59fdc, 33554431, 30, 26, 0xa57fffffe5a59fdc) + EXT( 0xa5a5a5a5a5a59fdb, 30, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a59fdb, 30, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a59fdb, 67108863, 30, 27, 0xa4ffffffe5a59fdb) + EXT( 0xa5a5a5a5a5a59fda, 30, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a59fda, 30, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a59fda, 134217727, 30, 28, 0xa5ffffffe5a59fda) + EXT( 0xa5a5a5a5a5a59fd9, 30, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a59fd9, 30, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a59fd9, 268435455, 30, 29, 0xa3ffffffe5a59fd9) + EXT( 0xa5a5a5a5a5a59fd8, 30, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a59fd8, 30, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a59fd8, 536870911, 30, 30, 0xa7ffffffe5a59fd8) + EXT( 0xa5a5a5a5a5a59fd7, 30, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a59fd7, 30, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a59fd7, 1073741823, 30, 31, 0xafffffffe5a59fd7) + EXT( 0xa5a5a5a5a5a59fd6, 30, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a59fd6, 30, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a59fd6, 2147483647, 30, 32, 0x9fffffffe5a59fd6) + EXT( 0xa5a5a5a5a5a59fd5, 30, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a59fd5, 30, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a59fd5, 4294967295, 30, 33, 0xbfffffffe5a59fd5) + EXT( 0xa5a5a5a5a5a59fd4, 31, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fd4, 31, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59fd4, 0, 31, 1, 0xa5a5a5a525a59fd4) + EXT( 0xa5a5a5a5a5a59fd3, 31, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fd3, 31, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59fd3, 1, 31, 2, 0xa5a5a5a4a5a59fd3) + EXT( 0xa5a5a5a5a5a59fd2, 31, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59fd2, 31, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59fd2, 3, 31, 3, 0xa5a5a5a5a5a59fd2) + EXT( 0xa5a5a5a5a5a59fd1, 31, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59fd1, 31, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59fd1, 7, 31, 4, 0xa5a5a5a3a5a59fd1) + EXT( 0xa5a5a5a5a5a59fd0, 31, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59fd0, 31, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59fd0, 15, 31, 5, 0xa5a5a5a7a5a59fd0) + EXT( 0xa5a5a5a5a5a59fcf, 31, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59fcf, 31, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59fcf, 31, 31, 6, 0xa5a5a5afa5a59fcf) + EXT( 0xa5a5a5a5a5a59fce, 31, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59fce, 31, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59fce, 63, 31, 7, 0xa5a5a59fa5a59fce) + EXT( 0xa5a5a5a5a5a59fcd, 31, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59fcd, 31, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59fcd, 127, 31, 8, 0xa5a5a5bfa5a59fcd) + EXT( 0xa5a5a5a5a5a59fcc, 31, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59fcc, 31, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a59fcc, 255, 31, 9, 0xa5a5a57fa5a59fcc) + EXT( 0xa5a5a5a5a5a59fcb, 31, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59fcb, 31, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59fcb, 511, 31, 10, 0xa5a5a4ffa5a59fcb) + EXT( 0xa5a5a5a5a5a59fca, 31, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a59fca, 31, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59fca, 1023, 31, 11, 0xa5a5a5ffa5a59fca) + EXT( 0xa5a5a5a5a5a59fc9, 31, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a59fc9, 31, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59fc9, 2047, 31, 12, 0xa5a5a3ffa5a59fc9) + EXT( 0xa5a5a5a5a5a59fc8, 31, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59fc8, 31, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59fc8, 4095, 31, 13, 0xa5a5a7ffa5a59fc8) + EXT( 0xa5a5a5a5a5a59fc7, 31, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59fc7, 31, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59fc7, 8191, 31, 14, 0xa5a5afffa5a59fc7) + EXT( 0xa5a5a5a5a5a59fc6, 31, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a59fc6, 31, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59fc6, 16383, 31, 15, 0xa5a59fffa5a59fc6) + EXT( 0xa5a5a5a5a5a59fc5, 31, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a59fc5, 31, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59fc5, 32767, 31, 16, 0xa5a5bfffa5a59fc5) + EXT( 0xa5a5a5a5a5a59fc4, 31, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59fc4, 31, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a59fc4, 65535, 31, 17, 0xa5a57fffa5a59fc4) + EXT( 0xa5a5a5a5a5a59fc3, 31, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59fc3, 31, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59fc3, 131071, 31, 18, 0xa5a4ffffa5a59fc3) + EXT( 0xa5a5a5a5a5a59fc2, 31, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a59fc2, 31, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59fc2, 262143, 31, 19, 0xa5a5ffffa5a59fc2) + EXT( 0xa5a5a5a5a5a59fc1, 31, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a59fc1, 31, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59fc1, 524287, 31, 20, 0xa5a3ffffa5a59fc1) + EXT( 0xa5a5a5a5a5a59fc0, 31, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a59fc0, 31, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59fc0, 1048575, 31, 21, 0xa5a7ffffa5a59fc0) + EXT( 0xa5a5a5a5a5a59fbf, 31, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a59fbf, 31, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59fbf, 2097151, 31, 22, 0xa5afffffa5a59fbf) + EXT( 0xa5a5a5a5a5a59fbe, 31, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a59fbe, 31, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a59fbe, 4194303, 31, 23, 0xa59fffffa5a59fbe) + EXT( 0xa5a5a5a5a5a59fbd, 31, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a59fbd, 31, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a59fbd, 8388607, 31, 24, 0xa5bfffffa5a59fbd) + EXT( 0xa5a5a5a5a5a59fbc, 31, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a59fbc, 31, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a59fbc, 16777215, 31, 25, 0xa57fffffa5a59fbc) + EXT( 0xa5a5a5a5a5a59fbb, 31, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a59fbb, 31, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a59fbb, 33554431, 31, 26, 0xa4ffffffa5a59fbb) + EXT( 0xa5a5a5a5a5a59fba, 31, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a59fba, 31, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a59fba, 67108863, 31, 27, 0xa5ffffffa5a59fba) + EXT( 0xa5a5a5a5a5a59fb9, 31, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a59fb9, 31, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a59fb9, 134217727, 31, 28, 0xa3ffffffa5a59fb9) + EXT( 0xa5a5a5a5a5a59fb8, 31, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a59fb8, 31, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a59fb8, 268435455, 31, 29, 0xa7ffffffa5a59fb8) + EXT( 0xa5a5a5a5a5a59fb7, 31, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a59fb7, 31, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a59fb7, 536870911, 31, 30, 0xafffffffa5a59fb7) + EXT( 0xa5a5a5a5a5a59fb6, 31, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a59fb6, 31, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a59fb6, 1073741823, 31, 31, 0x9fffffffa5a59fb6) + EXT( 0xa5a5a5a5a5a59fb5, 31, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a59fb5, 31, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a59fb5, 2147483647, 31, 32, 0xbfffffffa5a59fb5) + EXT( 0xa5a5a5a5a5a59fb4, 32, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fb4, 32, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59fb4, 0, 32, 1, 0xa5a5a5a4a5a59fb4) + EXT( 0xa5a5a5a5a5a59fb3, 32, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59fb3, 32, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59fb3, 1, 32, 2, 0xa5a5a5a5a5a59fb3) + EXT( 0xa5a5a5a5a5a59fb2, 32, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59fb2, 32, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59fb2, 3, 32, 3, 0xa5a5a5a3a5a59fb2) + EXT( 0xa5a5a5a5a5a59fb1, 32, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59fb1, 32, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59fb1, 7, 32, 4, 0xa5a5a5a7a5a59fb1) + EXT( 0xa5a5a5a5a5a59fb0, 32, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59fb0, 32, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59fb0, 15, 32, 5, 0xa5a5a5afa5a59fb0) + EXT( 0xa5a5a5a5a5a59faf, 32, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59faf, 32, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59faf, 31, 32, 6, 0xa5a5a59fa5a59faf) + EXT( 0xa5a5a5a5a5a59fae, 32, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59fae, 32, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59fae, 63, 32, 7, 0xa5a5a5bfa5a59fae) + EXT( 0xa5a5a5a5a5a59fad, 32, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59fad, 32, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a59fad, 127, 32, 8, 0xa5a5a57fa5a59fad) + EXT( 0xa5a5a5a5a5a59fac, 32, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59fac, 32, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59fac, 255, 32, 9, 0xa5a5a4ffa5a59fac) + EXT( 0xa5a5a5a5a5a59fab, 32, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a59fab, 32, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59fab, 511, 32, 10, 0xa5a5a5ffa5a59fab) + EXT( 0xa5a5a5a5a5a59faa, 32, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a59faa, 32, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59faa, 1023, 32, 11, 0xa5a5a3ffa5a59faa) + EXT( 0xa5a5a5a5a5a59fa9, 32, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59fa9, 32, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59fa9, 2047, 32, 12, 0xa5a5a7ffa5a59fa9) + EXT( 0xa5a5a5a5a5a59fa8, 32, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59fa8, 32, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59fa8, 4095, 32, 13, 0xa5a5afffa5a59fa8) + EXT( 0xa5a5a5a5a5a59fa7, 32, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a59fa7, 32, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59fa7, 8191, 32, 14, 0xa5a59fffa5a59fa7) + EXT( 0xa5a5a5a5a5a59fa6, 32, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a59fa6, 32, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59fa6, 16383, 32, 15, 0xa5a5bfffa5a59fa6) + EXT( 0xa5a5a5a5a5a59fa5, 32, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59fa5, 32, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a59fa5, 32767, 32, 16, 0xa5a57fffa5a59fa5) + EXT( 0xa5a5a5a5a5a59fa4, 32, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59fa4, 32, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59fa4, 65535, 32, 17, 0xa5a4ffffa5a59fa4) + EXT( 0xa5a5a5a5a5a59fa3, 32, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a59fa3, 32, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59fa3, 131071, 32, 18, 0xa5a5ffffa5a59fa3) + EXT( 0xa5a5a5a5a5a59fa2, 32, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a59fa2, 32, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59fa2, 262143, 32, 19, 0xa5a3ffffa5a59fa2) + EXT( 0xa5a5a5a5a5a59fa1, 32, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a59fa1, 32, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59fa1, 524287, 32, 20, 0xa5a7ffffa5a59fa1) + EXT( 0xa5a5a5a5a5a59fa0, 32, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a59fa0, 32, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59fa0, 1048575, 32, 21, 0xa5afffffa5a59fa0) + EXT( 0xa5a5a5a5a5a59f9f, 32, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a59f9f, 32, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a59f9f, 2097151, 32, 22, 0xa59fffffa5a59f9f) + EXT( 0xa5a5a5a5a5a59f9e, 32, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a59f9e, 32, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a59f9e, 4194303, 32, 23, 0xa5bfffffa5a59f9e) + EXT( 0xa5a5a5a5a5a59f9d, 32, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a59f9d, 32, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a59f9d, 8388607, 32, 24, 0xa57fffffa5a59f9d) + EXT( 0xa5a5a5a5a5a59f9c, 32, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a59f9c, 32, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a59f9c, 16777215, 32, 25, 0xa4ffffffa5a59f9c) + EXT( 0xa5a5a5a5a5a59f9b, 32, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a59f9b, 32, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a59f9b, 33554431, 32, 26, 0xa5ffffffa5a59f9b) + EXT( 0xa5a5a5a5a5a59f9a, 32, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a59f9a, 32, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a59f9a, 67108863, 32, 27, 0xa3ffffffa5a59f9a) + EXT( 0xa5a5a5a5a5a59f99, 32, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a59f99, 32, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a59f99, 134217727, 32, 28, 0xa7ffffffa5a59f99) + EXT( 0xa5a5a5a5a5a59f98, 32, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a59f98, 32, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a59f98, 268435455, 32, 29, 0xafffffffa5a59f98) + EXT( 0xa5a5a5a5a5a59f97, 32, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a59f97, 32, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a59f97, 536870911, 32, 30, 0x9fffffffa5a59f97) + EXT( 0xa5a5a5a5a5a59f96, 32, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a59f96, 32, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a59f96, 1073741823, 32, 31, 0xbfffffffa5a59f96) + EXT( 0xa5a5a5a5a5a59f95, 33, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f95, 33, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f95, 0, 33, 1, 0xa5a5a5a5a5a59f95) + EXT( 0xa5a5a5a5a5a59f94, 33, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f94, 33, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f94, 1, 33, 2, 0xa5a5a5a3a5a59f94) + EXT( 0xa5a5a5a5a5a59f93, 33, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f93, 33, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f93, 3, 33, 3, 0xa5a5a5a7a5a59f93) + EXT( 0xa5a5a5a5a5a59f92, 33, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f92, 33, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f92, 7, 33, 4, 0xa5a5a5afa5a59f92) + EXT( 0xa5a5a5a5a5a59f91, 33, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59f91, 33, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59f91, 15, 33, 5, 0xa5a5a59fa5a59f91) + EXT( 0xa5a5a5a5a5a59f90, 33, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59f90, 33, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59f90, 31, 33, 6, 0xa5a5a5bfa5a59f90) + EXT( 0xa5a5a5a5a5a59f8f, 33, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59f8f, 33, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a59f8f, 63, 33, 7, 0xa5a5a57fa5a59f8f) + EXT( 0xa5a5a5a5a5a59f8e, 33, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59f8e, 33, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59f8e, 127, 33, 8, 0xa5a5a4ffa5a59f8e) + EXT( 0xa5a5a5a5a5a59f8d, 33, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a59f8d, 33, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59f8d, 255, 33, 9, 0xa5a5a5ffa5a59f8d) + EXT( 0xa5a5a5a5a5a59f8c, 33, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a59f8c, 33, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f8c, 511, 33, 10, 0xa5a5a3ffa5a59f8c) + EXT( 0xa5a5a5a5a5a59f8b, 33, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59f8b, 33, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f8b, 1023, 33, 11, 0xa5a5a7ffa5a59f8b) + EXT( 0xa5a5a5a5a5a59f8a, 33, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59f8a, 33, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f8a, 2047, 33, 12, 0xa5a5afffa5a59f8a) + EXT( 0xa5a5a5a5a5a59f89, 33, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a59f89, 33, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59f89, 4095, 33, 13, 0xa5a59fffa5a59f89) + EXT( 0xa5a5a5a5a5a59f88, 33, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a59f88, 33, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59f88, 8191, 33, 14, 0xa5a5bfffa5a59f88) + EXT( 0xa5a5a5a5a5a59f87, 33, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59f87, 33, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a59f87, 16383, 33, 15, 0xa5a57fffa5a59f87) + EXT( 0xa5a5a5a5a5a59f86, 33, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59f86, 33, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59f86, 32767, 33, 16, 0xa5a4ffffa5a59f86) + EXT( 0xa5a5a5a5a5a59f85, 33, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a59f85, 33, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59f85, 65535, 33, 17, 0xa5a5ffffa5a59f85) + EXT( 0xa5a5a5a5a5a59f84, 33, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a59f84, 33, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59f84, 131071, 33, 18, 0xa5a3ffffa5a59f84) + EXT( 0xa5a5a5a5a5a59f83, 33, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a59f83, 33, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59f83, 262143, 33, 19, 0xa5a7ffffa5a59f83) + EXT( 0xa5a5a5a5a5a59f82, 33, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a59f82, 33, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59f82, 524287, 33, 20, 0xa5afffffa5a59f82) + EXT( 0xa5a5a5a5a5a59f81, 33, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a59f81, 33, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a59f81, 1048575, 33, 21, 0xa59fffffa5a59f81) + EXT( 0xa5a5a5a5a5a59f80, 33, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a59f80, 33, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a59f80, 2097151, 33, 22, 0xa5bfffffa5a59f80) + EXT( 0xa5a5a5a5a5a59f7f, 33, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a59f7f, 33, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a59f7f, 4194303, 33, 23, 0xa57fffffa5a59f7f) + EXT( 0xa5a5a5a5a5a59f7e, 33, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a59f7e, 33, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a59f7e, 8388607, 33, 24, 0xa4ffffffa5a59f7e) + EXT( 0xa5a5a5a5a5a59f7d, 33, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a59f7d, 33, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a59f7d, 16777215, 33, 25, 0xa5ffffffa5a59f7d) + EXT( 0xa5a5a5a5a5a59f7c, 33, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a59f7c, 33, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a59f7c, 33554431, 33, 26, 0xa3ffffffa5a59f7c) + EXT( 0xa5a5a5a5a5a59f7b, 33, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a59f7b, 33, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a59f7b, 67108863, 33, 27, 0xa7ffffffa5a59f7b) + EXT( 0xa5a5a5a5a5a59f7a, 33, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a59f7a, 33, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a59f7a, 134217727, 33, 28, 0xafffffffa5a59f7a) + EXT( 0xa5a5a5a5a5a59f79, 33, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a59f79, 33, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a59f79, 268435455, 33, 29, 0x9fffffffa5a59f79) + EXT( 0xa5a5a5a5a5a59f78, 33, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a59f78, 33, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a59f78, 536870911, 33, 30, 0xbfffffffa5a59f78) + EXT( 0xa5a5a5a5a5a59f77, 34, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59f77, 34, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f77, 0, 34, 1, 0xa5a5a5a1a5a59f77) + EXT( 0xa5a5a5a5a5a59f76, 34, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f76, 34, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f76, 1, 34, 2, 0xa5a5a5a5a5a59f76) + EXT( 0xa5a5a5a5a5a59f75, 34, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f75, 34, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f75, 3, 34, 3, 0xa5a5a5ada5a59f75) + EXT( 0xa5a5a5a5a5a59f74, 34, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59f74, 34, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59f74, 7, 34, 4, 0xa5a5a59da5a59f74) + EXT( 0xa5a5a5a5a5a59f73, 34, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59f73, 34, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59f73, 15, 34, 5, 0xa5a5a5bda5a59f73) + EXT( 0xa5a5a5a5a5a59f72, 34, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59f72, 34, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a59f72, 31, 34, 6, 0xa5a5a57da5a59f72) + EXT( 0xa5a5a5a5a5a59f71, 34, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59f71, 34, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59f71, 63, 34, 7, 0xa5a5a4fda5a59f71) + EXT( 0xa5a5a5a5a5a59f70, 34, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a59f70, 34, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59f70, 127, 34, 8, 0xa5a5a5fda5a59f70) + EXT( 0xa5a5a5a5a5a59f6f, 34, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a59f6f, 34, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f6f, 255, 34, 9, 0xa5a5a3fda5a59f6f) + EXT( 0xa5a5a5a5a5a59f6e, 34, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59f6e, 34, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f6e, 511, 34, 10, 0xa5a5a7fda5a59f6e) + EXT( 0xa5a5a5a5a5a59f6d, 34, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59f6d, 34, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f6d, 1023, 34, 11, 0xa5a5affda5a59f6d) + EXT( 0xa5a5a5a5a5a59f6c, 34, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a59f6c, 34, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59f6c, 2047, 34, 12, 0xa5a59ffda5a59f6c) + EXT( 0xa5a5a5a5a5a59f6b, 34, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a59f6b, 34, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59f6b, 4095, 34, 13, 0xa5a5bffda5a59f6b) + EXT( 0xa5a5a5a5a5a59f6a, 34, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59f6a, 34, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a59f6a, 8191, 34, 14, 0xa5a57ffda5a59f6a) + EXT( 0xa5a5a5a5a5a59f69, 34, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59f69, 34, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59f69, 16383, 34, 15, 0xa5a4fffda5a59f69) + EXT( 0xa5a5a5a5a5a59f68, 34, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a59f68, 34, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59f68, 32767, 34, 16, 0xa5a5fffda5a59f68) + EXT( 0xa5a5a5a5a5a59f67, 34, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a59f67, 34, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59f67, 65535, 34, 17, 0xa5a3fffda5a59f67) + EXT( 0xa5a5a5a5a5a59f66, 34, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a59f66, 34, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59f66, 131071, 34, 18, 0xa5a7fffda5a59f66) + EXT( 0xa5a5a5a5a5a59f65, 34, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a59f65, 34, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59f65, 262143, 34, 19, 0xa5affffda5a59f65) + EXT( 0xa5a5a5a5a5a59f64, 34, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a59f64, 34, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a59f64, 524287, 34, 20, 0xa59ffffda5a59f64) + EXT( 0xa5a5a5a5a5a59f63, 34, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a59f63, 34, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a59f63, 1048575, 34, 21, 0xa5bffffda5a59f63) + EXT( 0xa5a5a5a5a5a59f62, 34, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a59f62, 34, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a59f62, 2097151, 34, 22, 0xa57ffffda5a59f62) + EXT( 0xa5a5a5a5a5a59f61, 34, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a59f61, 34, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a59f61, 4194303, 34, 23, 0xa4fffffda5a59f61) + EXT( 0xa5a5a5a5a5a59f60, 34, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a59f60, 34, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a59f60, 8388607, 34, 24, 0xa5fffffda5a59f60) + EXT( 0xa5a5a5a5a5a59f5f, 34, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a59f5f, 34, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a59f5f, 16777215, 34, 25, 0xa3fffffda5a59f5f) + EXT( 0xa5a5a5a5a5a59f5e, 34, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a59f5e, 34, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a59f5e, 33554431, 34, 26, 0xa7fffffda5a59f5e) + EXT( 0xa5a5a5a5a5a59f5d, 34, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a59f5d, 34, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a59f5d, 67108863, 34, 27, 0xaffffffda5a59f5d) + EXT( 0xa5a5a5a5a5a59f5c, 34, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a59f5c, 34, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a59f5c, 134217727, 34, 28, 0x9ffffffda5a59f5c) + EXT( 0xa5a5a5a5a5a59f5b, 34, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a59f5b, 34, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a59f5b, 268435455, 34, 29, 0xbffffffda5a59f5b) + EXT( 0xa5a5a5a5a5a59f5a, 35, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f5a, 35, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f5a, 0, 35, 1, 0xa5a5a5a5a5a59f5a) + EXT( 0xa5a5a5a5a5a59f59, 35, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f59, 35, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f59, 1, 35, 2, 0xa5a5a5ada5a59f59) + EXT( 0xa5a5a5a5a5a59f58, 35, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59f58, 35, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59f58, 3, 35, 3, 0xa5a5a59da5a59f58) + EXT( 0xa5a5a5a5a5a59f57, 35, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59f57, 35, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59f57, 7, 35, 4, 0xa5a5a5bda5a59f57) + EXT( 0xa5a5a5a5a5a59f56, 35, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59f56, 35, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a59f56, 15, 35, 5, 0xa5a5a57da5a59f56) + EXT( 0xa5a5a5a5a5a59f55, 35, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59f55, 35, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59f55, 31, 35, 6, 0xa5a5a4fda5a59f55) + EXT( 0xa5a5a5a5a5a59f54, 35, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a59f54, 35, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59f54, 63, 35, 7, 0xa5a5a5fda5a59f54) + EXT( 0xa5a5a5a5a5a59f53, 35, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a59f53, 35, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f53, 127, 35, 8, 0xa5a5a3fda5a59f53) + EXT( 0xa5a5a5a5a5a59f52, 35, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59f52, 35, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f52, 255, 35, 9, 0xa5a5a7fda5a59f52) + EXT( 0xa5a5a5a5a5a59f51, 35, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59f51, 35, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f51, 511, 35, 10, 0xa5a5affda5a59f51) + EXT( 0xa5a5a5a5a5a59f50, 35, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a59f50, 35, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59f50, 1023, 35, 11, 0xa5a59ffda5a59f50) + EXT( 0xa5a5a5a5a5a59f4f, 35, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a59f4f, 35, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59f4f, 2047, 35, 12, 0xa5a5bffda5a59f4f) + EXT( 0xa5a5a5a5a5a59f4e, 35, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59f4e, 35, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a59f4e, 4095, 35, 13, 0xa5a57ffda5a59f4e) + EXT( 0xa5a5a5a5a5a59f4d, 35, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59f4d, 35, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59f4d, 8191, 35, 14, 0xa5a4fffda5a59f4d) + EXT( 0xa5a5a5a5a5a59f4c, 35, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a59f4c, 35, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59f4c, 16383, 35, 15, 0xa5a5fffda5a59f4c) + EXT( 0xa5a5a5a5a5a59f4b, 35, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a59f4b, 35, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59f4b, 32767, 35, 16, 0xa5a3fffda5a59f4b) + EXT( 0xa5a5a5a5a5a59f4a, 35, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a59f4a, 35, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59f4a, 65535, 35, 17, 0xa5a7fffda5a59f4a) + EXT( 0xa5a5a5a5a5a59f49, 35, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a59f49, 35, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59f49, 131071, 35, 18, 0xa5affffda5a59f49) + EXT( 0xa5a5a5a5a5a59f48, 35, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a59f48, 35, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a59f48, 262143, 35, 19, 0xa59ffffda5a59f48) + EXT( 0xa5a5a5a5a5a59f47, 35, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a59f47, 35, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a59f47, 524287, 35, 20, 0xa5bffffda5a59f47) + EXT( 0xa5a5a5a5a5a59f46, 35, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a59f46, 35, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a59f46, 1048575, 35, 21, 0xa57ffffda5a59f46) + EXT( 0xa5a5a5a5a5a59f45, 35, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a59f45, 35, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a59f45, 2097151, 35, 22, 0xa4fffffda5a59f45) + EXT( 0xa5a5a5a5a5a59f44, 35, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a59f44, 35, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a59f44, 4194303, 35, 23, 0xa5fffffda5a59f44) + EXT( 0xa5a5a5a5a5a59f43, 35, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a59f43, 35, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a59f43, 8388607, 35, 24, 0xa3fffffda5a59f43) + EXT( 0xa5a5a5a5a5a59f42, 35, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a59f42, 35, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a59f42, 16777215, 35, 25, 0xa7fffffda5a59f42) + EXT( 0xa5a5a5a5a5a59f41, 35, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a59f41, 35, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a59f41, 33554431, 35, 26, 0xaffffffda5a59f41) + EXT( 0xa5a5a5a5a5a59f40, 35, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a59f40, 35, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a59f40, 67108863, 35, 27, 0x9ffffffda5a59f40) + EXT( 0xa5a5a5a5a5a59f3f, 35, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a59f3f, 35, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a59f3f, 134217727, 35, 28, 0xbffffffda5a59f3f) + EXT( 0xa5a5a5a5a5a59f3e, 36, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f3e, 36, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f3e, 0, 36, 1, 0xa5a5a5a5a5a59f3e) + EXT( 0xa5a5a5a5a5a59f3d, 36, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f3d, 36, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f3d, 1, 36, 2, 0xa5a5a595a5a59f3d) + EXT( 0xa5a5a5a5a5a59f3c, 36, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f3c, 36, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f3c, 3, 36, 3, 0xa5a5a5b5a5a59f3c) + EXT( 0xa5a5a5a5a5a59f3b, 36, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59f3b, 36, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59f3b, 7, 36, 4, 0xa5a5a575a5a59f3b) + EXT( 0xa5a5a5a5a5a59f3a, 36, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59f3a, 36, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59f3a, 15, 36, 5, 0xa5a5a4f5a5a59f3a) + EXT( 0xa5a5a5a5a5a59f39, 36, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a59f39, 36, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59f39, 31, 36, 6, 0xa5a5a5f5a5a59f39) + EXT( 0xa5a5a5a5a5a59f38, 36, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a59f38, 36, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f38, 63, 36, 7, 0xa5a5a3f5a5a59f38) + EXT( 0xa5a5a5a5a5a59f37, 36, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59f37, 36, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f37, 127, 36, 8, 0xa5a5a7f5a5a59f37) + EXT( 0xa5a5a5a5a5a59f36, 36, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59f36, 36, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f36, 255, 36, 9, 0xa5a5aff5a5a59f36) + EXT( 0xa5a5a5a5a5a59f35, 36, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a59f35, 36, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59f35, 511, 36, 10, 0xa5a59ff5a5a59f35) + EXT( 0xa5a5a5a5a5a59f34, 36, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a59f34, 36, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59f34, 1023, 36, 11, 0xa5a5bff5a5a59f34) + EXT( 0xa5a5a5a5a5a59f33, 36, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59f33, 36, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a59f33, 2047, 36, 12, 0xa5a57ff5a5a59f33) + EXT( 0xa5a5a5a5a5a59f32, 36, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59f32, 36, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59f32, 4095, 36, 13, 0xa5a4fff5a5a59f32) + EXT( 0xa5a5a5a5a5a59f31, 36, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a59f31, 36, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59f31, 8191, 36, 14, 0xa5a5fff5a5a59f31) + EXT( 0xa5a5a5a5a5a59f30, 36, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a59f30, 36, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59f30, 16383, 36, 15, 0xa5a3fff5a5a59f30) + EXT( 0xa5a5a5a5a5a59f2f, 36, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a59f2f, 36, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59f2f, 32767, 36, 16, 0xa5a7fff5a5a59f2f) + EXT( 0xa5a5a5a5a5a59f2e, 36, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a59f2e, 36, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59f2e, 65535, 36, 17, 0xa5affff5a5a59f2e) + EXT( 0xa5a5a5a5a5a59f2d, 36, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a59f2d, 36, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a59f2d, 131071, 36, 18, 0xa59ffff5a5a59f2d) + EXT( 0xa5a5a5a5a5a59f2c, 36, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a59f2c, 36, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a59f2c, 262143, 36, 19, 0xa5bffff5a5a59f2c) + EXT( 0xa5a5a5a5a5a59f2b, 36, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a59f2b, 36, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a59f2b, 524287, 36, 20, 0xa57ffff5a5a59f2b) + EXT( 0xa5a5a5a5a5a59f2a, 36, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a59f2a, 36, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a59f2a, 1048575, 36, 21, 0xa4fffff5a5a59f2a) + EXT( 0xa5a5a5a5a5a59f29, 36, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a59f29, 36, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a59f29, 2097151, 36, 22, 0xa5fffff5a5a59f29) + EXT( 0xa5a5a5a5a5a59f28, 36, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a59f28, 36, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a59f28, 4194303, 36, 23, 0xa3fffff5a5a59f28) + EXT( 0xa5a5a5a5a5a59f27, 36, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a59f27, 36, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a59f27, 8388607, 36, 24, 0xa7fffff5a5a59f27) + EXT( 0xa5a5a5a5a5a59f26, 36, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a59f26, 36, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a59f26, 16777215, 36, 25, 0xaffffff5a5a59f26) + EXT( 0xa5a5a5a5a5a59f25, 36, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a59f25, 36, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a59f25, 33554431, 36, 26, 0x9ffffff5a5a59f25) + EXT( 0xa5a5a5a5a5a59f24, 36, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a59f24, 36, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a59f24, 67108863, 36, 27, 0xbffffff5a5a59f24) + EXT( 0xa5a5a5a5a5a59f23, 37, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59f23, 37, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f23, 0, 37, 1, 0xa5a5a585a5a59f23) + EXT( 0xa5a5a5a5a5a59f22, 37, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f22, 37, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f22, 1, 37, 2, 0xa5a5a5a5a5a59f22) + EXT( 0xa5a5a5a5a5a59f21, 37, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59f21, 37, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59f21, 3, 37, 3, 0xa5a5a565a5a59f21) + EXT( 0xa5a5a5a5a5a59f20, 37, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59f20, 37, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59f20, 7, 37, 4, 0xa5a5a4e5a5a59f20) + EXT( 0xa5a5a5a5a5a59f1f, 37, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a59f1f, 37, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59f1f, 15, 37, 5, 0xa5a5a5e5a5a59f1f) + EXT( 0xa5a5a5a5a5a59f1e, 37, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a59f1e, 37, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f1e, 31, 37, 6, 0xa5a5a3e5a5a59f1e) + EXT( 0xa5a5a5a5a5a59f1d, 37, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59f1d, 37, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f1d, 63, 37, 7, 0xa5a5a7e5a5a59f1d) + EXT( 0xa5a5a5a5a5a59f1c, 37, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59f1c, 37, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f1c, 127, 37, 8, 0xa5a5afe5a5a59f1c) + EXT( 0xa5a5a5a5a5a59f1b, 37, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a59f1b, 37, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59f1b, 255, 37, 9, 0xa5a59fe5a5a59f1b) + EXT( 0xa5a5a5a5a5a59f1a, 37, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a59f1a, 37, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59f1a, 511, 37, 10, 0xa5a5bfe5a5a59f1a) + EXT( 0xa5a5a5a5a5a59f19, 37, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59f19, 37, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a59f19, 1023, 37, 11, 0xa5a57fe5a5a59f19) + EXT( 0xa5a5a5a5a5a59f18, 37, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59f18, 37, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59f18, 2047, 37, 12, 0xa5a4ffe5a5a59f18) + EXT( 0xa5a5a5a5a5a59f17, 37, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a59f17, 37, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59f17, 4095, 37, 13, 0xa5a5ffe5a5a59f17) + EXT( 0xa5a5a5a5a5a59f16, 37, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a59f16, 37, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59f16, 8191, 37, 14, 0xa5a3ffe5a5a59f16) + EXT( 0xa5a5a5a5a5a59f15, 37, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a59f15, 37, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59f15, 16383, 37, 15, 0xa5a7ffe5a5a59f15) + EXT( 0xa5a5a5a5a5a59f14, 37, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a59f14, 37, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59f14, 32767, 37, 16, 0xa5afffe5a5a59f14) + EXT( 0xa5a5a5a5a5a59f13, 37, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a59f13, 37, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a59f13, 65535, 37, 17, 0xa59fffe5a5a59f13) + EXT( 0xa5a5a5a5a5a59f12, 37, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a59f12, 37, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a59f12, 131071, 37, 18, 0xa5bfffe5a5a59f12) + EXT( 0xa5a5a5a5a5a59f11, 37, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a59f11, 37, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a59f11, 262143, 37, 19, 0xa57fffe5a5a59f11) + EXT( 0xa5a5a5a5a5a59f10, 37, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a59f10, 37, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a59f10, 524287, 37, 20, 0xa4ffffe5a5a59f10) + EXT( 0xa5a5a5a5a5a59f0f, 37, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a59f0f, 37, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a59f0f, 1048575, 37, 21, 0xa5ffffe5a5a59f0f) + EXT( 0xa5a5a5a5a5a59f0e, 37, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a59f0e, 37, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a59f0e, 2097151, 37, 22, 0xa3ffffe5a5a59f0e) + EXT( 0xa5a5a5a5a5a59f0d, 37, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a59f0d, 37, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a59f0d, 4194303, 37, 23, 0xa7ffffe5a5a59f0d) + EXT( 0xa5a5a5a5a5a59f0c, 37, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a59f0c, 37, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a59f0c, 8388607, 37, 24, 0xafffffe5a5a59f0c) + EXT( 0xa5a5a5a5a5a59f0b, 37, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a59f0b, 37, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a59f0b, 16777215, 37, 25, 0x9fffffe5a5a59f0b) + EXT( 0xa5a5a5a5a5a59f0a, 37, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a59f0a, 37, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a59f0a, 33554431, 37, 26, 0xbfffffe5a5a59f0a) + EXT( 0xa5a5a5a5a5a59f09, 38, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f09, 38, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f09, 0, 38, 1, 0xa5a5a5a5a5a59f09) + EXT( 0xa5a5a5a5a5a59f08, 38, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f08, 38, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f08, 1, 38, 2, 0xa5a5a565a5a59f08) + EXT( 0xa5a5a5a5a5a59f07, 38, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f07, 38, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59f07, 3, 38, 3, 0xa5a5a4e5a5a59f07) + EXT( 0xa5a5a5a5a5a59f06, 38, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59f06, 38, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59f06, 7, 38, 4, 0xa5a5a5e5a5a59f06) + EXT( 0xa5a5a5a5a5a59f05, 38, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59f05, 38, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f05, 15, 38, 5, 0xa5a5a3e5a5a59f05) + EXT( 0xa5a5a5a5a5a59f04, 38, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59f04, 38, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f04, 31, 38, 6, 0xa5a5a7e5a5a59f04) + EXT( 0xa5a5a5a5a5a59f03, 38, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59f03, 38, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f03, 63, 38, 7, 0xa5a5afe5a5a59f03) + EXT( 0xa5a5a5a5a5a59f02, 38, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59f02, 38, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59f02, 127, 38, 8, 0xa5a59fe5a5a59f02) + EXT( 0xa5a5a5a5a5a59f01, 38, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59f01, 38, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59f01, 255, 38, 9, 0xa5a5bfe5a5a59f01) + EXT( 0xa5a5a5a5a5a59f00, 38, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59f00, 38, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a59f00, 511, 38, 10, 0xa5a57fe5a5a59f00) + EXT( 0xa5a5a5a5a5a59eff, 38, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59eff, 38, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59eff, 1023, 38, 11, 0xa5a4ffe5a5a59eff) + EXT( 0xa5a5a5a5a5a59efe, 38, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a59efe, 38, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59efe, 2047, 38, 12, 0xa5a5ffe5a5a59efe) + EXT( 0xa5a5a5a5a5a59efd, 38, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a59efd, 38, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59efd, 4095, 38, 13, 0xa5a3ffe5a5a59efd) + EXT( 0xa5a5a5a5a5a59efc, 38, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59efc, 38, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59efc, 8191, 38, 14, 0xa5a7ffe5a5a59efc) + EXT( 0xa5a5a5a5a5a59efb, 38, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59efb, 38, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59efb, 16383, 38, 15, 0xa5afffe5a5a59efb) + EXT( 0xa5a5a5a5a5a59efa, 38, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a59efa, 38, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59efa, 32767, 38, 16, 0xa59fffe5a5a59efa) + EXT( 0xa5a5a5a5a5a59ef9, 38, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a59ef9, 38, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59ef9, 65535, 38, 17, 0xa5bfffe5a5a59ef9) + EXT( 0xa5a5a5a5a5a59ef8, 38, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59ef8, 38, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a59ef8, 131071, 38, 18, 0xa57fffe5a5a59ef8) + EXT( 0xa5a5a5a5a5a59ef7, 38, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59ef7, 38, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59ef7, 262143, 38, 19, 0xa4ffffe5a5a59ef7) + EXT( 0xa5a5a5a5a5a59ef6, 38, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a59ef6, 38, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59ef6, 524287, 38, 20, 0xa5ffffe5a5a59ef6) + EXT( 0xa5a5a5a5a5a59ef5, 38, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a59ef5, 38, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59ef5, 1048575, 38, 21, 0xa3ffffe5a5a59ef5) + EXT( 0xa5a5a5a5a5a59ef4, 38, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a59ef4, 38, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59ef4, 2097151, 38, 22, 0xa7ffffe5a5a59ef4) + EXT( 0xa5a5a5a5a5a59ef3, 38, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a59ef3, 38, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a59ef3, 4194303, 38, 23, 0xafffffe5a5a59ef3) + EXT( 0xa5a5a5a5a5a59ef2, 38, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a59ef2, 38, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a59ef2, 8388607, 38, 24, 0x9fffffe5a5a59ef2) + EXT( 0xa5a5a5a5a5a59ef1, 38, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a59ef1, 38, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a59ef1, 16777215, 38, 25, 0xbfffffe5a5a59ef1) + EXT( 0xa5a5a5a5a5a59ef0, 39, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59ef0, 39, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ef0, 0, 39, 1, 0xa5a5a525a5a59ef0) + EXT( 0xa5a5a5a5a5a59eef, 39, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59eef, 39, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59eef, 1, 39, 2, 0xa5a5a4a5a5a59eef) + EXT( 0xa5a5a5a5a5a59eee, 39, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59eee, 39, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59eee, 3, 39, 3, 0xa5a5a5a5a5a59eee) + EXT( 0xa5a5a5a5a5a59eed, 39, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59eed, 39, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59eed, 7, 39, 4, 0xa5a5a3a5a5a59eed) + EXT( 0xa5a5a5a5a5a59eec, 39, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59eec, 39, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59eec, 15, 39, 5, 0xa5a5a7a5a5a59eec) + EXT( 0xa5a5a5a5a5a59eeb, 39, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59eeb, 39, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59eeb, 31, 39, 6, 0xa5a5afa5a5a59eeb) + EXT( 0xa5a5a5a5a5a59eea, 39, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59eea, 39, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59eea, 63, 39, 7, 0xa5a59fa5a5a59eea) + EXT( 0xa5a5a5a5a5a59ee9, 39, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59ee9, 39, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59ee9, 127, 39, 8, 0xa5a5bfa5a5a59ee9) + EXT( 0xa5a5a5a5a5a59ee8, 39, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59ee8, 39, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a59ee8, 255, 39, 9, 0xa5a57fa5a5a59ee8) + EXT( 0xa5a5a5a5a5a59ee7, 39, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59ee7, 39, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59ee7, 511, 39, 10, 0xa5a4ffa5a5a59ee7) + EXT( 0xa5a5a5a5a5a59ee6, 39, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a59ee6, 39, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59ee6, 1023, 39, 11, 0xa5a5ffa5a5a59ee6) + EXT( 0xa5a5a5a5a5a59ee5, 39, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a59ee5, 39, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59ee5, 2047, 39, 12, 0xa5a3ffa5a5a59ee5) + EXT( 0xa5a5a5a5a5a59ee4, 39, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59ee4, 39, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59ee4, 4095, 39, 13, 0xa5a7ffa5a5a59ee4) + EXT( 0xa5a5a5a5a5a59ee3, 39, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59ee3, 39, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59ee3, 8191, 39, 14, 0xa5afffa5a5a59ee3) + EXT( 0xa5a5a5a5a5a59ee2, 39, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a59ee2, 39, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59ee2, 16383, 39, 15, 0xa59fffa5a5a59ee2) + EXT( 0xa5a5a5a5a5a59ee1, 39, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a59ee1, 39, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59ee1, 32767, 39, 16, 0xa5bfffa5a5a59ee1) + EXT( 0xa5a5a5a5a5a59ee0, 39, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59ee0, 39, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a59ee0, 65535, 39, 17, 0xa57fffa5a5a59ee0) + EXT( 0xa5a5a5a5a5a59edf, 39, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59edf, 39, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59edf, 131071, 39, 18, 0xa4ffffa5a5a59edf) + EXT( 0xa5a5a5a5a5a59ede, 39, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a59ede, 39, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59ede, 262143, 39, 19, 0xa5ffffa5a5a59ede) + EXT( 0xa5a5a5a5a5a59edd, 39, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a59edd, 39, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59edd, 524287, 39, 20, 0xa3ffffa5a5a59edd) + EXT( 0xa5a5a5a5a5a59edc, 39, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a59edc, 39, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59edc, 1048575, 39, 21, 0xa7ffffa5a5a59edc) + EXT( 0xa5a5a5a5a5a59edb, 39, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a59edb, 39, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a59edb, 2097151, 39, 22, 0xafffffa5a5a59edb) + EXT( 0xa5a5a5a5a5a59eda, 39, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a59eda, 39, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a59eda, 4194303, 39, 23, 0x9fffffa5a5a59eda) + EXT( 0xa5a5a5a5a5a59ed9, 39, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a59ed9, 39, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a59ed9, 8388607, 39, 24, 0xbfffffa5a5a59ed9) + EXT( 0xa5a5a5a5a5a59ed8, 40, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59ed8, 40, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ed8, 0, 40, 1, 0xa5a5a4a5a5a59ed8) + EXT( 0xa5a5a5a5a5a59ed7, 40, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59ed7, 40, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ed7, 1, 40, 2, 0xa5a5a5a5a5a59ed7) + EXT( 0xa5a5a5a5a5a59ed6, 40, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59ed6, 40, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ed6, 3, 40, 3, 0xa5a5a3a5a5a59ed6) + EXT( 0xa5a5a5a5a5a59ed5, 40, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59ed5, 40, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ed5, 7, 40, 4, 0xa5a5a7a5a5a59ed5) + EXT( 0xa5a5a5a5a5a59ed4, 40, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59ed4, 40, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ed4, 15, 40, 5, 0xa5a5afa5a5a59ed4) + EXT( 0xa5a5a5a5a5a59ed3, 40, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59ed3, 40, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59ed3, 31, 40, 6, 0xa5a59fa5a5a59ed3) + EXT( 0xa5a5a5a5a5a59ed2, 40, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59ed2, 40, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59ed2, 63, 40, 7, 0xa5a5bfa5a5a59ed2) + EXT( 0xa5a5a5a5a5a59ed1, 40, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59ed1, 40, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a59ed1, 127, 40, 8, 0xa5a57fa5a5a59ed1) + EXT( 0xa5a5a5a5a5a59ed0, 40, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59ed0, 40, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59ed0, 255, 40, 9, 0xa5a4ffa5a5a59ed0) + EXT( 0xa5a5a5a5a5a59ecf, 40, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a59ecf, 40, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59ecf, 511, 40, 10, 0xa5a5ffa5a5a59ecf) + EXT( 0xa5a5a5a5a5a59ece, 40, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a59ece, 40, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59ece, 1023, 40, 11, 0xa5a3ffa5a5a59ece) + EXT( 0xa5a5a5a5a5a59ecd, 40, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59ecd, 40, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59ecd, 2047, 40, 12, 0xa5a7ffa5a5a59ecd) + EXT( 0xa5a5a5a5a5a59ecc, 40, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59ecc, 40, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59ecc, 4095, 40, 13, 0xa5afffa5a5a59ecc) + EXT( 0xa5a5a5a5a5a59ecb, 40, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a59ecb, 40, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59ecb, 8191, 40, 14, 0xa59fffa5a5a59ecb) + EXT( 0xa5a5a5a5a5a59eca, 40, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a59eca, 40, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59eca, 16383, 40, 15, 0xa5bfffa5a5a59eca) + EXT( 0xa5a5a5a5a5a59ec9, 40, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59ec9, 40, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a59ec9, 32767, 40, 16, 0xa57fffa5a5a59ec9) + EXT( 0xa5a5a5a5a5a59ec8, 40, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59ec8, 40, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59ec8, 65535, 40, 17, 0xa4ffffa5a5a59ec8) + EXT( 0xa5a5a5a5a5a59ec7, 40, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a59ec7, 40, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59ec7, 131071, 40, 18, 0xa5ffffa5a5a59ec7) + EXT( 0xa5a5a5a5a5a59ec6, 40, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a59ec6, 40, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59ec6, 262143, 40, 19, 0xa3ffffa5a5a59ec6) + EXT( 0xa5a5a5a5a5a59ec5, 40, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a59ec5, 40, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59ec5, 524287, 40, 20, 0xa7ffffa5a5a59ec5) + EXT( 0xa5a5a5a5a5a59ec4, 40, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a59ec4, 40, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a59ec4, 1048575, 40, 21, 0xafffffa5a5a59ec4) + EXT( 0xa5a5a5a5a5a59ec3, 40, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a59ec3, 40, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a59ec3, 2097151, 40, 22, 0x9fffffa5a5a59ec3) + EXT( 0xa5a5a5a5a5a59ec2, 40, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a59ec2, 40, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a59ec2, 4194303, 40, 23, 0xbfffffa5a5a59ec2) + EXT( 0xa5a5a5a5a5a59ec1, 41, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59ec1, 41, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59ec1, 0, 41, 1, 0xa5a5a5a5a5a59ec1) + EXT( 0xa5a5a5a5a5a59ec0, 41, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59ec0, 41, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ec0, 1, 41, 2, 0xa5a5a3a5a5a59ec0) + EXT( 0xa5a5a5a5a5a59ebf, 41, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59ebf, 41, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ebf, 3, 41, 3, 0xa5a5a7a5a5a59ebf) + EXT( 0xa5a5a5a5a5a59ebe, 41, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59ebe, 41, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ebe, 7, 41, 4, 0xa5a5afa5a5a59ebe) + EXT( 0xa5a5a5a5a5a59ebd, 41, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59ebd, 41, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59ebd, 15, 41, 5, 0xa5a59fa5a5a59ebd) + EXT( 0xa5a5a5a5a5a59ebc, 41, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59ebc, 41, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59ebc, 31, 41, 6, 0xa5a5bfa5a5a59ebc) + EXT( 0xa5a5a5a5a5a59ebb, 41, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59ebb, 41, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a59ebb, 63, 41, 7, 0xa5a57fa5a5a59ebb) + EXT( 0xa5a5a5a5a5a59eba, 41, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59eba, 41, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59eba, 127, 41, 8, 0xa5a4ffa5a5a59eba) + EXT( 0xa5a5a5a5a5a59eb9, 41, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a59eb9, 41, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59eb9, 255, 41, 9, 0xa5a5ffa5a5a59eb9) + EXT( 0xa5a5a5a5a5a59eb8, 41, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a59eb8, 41, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59eb8, 511, 41, 10, 0xa5a3ffa5a5a59eb8) + EXT( 0xa5a5a5a5a5a59eb7, 41, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59eb7, 41, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59eb7, 1023, 41, 11, 0xa5a7ffa5a5a59eb7) + EXT( 0xa5a5a5a5a5a59eb6, 41, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59eb6, 41, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59eb6, 2047, 41, 12, 0xa5afffa5a5a59eb6) + EXT( 0xa5a5a5a5a5a59eb5, 41, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a59eb5, 41, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59eb5, 4095, 41, 13, 0xa59fffa5a5a59eb5) + EXT( 0xa5a5a5a5a5a59eb4, 41, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a59eb4, 41, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59eb4, 8191, 41, 14, 0xa5bfffa5a5a59eb4) + EXT( 0xa5a5a5a5a5a59eb3, 41, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59eb3, 41, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a59eb3, 16383, 41, 15, 0xa57fffa5a5a59eb3) + EXT( 0xa5a5a5a5a5a59eb2, 41, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59eb2, 41, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59eb2, 32767, 41, 16, 0xa4ffffa5a5a59eb2) + EXT( 0xa5a5a5a5a5a59eb1, 41, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a59eb1, 41, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59eb1, 65535, 41, 17, 0xa5ffffa5a5a59eb1) + EXT( 0xa5a5a5a5a5a59eb0, 41, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a59eb0, 41, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59eb0, 131071, 41, 18, 0xa3ffffa5a5a59eb0) + EXT( 0xa5a5a5a5a5a59eaf, 41, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a59eaf, 41, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59eaf, 262143, 41, 19, 0xa7ffffa5a5a59eaf) + EXT( 0xa5a5a5a5a5a59eae, 41, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a59eae, 41, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a59eae, 524287, 41, 20, 0xafffffa5a5a59eae) + EXT( 0xa5a5a5a5a5a59ead, 41, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a59ead, 41, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a59ead, 1048575, 41, 21, 0x9fffffa5a5a59ead) + EXT( 0xa5a5a5a5a5a59eac, 41, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a59eac, 41, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a59eac, 2097151, 41, 22, 0xbfffffa5a5a59eac) + EXT( 0xa5a5a5a5a5a59eab, 42, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59eab, 42, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59eab, 0, 42, 1, 0xa5a5a1a5a5a59eab) + EXT( 0xa5a5a5a5a5a59eaa, 42, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59eaa, 42, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59eaa, 1, 42, 2, 0xa5a5a5a5a5a59eaa) + EXT( 0xa5a5a5a5a5a59ea9, 42, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59ea9, 42, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ea9, 3, 42, 3, 0xa5a5ada5a5a59ea9) + EXT( 0xa5a5a5a5a5a59ea8, 42, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59ea8, 42, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59ea8, 7, 42, 4, 0xa5a59da5a5a59ea8) + EXT( 0xa5a5a5a5a5a59ea7, 42, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59ea7, 42, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59ea7, 15, 42, 5, 0xa5a5bda5a5a59ea7) + EXT( 0xa5a5a5a5a5a59ea6, 42, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59ea6, 42, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a59ea6, 31, 42, 6, 0xa5a57da5a5a59ea6) + EXT( 0xa5a5a5a5a5a59ea5, 42, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59ea5, 42, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59ea5, 63, 42, 7, 0xa5a4fda5a5a59ea5) + EXT( 0xa5a5a5a5a5a59ea4, 42, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a59ea4, 42, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59ea4, 127, 42, 8, 0xa5a5fda5a5a59ea4) + EXT( 0xa5a5a5a5a5a59ea3, 42, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a59ea3, 42, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59ea3, 255, 42, 9, 0xa5a3fda5a5a59ea3) + EXT( 0xa5a5a5a5a5a59ea2, 42, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59ea2, 42, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59ea2, 511, 42, 10, 0xa5a7fda5a5a59ea2) + EXT( 0xa5a5a5a5a5a59ea1, 42, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59ea1, 42, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59ea1, 1023, 42, 11, 0xa5affda5a5a59ea1) + EXT( 0xa5a5a5a5a5a59ea0, 42, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a59ea0, 42, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59ea0, 2047, 42, 12, 0xa59ffda5a5a59ea0) + EXT( 0xa5a5a5a5a5a59e9f, 42, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a59e9f, 42, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59e9f, 4095, 42, 13, 0xa5bffda5a5a59e9f) + EXT( 0xa5a5a5a5a5a59e9e, 42, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59e9e, 42, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a59e9e, 8191, 42, 14, 0xa57ffda5a5a59e9e) + EXT( 0xa5a5a5a5a5a59e9d, 42, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59e9d, 42, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59e9d, 16383, 42, 15, 0xa4fffda5a5a59e9d) + EXT( 0xa5a5a5a5a5a59e9c, 42, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a59e9c, 42, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59e9c, 32767, 42, 16, 0xa5fffda5a5a59e9c) + EXT( 0xa5a5a5a5a5a59e9b, 42, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a59e9b, 42, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59e9b, 65535, 42, 17, 0xa3fffda5a5a59e9b) + EXT( 0xa5a5a5a5a5a59e9a, 42, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a59e9a, 42, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59e9a, 131071, 42, 18, 0xa7fffda5a5a59e9a) + EXT( 0xa5a5a5a5a5a59e99, 42, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a59e99, 42, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a59e99, 262143, 42, 19, 0xaffffda5a5a59e99) + EXT( 0xa5a5a5a5a5a59e98, 42, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a59e98, 42, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a59e98, 524287, 42, 20, 0x9ffffda5a5a59e98) + EXT( 0xa5a5a5a5a5a59e97, 42, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a59e97, 42, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a59e97, 1048575, 42, 21, 0xbffffda5a5a59e97) + EXT( 0xa5a5a5a5a5a59e96, 43, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e96, 43, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e96, 0, 43, 1, 0xa5a5a5a5a5a59e96) + EXT( 0xa5a5a5a5a5a59e95, 43, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e95, 43, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e95, 1, 43, 2, 0xa5a5ada5a5a59e95) + EXT( 0xa5a5a5a5a5a59e94, 43, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e94, 43, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59e94, 3, 43, 3, 0xa5a59da5a5a59e94) + EXT( 0xa5a5a5a5a5a59e93, 43, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59e93, 43, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59e93, 7, 43, 4, 0xa5a5bda5a5a59e93) + EXT( 0xa5a5a5a5a5a59e92, 43, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59e92, 43, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a59e92, 15, 43, 5, 0xa5a57da5a5a59e92) + EXT( 0xa5a5a5a5a5a59e91, 43, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59e91, 43, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59e91, 31, 43, 6, 0xa5a4fda5a5a59e91) + EXT( 0xa5a5a5a5a5a59e90, 43, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a59e90, 43, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59e90, 63, 43, 7, 0xa5a5fda5a5a59e90) + EXT( 0xa5a5a5a5a5a59e8f, 43, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a59e8f, 43, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e8f, 127, 43, 8, 0xa5a3fda5a5a59e8f) + EXT( 0xa5a5a5a5a5a59e8e, 43, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59e8e, 43, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e8e, 255, 43, 9, 0xa5a7fda5a5a59e8e) + EXT( 0xa5a5a5a5a5a59e8d, 43, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59e8d, 43, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e8d, 511, 43, 10, 0xa5affda5a5a59e8d) + EXT( 0xa5a5a5a5a5a59e8c, 43, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a59e8c, 43, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59e8c, 1023, 43, 11, 0xa59ffda5a5a59e8c) + EXT( 0xa5a5a5a5a5a59e8b, 43, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a59e8b, 43, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59e8b, 2047, 43, 12, 0xa5bffda5a5a59e8b) + EXT( 0xa5a5a5a5a5a59e8a, 43, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59e8a, 43, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a59e8a, 4095, 43, 13, 0xa57ffda5a5a59e8a) + EXT( 0xa5a5a5a5a5a59e89, 43, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59e89, 43, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59e89, 8191, 43, 14, 0xa4fffda5a5a59e89) + EXT( 0xa5a5a5a5a5a59e88, 43, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a59e88, 43, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59e88, 16383, 43, 15, 0xa5fffda5a5a59e88) + EXT( 0xa5a5a5a5a5a59e87, 43, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a59e87, 43, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59e87, 32767, 43, 16, 0xa3fffda5a5a59e87) + EXT( 0xa5a5a5a5a5a59e86, 43, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a59e86, 43, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59e86, 65535, 43, 17, 0xa7fffda5a5a59e86) + EXT( 0xa5a5a5a5a5a59e85, 43, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a59e85, 43, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a59e85, 131071, 43, 18, 0xaffffda5a5a59e85) + EXT( 0xa5a5a5a5a5a59e84, 43, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a59e84, 43, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a59e84, 262143, 43, 19, 0x9ffffda5a5a59e84) + EXT( 0xa5a5a5a5a5a59e83, 43, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a59e83, 43, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a59e83, 524287, 43, 20, 0xbffffda5a5a59e83) + EXT( 0xa5a5a5a5a5a59e82, 44, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e82, 44, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e82, 0, 44, 1, 0xa5a5a5a5a5a59e82) + EXT( 0xa5a5a5a5a5a59e81, 44, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e81, 44, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e81, 1, 44, 2, 0xa5a595a5a5a59e81) + EXT( 0xa5a5a5a5a5a59e80, 44, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e80, 44, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e80, 3, 44, 3, 0xa5a5b5a5a5a59e80) + EXT( 0xa5a5a5a5a5a59e7f, 44, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59e7f, 44, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59e7f, 7, 44, 4, 0xa5a575a5a5a59e7f) + EXT( 0xa5a5a5a5a5a59e7e, 44, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59e7e, 44, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59e7e, 15, 44, 5, 0xa5a4f5a5a5a59e7e) + EXT( 0xa5a5a5a5a5a59e7d, 44, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a59e7d, 44, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59e7d, 31, 44, 6, 0xa5a5f5a5a5a59e7d) + EXT( 0xa5a5a5a5a5a59e7c, 44, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a59e7c, 44, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59e7c, 63, 44, 7, 0xa5a3f5a5a5a59e7c) + EXT( 0xa5a5a5a5a5a59e7b, 44, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59e7b, 44, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59e7b, 127, 44, 8, 0xa5a7f5a5a5a59e7b) + EXT( 0xa5a5a5a5a5a59e7a, 44, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59e7a, 44, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59e7a, 255, 44, 9, 0xa5aff5a5a5a59e7a) + EXT( 0xa5a5a5a5a5a59e79, 44, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a59e79, 44, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59e79, 511, 44, 10, 0xa59ff5a5a5a59e79) + EXT( 0xa5a5a5a5a5a59e78, 44, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a59e78, 44, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59e78, 1023, 44, 11, 0xa5bff5a5a5a59e78) + EXT( 0xa5a5a5a5a5a59e77, 44, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59e77, 44, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a59e77, 2047, 44, 12, 0xa57ff5a5a5a59e77) + EXT( 0xa5a5a5a5a5a59e76, 44, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59e76, 44, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59e76, 4095, 44, 13, 0xa4fff5a5a5a59e76) + EXT( 0xa5a5a5a5a5a59e75, 44, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a59e75, 44, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59e75, 8191, 44, 14, 0xa5fff5a5a5a59e75) + EXT( 0xa5a5a5a5a5a59e74, 44, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a59e74, 44, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59e74, 16383, 44, 15, 0xa3fff5a5a5a59e74) + EXT( 0xa5a5a5a5a5a59e73, 44, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a59e73, 44, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59e73, 32767, 44, 16, 0xa7fff5a5a5a59e73) + EXT( 0xa5a5a5a5a5a59e72, 44, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a59e72, 44, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a59e72, 65535, 44, 17, 0xaffff5a5a5a59e72) + EXT( 0xa5a5a5a5a5a59e71, 44, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a59e71, 44, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a59e71, 131071, 44, 18, 0x9ffff5a5a5a59e71) + EXT( 0xa5a5a5a5a5a59e70, 44, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a59e70, 44, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a59e70, 262143, 44, 19, 0xbffff5a5a5a59e70) + EXT( 0xa5a5a5a5a5a59e6f, 45, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e6f, 45, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e6f, 0, 45, 1, 0xa5a585a5a5a59e6f) + EXT( 0xa5a5a5a5a5a59e6e, 45, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e6e, 45, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e6e, 1, 45, 2, 0xa5a5a5a5a5a59e6e) + EXT( 0xa5a5a5a5a5a59e6d, 45, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59e6d, 45, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e6d, 3, 45, 3, 0xa5a565a5a5a59e6d) + EXT( 0xa5a5a5a5a5a59e6c, 45, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59e6c, 45, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59e6c, 7, 45, 4, 0xa5a4e5a5a5a59e6c) + EXT( 0xa5a5a5a5a5a59e6b, 45, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a59e6b, 45, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59e6b, 15, 45, 5, 0xa5a5e5a5a5a59e6b) + EXT( 0xa5a5a5a5a5a59e6a, 45, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a59e6a, 45, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59e6a, 31, 45, 6, 0xa5a3e5a5a5a59e6a) + EXT( 0xa5a5a5a5a5a59e69, 45, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59e69, 45, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59e69, 63, 45, 7, 0xa5a7e5a5a5a59e69) + EXT( 0xa5a5a5a5a5a59e68, 45, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59e68, 45, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59e68, 127, 45, 8, 0xa5afe5a5a5a59e68) + EXT( 0xa5a5a5a5a5a59e67, 45, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a59e67, 45, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59e67, 255, 45, 9, 0xa59fe5a5a5a59e67) + EXT( 0xa5a5a5a5a5a59e66, 45, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a59e66, 45, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59e66, 511, 45, 10, 0xa5bfe5a5a5a59e66) + EXT( 0xa5a5a5a5a5a59e65, 45, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59e65, 45, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a59e65, 1023, 45, 11, 0xa57fe5a5a5a59e65) + EXT( 0xa5a5a5a5a5a59e64, 45, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59e64, 45, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59e64, 2047, 45, 12, 0xa4ffe5a5a5a59e64) + EXT( 0xa5a5a5a5a5a59e63, 45, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a59e63, 45, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59e63, 4095, 45, 13, 0xa5ffe5a5a5a59e63) + EXT( 0xa5a5a5a5a5a59e62, 45, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a59e62, 45, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59e62, 8191, 45, 14, 0xa3ffe5a5a5a59e62) + EXT( 0xa5a5a5a5a5a59e61, 45, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a59e61, 45, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59e61, 16383, 45, 15, 0xa7ffe5a5a5a59e61) + EXT( 0xa5a5a5a5a5a59e60, 45, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a59e60, 45, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a59e60, 32767, 45, 16, 0xafffe5a5a5a59e60) + EXT( 0xa5a5a5a5a5a59e5f, 45, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a59e5f, 45, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a59e5f, 65535, 45, 17, 0x9fffe5a5a5a59e5f) + EXT( 0xa5a5a5a5a5a59e5e, 45, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a59e5e, 45, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a59e5e, 131071, 45, 18, 0xbfffe5a5a5a59e5e) + EXT( 0xa5a5a5a5a5a59e5d, 46, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e5d, 46, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e5d, 0, 46, 1, 0xa5a5a5a5a5a59e5d) + EXT( 0xa5a5a5a5a5a59e5c, 46, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e5c, 46, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e5c, 1, 46, 2, 0xa5a565a5a5a59e5c) + EXT( 0xa5a5a5a5a5a59e5b, 46, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e5b, 46, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59e5b, 3, 46, 3, 0xa5a4e5a5a5a59e5b) + EXT( 0xa5a5a5a5a5a59e5a, 46, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59e5a, 46, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59e5a, 7, 46, 4, 0xa5a5e5a5a5a59e5a) + EXT( 0xa5a5a5a5a5a59e59, 46, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59e59, 46, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e59, 15, 46, 5, 0xa5a3e5a5a5a59e59) + EXT( 0xa5a5a5a5a5a59e58, 46, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59e58, 46, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e58, 31, 46, 6, 0xa5a7e5a5a5a59e58) + EXT( 0xa5a5a5a5a5a59e57, 46, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59e57, 46, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e57, 63, 46, 7, 0xa5afe5a5a5a59e57) + EXT( 0xa5a5a5a5a5a59e56, 46, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59e56, 46, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59e56, 127, 46, 8, 0xa59fe5a5a5a59e56) + EXT( 0xa5a5a5a5a5a59e55, 46, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59e55, 46, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59e55, 255, 46, 9, 0xa5bfe5a5a5a59e55) + EXT( 0xa5a5a5a5a5a59e54, 46, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59e54, 46, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a59e54, 511, 46, 10, 0xa57fe5a5a5a59e54) + EXT( 0xa5a5a5a5a5a59e53, 46, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59e53, 46, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59e53, 1023, 46, 11, 0xa4ffe5a5a5a59e53) + EXT( 0xa5a5a5a5a5a59e52, 46, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a59e52, 46, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59e52, 2047, 46, 12, 0xa5ffe5a5a5a59e52) + EXT( 0xa5a5a5a5a5a59e51, 46, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a59e51, 46, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59e51, 4095, 46, 13, 0xa3ffe5a5a5a59e51) + EXT( 0xa5a5a5a5a5a59e50, 46, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59e50, 46, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59e50, 8191, 46, 14, 0xa7ffe5a5a5a59e50) + EXT( 0xa5a5a5a5a5a59e4f, 46, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59e4f, 46, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59e4f, 16383, 46, 15, 0xafffe5a5a5a59e4f) + EXT( 0xa5a5a5a5a5a59e4e, 46, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a59e4e, 46, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59e4e, 32767, 46, 16, 0x9fffe5a5a5a59e4e) + EXT( 0xa5a5a5a5a5a59e4d, 46, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a59e4d, 46, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59e4d, 65535, 46, 17, 0xbfffe5a5a5a59e4d) + EXT( 0xa5a5a5a5a5a59e4c, 47, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e4c, 47, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e4c, 0, 47, 1, 0xa5a525a5a5a59e4c) + EXT( 0xa5a5a5a5a5a59e4b, 47, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e4b, 47, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e4b, 1, 47, 2, 0xa5a4a5a5a5a59e4b) + EXT( 0xa5a5a5a5a5a59e4a, 47, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59e4a, 47, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e4a, 3, 47, 3, 0xa5a5a5a5a5a59e4a) + EXT( 0xa5a5a5a5a5a59e49, 47, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59e49, 47, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e49, 7, 47, 4, 0xa5a3a5a5a5a59e49) + EXT( 0xa5a5a5a5a5a59e48, 47, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59e48, 47, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e48, 15, 47, 5, 0xa5a7a5a5a5a59e48) + EXT( 0xa5a5a5a5a5a59e47, 47, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59e47, 47, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e47, 31, 47, 6, 0xa5afa5a5a5a59e47) + EXT( 0xa5a5a5a5a5a59e46, 47, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59e46, 47, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59e46, 63, 47, 7, 0xa59fa5a5a5a59e46) + EXT( 0xa5a5a5a5a5a59e45, 47, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59e45, 47, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59e45, 127, 47, 8, 0xa5bfa5a5a5a59e45) + EXT( 0xa5a5a5a5a5a59e44, 47, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59e44, 47, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a59e44, 255, 47, 9, 0xa57fa5a5a5a59e44) + EXT( 0xa5a5a5a5a5a59e43, 47, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59e43, 47, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59e43, 511, 47, 10, 0xa4ffa5a5a5a59e43) + EXT( 0xa5a5a5a5a5a59e42, 47, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a59e42, 47, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59e42, 1023, 47, 11, 0xa5ffa5a5a5a59e42) + EXT( 0xa5a5a5a5a5a59e41, 47, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a59e41, 47, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59e41, 2047, 47, 12, 0xa3ffa5a5a5a59e41) + EXT( 0xa5a5a5a5a5a59e40, 47, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59e40, 47, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59e40, 4095, 47, 13, 0xa7ffa5a5a5a59e40) + EXT( 0xa5a5a5a5a5a59e3f, 47, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59e3f, 47, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59e3f, 8191, 47, 14, 0xafffa5a5a5a59e3f) + EXT( 0xa5a5a5a5a5a59e3e, 47, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a59e3e, 47, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59e3e, 16383, 47, 15, 0x9fffa5a5a5a59e3e) + EXT( 0xa5a5a5a5a5a59e3d, 47, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a59e3d, 47, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59e3d, 32767, 47, 16, 0xbfffa5a5a5a59e3d) + EXT( 0xa5a5a5a5a5a59e3c, 48, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e3c, 48, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e3c, 0, 48, 1, 0xa5a4a5a5a5a59e3c) + EXT( 0xa5a5a5a5a5a59e3b, 48, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e3b, 48, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e3b, 1, 48, 2, 0xa5a5a5a5a5a59e3b) + EXT( 0xa5a5a5a5a5a59e3a, 48, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59e3a, 48, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e3a, 3, 48, 3, 0xa5a3a5a5a5a59e3a) + EXT( 0xa5a5a5a5a5a59e39, 48, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59e39, 48, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e39, 7, 48, 4, 0xa5a7a5a5a5a59e39) + EXT( 0xa5a5a5a5a5a59e38, 48, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59e38, 48, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e38, 15, 48, 5, 0xa5afa5a5a5a59e38) + EXT( 0xa5a5a5a5a5a59e37, 48, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59e37, 48, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59e37, 31, 48, 6, 0xa59fa5a5a5a59e37) + EXT( 0xa5a5a5a5a5a59e36, 48, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59e36, 48, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59e36, 63, 48, 7, 0xa5bfa5a5a5a59e36) + EXT( 0xa5a5a5a5a5a59e35, 48, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59e35, 48, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a59e35, 127, 48, 8, 0xa57fa5a5a5a59e35) + EXT( 0xa5a5a5a5a5a59e34, 48, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59e34, 48, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59e34, 255, 48, 9, 0xa4ffa5a5a5a59e34) + EXT( 0xa5a5a5a5a5a59e33, 48, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a59e33, 48, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59e33, 511, 48, 10, 0xa5ffa5a5a5a59e33) + EXT( 0xa5a5a5a5a5a59e32, 48, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a59e32, 48, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59e32, 1023, 48, 11, 0xa3ffa5a5a5a59e32) + EXT( 0xa5a5a5a5a5a59e31, 48, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59e31, 48, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59e31, 2047, 48, 12, 0xa7ffa5a5a5a59e31) + EXT( 0xa5a5a5a5a5a59e30, 48, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59e30, 48, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59e30, 4095, 48, 13, 0xafffa5a5a5a59e30) + EXT( 0xa5a5a5a5a5a59e2f, 48, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a59e2f, 48, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59e2f, 8191, 48, 14, 0x9fffa5a5a5a59e2f) + EXT( 0xa5a5a5a5a5a59e2e, 48, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a59e2e, 48, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59e2e, 16383, 48, 15, 0xbfffa5a5a5a59e2e) + EXT( 0xa5a5a5a5a5a59e2d, 49, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e2d, 49, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e2d, 0, 49, 1, 0xa5a5a5a5a5a59e2d) + EXT( 0xa5a5a5a5a5a59e2c, 49, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e2c, 49, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e2c, 1, 49, 2, 0xa5a3a5a5a5a59e2c) + EXT( 0xa5a5a5a5a5a59e2b, 49, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e2b, 49, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e2b, 3, 49, 3, 0xa5a7a5a5a5a59e2b) + EXT( 0xa5a5a5a5a5a59e2a, 49, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e2a, 49, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e2a, 7, 49, 4, 0xa5afa5a5a5a59e2a) + EXT( 0xa5a5a5a5a5a59e29, 49, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59e29, 49, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59e29, 15, 49, 5, 0xa59fa5a5a5a59e29) + EXT( 0xa5a5a5a5a5a59e28, 49, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59e28, 49, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59e28, 31, 49, 6, 0xa5bfa5a5a5a59e28) + EXT( 0xa5a5a5a5a5a59e27, 49, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59e27, 49, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a59e27, 63, 49, 7, 0xa57fa5a5a5a59e27) + EXT( 0xa5a5a5a5a5a59e26, 49, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59e26, 49, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59e26, 127, 49, 8, 0xa4ffa5a5a5a59e26) + EXT( 0xa5a5a5a5a5a59e25, 49, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a59e25, 49, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59e25, 255, 49, 9, 0xa5ffa5a5a5a59e25) + EXT( 0xa5a5a5a5a5a59e24, 49, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a59e24, 49, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59e24, 511, 49, 10, 0xa3ffa5a5a5a59e24) + EXT( 0xa5a5a5a5a5a59e23, 49, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59e23, 49, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59e23, 1023, 49, 11, 0xa7ffa5a5a5a59e23) + EXT( 0xa5a5a5a5a5a59e22, 49, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59e22, 49, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59e22, 2047, 49, 12, 0xafffa5a5a5a59e22) + EXT( 0xa5a5a5a5a5a59e21, 49, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a59e21, 49, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59e21, 4095, 49, 13, 0x9fffa5a5a5a59e21) + EXT( 0xa5a5a5a5a5a59e20, 49, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a59e20, 49, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59e20, 8191, 49, 14, 0xbfffa5a5a5a59e20) + EXT( 0xa5a5a5a5a5a59e1f, 50, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e1f, 50, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e1f, 0, 50, 1, 0xa5a1a5a5a5a59e1f) + EXT( 0xa5a5a5a5a5a59e1e, 50, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e1e, 50, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e1e, 1, 50, 2, 0xa5a5a5a5a5a59e1e) + EXT( 0xa5a5a5a5a5a59e1d, 50, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e1d, 50, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e1d, 3, 50, 3, 0xa5ada5a5a5a59e1d) + EXT( 0xa5a5a5a5a5a59e1c, 50, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59e1c, 50, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59e1c, 7, 50, 4, 0xa59da5a5a5a59e1c) + EXT( 0xa5a5a5a5a5a59e1b, 50, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59e1b, 50, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59e1b, 15, 50, 5, 0xa5bda5a5a5a59e1b) + EXT( 0xa5a5a5a5a5a59e1a, 50, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59e1a, 50, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a59e1a, 31, 50, 6, 0xa57da5a5a5a59e1a) + EXT( 0xa5a5a5a5a5a59e19, 50, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59e19, 50, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59e19, 63, 50, 7, 0xa4fda5a5a5a59e19) + EXT( 0xa5a5a5a5a5a59e18, 50, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a59e18, 50, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59e18, 127, 50, 8, 0xa5fda5a5a5a59e18) + EXT( 0xa5a5a5a5a5a59e17, 50, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a59e17, 50, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59e17, 255, 50, 9, 0xa3fda5a5a5a59e17) + EXT( 0xa5a5a5a5a5a59e16, 50, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59e16, 50, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59e16, 511, 50, 10, 0xa7fda5a5a5a59e16) + EXT( 0xa5a5a5a5a5a59e15, 50, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59e15, 50, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59e15, 1023, 50, 11, 0xaffda5a5a5a59e15) + EXT( 0xa5a5a5a5a5a59e14, 50, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a59e14, 50, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59e14, 2047, 50, 12, 0x9ffda5a5a5a59e14) + EXT( 0xa5a5a5a5a5a59e13, 50, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a59e13, 50, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59e13, 4095, 50, 13, 0xbffda5a5a5a59e13) + EXT( 0xa5a5a5a5a5a59e12, 51, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e12, 51, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e12, 0, 51, 1, 0xa5a5a5a5a5a59e12) + EXT( 0xa5a5a5a5a5a59e11, 51, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e11, 51, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e11, 1, 51, 2, 0xa5ada5a5a5a59e11) + EXT( 0xa5a5a5a5a5a59e10, 51, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e10, 51, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59e10, 3, 51, 3, 0xa59da5a5a5a59e10) + EXT( 0xa5a5a5a5a5a59e0f, 51, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59e0f, 51, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59e0f, 7, 51, 4, 0xa5bda5a5a5a59e0f) + EXT( 0xa5a5a5a5a5a59e0e, 51, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59e0e, 51, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a59e0e, 15, 51, 5, 0xa57da5a5a5a59e0e) + EXT( 0xa5a5a5a5a5a59e0d, 51, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59e0d, 51, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59e0d, 31, 51, 6, 0xa4fda5a5a5a59e0d) + EXT( 0xa5a5a5a5a5a59e0c, 51, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a59e0c, 51, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59e0c, 63, 51, 7, 0xa5fda5a5a5a59e0c) + EXT( 0xa5a5a5a5a5a59e0b, 51, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a59e0b, 51, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e0b, 127, 51, 8, 0xa3fda5a5a5a59e0b) + EXT( 0xa5a5a5a5a5a59e0a, 51, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59e0a, 51, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e0a, 255, 51, 9, 0xa7fda5a5a5a59e0a) + EXT( 0xa5a5a5a5a5a59e09, 51, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59e09, 51, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59e09, 511, 51, 10, 0xaffda5a5a5a59e09) + EXT( 0xa5a5a5a5a5a59e08, 51, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a59e08, 51, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59e08, 1023, 51, 11, 0x9ffda5a5a5a59e08) + EXT( 0xa5a5a5a5a5a59e07, 51, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a59e07, 51, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59e07, 2047, 51, 12, 0xbffda5a5a5a59e07) + EXT( 0xa5a5a5a5a5a59e06, 52, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e06, 52, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e06, 0, 52, 1, 0xa5a5a5a5a5a59e06) + EXT( 0xa5a5a5a5a5a59e05, 52, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e05, 52, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e05, 1, 52, 2, 0xa595a5a5a5a59e05) + EXT( 0xa5a5a5a5a5a59e04, 52, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e04, 52, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e04, 3, 52, 3, 0xa5b5a5a5a5a59e04) + EXT( 0xa5a5a5a5a5a59e03, 52, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59e03, 52, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59e03, 7, 52, 4, 0xa575a5a5a5a59e03) + EXT( 0xa5a5a5a5a5a59e02, 52, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59e02, 52, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59e02, 15, 52, 5, 0xa4f5a5a5a5a59e02) + EXT( 0xa5a5a5a5a5a59e01, 52, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a59e01, 52, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59e01, 31, 52, 6, 0xa5f5a5a5a5a59e01) + EXT( 0xa5a5a5a5a5a59e00, 52, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a59e00, 52, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59e00, 63, 52, 7, 0xa3f5a5a5a5a59e00) + EXT( 0xa5a5a5a5a5a59dff, 52, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59dff, 52, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59dff, 127, 52, 8, 0xa7f5a5a5a5a59dff) + EXT( 0xa5a5a5a5a5a59dfe, 52, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59dfe, 52, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59dfe, 255, 52, 9, 0xaff5a5a5a5a59dfe) + EXT( 0xa5a5a5a5a5a59dfd, 52, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a59dfd, 52, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59dfd, 511, 52, 10, 0x9ff5a5a5a5a59dfd) + EXT( 0xa5a5a5a5a5a59dfc, 52, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a59dfc, 52, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59dfc, 1023, 52, 11, 0xbff5a5a5a5a59dfc) + EXT( 0xa5a5a5a5a5a59dfb, 53, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dfb, 53, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dfb, 0, 53, 1, 0xa585a5a5a5a59dfb) + EXT( 0xa5a5a5a5a5a59dfa, 53, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dfa, 53, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dfa, 1, 53, 2, 0xa5a5a5a5a5a59dfa) + EXT( 0xa5a5a5a5a5a59df9, 53, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59df9, 53, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59df9, 3, 53, 3, 0xa565a5a5a5a59df9) + EXT( 0xa5a5a5a5a5a59df8, 53, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59df8, 53, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59df8, 7, 53, 4, 0xa4e5a5a5a5a59df8) + EXT( 0xa5a5a5a5a5a59df7, 53, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a59df7, 53, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59df7, 15, 53, 5, 0xa5e5a5a5a5a59df7) + EXT( 0xa5a5a5a5a5a59df6, 53, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a59df6, 53, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59df6, 31, 53, 6, 0xa3e5a5a5a5a59df6) + EXT( 0xa5a5a5a5a5a59df5, 53, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59df5, 53, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59df5, 63, 53, 7, 0xa7e5a5a5a5a59df5) + EXT( 0xa5a5a5a5a5a59df4, 53, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59df4, 53, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59df4, 127, 53, 8, 0xafe5a5a5a5a59df4) + EXT( 0xa5a5a5a5a5a59df3, 53, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a59df3, 53, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59df3, 255, 53, 9, 0x9fe5a5a5a5a59df3) + EXT( 0xa5a5a5a5a5a59df2, 53, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a59df2, 53, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59df2, 511, 53, 10, 0xbfe5a5a5a5a59df2) + EXT( 0xa5a5a5a5a5a59df1, 54, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59df1, 54, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59df1, 0, 54, 1, 0xa5a5a5a5a5a59df1) + EXT( 0xa5a5a5a5a5a59df0, 54, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59df0, 54, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59df0, 1, 54, 2, 0xa565a5a5a5a59df0) + EXT( 0xa5a5a5a5a5a59def, 54, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59def, 54, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59def, 3, 54, 3, 0xa4e5a5a5a5a59def) + EXT( 0xa5a5a5a5a5a59dee, 54, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59dee, 54, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59dee, 7, 54, 4, 0xa5e5a5a5a5a59dee) + EXT( 0xa5a5a5a5a5a59ded, 54, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59ded, 54, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59ded, 15, 54, 5, 0xa3e5a5a5a5a59ded) + EXT( 0xa5a5a5a5a5a59dec, 54, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59dec, 54, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59dec, 31, 54, 6, 0xa7e5a5a5a5a59dec) + EXT( 0xa5a5a5a5a5a59deb, 54, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59deb, 54, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59deb, 63, 54, 7, 0xafe5a5a5a5a59deb) + EXT( 0xa5a5a5a5a5a59dea, 54, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59dea, 54, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59dea, 127, 54, 8, 0x9fe5a5a5a5a59dea) + EXT( 0xa5a5a5a5a5a59de9, 54, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59de9, 54, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59de9, 255, 54, 9, 0xbfe5a5a5a5a59de9) + EXT( 0xa5a5a5a5a5a59de8, 55, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de8, 55, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59de8, 0, 55, 1, 0xa525a5a5a5a59de8) + EXT( 0xa5a5a5a5a5a59de7, 55, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de7, 55, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59de7, 1, 55, 2, 0xa4a5a5a5a5a59de7) + EXT( 0xa5a5a5a5a5a59de6, 55, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59de6, 55, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59de6, 3, 55, 3, 0xa5a5a5a5a5a59de6) + EXT( 0xa5a5a5a5a5a59de5, 55, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59de5, 55, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59de5, 7, 55, 4, 0xa3a5a5a5a5a59de5) + EXT( 0xa5a5a5a5a5a59de4, 55, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59de4, 55, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59de4, 15, 55, 5, 0xa7a5a5a5a5a59de4) + EXT( 0xa5a5a5a5a5a59de3, 55, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59de3, 55, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59de3, 31, 55, 6, 0xafa5a5a5a5a59de3) + EXT( 0xa5a5a5a5a5a59de2, 55, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59de2, 55, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59de2, 63, 55, 7, 0x9fa5a5a5a5a59de2) + EXT( 0xa5a5a5a5a5a59de1, 55, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59de1, 55, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59de1, 127, 55, 8, 0xbfa5a5a5a5a59de1) + EXT( 0xa5a5a5a5a5a59de0, 56, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de0, 56, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59de0, 0, 56, 1, 0xa4a5a5a5a5a59de0) + EXT( 0xa5a5a5a5a5a59ddf, 56, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59ddf, 56, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ddf, 1, 56, 2, 0xa5a5a5a5a5a59ddf) + EXT( 0xa5a5a5a5a5a59dde, 56, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59dde, 56, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59dde, 3, 56, 3, 0xa3a5a5a5a5a59dde) + EXT( 0xa5a5a5a5a5a59ddd, 56, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59ddd, 56, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ddd, 7, 56, 4, 0xa7a5a5a5a5a59ddd) + EXT( 0xa5a5a5a5a5a59ddc, 56, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59ddc, 56, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ddc, 15, 56, 5, 0xafa5a5a5a5a59ddc) + EXT( 0xa5a5a5a5a5a59ddb, 56, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59ddb, 56, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59ddb, 31, 56, 6, 0x9fa5a5a5a5a59ddb) + EXT( 0xa5a5a5a5a5a59dda, 56, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59dda, 56, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59dda, 63, 56, 7, 0xbfa5a5a5a5a59dda) + EXT( 0xa5a5a5a5a5a59dd9, 57, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dd9, 57, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dd9, 0, 57, 1, 0xa5a5a5a5a5a59dd9) + EXT( 0xa5a5a5a5a5a59dd8, 57, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dd8, 57, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dd8, 1, 57, 2, 0xa3a5a5a5a5a59dd8) + EXT( 0xa5a5a5a5a5a59dd7, 57, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59dd7, 57, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dd7, 3, 57, 3, 0xa7a5a5a5a5a59dd7) + EXT( 0xa5a5a5a5a5a59dd6, 57, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59dd6, 57, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dd6, 7, 57, 4, 0xafa5a5a5a5a59dd6) + EXT( 0xa5a5a5a5a5a59dd5, 57, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59dd5, 57, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59dd5, 15, 57, 5, 0x9fa5a5a5a5a59dd5) + EXT( 0xa5a5a5a5a5a59dd4, 57, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59dd4, 57, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59dd4, 31, 57, 6, 0xbfa5a5a5a5a59dd4) + EXT( 0xa5a5a5a5a5a59dd3, 58, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dd3, 58, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dd3, 0, 58, 1, 0xa1a5a5a5a5a59dd3) + EXT( 0xa5a5a5a5a5a59dd2, 58, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dd2, 58, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dd2, 1, 58, 2, 0xa5a5a5a5a5a59dd2) + EXT( 0xa5a5a5a5a5a59dd1, 58, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dd1, 58, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dd1, 3, 58, 3, 0xada5a5a5a5a59dd1) + EXT( 0xa5a5a5a5a5a59dd0, 58, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59dd0, 58, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59dd0, 7, 58, 4, 0x9da5a5a5a5a59dd0) + EXT( 0xa5a5a5a5a5a59dcf, 58, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59dcf, 58, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59dcf, 15, 58, 5, 0xbda5a5a5a5a59dcf) + EXT( 0xa5a5a5a5a5a59dce, 59, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dce, 59, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dce, 0, 59, 1, 0xa5a5a5a5a5a59dce) + EXT( 0xa5a5a5a5a5a59dcd, 59, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dcd, 59, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dcd, 1, 59, 2, 0xada5a5a5a5a59dcd) + EXT( 0xa5a5a5a5a5a59dcc, 59, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59dcc, 59, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59dcc, 3, 59, 3, 0x9da5a5a5a5a59dcc) + EXT( 0xa5a5a5a5a5a59dcb, 59, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59dcb, 59, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59dcb, 7, 59, 4, 0xbda5a5a5a5a59dcb) + EXT( 0xa5a5a5a5a5a59dca, 60, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dca, 60, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dca, 0, 60, 1, 0xa5a5a5a5a5a59dca) + EXT( 0xa5a5a5a5a5a59dc9, 60, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dc9, 60, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dc9, 1, 60, 2, 0x95a5a5a5a5a59dc9) + EXT( 0xa5a5a5a5a5a59dc8, 60, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59dc8, 60, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dc8, 3, 60, 3, 0xb5a5a5a5a5a59dc8) + EXT( 0xa5a5a5a5a5a59dc7, 61, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dc7, 61, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dc7, 0, 61, 1, 0x85a5a5a5a5a59dc7) + EXT( 0xa5a5a5a5a5a59dc6, 61, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dc6, 61, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dc6, 1, 61, 2, 0xa5a5a5a5a5a59dc6) + EXT( 0xa5a5a5a5a5a59dc5, 62, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dc5, 62, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dc5, 0, 62, 1, 0xa5a5a5a5a5a59dc5) + +# else + EXT( 0xa5a5a5a5a5a5a5a4, 0, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a5a4, 0, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a5a4, 0, 0, 1, 0x25a5a5a5a5a5a5a4) + EXT( 0xa5a5a5a5a5a5a5a3, 0, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a5a3, 0, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a5a3, 1, 0, 2, 0x65a5a5a5a5a5a5a3) + EXT( 0xa5a5a5a5a5a5a5a2, 0, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a5a2, 0, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a5a2, 3, 0, 3, 0x65a5a5a5a5a5a5a2) + EXT( 0xa5a5a5a5a5a5a5a1, 0, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a5a1, 0, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a5a1, 7, 0, 4, 0x75a5a5a5a5a5a5a1) + EXT( 0xa5a5a5a5a5a5a5a0, 0, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a5a0, 0, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a5a0, 15, 0, 5, 0x7da5a5a5a5a5a5a0) + EXT( 0xa5a5a5a5a5a5a59f, 0, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a59f, 0, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a59f, 31, 0, 6, 0x7da5a5a5a5a5a59f) + EXT( 0xa5a5a5a5a5a5a59e, 0, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a59e, 0, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a59e, 63, 0, 7, 0x7fa5a5a5a5a5a59e) + EXT( 0xa5a5a5a5a5a5a59d, 0, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a59d, 0, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a59d, 127, 0, 8, 0x7fa5a5a5a5a5a59d) + EXT( 0xa5a5a5a5a5a5a59c, 0, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a59c, 0, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a59c, 255, 0, 9, 0x7fa5a5a5a5a5a59c) + EXT( 0xa5a5a5a5a5a5a59b, 0, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a59b, 0, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a59b, 511, 0, 10, 0x7fe5a5a5a5a5a59b) + EXT( 0xa5a5a5a5a5a5a59a, 0, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a59a, 0, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a59a, 1023, 0, 11, 0x7fe5a5a5a5a5a59a) + EXT( 0xa5a5a5a5a5a5a599, 0, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a599, 0, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a599, 2047, 0, 12, 0x7ff5a5a5a5a5a599) + EXT( 0xa5a5a5a5a5a5a598, 0, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a598, 0, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a598, 4095, 0, 13, 0x7ffda5a5a5a5a598) + EXT( 0xa5a5a5a5a5a5a597, 0, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a597, 0, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a597, 8191, 0, 14, 0x7ffda5a5a5a5a597) + EXT( 0xa5a5a5a5a5a5a596, 0, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a596, 0, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a596, 16383, 0, 15, 0x7fffa5a5a5a5a596) + EXT( 0xa5a5a5a5a5a5a595, 0, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a595, 0, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a595, 32767, 0, 16, 0x7fffa5a5a5a5a595) + EXT( 0xa5a5a5a5a5a5a594, 0, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a594, 0, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a594, 65535, 0, 17, 0x7fffa5a5a5a5a594) + EXT( 0xa5a5a5a5a5a5a593, 0, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a593, 0, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a593, 131071, 0, 18, 0x7fffe5a5a5a5a593) + EXT( 0xa5a5a5a5a5a5a592, 0, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a592, 0, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a592, 262143, 0, 19, 0x7fffe5a5a5a5a592) + EXT( 0xa5a5a5a5a5a5a591, 0, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a591, 0, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a591, 524287, 0, 20, 0x7ffff5a5a5a5a591) + EXT( 0xa5a5a5a5a5a5a590, 0, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a590, 0, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a590, 1048575, 0, 21, 0x7ffffda5a5a5a590) + EXT( 0xa5a5a5a5a5a5a58f, 0, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a58f, 0, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a58f, 2097151, 0, 22, 0x7ffffda5a5a5a58f) + EXT( 0xa5a5a5a5a5a5a58e, 0, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a58e, 0, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a58e, 4194303, 0, 23, 0x7fffffa5a5a5a58e) + EXT( 0xa5a5a5a5a5a5a58d, 0, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a58d, 0, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a58d, 8388607, 0, 24, 0x7fffffa5a5a5a58d) + EXT( 0xa5a5a5a5a5a5a58c, 0, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a58c, 0, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a58c, 16777215, 0, 25, 0x7fffffa5a5a5a58c) + EXT( 0xa5a5a5a5a5a5a58b, 0, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a58b, 0, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a58b, 33554431, 0, 26, 0x7fffffe5a5a5a58b) + EXT( 0xa5a5a5a5a5a5a58a, 0, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a58a, 0, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a58a, 67108863, 0, 27, 0x7fffffe5a5a5a58a) + EXT( 0xa5a5a5a5a5a5a589, 0, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a589, 0, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a589, 134217727, 0, 28, 0x7ffffff5a5a5a589) + EXT( 0xa5a5a5a5a5a5a588, 0, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a588, 0, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a588, 268435455, 0, 29, 0x7ffffffda5a5a588) + EXT( 0xa5a5a5a5a5a5a587, 0, 30, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a587, 0, 30, 0x0000000029696969) + DEP( 0xa5a5a5a5a5a5a587, 536870911, 0, 30, 0x7ffffffda5a5a587) + EXT( 0xa5a5a5a5a5a5a586, 0, 31, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a586, 0, 31, 0x0000000052d2d2d2) + DEP( 0xa5a5a5a5a5a5a586, 1073741823, 0, 31, 0x7fffffffa5a5a586) + EXT( 0xa5a5a5a5a5a5a585, 0, 32, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a585, 0, 32, 0x00000000a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a585, 2147483647, 0, 32, 0x7fffffffa5a5a585) + EXT( 0xa5a5a5a5a5a5a584, 0, 33, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a584, 0, 33, 0x000000014b4b4b4b) + DEP( 0xa5a5a5a5a5a5a584, 4294967295, 0, 33, 0x7fffffffa5a5a584) + EXT( 0xa5a5a5a5a5a5a583, 0, 34, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a583, 0, 34, 0x0000000296969696) + DEP( 0xa5a5a5a5a5a5a583, 8589934591, 0, 34, 0x7fffffffe5a5a583) + EXT( 0xa5a5a5a5a5a5a582, 0, 35, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a582, 0, 35, 0x000000052d2d2d2d) + DEP( 0xa5a5a5a5a5a5a582, 17179869183, 0, 35, 0x7fffffffe5a5a582) + EXT( 0xa5a5a5a5a5a5a581, 0, 36, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a581, 0, 36, 0x0000000a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a581, 34359738367, 0, 36, 0x7ffffffff5a5a581) + EXT( 0xa5a5a5a5a5a5a580, 0, 37, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a580, 0, 37, 0x00000014b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a580, 68719476735, 0, 37, 0x7ffffffffda5a580) + EXT( 0xa5a5a5a5a5a5a57f, 0, 38, 0xffffffe969696969) + EXTU(0xa5a5a5a5a5a5a57f, 0, 38, 0x0000002969696969) + DEP( 0xa5a5a5a5a5a5a57f, 137438953471, 0, 38, 0x7ffffffffda5a57f) + EXT( 0xa5a5a5a5a5a5a57e, 0, 39, 0xffffffd2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a57e, 0, 39, 0x00000052d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a57e, 274877906943, 0, 39, 0x7fffffffffa5a57e) + EXT( 0xa5a5a5a5a5a5a57d, 0, 40, 0xffffffa5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a57d, 0, 40, 0x000000a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a57d, 549755813887, 0, 40, 0x7fffffffffa5a57d) + EXT( 0xa5a5a5a5a5a5a57c, 0, 41, 0xffffff4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a57c, 0, 41, 0x0000014b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a57c, 1099511627775, 0, 41, 0x7fffffffffa5a57c) + EXT( 0xa5a5a5a5a5a5a57b, 0, 42, 0xfffffe9696969696) + EXTU(0xa5a5a5a5a5a5a57b, 0, 42, 0x0000029696969696) + DEP( 0xa5a5a5a5a5a5a57b, 2199023255551, 0, 42, 0x7fffffffffe5a57b) + EXT( 0xa5a5a5a5a5a5a57a, 0, 43, 0xfffffd2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a57a, 0, 43, 0x0000052d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a57a, 4398046511103, 0, 43, 0x7fffffffffe5a57a) + EXT( 0xa5a5a5a5a5a5a579, 0, 44, 0xfffffa5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a579, 0, 44, 0x00000a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a579, 8796093022207, 0, 44, 0x7ffffffffff5a579) + EXT( 0xa5a5a5a5a5a5a578, 0, 45, 0xfffff4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a578, 0, 45, 0x000014b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a578, 17592186044415, 0, 45, 0x7ffffffffffda578) + EXT( 0xa5a5a5a5a5a5a577, 0, 46, 0xffffe96969696969) + EXTU(0xa5a5a5a5a5a5a577, 0, 46, 0x0000296969696969) + DEP( 0xa5a5a5a5a5a5a577, 35184372088831, 0, 46, 0x7ffffffffffda577) + EXT( 0xa5a5a5a5a5a5a576, 0, 47, 0xffffd2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a576, 0, 47, 0x000052d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a576, 70368744177663, 0, 47, 0x7fffffffffffa576) + EXT( 0xa5a5a5a5a5a5a575, 0, 48, 0xffffa5a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a575, 0, 48, 0x0000a5a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a575, 140737488355327, 0, 48, 0x7fffffffffffa575) + EXT( 0xa5a5a5a5a5a5a574, 0, 49, 0xffff4b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a574, 0, 49, 0x00014b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a574, 281474976710655, 0, 49, 0x7fffffffffffa574) + EXT( 0xa5a5a5a5a5a5a573, 0, 50, 0xfffe969696969696) + EXTU(0xa5a5a5a5a5a5a573, 0, 50, 0x0002969696969696) + DEP( 0xa5a5a5a5a5a5a573, 562949953421311, 0, 50, 0x7fffffffffffe573) + EXT( 0xa5a5a5a5a5a5a572, 0, 51, 0xfffd2d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a572, 0, 51, 0x00052d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a572, 1125899906842623, 0, 51, 0x7fffffffffffe572) + EXT( 0xa5a5a5a5a5a5a571, 0, 52, 0xfffa5a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a571, 0, 52, 0x000a5a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a571, 2251799813685247, 0, 52, 0x7ffffffffffff571) + EXT( 0xa5a5a5a5a5a5a570, 0, 53, 0xfff4b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a570, 0, 53, 0x0014b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a570, 4503599627370495, 0, 53, 0x7ffffffffffffd70) + EXT( 0xa5a5a5a5a5a5a56f, 0, 54, 0xffe9696969696969) + EXTU(0xa5a5a5a5a5a5a56f, 0, 54, 0x0029696969696969) + DEP( 0xa5a5a5a5a5a5a56f, 9007199254740991, 0, 54, 0x7ffffffffffffd6f) + EXT( 0xa5a5a5a5a5a5a56e, 0, 55, 0xffd2d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a56e, 0, 55, 0x0052d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a56e, 18014398509481983, 0, 55, 0x7fffffffffffff6e) + EXT( 0xa5a5a5a5a5a5a56d, 0, 56, 0xffa5a5a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a56d, 0, 56, 0x00a5a5a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a56d, 36028797018963967, 0, 56, 0x7fffffffffffff6d) + EXT( 0xa5a5a5a5a5a5a56c, 0, 57, 0xff4b4b4b4b4b4b4a) + EXTU(0xa5a5a5a5a5a5a56c, 0, 57, 0x014b4b4b4b4b4b4a) + DEP( 0xa5a5a5a5a5a5a56c, 72057594037927935, 0, 57, 0x7fffffffffffffec) + EXT( 0xa5a5a5a5a5a5a56b, 0, 58, 0xfe96969696969695) + EXTU(0xa5a5a5a5a5a5a56b, 0, 58, 0x0296969696969695) + DEP( 0xa5a5a5a5a5a5a56b, 144115188075855871, 0, 58, 0x7fffffffffffffeb) + EXT( 0xa5a5a5a5a5a5a56a, 0, 59, 0xfd2d2d2d2d2d2d2b) + EXTU(0xa5a5a5a5a5a5a56a, 0, 59, 0x052d2d2d2d2d2d2b) + DEP( 0xa5a5a5a5a5a5a56a, 288230376151711743, 0, 59, 0x7fffffffffffffea) + EXT( 0xa5a5a5a5a5a5a569, 0, 60, 0xfa5a5a5a5a5a5a56) + EXTU(0xa5a5a5a5a5a5a569, 0, 60, 0x0a5a5a5a5a5a5a56) + DEP( 0xa5a5a5a5a5a5a569, 576460752303423487, 0, 60, 0x7ffffffffffffff9) + EXT( 0xa5a5a5a5a5a5a568, 0, 61, 0xf4b4b4b4b4b4b4ad) + EXTU(0xa5a5a5a5a5a5a568, 0, 61, 0x14b4b4b4b4b4b4ad) + DEP( 0xa5a5a5a5a5a5a568, 1152921504606846975, 0, 61, 0x7ffffffffffffff8) + EXT( 0xa5a5a5a5a5a5a567, 0, 62, 0xe969696969696959) + EXTU(0xa5a5a5a5a5a5a567, 0, 62, 0x2969696969696959) + DEP( 0xa5a5a5a5a5a5a567, 2305843009213693951, 0, 62, 0x7fffffffffffffff) + EXT( 0xa5a5a5a5a5a5a566, 0, 63, 0xd2d2d2d2d2d2d2b3) + EXTU(0xa5a5a5a5a5a5a566, 0, 63, 0x52d2d2d2d2d2d2b3) + DEP( 0xa5a5a5a5a5a5a566, 4611686018427387903, 0, 63, 0x7ffffffffffffffe) + EXT( 0xa5a5a5a5a5a5a565, 1, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a565, 1, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a565, 0, 1, 1, 0xa5a5a5a5a5a5a565) + EXT( 0xa5a5a5a5a5a5a564, 1, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a564, 1, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a564, 1, 1, 2, 0xa5a5a5a5a5a5a564) + EXT( 0xa5a5a5a5a5a5a563, 1, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a563, 1, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a563, 3, 1, 3, 0xb5a5a5a5a5a5a563) + EXT( 0xa5a5a5a5a5a5a562, 1, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a562, 1, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a562, 7, 1, 4, 0xbda5a5a5a5a5a562) + EXT( 0xa5a5a5a5a5a5a561, 1, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a561, 1, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a561, 15, 1, 5, 0xbda5a5a5a5a5a561) + EXT( 0xa5a5a5a5a5a5a560, 1, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a560, 1, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a560, 31, 1, 6, 0xbfa5a5a5a5a5a560) + EXT( 0xa5a5a5a5a5a5a55f, 1, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a55f, 1, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a55f, 63, 1, 7, 0xbfa5a5a5a5a5a55f) + EXT( 0xa5a5a5a5a5a5a55e, 1, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a55e, 1, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a55e, 127, 1, 8, 0xbfa5a5a5a5a5a55e) + EXT( 0xa5a5a5a5a5a5a55d, 1, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a55d, 1, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a55d, 255, 1, 9, 0xbfe5a5a5a5a5a55d) + EXT( 0xa5a5a5a5a5a5a55c, 1, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a55c, 1, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a55c, 511, 1, 10, 0xbfe5a5a5a5a5a55c) + EXT( 0xa5a5a5a5a5a5a55b, 1, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a55b, 1, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a55b, 1023, 1, 11, 0xbff5a5a5a5a5a55b) + EXT( 0xa5a5a5a5a5a5a55a, 1, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a55a, 1, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a55a, 2047, 1, 12, 0xbffda5a5a5a5a55a) + EXT( 0xa5a5a5a5a5a5a559, 1, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a559, 1, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a559, 4095, 1, 13, 0xbffda5a5a5a5a559) + EXT( 0xa5a5a5a5a5a5a558, 1, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a558, 1, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a558, 8191, 1, 14, 0xbfffa5a5a5a5a558) + EXT( 0xa5a5a5a5a5a5a557, 1, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a557, 1, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a557, 16383, 1, 15, 0xbfffa5a5a5a5a557) + EXT( 0xa5a5a5a5a5a5a556, 1, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a556, 1, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a556, 32767, 1, 16, 0xbfffa5a5a5a5a556) + EXT( 0xa5a5a5a5a5a5a555, 1, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a555, 1, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a555, 65535, 1, 17, 0xbfffe5a5a5a5a555) + EXT( 0xa5a5a5a5a5a5a554, 1, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a554, 1, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a554, 131071, 1, 18, 0xbfffe5a5a5a5a554) + EXT( 0xa5a5a5a5a5a5a553, 1, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a553, 1, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a553, 262143, 1, 19, 0xbffff5a5a5a5a553) + EXT( 0xa5a5a5a5a5a5a552, 1, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a552, 1, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a552, 524287, 1, 20, 0xbffffda5a5a5a552) + EXT( 0xa5a5a5a5a5a5a551, 1, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a551, 1, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a551, 1048575, 1, 21, 0xbffffda5a5a5a551) + EXT( 0xa5a5a5a5a5a5a550, 1, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a550, 1, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a550, 2097151, 1, 22, 0xbfffffa5a5a5a550) + EXT( 0xa5a5a5a5a5a5a54f, 1, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a54f, 1, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a54f, 4194303, 1, 23, 0xbfffffa5a5a5a54f) + EXT( 0xa5a5a5a5a5a5a54e, 1, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a54e, 1, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a54e, 8388607, 1, 24, 0xbfffffa5a5a5a54e) + EXT( 0xa5a5a5a5a5a5a54d, 1, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a54d, 1, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a54d, 16777215, 1, 25, 0xbfffffe5a5a5a54d) + EXT( 0xa5a5a5a5a5a5a54c, 1, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a54c, 1, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a54c, 33554431, 1, 26, 0xbfffffe5a5a5a54c) + EXT( 0xa5a5a5a5a5a5a54b, 1, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a54b, 1, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a54b, 67108863, 1, 27, 0xbffffff5a5a5a54b) + EXT( 0xa5a5a5a5a5a5a54a, 1, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a54a, 1, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a54a, 134217727, 1, 28, 0xbffffffda5a5a54a) + EXT( 0xa5a5a5a5a5a5a549, 1, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a5a549, 1, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a549, 268435455, 1, 29, 0xbffffffda5a5a549) + EXT( 0xa5a5a5a5a5a5a548, 1, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a5a548, 1, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a548, 536870911, 1, 30, 0xbfffffffa5a5a548) + EXT( 0xa5a5a5a5a5a5a547, 1, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a5a547, 1, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a547, 1073741823, 1, 31, 0xbfffffffa5a5a547) + EXT( 0xa5a5a5a5a5a5a546, 1, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a5a546, 1, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a546, 2147483647, 1, 32, 0xbfffffffa5a5a546) + EXT( 0xa5a5a5a5a5a5a545, 1, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a5a545, 1, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a545, 4294967295, 1, 33, 0xbfffffffe5a5a545) + EXT( 0xa5a5a5a5a5a5a544, 1, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a5a544, 1, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a544, 8589934591, 1, 34, 0xbfffffffe5a5a544) + EXT( 0xa5a5a5a5a5a5a543, 1, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a543, 1, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a543, 17179869183, 1, 35, 0xbffffffff5a5a543) + EXT( 0xa5a5a5a5a5a5a542, 1, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a542, 1, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a542, 34359738367, 1, 36, 0xbffffffffda5a542) + EXT( 0xa5a5a5a5a5a5a541, 1, 37, 0x0000000969696969) + EXTU(0xa5a5a5a5a5a5a541, 1, 37, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a541, 68719476735, 1, 37, 0xbffffffffda5a541) + EXT( 0xa5a5a5a5a5a5a540, 1, 38, 0x00000012d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a540, 1, 38, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a540, 137438953471, 1, 38, 0xbfffffffffa5a540) + EXT( 0xa5a5a5a5a5a5a53f, 1, 39, 0x00000025a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a53f, 1, 39, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a53f, 274877906943, 1, 39, 0xbfffffffffa5a53f) + EXT( 0xa5a5a5a5a5a5a53e, 1, 40, 0x0000004b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a53e, 1, 40, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a53e, 549755813887, 1, 40, 0xbfffffffffa5a53e) + EXT( 0xa5a5a5a5a5a5a53d, 1, 41, 0x0000009696969696) + EXTU(0xa5a5a5a5a5a5a53d, 1, 41, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a53d, 1099511627775, 1, 41, 0xbfffffffffe5a53d) + EXT( 0xa5a5a5a5a5a5a53c, 1, 42, 0x0000012d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a53c, 1, 42, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a53c, 2199023255551, 1, 42, 0xbfffffffffe5a53c) + EXT( 0xa5a5a5a5a5a5a53b, 1, 43, 0x0000025a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a53b, 1, 43, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a53b, 4398046511103, 1, 43, 0xbffffffffff5a53b) + EXT( 0xa5a5a5a5a5a5a53a, 1, 44, 0x000004b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a53a, 1, 44, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a53a, 8796093022207, 1, 44, 0xbffffffffffda53a) + EXT( 0xa5a5a5a5a5a5a539, 1, 45, 0x0000096969696969) + EXTU(0xa5a5a5a5a5a5a539, 1, 45, 0x0000096969696969) + DEP( 0xa5a5a5a5a5a5a539, 17592186044415, 1, 45, 0xbffffffffffda539) + EXT( 0xa5a5a5a5a5a5a538, 1, 46, 0x000012d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a538, 1, 46, 0x000012d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a538, 35184372088831, 1, 46, 0xbfffffffffffa538) + EXT( 0xa5a5a5a5a5a5a537, 1, 47, 0x000025a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a537, 1, 47, 0x000025a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a537, 70368744177663, 1, 47, 0xbfffffffffffa537) + EXT( 0xa5a5a5a5a5a5a536, 1, 48, 0x00004b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a536, 1, 48, 0x00004b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a536, 140737488355327, 1, 48, 0xbfffffffffffa536) + EXT( 0xa5a5a5a5a5a5a535, 1, 49, 0x0000969696969696) + EXTU(0xa5a5a5a5a5a5a535, 1, 49, 0x0000969696969696) + DEP( 0xa5a5a5a5a5a5a535, 281474976710655, 1, 49, 0xbfffffffffffe535) + EXT( 0xa5a5a5a5a5a5a534, 1, 50, 0x00012d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a534, 1, 50, 0x00012d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a534, 562949953421311, 1, 50, 0xbfffffffffffe534) + EXT( 0xa5a5a5a5a5a5a533, 1, 51, 0x00025a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a533, 1, 51, 0x00025a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a533, 1125899906842623, 1, 51, 0xbffffffffffff533) + EXT( 0xa5a5a5a5a5a5a532, 1, 52, 0x0004b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a532, 1, 52, 0x0004b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a532, 2251799813685247, 1, 52, 0xbffffffffffffd32) + EXT( 0xa5a5a5a5a5a5a531, 1, 53, 0x0009696969696969) + EXTU(0xa5a5a5a5a5a5a531, 1, 53, 0x0009696969696969) + DEP( 0xa5a5a5a5a5a5a531, 4503599627370495, 1, 53, 0xbffffffffffffd31) + EXT( 0xa5a5a5a5a5a5a530, 1, 54, 0x0012d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a530, 1, 54, 0x0012d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a530, 9007199254740991, 1, 54, 0xbfffffffffffff30) + EXT( 0xa5a5a5a5a5a5a52f, 1, 55, 0x0025a5a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a52f, 1, 55, 0x0025a5a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a52f, 18014398509481983, 1, 55, 0xbfffffffffffff2f) + EXT( 0xa5a5a5a5a5a5a52e, 1, 56, 0x004b4b4b4b4b4b4a) + EXTU(0xa5a5a5a5a5a5a52e, 1, 56, 0x004b4b4b4b4b4b4a) + DEP( 0xa5a5a5a5a5a5a52e, 36028797018963967, 1, 56, 0xbfffffffffffffae) + EXT( 0xa5a5a5a5a5a5a52d, 1, 57, 0x0096969696969694) + EXTU(0xa5a5a5a5a5a5a52d, 1, 57, 0x0096969696969694) + DEP( 0xa5a5a5a5a5a5a52d, 72057594037927935, 1, 57, 0xbfffffffffffffed) + EXT( 0xa5a5a5a5a5a5a52c, 1, 58, 0x012d2d2d2d2d2d29) + EXTU(0xa5a5a5a5a5a5a52c, 1, 58, 0x012d2d2d2d2d2d29) + DEP( 0xa5a5a5a5a5a5a52c, 144115188075855871, 1, 58, 0xbfffffffffffffec) + EXT( 0xa5a5a5a5a5a5a52b, 1, 59, 0x025a5a5a5a5a5a52) + EXTU(0xa5a5a5a5a5a5a52b, 1, 59, 0x025a5a5a5a5a5a52) + DEP( 0xa5a5a5a5a5a5a52b, 288230376151711743, 1, 59, 0xbffffffffffffffb) + EXT( 0xa5a5a5a5a5a5a52a, 1, 60, 0x04b4b4b4b4b4b4a5) + EXTU(0xa5a5a5a5a5a5a52a, 1, 60, 0x04b4b4b4b4b4b4a5) + DEP( 0xa5a5a5a5a5a5a52a, 576460752303423487, 1, 60, 0xbffffffffffffffa) + EXT( 0xa5a5a5a5a5a5a529, 1, 61, 0x096969696969694a) + EXTU(0xa5a5a5a5a5a5a529, 1, 61, 0x096969696969694a) + DEP( 0xa5a5a5a5a5a5a529, 1152921504606846975, 1, 61, 0xbffffffffffffffd) + EXT( 0xa5a5a5a5a5a5a528, 1, 62, 0x12d2d2d2d2d2d294) + EXTU(0xa5a5a5a5a5a5a528, 1, 62, 0x12d2d2d2d2d2d294) + DEP( 0xa5a5a5a5a5a5a528, 2305843009213693951, 1, 62, 0xbffffffffffffffe) + EXT( 0xa5a5a5a5a5a5a527, 2, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a527, 2, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a527, 0, 2, 1, 0x85a5a5a5a5a5a527) + EXT( 0xa5a5a5a5a5a5a526, 2, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a526, 2, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a526, 1, 2, 2, 0x95a5a5a5a5a5a526) + EXT( 0xa5a5a5a5a5a5a525, 2, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a525, 2, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a525, 3, 2, 3, 0x9da5a5a5a5a5a525) + EXT( 0xa5a5a5a5a5a5a524, 2, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a524, 2, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a524, 7, 2, 4, 0x9da5a5a5a5a5a524) + EXT( 0xa5a5a5a5a5a5a523, 2, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a523, 2, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a523, 15, 2, 5, 0x9fa5a5a5a5a5a523) + EXT( 0xa5a5a5a5a5a5a522, 2, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a522, 2, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a522, 31, 2, 6, 0x9fa5a5a5a5a5a522) + EXT( 0xa5a5a5a5a5a5a521, 2, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a521, 2, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a521, 63, 2, 7, 0x9fa5a5a5a5a5a521) + EXT( 0xa5a5a5a5a5a5a520, 2, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a520, 2, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a520, 127, 2, 8, 0x9fe5a5a5a5a5a520) + EXT( 0xa5a5a5a5a5a5a51f, 2, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a51f, 2, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a51f, 255, 2, 9, 0x9fe5a5a5a5a5a51f) + EXT( 0xa5a5a5a5a5a5a51e, 2, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a51e, 2, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a51e, 511, 2, 10, 0x9ff5a5a5a5a5a51e) + EXT( 0xa5a5a5a5a5a5a51d, 2, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a51d, 2, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a51d, 1023, 2, 11, 0x9ffda5a5a5a5a51d) + EXT( 0xa5a5a5a5a5a5a51c, 2, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a51c, 2, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a51c, 2047, 2, 12, 0x9ffda5a5a5a5a51c) + EXT( 0xa5a5a5a5a5a5a51b, 2, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a51b, 2, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a51b, 4095, 2, 13, 0x9fffa5a5a5a5a51b) + EXT( 0xa5a5a5a5a5a5a51a, 2, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a51a, 2, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a51a, 8191, 2, 14, 0x9fffa5a5a5a5a51a) + EXT( 0xa5a5a5a5a5a5a519, 2, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a519, 2, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a519, 16383, 2, 15, 0x9fffa5a5a5a5a519) + EXT( 0xa5a5a5a5a5a5a518, 2, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a518, 2, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a518, 32767, 2, 16, 0x9fffe5a5a5a5a518) + EXT( 0xa5a5a5a5a5a5a517, 2, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a517, 2, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a517, 65535, 2, 17, 0x9fffe5a5a5a5a517) + EXT( 0xa5a5a5a5a5a5a516, 2, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a516, 2, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a516, 131071, 2, 18, 0x9ffff5a5a5a5a516) + EXT( 0xa5a5a5a5a5a5a515, 2, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a515, 2, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a515, 262143, 2, 19, 0x9ffffda5a5a5a515) + EXT( 0xa5a5a5a5a5a5a514, 2, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a514, 2, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a514, 524287, 2, 20, 0x9ffffda5a5a5a514) + EXT( 0xa5a5a5a5a5a5a513, 2, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a513, 2, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a513, 1048575, 2, 21, 0x9fffffa5a5a5a513) + EXT( 0xa5a5a5a5a5a5a512, 2, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a512, 2, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a512, 2097151, 2, 22, 0x9fffffa5a5a5a512) + EXT( 0xa5a5a5a5a5a5a511, 2, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a511, 2, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a511, 4194303, 2, 23, 0x9fffffa5a5a5a511) + EXT( 0xa5a5a5a5a5a5a510, 2, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a510, 2, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a510, 8388607, 2, 24, 0x9fffffe5a5a5a510) + EXT( 0xa5a5a5a5a5a5a50f, 2, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a50f, 2, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a50f, 16777215, 2, 25, 0x9fffffe5a5a5a50f) + EXT( 0xa5a5a5a5a5a5a50e, 2, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a50e, 2, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a50e, 33554431, 2, 26, 0x9ffffff5a5a5a50e) + EXT( 0xa5a5a5a5a5a5a50d, 2, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a50d, 2, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a50d, 67108863, 2, 27, 0x9ffffffda5a5a50d) + EXT( 0xa5a5a5a5a5a5a50c, 2, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a5a50c, 2, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a50c, 134217727, 2, 28, 0x9ffffffda5a5a50c) + EXT( 0xa5a5a5a5a5a5a50b, 2, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a5a50b, 2, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a50b, 268435455, 2, 29, 0x9fffffffa5a5a50b) + EXT( 0xa5a5a5a5a5a5a50a, 2, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a5a50a, 2, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a50a, 536870911, 2, 30, 0x9fffffffa5a5a50a) + EXT( 0xa5a5a5a5a5a5a509, 2, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a5a509, 2, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a509, 1073741823, 2, 31, 0x9fffffffa5a5a509) + EXT( 0xa5a5a5a5a5a5a508, 2, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a5a508, 2, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a508, 2147483647, 2, 32, 0x9fffffffe5a5a508) + EXT( 0xa5a5a5a5a5a5a507, 2, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a507, 2, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a507, 4294967295, 2, 33, 0x9fffffffe5a5a507) + EXT( 0xa5a5a5a5a5a5a506, 2, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a506, 2, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a506, 8589934591, 2, 34, 0x9ffffffff5a5a506) + EXT( 0xa5a5a5a5a5a5a505, 2, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a505, 2, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a505, 17179869183, 2, 35, 0x9ffffffffda5a505) + EXT( 0xa5a5a5a5a5a5a504, 2, 36, 0xfffffff969696969) + EXTU(0xa5a5a5a5a5a5a504, 2, 36, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a504, 34359738367, 2, 36, 0x9ffffffffda5a504) + EXT( 0xa5a5a5a5a5a5a503, 2, 37, 0xfffffff2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a503, 2, 37, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a503, 68719476735, 2, 37, 0x9fffffffffa5a503) + EXT( 0xa5a5a5a5a5a5a502, 2, 38, 0xffffffe5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a502, 2, 38, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a502, 137438953471, 2, 38, 0x9fffffffffa5a502) + EXT( 0xa5a5a5a5a5a5a501, 2, 39, 0xffffffcb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a501, 2, 39, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a501, 274877906943, 2, 39, 0x9fffffffffa5a501) + EXT( 0xa5a5a5a5a5a5a500, 2, 40, 0xffffff9696969696) + EXTU(0xa5a5a5a5a5a5a500, 2, 40, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a500, 549755813887, 2, 40, 0x9fffffffffe5a500) + EXT( 0xa5a5a5a5a5a5a4ff, 2, 41, 0xffffff2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a4ff, 2, 41, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a4ff, 1099511627775, 2, 41, 0x9fffffffffe5a4ff) + EXT( 0xa5a5a5a5a5a5a4fe, 2, 42, 0xfffffe5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a4fe, 2, 42, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a4fe, 2199023255551, 2, 42, 0x9ffffffffff5a4fe) + EXT( 0xa5a5a5a5a5a5a4fd, 2, 43, 0xfffffcb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a4fd, 2, 43, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a4fd, 4398046511103, 2, 43, 0x9ffffffffffda4fd) + EXT( 0xa5a5a5a5a5a5a4fc, 2, 44, 0xfffff96969696969) + EXTU(0xa5a5a5a5a5a5a4fc, 2, 44, 0x0000096969696969) + DEP( 0xa5a5a5a5a5a5a4fc, 8796093022207, 2, 44, 0x9ffffffffffda4fc) + EXT( 0xa5a5a5a5a5a5a4fb, 2, 45, 0xfffff2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a4fb, 2, 45, 0x000012d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a4fb, 17592186044415, 2, 45, 0x9fffffffffffa4fb) + EXT( 0xa5a5a5a5a5a5a4fa, 2, 46, 0xffffe5a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a4fa, 2, 46, 0x000025a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a4fa, 35184372088831, 2, 46, 0x9fffffffffffa4fa) + EXT( 0xa5a5a5a5a5a5a4f9, 2, 47, 0xffffcb4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a4f9, 2, 47, 0x00004b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a4f9, 70368744177663, 2, 47, 0x9fffffffffffa4f9) + EXT( 0xa5a5a5a5a5a5a4f8, 2, 48, 0xffff969696969696) + EXTU(0xa5a5a5a5a5a5a4f8, 2, 48, 0x0000969696969696) + DEP( 0xa5a5a5a5a5a5a4f8, 140737488355327, 2, 48, 0x9fffffffffffe4f8) + EXT( 0xa5a5a5a5a5a5a4f7, 2, 49, 0xffff2d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a4f7, 2, 49, 0x00012d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a4f7, 281474976710655, 2, 49, 0x9fffffffffffe4f7) + EXT( 0xa5a5a5a5a5a5a4f6, 2, 50, 0xfffe5a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a4f6, 2, 50, 0x00025a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a4f6, 562949953421311, 2, 50, 0x9ffffffffffff4f6) + EXT( 0xa5a5a5a5a5a5a4f5, 2, 51, 0xfffcb4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a4f5, 2, 51, 0x0004b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a4f5, 1125899906842623, 2, 51, 0x9ffffffffffffcf5) + EXT( 0xa5a5a5a5a5a5a4f4, 2, 52, 0xfff9696969696969) + EXTU(0xa5a5a5a5a5a5a4f4, 2, 52, 0x0009696969696969) + DEP( 0xa5a5a5a5a5a5a4f4, 2251799813685247, 2, 52, 0x9ffffffffffffcf4) + EXT( 0xa5a5a5a5a5a5a4f3, 2, 53, 0xfff2d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a4f3, 2, 53, 0x0012d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a4f3, 4503599627370495, 2, 53, 0x9ffffffffffffef3) + EXT( 0xa5a5a5a5a5a5a4f2, 2, 54, 0xffe5a5a5a5a5a5a4) + EXTU(0xa5a5a5a5a5a5a4f2, 2, 54, 0x0025a5a5a5a5a5a4) + DEP( 0xa5a5a5a5a5a5a4f2, 9007199254740991, 2, 54, 0x9ffffffffffffff2) + EXT( 0xa5a5a5a5a5a5a4f1, 2, 55, 0xffcb4b4b4b4b4b49) + EXTU(0xa5a5a5a5a5a5a4f1, 2, 55, 0x004b4b4b4b4b4b49) + DEP( 0xa5a5a5a5a5a5a4f1, 18014398509481983, 2, 55, 0x9ffffffffffffff1) + EXT( 0xa5a5a5a5a5a5a4f0, 2, 56, 0xff96969696969693) + EXTU(0xa5a5a5a5a5a5a4f0, 2, 56, 0x0096969696969693) + DEP( 0xa5a5a5a5a5a5a4f0, 36028797018963967, 2, 56, 0x9ffffffffffffff0) + EXT( 0xa5a5a5a5a5a5a4ef, 2, 57, 0xff2d2d2d2d2d2d27) + EXTU(0xa5a5a5a5a5a5a4ef, 2, 57, 0x012d2d2d2d2d2d27) + DEP( 0xa5a5a5a5a5a5a4ef, 72057594037927935, 2, 57, 0x9fffffffffffffef) + EXT( 0xa5a5a5a5a5a5a4ee, 2, 58, 0xfe5a5a5a5a5a5a4e) + EXTU(0xa5a5a5a5a5a5a4ee, 2, 58, 0x025a5a5a5a5a5a4e) + DEP( 0xa5a5a5a5a5a5a4ee, 144115188075855871, 2, 58, 0x9ffffffffffffffe) + EXT( 0xa5a5a5a5a5a5a4ed, 2, 59, 0xfcb4b4b4b4b4b49d) + EXTU(0xa5a5a5a5a5a5a4ed, 2, 59, 0x04b4b4b4b4b4b49d) + DEP( 0xa5a5a5a5a5a5a4ed, 288230376151711743, 2, 59, 0x9ffffffffffffffd) + EXT( 0xa5a5a5a5a5a5a4ec, 2, 60, 0xf96969696969693b) + EXTU(0xa5a5a5a5a5a5a4ec, 2, 60, 0x096969696969693b) + DEP( 0xa5a5a5a5a5a5a4ec, 576460752303423487, 2, 60, 0x9ffffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4eb, 2, 61, 0xf2d2d2d2d2d2d275) + EXTU(0xa5a5a5a5a5a5a4eb, 2, 61, 0x12d2d2d2d2d2d275) + DEP( 0xa5a5a5a5a5a5a4eb, 1152921504606846975, 2, 61, 0x9fffffffffffffff) + EXT( 0xa5a5a5a5a5a5a4ea, 3, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a4ea, 3, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a4ea, 0, 3, 1, 0xa5a5a5a5a5a5a4ea) + EXT( 0xa5a5a5a5a5a5a4e9, 3, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a4e9, 3, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a4e9, 1, 3, 2, 0xada5a5a5a5a5a4e9) + EXT( 0xa5a5a5a5a5a5a4e8, 3, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a4e8, 3, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a4e8, 3, 3, 3, 0xada5a5a5a5a5a4e8) + EXT( 0xa5a5a5a5a5a5a4e7, 3, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a4e7, 3, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a4e7, 7, 3, 4, 0xafa5a5a5a5a5a4e7) + EXT( 0xa5a5a5a5a5a5a4e6, 3, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a4e6, 3, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a4e6, 15, 3, 5, 0xafa5a5a5a5a5a4e6) + EXT( 0xa5a5a5a5a5a5a4e5, 3, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a4e5, 3, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a4e5, 31, 3, 6, 0xafa5a5a5a5a5a4e5) + EXT( 0xa5a5a5a5a5a5a4e4, 3, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a4e4, 3, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a4e4, 63, 3, 7, 0xafe5a5a5a5a5a4e4) + EXT( 0xa5a5a5a5a5a5a4e3, 3, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a4e3, 3, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a4e3, 127, 3, 8, 0xafe5a5a5a5a5a4e3) + EXT( 0xa5a5a5a5a5a5a4e2, 3, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a4e2, 3, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a4e2, 255, 3, 9, 0xaff5a5a5a5a5a4e2) + EXT( 0xa5a5a5a5a5a5a4e1, 3, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a4e1, 3, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a4e1, 511, 3, 10, 0xaffda5a5a5a5a4e1) + EXT( 0xa5a5a5a5a5a5a4e0, 3, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a4e0, 3, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a4e0, 1023, 3, 11, 0xaffda5a5a5a5a4e0) + EXT( 0xa5a5a5a5a5a5a4df, 3, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a4df, 3, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a4df, 2047, 3, 12, 0xafffa5a5a5a5a4df) + EXT( 0xa5a5a5a5a5a5a4de, 3, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a4de, 3, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a4de, 4095, 3, 13, 0xafffa5a5a5a5a4de) + EXT( 0xa5a5a5a5a5a5a4dd, 3, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a4dd, 3, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a4dd, 8191, 3, 14, 0xafffa5a5a5a5a4dd) + EXT( 0xa5a5a5a5a5a5a4dc, 3, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a4dc, 3, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a4dc, 16383, 3, 15, 0xafffe5a5a5a5a4dc) + EXT( 0xa5a5a5a5a5a5a4db, 3, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a4db, 3, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a4db, 32767, 3, 16, 0xafffe5a5a5a5a4db) + EXT( 0xa5a5a5a5a5a5a4da, 3, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a4da, 3, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a4da, 65535, 3, 17, 0xaffff5a5a5a5a4da) + EXT( 0xa5a5a5a5a5a5a4d9, 3, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a4d9, 3, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a4d9, 131071, 3, 18, 0xaffffda5a5a5a4d9) + EXT( 0xa5a5a5a5a5a5a4d8, 3, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a4d8, 3, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a4d8, 262143, 3, 19, 0xaffffda5a5a5a4d8) + EXT( 0xa5a5a5a5a5a5a4d7, 3, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a4d7, 3, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a4d7, 524287, 3, 20, 0xafffffa5a5a5a4d7) + EXT( 0xa5a5a5a5a5a5a4d6, 3, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a4d6, 3, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a4d6, 1048575, 3, 21, 0xafffffa5a5a5a4d6) + EXT( 0xa5a5a5a5a5a5a4d5, 3, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a4d5, 3, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a4d5, 2097151, 3, 22, 0xafffffa5a5a5a4d5) + EXT( 0xa5a5a5a5a5a5a4d4, 3, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a4d4, 3, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a4d4, 4194303, 3, 23, 0xafffffe5a5a5a4d4) + EXT( 0xa5a5a5a5a5a5a4d3, 3, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a4d3, 3, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a4d3, 8388607, 3, 24, 0xafffffe5a5a5a4d3) + EXT( 0xa5a5a5a5a5a5a4d2, 3, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a4d2, 3, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a4d2, 16777215, 3, 25, 0xaffffff5a5a5a4d2) + EXT( 0xa5a5a5a5a5a5a4d1, 3, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a4d1, 3, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a4d1, 33554431, 3, 26, 0xaffffffda5a5a4d1) + EXT( 0xa5a5a5a5a5a5a4d0, 3, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a4d0, 3, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a4d0, 67108863, 3, 27, 0xaffffffda5a5a4d0) + EXT( 0xa5a5a5a5a5a5a4cf, 3, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a4cf, 3, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a4cf, 134217727, 3, 28, 0xafffffffa5a5a4cf) + EXT( 0xa5a5a5a5a5a5a4ce, 3, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a4ce, 3, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a4ce, 268435455, 3, 29, 0xafffffffa5a5a4ce) + EXT( 0xa5a5a5a5a5a5a4cd, 3, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a4cd, 3, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a4cd, 536870911, 3, 30, 0xafffffffa5a5a4cd) + EXT( 0xa5a5a5a5a5a5a4cc, 3, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a4cc, 3, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a4cc, 1073741823, 3, 31, 0xafffffffe5a5a4cc) + EXT( 0xa5a5a5a5a5a5a4cb, 3, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a4cb, 3, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a4cb, 2147483647, 3, 32, 0xafffffffe5a5a4cb) + EXT( 0xa5a5a5a5a5a5a4ca, 3, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a4ca, 3, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a4ca, 4294967295, 3, 33, 0xaffffffff5a5a4ca) + EXT( 0xa5a5a5a5a5a5a4c9, 3, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a4c9, 3, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a4c9, 8589934591, 3, 34, 0xaffffffffda5a4c9) + EXT( 0xa5a5a5a5a5a5a4c8, 3, 35, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a4c8, 3, 35, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a4c8, 17179869183, 3, 35, 0xaffffffffda5a4c8) + EXT( 0xa5a5a5a5a5a5a4c7, 3, 36, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a4c7, 3, 36, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a4c7, 34359738367, 3, 36, 0xafffffffffa5a4c7) + EXT( 0xa5a5a5a5a5a5a4c6, 3, 37, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a4c6, 3, 37, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a4c6, 68719476735, 3, 37, 0xafffffffffa5a4c6) + EXT( 0xa5a5a5a5a5a5a4c5, 3, 38, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a4c5, 3, 38, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a4c5, 137438953471, 3, 38, 0xafffffffffa5a4c5) + EXT( 0xa5a5a5a5a5a5a4c4, 3, 39, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a4c4, 3, 39, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a4c4, 274877906943, 3, 39, 0xafffffffffe5a4c4) + EXT( 0xa5a5a5a5a5a5a4c3, 3, 40, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a4c3, 3, 40, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a4c3, 549755813887, 3, 40, 0xafffffffffe5a4c3) + EXT( 0xa5a5a5a5a5a5a4c2, 3, 41, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a4c2, 3, 41, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a4c2, 1099511627775, 3, 41, 0xaffffffffff5a4c2) + EXT( 0xa5a5a5a5a5a5a4c1, 3, 42, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a4c1, 3, 42, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a4c1, 2199023255551, 3, 42, 0xaffffffffffda4c1) + EXT( 0xa5a5a5a5a5a5a4c0, 3, 43, 0x0000016969696969) + EXTU(0xa5a5a5a5a5a5a4c0, 3, 43, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a4c0, 4398046511103, 3, 43, 0xaffffffffffda4c0) + EXT( 0xa5a5a5a5a5a5a4bf, 3, 44, 0x000002d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a4bf, 3, 44, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a4bf, 8796093022207, 3, 44, 0xafffffffffffa4bf) + EXT( 0xa5a5a5a5a5a5a4be, 3, 45, 0x000005a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a4be, 3, 45, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a4be, 17592186044415, 3, 45, 0xafffffffffffa4be) + EXT( 0xa5a5a5a5a5a5a4bd, 3, 46, 0x00000b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a4bd, 3, 46, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a4bd, 35184372088831, 3, 46, 0xafffffffffffa4bd) + EXT( 0xa5a5a5a5a5a5a4bc, 3, 47, 0x0000169696969696) + EXTU(0xa5a5a5a5a5a5a4bc, 3, 47, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a4bc, 70368744177663, 3, 47, 0xafffffffffffe4bc) + EXT( 0xa5a5a5a5a5a5a4bb, 3, 48, 0x00002d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a4bb, 3, 48, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a4bb, 140737488355327, 3, 48, 0xafffffffffffe4bb) + EXT( 0xa5a5a5a5a5a5a4ba, 3, 49, 0x00005a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a4ba, 3, 49, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a4ba, 281474976710655, 3, 49, 0xaffffffffffff4ba) + EXT( 0xa5a5a5a5a5a5a4b9, 3, 50, 0x0000b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a4b9, 3, 50, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a4b9, 562949953421311, 3, 50, 0xaffffffffffffcb9) + EXT( 0xa5a5a5a5a5a5a4b8, 3, 51, 0x0001696969696969) + EXTU(0xa5a5a5a5a5a5a4b8, 3, 51, 0x0001696969696969) + DEP( 0xa5a5a5a5a5a5a4b8, 1125899906842623, 3, 51, 0xaffffffffffffcb8) + EXT( 0xa5a5a5a5a5a5a4b7, 3, 52, 0x0002d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a4b7, 3, 52, 0x0002d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a4b7, 2251799813685247, 3, 52, 0xaffffffffffffeb7) + EXT( 0xa5a5a5a5a5a5a4b6, 3, 53, 0x0005a5a5a5a5a5a4) + EXTU(0xa5a5a5a5a5a5a4b6, 3, 53, 0x0005a5a5a5a5a5a4) + DEP( 0xa5a5a5a5a5a5a4b6, 4503599627370495, 3, 53, 0xafffffffffffffb6) + EXT( 0xa5a5a5a5a5a5a4b5, 3, 54, 0x000b4b4b4b4b4b49) + EXTU(0xa5a5a5a5a5a5a4b5, 3, 54, 0x000b4b4b4b4b4b49) + DEP( 0xa5a5a5a5a5a5a4b5, 9007199254740991, 3, 54, 0xafffffffffffffb5) + EXT( 0xa5a5a5a5a5a5a4b4, 3, 55, 0x0016969696969692) + EXTU(0xa5a5a5a5a5a5a4b4, 3, 55, 0x0016969696969692) + DEP( 0xa5a5a5a5a5a5a4b4, 18014398509481983, 3, 55, 0xaffffffffffffff4) + EXT( 0xa5a5a5a5a5a5a4b3, 3, 56, 0x002d2d2d2d2d2d25) + EXTU(0xa5a5a5a5a5a5a4b3, 3, 56, 0x002d2d2d2d2d2d25) + DEP( 0xa5a5a5a5a5a5a4b3, 36028797018963967, 3, 56, 0xaffffffffffffff3) + EXT( 0xa5a5a5a5a5a5a4b2, 3, 57, 0x005a5a5a5a5a5a4b) + EXTU(0xa5a5a5a5a5a5a4b2, 3, 57, 0x005a5a5a5a5a5a4b) + DEP( 0xa5a5a5a5a5a5a4b2, 72057594037927935, 3, 57, 0xaffffffffffffff2) + EXT( 0xa5a5a5a5a5a5a4b1, 3, 58, 0x00b4b4b4b4b4b496) + EXTU(0xa5a5a5a5a5a5a4b1, 3, 58, 0x00b4b4b4b4b4b496) + DEP( 0xa5a5a5a5a5a5a4b1, 144115188075855871, 3, 58, 0xaffffffffffffff9) + EXT( 0xa5a5a5a5a5a5a4b0, 3, 59, 0x016969696969692c) + EXTU(0xa5a5a5a5a5a5a4b0, 3, 59, 0x016969696969692c) + DEP( 0xa5a5a5a5a5a5a4b0, 288230376151711743, 3, 59, 0xaffffffffffffffc) + EXT( 0xa5a5a5a5a5a5a4af, 3, 60, 0x02d2d2d2d2d2d257) + EXTU(0xa5a5a5a5a5a5a4af, 3, 60, 0x02d2d2d2d2d2d257) + DEP( 0xa5a5a5a5a5a5a4af, 576460752303423487, 3, 60, 0xafffffffffffffff) + EXT( 0xa5a5a5a5a5a5a4ae, 4, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a4ae, 4, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a4ae, 0, 4, 1, 0xa5a5a5a5a5a5a4ae) + EXT( 0xa5a5a5a5a5a5a4ad, 4, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a4ad, 4, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a4ad, 1, 4, 2, 0xa5a5a5a5a5a5a4ad) + EXT( 0xa5a5a5a5a5a5a4ac, 4, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a4ac, 4, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a4ac, 3, 4, 3, 0xa7a5a5a5a5a5a4ac) + EXT( 0xa5a5a5a5a5a5a4ab, 4, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a4ab, 4, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a4ab, 7, 4, 4, 0xa7a5a5a5a5a5a4ab) + EXT( 0xa5a5a5a5a5a5a4aa, 4, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a4aa, 4, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a4aa, 15, 4, 5, 0xa7a5a5a5a5a5a4aa) + EXT( 0xa5a5a5a5a5a5a4a9, 4, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a4a9, 4, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a4a9, 31, 4, 6, 0xa7e5a5a5a5a5a4a9) + EXT( 0xa5a5a5a5a5a5a4a8, 4, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a4a8, 4, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a4a8, 63, 4, 7, 0xa7e5a5a5a5a5a4a8) + EXT( 0xa5a5a5a5a5a5a4a7, 4, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a4a7, 4, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a4a7, 127, 4, 8, 0xa7f5a5a5a5a5a4a7) + EXT( 0xa5a5a5a5a5a5a4a6, 4, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a4a6, 4, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a4a6, 255, 4, 9, 0xa7fda5a5a5a5a4a6) + EXT( 0xa5a5a5a5a5a5a4a5, 4, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a4a5, 4, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a4a5, 511, 4, 10, 0xa7fda5a5a5a5a4a5) + EXT( 0xa5a5a5a5a5a5a4a4, 4, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a4a4, 4, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a4a4, 1023, 4, 11, 0xa7ffa5a5a5a5a4a4) + EXT( 0xa5a5a5a5a5a5a4a3, 4, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a4a3, 4, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a4a3, 2047, 4, 12, 0xa7ffa5a5a5a5a4a3) + EXT( 0xa5a5a5a5a5a5a4a2, 4, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a4a2, 4, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a4a2, 4095, 4, 13, 0xa7ffa5a5a5a5a4a2) + EXT( 0xa5a5a5a5a5a5a4a1, 4, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a4a1, 4, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a4a1, 8191, 4, 14, 0xa7ffe5a5a5a5a4a1) + EXT( 0xa5a5a5a5a5a5a4a0, 4, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a4a0, 4, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a4a0, 16383, 4, 15, 0xa7ffe5a5a5a5a4a0) + EXT( 0xa5a5a5a5a5a5a49f, 4, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a49f, 4, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a49f, 32767, 4, 16, 0xa7fff5a5a5a5a49f) + EXT( 0xa5a5a5a5a5a5a49e, 4, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a49e, 4, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a49e, 65535, 4, 17, 0xa7fffda5a5a5a49e) + EXT( 0xa5a5a5a5a5a5a49d, 4, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a49d, 4, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a49d, 131071, 4, 18, 0xa7fffda5a5a5a49d) + EXT( 0xa5a5a5a5a5a5a49c, 4, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a49c, 4, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a49c, 262143, 4, 19, 0xa7ffffa5a5a5a49c) + EXT( 0xa5a5a5a5a5a5a49b, 4, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a49b, 4, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a49b, 524287, 4, 20, 0xa7ffffa5a5a5a49b) + EXT( 0xa5a5a5a5a5a5a49a, 4, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a49a, 4, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a49a, 1048575, 4, 21, 0xa7ffffa5a5a5a49a) + EXT( 0xa5a5a5a5a5a5a499, 4, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a499, 4, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a499, 2097151, 4, 22, 0xa7ffffe5a5a5a499) + EXT( 0xa5a5a5a5a5a5a498, 4, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a498, 4, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a498, 4194303, 4, 23, 0xa7ffffe5a5a5a498) + EXT( 0xa5a5a5a5a5a5a497, 4, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a497, 4, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a497, 8388607, 4, 24, 0xa7fffff5a5a5a497) + EXT( 0xa5a5a5a5a5a5a496, 4, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a496, 4, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a496, 16777215, 4, 25, 0xa7fffffda5a5a496) + EXT( 0xa5a5a5a5a5a5a495, 4, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a495, 4, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a495, 33554431, 4, 26, 0xa7fffffda5a5a495) + EXT( 0xa5a5a5a5a5a5a494, 4, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a494, 4, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a494, 67108863, 4, 27, 0xa7ffffffa5a5a494) + EXT( 0xa5a5a5a5a5a5a493, 4, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a493, 4, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a493, 134217727, 4, 28, 0xa7ffffffa5a5a493) + EXT( 0xa5a5a5a5a5a5a492, 4, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a492, 4, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a492, 268435455, 4, 29, 0xa7ffffffa5a5a492) + EXT( 0xa5a5a5a5a5a5a491, 4, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a491, 4, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a491, 536870911, 4, 30, 0xa7ffffffe5a5a491) + EXT( 0xa5a5a5a5a5a5a490, 4, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a490, 4, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a490, 1073741823, 4, 31, 0xa7ffffffe5a5a490) + EXT( 0xa5a5a5a5a5a5a48f, 4, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a48f, 4, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a48f, 2147483647, 4, 32, 0xa7fffffff5a5a48f) + EXT( 0xa5a5a5a5a5a5a48e, 4, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a48e, 4, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a48e, 4294967295, 4, 33, 0xa7fffffffda5a48e) + EXT( 0xa5a5a5a5a5a5a48d, 4, 34, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a48d, 4, 34, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a48d, 8589934591, 4, 34, 0xa7fffffffda5a48d) + EXT( 0xa5a5a5a5a5a5a48c, 4, 35, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a48c, 4, 35, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a48c, 17179869183, 4, 35, 0xa7ffffffffa5a48c) + EXT( 0xa5a5a5a5a5a5a48b, 4, 36, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a48b, 4, 36, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a48b, 34359738367, 4, 36, 0xa7ffffffffa5a48b) + EXT( 0xa5a5a5a5a5a5a48a, 4, 37, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a48a, 4, 37, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a48a, 68719476735, 4, 37, 0xa7ffffffffa5a48a) + EXT( 0xa5a5a5a5a5a5a489, 4, 38, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a489, 4, 38, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a489, 137438953471, 4, 38, 0xa7ffffffffe5a489) + EXT( 0xa5a5a5a5a5a5a488, 4, 39, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a488, 4, 39, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a488, 274877906943, 4, 39, 0xa7ffffffffe5a488) + EXT( 0xa5a5a5a5a5a5a487, 4, 40, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a487, 4, 40, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a487, 549755813887, 4, 40, 0xa7fffffffff5a487) + EXT( 0xa5a5a5a5a5a5a486, 4, 41, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a486, 4, 41, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a486, 1099511627775, 4, 41, 0xa7fffffffffda486) + EXT( 0xa5a5a5a5a5a5a485, 4, 42, 0x0000016969696969) + EXTU(0xa5a5a5a5a5a5a485, 4, 42, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a485, 2199023255551, 4, 42, 0xa7fffffffffda485) + EXT( 0xa5a5a5a5a5a5a484, 4, 43, 0x000002d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a484, 4, 43, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a484, 4398046511103, 4, 43, 0xa7ffffffffffa484) + EXT( 0xa5a5a5a5a5a5a483, 4, 44, 0x000005a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a483, 4, 44, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a483, 8796093022207, 4, 44, 0xa7ffffffffffa483) + EXT( 0xa5a5a5a5a5a5a482, 4, 45, 0x00000b4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a482, 4, 45, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a482, 17592186044415, 4, 45, 0xa7ffffffffffa482) + EXT( 0xa5a5a5a5a5a5a481, 4, 46, 0x0000169696969696) + EXTU(0xa5a5a5a5a5a5a481, 4, 46, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a481, 35184372088831, 4, 46, 0xa7ffffffffffe481) + EXT( 0xa5a5a5a5a5a5a480, 4, 47, 0x00002d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a480, 4, 47, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a480, 70368744177663, 4, 47, 0xa7ffffffffffe480) + EXT( 0xa5a5a5a5a5a5a47f, 4, 48, 0x00005a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a47f, 4, 48, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a47f, 140737488355327, 4, 48, 0xa7fffffffffff47f) + EXT( 0xa5a5a5a5a5a5a47e, 4, 49, 0x0000b4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a47e, 4, 49, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a47e, 281474976710655, 4, 49, 0xa7fffffffffffc7e) + EXT( 0xa5a5a5a5a5a5a47d, 4, 50, 0x0001696969696969) + EXTU(0xa5a5a5a5a5a5a47d, 4, 50, 0x0001696969696969) + DEP( 0xa5a5a5a5a5a5a47d, 562949953421311, 4, 50, 0xa7fffffffffffc7d) + EXT( 0xa5a5a5a5a5a5a47c, 4, 51, 0x0002d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a47c, 4, 51, 0x0002d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a47c, 1125899906842623, 4, 51, 0xa7fffffffffffe7c) + EXT( 0xa5a5a5a5a5a5a47b, 4, 52, 0x0005a5a5a5a5a5a4) + EXTU(0xa5a5a5a5a5a5a47b, 4, 52, 0x0005a5a5a5a5a5a4) + DEP( 0xa5a5a5a5a5a5a47b, 2251799813685247, 4, 52, 0xa7ffffffffffff7b) + EXT( 0xa5a5a5a5a5a5a47a, 4, 53, 0x000b4b4b4b4b4b48) + EXTU(0xa5a5a5a5a5a5a47a, 4, 53, 0x000b4b4b4b4b4b48) + DEP( 0xa5a5a5a5a5a5a47a, 4503599627370495, 4, 53, 0xa7fffffffffffffa) + EXT( 0xa5a5a5a5a5a5a479, 4, 54, 0x0016969696969691) + EXTU(0xa5a5a5a5a5a5a479, 4, 54, 0x0016969696969691) + DEP( 0xa5a5a5a5a5a5a479, 9007199254740991, 4, 54, 0xa7fffffffffffff9) + EXT( 0xa5a5a5a5a5a5a478, 4, 55, 0x002d2d2d2d2d2d23) + EXTU(0xa5a5a5a5a5a5a478, 4, 55, 0x002d2d2d2d2d2d23) + DEP( 0xa5a5a5a5a5a5a478, 18014398509481983, 4, 55, 0xa7fffffffffffff8) + EXT( 0xa5a5a5a5a5a5a477, 4, 56, 0x005a5a5a5a5a5a47) + EXTU(0xa5a5a5a5a5a5a477, 4, 56, 0x005a5a5a5a5a5a47) + DEP( 0xa5a5a5a5a5a5a477, 36028797018963967, 4, 56, 0xa7fffffffffffff7) + EXT( 0xa5a5a5a5a5a5a476, 4, 57, 0x00b4b4b4b4b4b48e) + EXTU(0xa5a5a5a5a5a5a476, 4, 57, 0x00b4b4b4b4b4b48e) + DEP( 0xa5a5a5a5a5a5a476, 72057594037927935, 4, 57, 0xa7fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a475, 4, 58, 0x016969696969691d) + EXTU(0xa5a5a5a5a5a5a475, 4, 58, 0x016969696969691d) + DEP( 0xa5a5a5a5a5a5a475, 144115188075855871, 4, 58, 0xa7fffffffffffffd) + EXT( 0xa5a5a5a5a5a5a474, 4, 59, 0x02d2d2d2d2d2d23a) + EXTU(0xa5a5a5a5a5a5a474, 4, 59, 0x02d2d2d2d2d2d23a) + DEP( 0xa5a5a5a5a5a5a474, 288230376151711743, 4, 59, 0xa7fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a473, 5, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a473, 5, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a473, 0, 5, 1, 0xa1a5a5a5a5a5a473) + EXT( 0xa5a5a5a5a5a5a472, 5, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a472, 5, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a472, 1, 5, 2, 0xa3a5a5a5a5a5a472) + EXT( 0xa5a5a5a5a5a5a471, 5, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a471, 5, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a471, 3, 5, 3, 0xa3a5a5a5a5a5a471) + EXT( 0xa5a5a5a5a5a5a470, 5, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a470, 5, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a470, 7, 5, 4, 0xa3a5a5a5a5a5a470) + EXT( 0xa5a5a5a5a5a5a46f, 5, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a46f, 5, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a46f, 15, 5, 5, 0xa3e5a5a5a5a5a46f) + EXT( 0xa5a5a5a5a5a5a46e, 5, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a46e, 5, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a46e, 31, 5, 6, 0xa3e5a5a5a5a5a46e) + EXT( 0xa5a5a5a5a5a5a46d, 5, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a46d, 5, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a46d, 63, 5, 7, 0xa3f5a5a5a5a5a46d) + EXT( 0xa5a5a5a5a5a5a46c, 5, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a46c, 5, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a46c, 127, 5, 8, 0xa3fda5a5a5a5a46c) + EXT( 0xa5a5a5a5a5a5a46b, 5, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a46b, 5, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a46b, 255, 5, 9, 0xa3fda5a5a5a5a46b) + EXT( 0xa5a5a5a5a5a5a46a, 5, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a46a, 5, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a46a, 511, 5, 10, 0xa3ffa5a5a5a5a46a) + EXT( 0xa5a5a5a5a5a5a469, 5, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a469, 5, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a469, 1023, 5, 11, 0xa3ffa5a5a5a5a469) + EXT( 0xa5a5a5a5a5a5a468, 5, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a468, 5, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a468, 2047, 5, 12, 0xa3ffa5a5a5a5a468) + EXT( 0xa5a5a5a5a5a5a467, 5, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a467, 5, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a467, 4095, 5, 13, 0xa3ffe5a5a5a5a467) + EXT( 0xa5a5a5a5a5a5a466, 5, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a466, 5, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a466, 8191, 5, 14, 0xa3ffe5a5a5a5a466) + EXT( 0xa5a5a5a5a5a5a465, 5, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a465, 5, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a465, 16383, 5, 15, 0xa3fff5a5a5a5a465) + EXT( 0xa5a5a5a5a5a5a464, 5, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a464, 5, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a464, 32767, 5, 16, 0xa3fffda5a5a5a464) + EXT( 0xa5a5a5a5a5a5a463, 5, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a463, 5, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a463, 65535, 5, 17, 0xa3fffda5a5a5a463) + EXT( 0xa5a5a5a5a5a5a462, 5, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a462, 5, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a462, 131071, 5, 18, 0xa3ffffa5a5a5a462) + EXT( 0xa5a5a5a5a5a5a461, 5, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a461, 5, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a461, 262143, 5, 19, 0xa3ffffa5a5a5a461) + EXT( 0xa5a5a5a5a5a5a460, 5, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a460, 5, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a460, 524287, 5, 20, 0xa3ffffa5a5a5a460) + EXT( 0xa5a5a5a5a5a5a45f, 5, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a45f, 5, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a45f, 1048575, 5, 21, 0xa3ffffe5a5a5a45f) + EXT( 0xa5a5a5a5a5a5a45e, 5, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a45e, 5, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a45e, 2097151, 5, 22, 0xa3ffffe5a5a5a45e) + EXT( 0xa5a5a5a5a5a5a45d, 5, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a45d, 5, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a45d, 4194303, 5, 23, 0xa3fffff5a5a5a45d) + EXT( 0xa5a5a5a5a5a5a45c, 5, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a45c, 5, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a45c, 8388607, 5, 24, 0xa3fffffda5a5a45c) + EXT( 0xa5a5a5a5a5a5a45b, 5, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a5a45b, 5, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a45b, 16777215, 5, 25, 0xa3fffffda5a5a45b) + EXT( 0xa5a5a5a5a5a5a45a, 5, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a5a45a, 5, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a45a, 33554431, 5, 26, 0xa3ffffffa5a5a45a) + EXT( 0xa5a5a5a5a5a5a459, 5, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a5a459, 5, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a459, 67108863, 5, 27, 0xa3ffffffa5a5a459) + EXT( 0xa5a5a5a5a5a5a458, 5, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a5a458, 5, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a458, 134217727, 5, 28, 0xa3ffffffa5a5a458) + EXT( 0xa5a5a5a5a5a5a457, 5, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a5a457, 5, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a457, 268435455, 5, 29, 0xa3ffffffe5a5a457) + EXT( 0xa5a5a5a5a5a5a456, 5, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a5a456, 5, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a456, 536870911, 5, 30, 0xa3ffffffe5a5a456) + EXT( 0xa5a5a5a5a5a5a455, 5, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a455, 5, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a455, 1073741823, 5, 31, 0xa3fffffff5a5a455) + EXT( 0xa5a5a5a5a5a5a454, 5, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a454, 5, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a454, 2147483647, 5, 32, 0xa3fffffffda5a454) + EXT( 0xa5a5a5a5a5a5a453, 5, 33, 0xffffffff69696969) + EXTU(0xa5a5a5a5a5a5a453, 5, 33, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a453, 4294967295, 5, 33, 0xa3fffffffda5a453) + EXT( 0xa5a5a5a5a5a5a452, 5, 34, 0xfffffffed2d2d2d2) + EXTU(0xa5a5a5a5a5a5a452, 5, 34, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a452, 8589934591, 5, 34, 0xa3ffffffffa5a452) + EXT( 0xa5a5a5a5a5a5a451, 5, 35, 0xfffffffda5a5a5a5) + EXTU(0xa5a5a5a5a5a5a451, 5, 35, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a451, 17179869183, 5, 35, 0xa3ffffffffa5a451) + EXT( 0xa5a5a5a5a5a5a450, 5, 36, 0xfffffffb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a450, 5, 36, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a450, 34359738367, 5, 36, 0xa3ffffffffa5a450) + EXT( 0xa5a5a5a5a5a5a44f, 5, 37, 0xfffffff696969696) + EXTU(0xa5a5a5a5a5a5a44f, 5, 37, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a44f, 68719476735, 5, 37, 0xa3ffffffffe5a44f) + EXT( 0xa5a5a5a5a5a5a44e, 5, 38, 0xffffffed2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a44e, 5, 38, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a44e, 137438953471, 5, 38, 0xa3ffffffffe5a44e) + EXT( 0xa5a5a5a5a5a5a44d, 5, 39, 0xffffffda5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a44d, 5, 39, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a44d, 274877906943, 5, 39, 0xa3fffffffff5a44d) + EXT( 0xa5a5a5a5a5a5a44c, 5, 40, 0xffffffb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a44c, 5, 40, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a44c, 549755813887, 5, 40, 0xa3fffffffffda44c) + EXT( 0xa5a5a5a5a5a5a44b, 5, 41, 0xffffff6969696969) + EXTU(0xa5a5a5a5a5a5a44b, 5, 41, 0x0000016969696969) + DEP( 0xa5a5a5a5a5a5a44b, 1099511627775, 5, 41, 0xa3fffffffffda44b) + EXT( 0xa5a5a5a5a5a5a44a, 5, 42, 0xfffffed2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a44a, 5, 42, 0x000002d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a44a, 2199023255551, 5, 42, 0xa3ffffffffffa44a) + EXT( 0xa5a5a5a5a5a5a449, 5, 43, 0xfffffda5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a449, 5, 43, 0x000005a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a449, 4398046511103, 5, 43, 0xa3ffffffffffa449) + EXT( 0xa5a5a5a5a5a5a448, 5, 44, 0xfffffb4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a448, 5, 44, 0x00000b4b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a448, 8796093022207, 5, 44, 0xa3ffffffffffa448) + EXT( 0xa5a5a5a5a5a5a447, 5, 45, 0xfffff69696969696) + EXTU(0xa5a5a5a5a5a5a447, 5, 45, 0x0000169696969696) + DEP( 0xa5a5a5a5a5a5a447, 17592186044415, 5, 45, 0xa3ffffffffffe447) + EXT( 0xa5a5a5a5a5a5a446, 5, 46, 0xffffed2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a446, 5, 46, 0x00002d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a446, 35184372088831, 5, 46, 0xa3ffffffffffe446) + EXT( 0xa5a5a5a5a5a5a445, 5, 47, 0xffffda5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a445, 5, 47, 0x00005a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a445, 70368744177663, 5, 47, 0xa3fffffffffff445) + EXT( 0xa5a5a5a5a5a5a444, 5, 48, 0xffffb4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a444, 5, 48, 0x0000b4b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a444, 140737488355327, 5, 48, 0xa3fffffffffffc44) + EXT( 0xa5a5a5a5a5a5a443, 5, 49, 0xffff696969696969) + EXTU(0xa5a5a5a5a5a5a443, 5, 49, 0x0001696969696969) + DEP( 0xa5a5a5a5a5a5a443, 281474976710655, 5, 49, 0xa3fffffffffffc43) + EXT( 0xa5a5a5a5a5a5a442, 5, 50, 0xfffed2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a442, 5, 50, 0x0002d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a442, 562949953421311, 5, 50, 0xa3fffffffffffe42) + EXT( 0xa5a5a5a5a5a5a441, 5, 51, 0xfffda5a5a5a5a5a4) + EXTU(0xa5a5a5a5a5a5a441, 5, 51, 0x0005a5a5a5a5a5a4) + DEP( 0xa5a5a5a5a5a5a441, 1125899906842623, 5, 51, 0xa3ffffffffffff41) + EXT( 0xa5a5a5a5a5a5a440, 5, 52, 0xfffb4b4b4b4b4b48) + EXTU(0xa5a5a5a5a5a5a440, 5, 52, 0x000b4b4b4b4b4b48) + DEP( 0xa5a5a5a5a5a5a440, 2251799813685247, 5, 52, 0xa3ffffffffffffc0) + EXT( 0xa5a5a5a5a5a5a43f, 5, 53, 0xfff6969696969690) + EXTU(0xa5a5a5a5a5a5a43f, 5, 53, 0x0016969696969690) + DEP( 0xa5a5a5a5a5a5a43f, 4503599627370495, 5, 53, 0xa3ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a43e, 5, 54, 0xffed2d2d2d2d2d21) + EXTU(0xa5a5a5a5a5a5a43e, 5, 54, 0x002d2d2d2d2d2d21) + DEP( 0xa5a5a5a5a5a5a43e, 9007199254740991, 5, 54, 0xa3fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a43d, 5, 55, 0xffda5a5a5a5a5a43) + EXTU(0xa5a5a5a5a5a5a43d, 5, 55, 0x005a5a5a5a5a5a43) + DEP( 0xa5a5a5a5a5a5a43d, 18014398509481983, 5, 55, 0xa3fffffffffffffd) + EXT( 0xa5a5a5a5a5a5a43c, 5, 56, 0xffb4b4b4b4b4b487) + EXTU(0xa5a5a5a5a5a5a43c, 5, 56, 0x00b4b4b4b4b4b487) + DEP( 0xa5a5a5a5a5a5a43c, 36028797018963967, 5, 56, 0xa3fffffffffffffc) + EXT( 0xa5a5a5a5a5a5a43b, 5, 57, 0xff6969696969690e) + EXTU(0xa5a5a5a5a5a5a43b, 5, 57, 0x016969696969690e) + DEP( 0xa5a5a5a5a5a5a43b, 72057594037927935, 5, 57, 0xa3ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a43a, 5, 58, 0xfed2d2d2d2d2d21d) + EXTU(0xa5a5a5a5a5a5a43a, 5, 58, 0x02d2d2d2d2d2d21d) + DEP( 0xa5a5a5a5a5a5a43a, 144115188075855871, 5, 58, 0xa3fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a439, 6, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a439, 6, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a439, 0, 6, 1, 0xa5a5a5a5a5a5a439) + EXT( 0xa5a5a5a5a5a5a438, 6, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a438, 6, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a438, 1, 6, 2, 0xa5a5a5a5a5a5a438) + EXT( 0xa5a5a5a5a5a5a437, 6, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a437, 6, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a437, 3, 6, 3, 0xa5a5a5a5a5a5a437) + EXT( 0xa5a5a5a5a5a5a436, 6, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a5a436, 6, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a436, 7, 6, 4, 0xa5e5a5a5a5a5a436) + EXT( 0xa5a5a5a5a5a5a435, 6, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a435, 6, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a435, 15, 6, 5, 0xa5e5a5a5a5a5a435) + EXT( 0xa5a5a5a5a5a5a434, 6, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a434, 6, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a434, 31, 6, 6, 0xa5f5a5a5a5a5a434) + EXT( 0xa5a5a5a5a5a5a433, 6, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a433, 6, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a433, 63, 6, 7, 0xa5fda5a5a5a5a433) + EXT( 0xa5a5a5a5a5a5a432, 6, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a5a432, 6, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a432, 127, 6, 8, 0xa5fda5a5a5a5a432) + EXT( 0xa5a5a5a5a5a5a431, 6, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a5a431, 6, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a431, 255, 6, 9, 0xa5ffa5a5a5a5a431) + EXT( 0xa5a5a5a5a5a5a430, 6, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a5a430, 6, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a430, 511, 6, 10, 0xa5ffa5a5a5a5a430) + EXT( 0xa5a5a5a5a5a5a42f, 6, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a5a42f, 6, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a42f, 1023, 6, 11, 0xa5ffa5a5a5a5a42f) + EXT( 0xa5a5a5a5a5a5a42e, 6, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a5a42e, 6, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a42e, 2047, 6, 12, 0xa5ffe5a5a5a5a42e) + EXT( 0xa5a5a5a5a5a5a42d, 6, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a42d, 6, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a42d, 4095, 6, 13, 0xa5ffe5a5a5a5a42d) + EXT( 0xa5a5a5a5a5a5a42c, 6, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a42c, 6, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a42c, 8191, 6, 14, 0xa5fff5a5a5a5a42c) + EXT( 0xa5a5a5a5a5a5a42b, 6, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a42b, 6, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a42b, 16383, 6, 15, 0xa5fffda5a5a5a42b) + EXT( 0xa5a5a5a5a5a5a42a, 6, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a5a42a, 6, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a42a, 32767, 6, 16, 0xa5fffda5a5a5a42a) + EXT( 0xa5a5a5a5a5a5a429, 6, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a5a429, 6, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a429, 65535, 6, 17, 0xa5ffffa5a5a5a429) + EXT( 0xa5a5a5a5a5a5a428, 6, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a5a428, 6, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a428, 131071, 6, 18, 0xa5ffffa5a5a5a428) + EXT( 0xa5a5a5a5a5a5a427, 6, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a5a427, 6, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a427, 262143, 6, 19, 0xa5ffffa5a5a5a427) + EXT( 0xa5a5a5a5a5a5a426, 6, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a5a426, 6, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a426, 524287, 6, 20, 0xa5ffffe5a5a5a426) + EXT( 0xa5a5a5a5a5a5a425, 6, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a425, 6, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a425, 1048575, 6, 21, 0xa5ffffe5a5a5a425) + EXT( 0xa5a5a5a5a5a5a424, 6, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a424, 6, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a424, 2097151, 6, 22, 0xa5fffff5a5a5a424) + EXT( 0xa5a5a5a5a5a5a423, 6, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a423, 6, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a423, 4194303, 6, 23, 0xa5fffffda5a5a423) + EXT( 0xa5a5a5a5a5a5a422, 6, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a5a422, 6, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a422, 8388607, 6, 24, 0xa5fffffda5a5a422) + EXT( 0xa5a5a5a5a5a5a421, 6, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a5a421, 6, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a421, 16777215, 6, 25, 0xa5ffffffa5a5a421) + EXT( 0xa5a5a5a5a5a5a420, 6, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a5a420, 6, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a420, 33554431, 6, 26, 0xa5ffffffa5a5a420) + EXT( 0xa5a5a5a5a5a5a41f, 6, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a5a41f, 6, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a41f, 67108863, 6, 27, 0xa5ffffffa5a5a41f) + EXT( 0xa5a5a5a5a5a5a41e, 6, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a5a41e, 6, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a41e, 134217727, 6, 28, 0xa5ffffffe5a5a41e) + EXT( 0xa5a5a5a5a5a5a41d, 6, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a5a41d, 6, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a41d, 268435455, 6, 29, 0xa5ffffffe5a5a41d) + EXT( 0xa5a5a5a5a5a5a41c, 6, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a41c, 6, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a41c, 536870911, 6, 30, 0xa5fffffff5a5a41c) + EXT( 0xa5a5a5a5a5a5a41b, 6, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a41b, 6, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a41b, 1073741823, 6, 31, 0xa5fffffffda5a41b) + EXT( 0xa5a5a5a5a5a5a41a, 6, 32, 0x0000000069696969) + EXTU(0xa5a5a5a5a5a5a41a, 6, 32, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a41a, 2147483647, 6, 32, 0xa5fffffffda5a41a) + EXT( 0xa5a5a5a5a5a5a419, 6, 33, 0x00000000d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a419, 6, 33, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a419, 4294967295, 6, 33, 0xa5ffffffffa5a419) + EXT( 0xa5a5a5a5a5a5a418, 6, 34, 0x00000001a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a418, 6, 34, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a418, 8589934591, 6, 34, 0xa5ffffffffa5a418) + EXT( 0xa5a5a5a5a5a5a417, 6, 35, 0x000000034b4b4b4b) + EXTU(0xa5a5a5a5a5a5a417, 6, 35, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a417, 17179869183, 6, 35, 0xa5ffffffffa5a417) + EXT( 0xa5a5a5a5a5a5a416, 6, 36, 0x0000000696969696) + EXTU(0xa5a5a5a5a5a5a416, 6, 36, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a416, 34359738367, 6, 36, 0xa5ffffffffe5a416) + EXT( 0xa5a5a5a5a5a5a415, 6, 37, 0x0000000d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a415, 6, 37, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a415, 68719476735, 6, 37, 0xa5ffffffffe5a415) + EXT( 0xa5a5a5a5a5a5a414, 6, 38, 0x0000001a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a414, 6, 38, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a414, 137438953471, 6, 38, 0xa5fffffffff5a414) + EXT( 0xa5a5a5a5a5a5a413, 6, 39, 0x00000034b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a413, 6, 39, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a413, 274877906943, 6, 39, 0xa5fffffffffda413) + EXT( 0xa5a5a5a5a5a5a412, 6, 40, 0x0000006969696969) + EXTU(0xa5a5a5a5a5a5a412, 6, 40, 0x0000006969696969) + DEP( 0xa5a5a5a5a5a5a412, 549755813887, 6, 40, 0xa5fffffffffda412) + EXT( 0xa5a5a5a5a5a5a411, 6, 41, 0x000000d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a411, 6, 41, 0x000000d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a411, 1099511627775, 6, 41, 0xa5ffffffffffa411) + EXT( 0xa5a5a5a5a5a5a410, 6, 42, 0x000001a5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a410, 6, 42, 0x000001a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a410, 2199023255551, 6, 42, 0xa5ffffffffffa410) + EXT( 0xa5a5a5a5a5a5a40f, 6, 43, 0x0000034b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a40f, 6, 43, 0x0000034b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a40f, 4398046511103, 6, 43, 0xa5ffffffffffa40f) + EXT( 0xa5a5a5a5a5a5a40e, 6, 44, 0x0000069696969696) + EXTU(0xa5a5a5a5a5a5a40e, 6, 44, 0x0000069696969696) + DEP( 0xa5a5a5a5a5a5a40e, 8796093022207, 6, 44, 0xa5ffffffffffe40e) + EXT( 0xa5a5a5a5a5a5a40d, 6, 45, 0x00000d2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a40d, 6, 45, 0x00000d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a40d, 17592186044415, 6, 45, 0xa5ffffffffffe40d) + EXT( 0xa5a5a5a5a5a5a40c, 6, 46, 0x00001a5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a40c, 6, 46, 0x00001a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a40c, 35184372088831, 6, 46, 0xa5fffffffffff40c) + EXT( 0xa5a5a5a5a5a5a40b, 6, 47, 0x000034b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a40b, 6, 47, 0x000034b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a40b, 70368744177663, 6, 47, 0xa5fffffffffffc0b) + EXT( 0xa5a5a5a5a5a5a40a, 6, 48, 0x0000696969696969) + EXTU(0xa5a5a5a5a5a5a40a, 6, 48, 0x0000696969696969) + DEP( 0xa5a5a5a5a5a5a40a, 140737488355327, 6, 48, 0xa5fffffffffffc0a) + EXT( 0xa5a5a5a5a5a5a409, 6, 49, 0x0000d2d2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a409, 6, 49, 0x0000d2d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a409, 281474976710655, 6, 49, 0xa5fffffffffffe09) + EXT( 0xa5a5a5a5a5a5a408, 6, 50, 0x0001a5a5a5a5a5a4) + EXTU(0xa5a5a5a5a5a5a408, 6, 50, 0x0001a5a5a5a5a5a4) + DEP( 0xa5a5a5a5a5a5a408, 562949953421311, 6, 50, 0xa5ffffffffffff08) + EXT( 0xa5a5a5a5a5a5a407, 6, 51, 0x00034b4b4b4b4b48) + EXTU(0xa5a5a5a5a5a5a407, 6, 51, 0x00034b4b4b4b4b48) + DEP( 0xa5a5a5a5a5a5a407, 1125899906842623, 6, 51, 0xa5ffffffffffff87) + EXT( 0xa5a5a5a5a5a5a406, 6, 52, 0x0006969696969690) + EXTU(0xa5a5a5a5a5a5a406, 6, 52, 0x0006969696969690) + DEP( 0xa5a5a5a5a5a5a406, 2251799813685247, 6, 52, 0xa5ffffffffffffc6) + EXT( 0xa5a5a5a5a5a5a405, 6, 53, 0x000d2d2d2d2d2d20) + EXTU(0xa5a5a5a5a5a5a405, 6, 53, 0x000d2d2d2d2d2d20) + DEP( 0xa5a5a5a5a5a5a405, 4503599627370495, 6, 53, 0xa5ffffffffffffe5) + EXT( 0xa5a5a5a5a5a5a404, 6, 54, 0x001a5a5a5a5a5a40) + EXTU(0xa5a5a5a5a5a5a404, 6, 54, 0x001a5a5a5a5a5a40) + DEP( 0xa5a5a5a5a5a5a404, 9007199254740991, 6, 54, 0xa5fffffffffffff4) + EXT( 0xa5a5a5a5a5a5a403, 6, 55, 0x0034b4b4b4b4b480) + EXTU(0xa5a5a5a5a5a5a403, 6, 55, 0x0034b4b4b4b4b480) + DEP( 0xa5a5a5a5a5a5a403, 18014398509481983, 6, 55, 0xa5fffffffffffffb) + EXT( 0xa5a5a5a5a5a5a402, 6, 56, 0x0069696969696900) + EXTU(0xa5a5a5a5a5a5a402, 6, 56, 0x0069696969696900) + DEP( 0xa5a5a5a5a5a5a402, 36028797018963967, 6, 56, 0xa5fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a401, 6, 57, 0x00d2d2d2d2d2d200) + EXTU(0xa5a5a5a5a5a5a401, 6, 57, 0x00d2d2d2d2d2d200) + DEP( 0xa5a5a5a5a5a5a401, 72057594037927935, 6, 57, 0xa5ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a400, 7, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a400, 7, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a400, 0, 7, 1, 0xa4a5a5a5a5a5a400) + EXT( 0xa5a5a5a5a5a5a3ff, 7, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3ff, 7, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a3ff, 1, 7, 2, 0xa4a5a5a5a5a5a3ff) + EXT( 0xa5a5a5a5a5a5a3fe, 7, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a3fe, 7, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a3fe, 3, 7, 3, 0xa4e5a5a5a5a5a3fe) + EXT( 0xa5a5a5a5a5a5a3fd, 7, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a3fd, 7, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a3fd, 7, 7, 4, 0xa4e5a5a5a5a5a3fd) + EXT( 0xa5a5a5a5a5a5a3fc, 7, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a3fc, 7, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a3fc, 15, 7, 5, 0xa4f5a5a5a5a5a3fc) + EXT( 0xa5a5a5a5a5a5a3fb, 7, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a3fb, 7, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a3fb, 31, 7, 6, 0xa4fda5a5a5a5a3fb) + EXT( 0xa5a5a5a5a5a5a3fa, 7, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a3fa, 7, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a3fa, 63, 7, 7, 0xa4fda5a5a5a5a3fa) + EXT( 0xa5a5a5a5a5a5a3f9, 7, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a3f9, 7, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a3f9, 127, 7, 8, 0xa4ffa5a5a5a5a3f9) + EXT( 0xa5a5a5a5a5a5a3f8, 7, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a3f8, 7, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a3f8, 255, 7, 9, 0xa4ffa5a5a5a5a3f8) + EXT( 0xa5a5a5a5a5a5a3f7, 7, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a3f7, 7, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a3f7, 511, 7, 10, 0xa4ffa5a5a5a5a3f7) + EXT( 0xa5a5a5a5a5a5a3f6, 7, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a3f6, 7, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a3f6, 1023, 7, 11, 0xa4ffe5a5a5a5a3f6) + EXT( 0xa5a5a5a5a5a5a3f5, 7, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a3f5, 7, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a3f5, 2047, 7, 12, 0xa4ffe5a5a5a5a3f5) + EXT( 0xa5a5a5a5a5a5a3f4, 7, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a3f4, 7, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a3f4, 4095, 7, 13, 0xa4fff5a5a5a5a3f4) + EXT( 0xa5a5a5a5a5a5a3f3, 7, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a3f3, 7, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a3f3, 8191, 7, 14, 0xa4fffda5a5a5a3f3) + EXT( 0xa5a5a5a5a5a5a3f2, 7, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a3f2, 7, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a3f2, 16383, 7, 15, 0xa4fffda5a5a5a3f2) + EXT( 0xa5a5a5a5a5a5a3f1, 7, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a3f1, 7, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a3f1, 32767, 7, 16, 0xa4ffffa5a5a5a3f1) + EXT( 0xa5a5a5a5a5a5a3f0, 7, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a3f0, 7, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a3f0, 65535, 7, 17, 0xa4ffffa5a5a5a3f0) + EXT( 0xa5a5a5a5a5a5a3ef, 7, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a3ef, 7, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a3ef, 131071, 7, 18, 0xa4ffffa5a5a5a3ef) + EXT( 0xa5a5a5a5a5a5a3ee, 7, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a3ee, 7, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a3ee, 262143, 7, 19, 0xa4ffffe5a5a5a3ee) + EXT( 0xa5a5a5a5a5a5a3ed, 7, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a3ed, 7, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a3ed, 524287, 7, 20, 0xa4ffffe5a5a5a3ed) + EXT( 0xa5a5a5a5a5a5a3ec, 7, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a3ec, 7, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a3ec, 1048575, 7, 21, 0xa4fffff5a5a5a3ec) + EXT( 0xa5a5a5a5a5a5a3eb, 7, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a3eb, 7, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a3eb, 2097151, 7, 22, 0xa4fffffda5a5a3eb) + EXT( 0xa5a5a5a5a5a5a3ea, 7, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a3ea, 7, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a3ea, 4194303, 7, 23, 0xa4fffffda5a5a3ea) + EXT( 0xa5a5a5a5a5a5a3e9, 7, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a3e9, 7, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a3e9, 8388607, 7, 24, 0xa4ffffffa5a5a3e9) + EXT( 0xa5a5a5a5a5a5a3e8, 7, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a3e8, 7, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a3e8, 16777215, 7, 25, 0xa4ffffffa5a5a3e8) + EXT( 0xa5a5a5a5a5a5a3e7, 7, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a3e7, 7, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a3e7, 33554431, 7, 26, 0xa4ffffffa5a5a3e7) + EXT( 0xa5a5a5a5a5a5a3e6, 7, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a3e6, 7, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a3e6, 67108863, 7, 27, 0xa4ffffffe5a5a3e6) + EXT( 0xa5a5a5a5a5a5a3e5, 7, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a3e5, 7, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a3e5, 134217727, 7, 28, 0xa4ffffffe5a5a3e5) + EXT( 0xa5a5a5a5a5a5a3e4, 7, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a3e4, 7, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a3e4, 268435455, 7, 29, 0xa4fffffff5a5a3e4) + EXT( 0xa5a5a5a5a5a5a3e3, 7, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a3e3, 7, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a3e3, 536870911, 7, 30, 0xa4fffffffda5a3e3) + EXT( 0xa5a5a5a5a5a5a3e2, 7, 31, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a3e2, 7, 31, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a3e2, 1073741823, 7, 31, 0xa4fffffffda5a3e2) + EXT( 0xa5a5a5a5a5a5a3e1, 7, 32, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a3e1, 7, 32, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a3e1, 2147483647, 7, 32, 0xa4ffffffffa5a3e1) + EXT( 0xa5a5a5a5a5a5a3e0, 7, 33, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a3e0, 7, 33, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a3e0, 4294967295, 7, 33, 0xa4ffffffffa5a3e0) + EXT( 0xa5a5a5a5a5a5a3df, 7, 34, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a3df, 7, 34, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a3df, 8589934591, 7, 34, 0xa4ffffffffa5a3df) + EXT( 0xa5a5a5a5a5a5a3de, 7, 35, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a3de, 7, 35, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a3de, 17179869183, 7, 35, 0xa4ffffffffe5a3de) + EXT( 0xa5a5a5a5a5a5a3dd, 7, 36, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a3dd, 7, 36, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a3dd, 34359738367, 7, 36, 0xa4ffffffffe5a3dd) + EXT( 0xa5a5a5a5a5a5a3dc, 7, 37, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a3dc, 7, 37, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a3dc, 68719476735, 7, 37, 0xa4fffffffff5a3dc) + EXT( 0xa5a5a5a5a5a5a3db, 7, 38, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a3db, 7, 38, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a3db, 137438953471, 7, 38, 0xa4fffffffffda3db) + EXT( 0xa5a5a5a5a5a5a3da, 7, 39, 0xffffffe969696969) + EXTU(0xa5a5a5a5a5a5a3da, 7, 39, 0x0000006969696969) + DEP( 0xa5a5a5a5a5a5a3da, 274877906943, 7, 39, 0xa4fffffffffda3da) + EXT( 0xa5a5a5a5a5a5a3d9, 7, 40, 0xffffffd2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a3d9, 7, 40, 0x000000d2d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a3d9, 549755813887, 7, 40, 0xa4ffffffffffa3d9) + EXT( 0xa5a5a5a5a5a5a3d8, 7, 41, 0xffffffa5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a3d8, 7, 41, 0x000001a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a3d8, 1099511627775, 7, 41, 0xa4ffffffffffa3d8) + EXT( 0xa5a5a5a5a5a5a3d7, 7, 42, 0xffffff4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a3d7, 7, 42, 0x0000034b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a3d7, 2199023255551, 7, 42, 0xa4ffffffffffa3d7) + EXT( 0xa5a5a5a5a5a5a3d6, 7, 43, 0xfffffe9696969696) + EXTU(0xa5a5a5a5a5a5a3d6, 7, 43, 0x0000069696969696) + DEP( 0xa5a5a5a5a5a5a3d6, 4398046511103, 7, 43, 0xa4ffffffffffe3d6) + EXT( 0xa5a5a5a5a5a5a3d5, 7, 44, 0xfffffd2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a3d5, 7, 44, 0x00000d2d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a3d5, 8796093022207, 7, 44, 0xa4ffffffffffe3d5) + EXT( 0xa5a5a5a5a5a5a3d4, 7, 45, 0xfffffa5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a3d4, 7, 45, 0x00001a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a3d4, 17592186044415, 7, 45, 0xa4fffffffffff3d4) + EXT( 0xa5a5a5a5a5a5a3d3, 7, 46, 0xfffff4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a3d3, 7, 46, 0x000034b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a3d3, 35184372088831, 7, 46, 0xa4fffffffffffbd3) + EXT( 0xa5a5a5a5a5a5a3d2, 7, 47, 0xffffe96969696968) + EXTU(0xa5a5a5a5a5a5a3d2, 7, 47, 0x0000696969696968) + DEP( 0xa5a5a5a5a5a5a3d2, 70368744177663, 7, 47, 0xa4ffffffffffffd2) + EXT( 0xa5a5a5a5a5a5a3d1, 7, 48, 0xffffd2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a3d1, 7, 48, 0x0000d2d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a3d1, 140737488355327, 7, 48, 0xa4ffffffffffffd1) + EXT( 0xa5a5a5a5a5a5a3d0, 7, 49, 0xffffa5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a3d0, 7, 49, 0x0001a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a3d0, 281474976710655, 7, 49, 0xa4ffffffffffffd0) + EXT( 0xa5a5a5a5a5a5a3cf, 7, 50, 0xffff4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a3cf, 7, 50, 0x00034b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a3cf, 562949953421311, 7, 50, 0xa4ffffffffffffcf) + EXT( 0xa5a5a5a5a5a5a3ce, 7, 51, 0xfffe96969696968f) + EXTU(0xa5a5a5a5a5a5a3ce, 7, 51, 0x000696969696968f) + DEP( 0xa5a5a5a5a5a5a3ce, 1125899906842623, 7, 51, 0xa4ffffffffffffce) + EXT( 0xa5a5a5a5a5a5a3cd, 7, 52, 0xfffd2d2d2d2d2d1e) + EXTU(0xa5a5a5a5a5a5a3cd, 7, 52, 0x000d2d2d2d2d2d1e) + DEP( 0xa5a5a5a5a5a5a3cd, 2251799813685247, 7, 52, 0xa4ffffffffffffed) + EXT( 0xa5a5a5a5a5a5a3cc, 7, 53, 0xfffa5a5a5a5a5a3c) + EXTU(0xa5a5a5a5a5a5a3cc, 7, 53, 0x001a5a5a5a5a5a3c) + DEP( 0xa5a5a5a5a5a5a3cc, 4503599627370495, 7, 53, 0xa4fffffffffffffc) + EXT( 0xa5a5a5a5a5a5a3cb, 7, 54, 0xfff4b4b4b4b4b479) + EXTU(0xa5a5a5a5a5a5a3cb, 7, 54, 0x0034b4b4b4b4b479) + DEP( 0xa5a5a5a5a5a5a3cb, 9007199254740991, 7, 54, 0xa4fffffffffffffb) + EXT( 0xa5a5a5a5a5a5a3ca, 7, 55, 0xffe96969696968f2) + EXTU(0xa5a5a5a5a5a5a3ca, 7, 55, 0x00696969696968f2) + DEP( 0xa5a5a5a5a5a5a3ca, 18014398509481983, 7, 55, 0xa4fffffffffffffe) + EXT( 0xa5a5a5a5a5a5a3c9, 7, 56, 0xffd2d2d2d2d2d1e4) + EXTU(0xa5a5a5a5a5a5a3c9, 7, 56, 0x00d2d2d2d2d2d1e4) + DEP( 0xa5a5a5a5a5a5a3c9, 36028797018963967, 7, 56, 0xa4ffffffffffffff) + EXT( 0xa5a5a5a5a5a5a3c8, 8, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a3c8, 8, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a3c8, 0, 8, 1, 0xa525a5a5a5a5a3c8) + EXT( 0xa5a5a5a5a5a5a3c7, 8, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a3c7, 8, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a3c7, 1, 8, 2, 0xa565a5a5a5a5a3c7) + EXT( 0xa5a5a5a5a5a5a3c6, 8, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a3c6, 8, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a3c6, 3, 8, 3, 0xa565a5a5a5a5a3c6) + EXT( 0xa5a5a5a5a5a5a3c5, 8, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a3c5, 8, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a3c5, 7, 8, 4, 0xa575a5a5a5a5a3c5) + EXT( 0xa5a5a5a5a5a5a3c4, 8, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a3c4, 8, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a3c4, 15, 8, 5, 0xa57da5a5a5a5a3c4) + EXT( 0xa5a5a5a5a5a5a3c3, 8, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a3c3, 8, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a3c3, 31, 8, 6, 0xa57da5a5a5a5a3c3) + EXT( 0xa5a5a5a5a5a5a3c2, 8, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a3c2, 8, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a3c2, 63, 8, 7, 0xa57fa5a5a5a5a3c2) + EXT( 0xa5a5a5a5a5a5a3c1, 8, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a3c1, 8, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a3c1, 127, 8, 8, 0xa57fa5a5a5a5a3c1) + EXT( 0xa5a5a5a5a5a5a3c0, 8, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a3c0, 8, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a3c0, 255, 8, 9, 0xa57fa5a5a5a5a3c0) + EXT( 0xa5a5a5a5a5a5a3bf, 8, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a3bf, 8, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a3bf, 511, 8, 10, 0xa57fe5a5a5a5a3bf) + EXT( 0xa5a5a5a5a5a5a3be, 8, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a3be, 8, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a3be, 1023, 8, 11, 0xa57fe5a5a5a5a3be) + EXT( 0xa5a5a5a5a5a5a3bd, 8, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a3bd, 8, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a3bd, 2047, 8, 12, 0xa57ff5a5a5a5a3bd) + EXT( 0xa5a5a5a5a5a5a3bc, 8, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a3bc, 8, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a3bc, 4095, 8, 13, 0xa57ffda5a5a5a3bc) + EXT( 0xa5a5a5a5a5a5a3bb, 8, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a3bb, 8, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a3bb, 8191, 8, 14, 0xa57ffda5a5a5a3bb) + EXT( 0xa5a5a5a5a5a5a3ba, 8, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a3ba, 8, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a3ba, 16383, 8, 15, 0xa57fffa5a5a5a3ba) + EXT( 0xa5a5a5a5a5a5a3b9, 8, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a3b9, 8, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a3b9, 32767, 8, 16, 0xa57fffa5a5a5a3b9) + EXT( 0xa5a5a5a5a5a5a3b8, 8, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a3b8, 8, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a3b8, 65535, 8, 17, 0xa57fffa5a5a5a3b8) + EXT( 0xa5a5a5a5a5a5a3b7, 8, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a3b7, 8, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a3b7, 131071, 8, 18, 0xa57fffe5a5a5a3b7) + EXT( 0xa5a5a5a5a5a5a3b6, 8, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a3b6, 8, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a3b6, 262143, 8, 19, 0xa57fffe5a5a5a3b6) + EXT( 0xa5a5a5a5a5a5a3b5, 8, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a3b5, 8, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a3b5, 524287, 8, 20, 0xa57ffff5a5a5a3b5) + EXT( 0xa5a5a5a5a5a5a3b4, 8, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a3b4, 8, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a3b4, 1048575, 8, 21, 0xa57ffffda5a5a3b4) + EXT( 0xa5a5a5a5a5a5a3b3, 8, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a3b3, 8, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a3b3, 2097151, 8, 22, 0xa57ffffda5a5a3b3) + EXT( 0xa5a5a5a5a5a5a3b2, 8, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a3b2, 8, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a3b2, 4194303, 8, 23, 0xa57fffffa5a5a3b2) + EXT( 0xa5a5a5a5a5a5a3b1, 8, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a3b1, 8, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a3b1, 8388607, 8, 24, 0xa57fffffa5a5a3b1) + EXT( 0xa5a5a5a5a5a5a3b0, 8, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a3b0, 8, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a3b0, 16777215, 8, 25, 0xa57fffffa5a5a3b0) + EXT( 0xa5a5a5a5a5a5a3af, 8, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a3af, 8, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a3af, 33554431, 8, 26, 0xa57fffffe5a5a3af) + EXT( 0xa5a5a5a5a5a5a3ae, 8, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a3ae, 8, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a3ae, 67108863, 8, 27, 0xa57fffffe5a5a3ae) + EXT( 0xa5a5a5a5a5a5a3ad, 8, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a3ad, 8, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a3ad, 134217727, 8, 28, 0xa57ffffff5a5a3ad) + EXT( 0xa5a5a5a5a5a5a3ac, 8, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a3ac, 8, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a3ac, 268435455, 8, 29, 0xa57ffffffda5a3ac) + EXT( 0xa5a5a5a5a5a5a3ab, 8, 30, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a3ab, 8, 30, 0x0000000029696969) + DEP( 0xa5a5a5a5a5a5a3ab, 536870911, 8, 30, 0xa57ffffffda5a3ab) + EXT( 0xa5a5a5a5a5a5a3aa, 8, 31, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a3aa, 8, 31, 0x0000000052d2d2d2) + DEP( 0xa5a5a5a5a5a5a3aa, 1073741823, 8, 31, 0xa57fffffffa5a3aa) + EXT( 0xa5a5a5a5a5a5a3a9, 8, 32, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a3a9, 8, 32, 0x00000000a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a3a9, 2147483647, 8, 32, 0xa57fffffffa5a3a9) + EXT( 0xa5a5a5a5a5a5a3a8, 8, 33, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a3a8, 8, 33, 0x000000014b4b4b4b) + DEP( 0xa5a5a5a5a5a5a3a8, 4294967295, 8, 33, 0xa57fffffffa5a3a8) + EXT( 0xa5a5a5a5a5a5a3a7, 8, 34, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a3a7, 8, 34, 0x0000000296969696) + DEP( 0xa5a5a5a5a5a5a3a7, 8589934591, 8, 34, 0xa57fffffffe5a3a7) + EXT( 0xa5a5a5a5a5a5a3a6, 8, 35, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a3a6, 8, 35, 0x000000052d2d2d2d) + DEP( 0xa5a5a5a5a5a5a3a6, 17179869183, 8, 35, 0xa57fffffffe5a3a6) + EXT( 0xa5a5a5a5a5a5a3a5, 8, 36, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a3a5, 8, 36, 0x0000000a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a3a5, 34359738367, 8, 36, 0xa57ffffffff5a3a5) + EXT( 0xa5a5a5a5a5a5a3a4, 8, 37, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a3a4, 8, 37, 0x00000014b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a3a4, 68719476735, 8, 37, 0xa57ffffffffda3a4) + EXT( 0xa5a5a5a5a5a5a3a3, 8, 38, 0xffffffe969696969) + EXTU(0xa5a5a5a5a5a5a3a3, 8, 38, 0x0000002969696969) + DEP( 0xa5a5a5a5a5a5a3a3, 137438953471, 8, 38, 0xa57ffffffffda3a3) + EXT( 0xa5a5a5a5a5a5a3a2, 8, 39, 0xffffffd2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a3a2, 8, 39, 0x00000052d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a3a2, 274877906943, 8, 39, 0xa57fffffffffa3a2) + EXT( 0xa5a5a5a5a5a5a3a1, 8, 40, 0xffffffa5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a3a1, 8, 40, 0x000000a5a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a3a1, 549755813887, 8, 40, 0xa57fffffffffa3a1) + EXT( 0xa5a5a5a5a5a5a3a0, 8, 41, 0xffffff4b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a3a0, 8, 41, 0x0000014b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a3a0, 1099511627775, 8, 41, 0xa57fffffffffa3a0) + EXT( 0xa5a5a5a5a5a5a39f, 8, 42, 0xfffffe9696969696) + EXTU(0xa5a5a5a5a5a5a39f, 8, 42, 0x0000029696969696) + DEP( 0xa5a5a5a5a5a5a39f, 2199023255551, 8, 42, 0xa57fffffffffe39f) + EXT( 0xa5a5a5a5a5a5a39e, 8, 43, 0xfffffd2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a39e, 8, 43, 0x0000052d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a39e, 4398046511103, 8, 43, 0xa57fffffffffe39e) + EXT( 0xa5a5a5a5a5a5a39d, 8, 44, 0xfffffa5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a39d, 8, 44, 0x00000a5a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a39d, 8796093022207, 8, 44, 0xa57ffffffffff39d) + EXT( 0xa5a5a5a5a5a5a39c, 8, 45, 0xfffff4b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a39c, 8, 45, 0x000014b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a39c, 17592186044415, 8, 45, 0xa57ffffffffffb9c) + EXT( 0xa5a5a5a5a5a5a39b, 8, 46, 0xffffe96969696968) + EXTU(0xa5a5a5a5a5a5a39b, 8, 46, 0x0000296969696968) + DEP( 0xa5a5a5a5a5a5a39b, 35184372088831, 8, 46, 0xa57fffffffffff9b) + EXT( 0xa5a5a5a5a5a5a39a, 8, 47, 0xffffd2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a39a, 8, 47, 0x000052d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a39a, 70368744177663, 8, 47, 0xa57fffffffffff9a) + EXT( 0xa5a5a5a5a5a5a399, 8, 48, 0xffffa5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a399, 8, 48, 0x0000a5a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a399, 140737488355327, 8, 48, 0xa57fffffffffff99) + EXT( 0xa5a5a5a5a5a5a398, 8, 49, 0xffff4b4b4b4b4b47) + EXTU(0xa5a5a5a5a5a5a398, 8, 49, 0x00014b4b4b4b4b47) + DEP( 0xa5a5a5a5a5a5a398, 281474976710655, 8, 49, 0xa57fffffffffff98) + EXT( 0xa5a5a5a5a5a5a397, 8, 50, 0xfffe96969696968e) + EXTU(0xa5a5a5a5a5a5a397, 8, 50, 0x000296969696968e) + DEP( 0xa5a5a5a5a5a5a397, 562949953421311, 8, 50, 0xa57fffffffffffd7) + EXT( 0xa5a5a5a5a5a5a396, 8, 51, 0xfffd2d2d2d2d2d1c) + EXTU(0xa5a5a5a5a5a5a396, 8, 51, 0x00052d2d2d2d2d1c) + DEP( 0xa5a5a5a5a5a5a396, 1125899906842623, 8, 51, 0xa57ffffffffffff6) + EXT( 0xa5a5a5a5a5a5a395, 8, 52, 0xfffa5a5a5a5a5a39) + EXTU(0xa5a5a5a5a5a5a395, 8, 52, 0x000a5a5a5a5a5a39) + DEP( 0xa5a5a5a5a5a5a395, 2251799813685247, 8, 52, 0xa57ffffffffffff5) + EXT( 0xa5a5a5a5a5a5a394, 8, 53, 0xfff4b4b4b4b4b472) + EXTU(0xa5a5a5a5a5a5a394, 8, 53, 0x0014b4b4b4b4b472) + DEP( 0xa5a5a5a5a5a5a394, 4503599627370495, 8, 53, 0xa57ffffffffffffc) + EXT( 0xa5a5a5a5a5a5a393, 8, 54, 0xffe96969696968e4) + EXTU(0xa5a5a5a5a5a5a393, 8, 54, 0x00296969696968e4) + DEP( 0xa5a5a5a5a5a5a393, 9007199254740991, 8, 54, 0xa57fffffffffffff) + EXT( 0xa5a5a5a5a5a5a392, 8, 55, 0xffd2d2d2d2d2d1c9) + EXTU(0xa5a5a5a5a5a5a392, 8, 55, 0x0052d2d2d2d2d1c9) + DEP( 0xa5a5a5a5a5a5a392, 18014398509481983, 8, 55, 0xa57ffffffffffffe) + EXT( 0xa5a5a5a5a5a5a391, 9, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a391, 9, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a391, 0, 9, 1, 0xa5a5a5a5a5a5a391) + EXT( 0xa5a5a5a5a5a5a390, 9, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a390, 9, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a390, 1, 9, 2, 0xa5a5a5a5a5a5a390) + EXT( 0xa5a5a5a5a5a5a38f, 9, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a38f, 9, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a38f, 3, 9, 3, 0xa5b5a5a5a5a5a38f) + EXT( 0xa5a5a5a5a5a5a38e, 9, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a38e, 9, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a38e, 7, 9, 4, 0xa5bda5a5a5a5a38e) + EXT( 0xa5a5a5a5a5a5a38d, 9, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a38d, 9, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a38d, 15, 9, 5, 0xa5bda5a5a5a5a38d) + EXT( 0xa5a5a5a5a5a5a38c, 9, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a38c, 9, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a38c, 31, 9, 6, 0xa5bfa5a5a5a5a38c) + EXT( 0xa5a5a5a5a5a5a38b, 9, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a38b, 9, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a38b, 63, 9, 7, 0xa5bfa5a5a5a5a38b) + EXT( 0xa5a5a5a5a5a5a38a, 9, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a38a, 9, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a38a, 127, 9, 8, 0xa5bfa5a5a5a5a38a) + EXT( 0xa5a5a5a5a5a5a389, 9, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a389, 9, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a389, 255, 9, 9, 0xa5bfe5a5a5a5a389) + EXT( 0xa5a5a5a5a5a5a388, 9, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a388, 9, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a388, 511, 9, 10, 0xa5bfe5a5a5a5a388) + EXT( 0xa5a5a5a5a5a5a387, 9, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a387, 9, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a387, 1023, 9, 11, 0xa5bff5a5a5a5a387) + EXT( 0xa5a5a5a5a5a5a386, 9, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a386, 9, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a386, 2047, 9, 12, 0xa5bffda5a5a5a386) + EXT( 0xa5a5a5a5a5a5a385, 9, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a385, 9, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a385, 4095, 9, 13, 0xa5bffda5a5a5a385) + EXT( 0xa5a5a5a5a5a5a384, 9, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a384, 9, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a384, 8191, 9, 14, 0xa5bfffa5a5a5a384) + EXT( 0xa5a5a5a5a5a5a383, 9, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a383, 9, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a383, 16383, 9, 15, 0xa5bfffa5a5a5a383) + EXT( 0xa5a5a5a5a5a5a382, 9, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a382, 9, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a382, 32767, 9, 16, 0xa5bfffa5a5a5a382) + EXT( 0xa5a5a5a5a5a5a381, 9, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a381, 9, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a381, 65535, 9, 17, 0xa5bfffe5a5a5a381) + EXT( 0xa5a5a5a5a5a5a380, 9, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a380, 9, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a380, 131071, 9, 18, 0xa5bfffe5a5a5a380) + EXT( 0xa5a5a5a5a5a5a37f, 9, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a37f, 9, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a37f, 262143, 9, 19, 0xa5bffff5a5a5a37f) + EXT( 0xa5a5a5a5a5a5a37e, 9, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a37e, 9, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a37e, 524287, 9, 20, 0xa5bffffda5a5a37e) + EXT( 0xa5a5a5a5a5a5a37d, 9, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a37d, 9, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a37d, 1048575, 9, 21, 0xa5bffffda5a5a37d) + EXT( 0xa5a5a5a5a5a5a37c, 9, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a37c, 9, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a37c, 2097151, 9, 22, 0xa5bfffffa5a5a37c) + EXT( 0xa5a5a5a5a5a5a37b, 9, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a37b, 9, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a37b, 4194303, 9, 23, 0xa5bfffffa5a5a37b) + EXT( 0xa5a5a5a5a5a5a37a, 9, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a37a, 9, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a37a, 8388607, 9, 24, 0xa5bfffffa5a5a37a) + EXT( 0xa5a5a5a5a5a5a379, 9, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a379, 9, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a379, 16777215, 9, 25, 0xa5bfffffe5a5a379) + EXT( 0xa5a5a5a5a5a5a378, 9, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a378, 9, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a378, 33554431, 9, 26, 0xa5bfffffe5a5a378) + EXT( 0xa5a5a5a5a5a5a377, 9, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a377, 9, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a377, 67108863, 9, 27, 0xa5bffffff5a5a377) + EXT( 0xa5a5a5a5a5a5a376, 9, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a376, 9, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a376, 134217727, 9, 28, 0xa5bffffffda5a376) + EXT( 0xa5a5a5a5a5a5a375, 9, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a5a375, 9, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a375, 268435455, 9, 29, 0xa5bffffffda5a375) + EXT( 0xa5a5a5a5a5a5a374, 9, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a5a374, 9, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a374, 536870911, 9, 30, 0xa5bfffffffa5a374) + EXT( 0xa5a5a5a5a5a5a373, 9, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a5a373, 9, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a373, 1073741823, 9, 31, 0xa5bfffffffa5a373) + EXT( 0xa5a5a5a5a5a5a372, 9, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a5a372, 9, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a372, 2147483647, 9, 32, 0xa5bfffffffa5a372) + EXT( 0xa5a5a5a5a5a5a371, 9, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a5a371, 9, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a371, 4294967295, 9, 33, 0xa5bfffffffe5a371) + EXT( 0xa5a5a5a5a5a5a370, 9, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a5a370, 9, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a370, 8589934591, 9, 34, 0xa5bfffffffe5a370) + EXT( 0xa5a5a5a5a5a5a36f, 9, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a36f, 9, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a36f, 17179869183, 9, 35, 0xa5bffffffff5a36f) + EXT( 0xa5a5a5a5a5a5a36e, 9, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a36e, 9, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a36e, 34359738367, 9, 36, 0xa5bffffffffda36e) + EXT( 0xa5a5a5a5a5a5a36d, 9, 37, 0x0000000969696969) + EXTU(0xa5a5a5a5a5a5a36d, 9, 37, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a36d, 68719476735, 9, 37, 0xa5bffffffffda36d) + EXT( 0xa5a5a5a5a5a5a36c, 9, 38, 0x00000012d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a36c, 9, 38, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a36c, 137438953471, 9, 38, 0xa5bfffffffffa36c) + EXT( 0xa5a5a5a5a5a5a36b, 9, 39, 0x00000025a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a36b, 9, 39, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a36b, 274877906943, 9, 39, 0xa5bfffffffffa36b) + EXT( 0xa5a5a5a5a5a5a36a, 9, 40, 0x0000004b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a36a, 9, 40, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a36a, 549755813887, 9, 40, 0xa5bfffffffffa36a) + EXT( 0xa5a5a5a5a5a5a369, 9, 41, 0x0000009696969696) + EXTU(0xa5a5a5a5a5a5a369, 9, 41, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a369, 1099511627775, 9, 41, 0xa5bfffffffffe369) + EXT( 0xa5a5a5a5a5a5a368, 9, 42, 0x0000012d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a368, 9, 42, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a368, 2199023255551, 9, 42, 0xa5bfffffffffe368) + EXT( 0xa5a5a5a5a5a5a367, 9, 43, 0x0000025a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a367, 9, 43, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a367, 4398046511103, 9, 43, 0xa5bffffffffff367) + EXT( 0xa5a5a5a5a5a5a366, 9, 44, 0x000004b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a366, 9, 44, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a366, 8796093022207, 9, 44, 0xa5bffffffffffb66) + EXT( 0xa5a5a5a5a5a5a365, 9, 45, 0x0000096969696968) + EXTU(0xa5a5a5a5a5a5a365, 9, 45, 0x0000096969696968) + DEP( 0xa5a5a5a5a5a5a365, 17592186044415, 9, 45, 0xa5bfffffffffff65) + EXT( 0xa5a5a5a5a5a5a364, 9, 46, 0x000012d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a364, 9, 46, 0x000012d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a364, 35184372088831, 9, 46, 0xa5bfffffffffff64) + EXT( 0xa5a5a5a5a5a5a363, 9, 47, 0x000025a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a363, 9, 47, 0x000025a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a363, 70368744177663, 9, 47, 0xa5bfffffffffff63) + EXT( 0xa5a5a5a5a5a5a362, 9, 48, 0x00004b4b4b4b4b46) + EXTU(0xa5a5a5a5a5a5a362, 9, 48, 0x00004b4b4b4b4b46) + DEP( 0xa5a5a5a5a5a5a362, 140737488355327, 9, 48, 0xa5bfffffffffffe2) + EXT( 0xa5a5a5a5a5a5a361, 9, 49, 0x000096969696968d) + EXTU(0xa5a5a5a5a5a5a361, 9, 49, 0x000096969696968d) + DEP( 0xa5a5a5a5a5a5a361, 281474976710655, 9, 49, 0xa5bfffffffffffe1) + EXT( 0xa5a5a5a5a5a5a360, 9, 50, 0x00012d2d2d2d2d1b) + EXTU(0xa5a5a5a5a5a5a360, 9, 50, 0x00012d2d2d2d2d1b) + DEP( 0xa5a5a5a5a5a5a360, 562949953421311, 9, 50, 0xa5bfffffffffffe0) + EXT( 0xa5a5a5a5a5a5a35f, 9, 51, 0x00025a5a5a5a5a35) + EXTU(0xa5a5a5a5a5a5a35f, 9, 51, 0x00025a5a5a5a5a35) + DEP( 0xa5a5a5a5a5a5a35f, 1125899906842623, 9, 51, 0xa5bfffffffffffff) + EXT( 0xa5a5a5a5a5a5a35e, 9, 52, 0x0004b4b4b4b4b46b) + EXTU(0xa5a5a5a5a5a5a35e, 9, 52, 0x0004b4b4b4b4b46b) + DEP( 0xa5a5a5a5a5a5a35e, 2251799813685247, 9, 52, 0xa5bffffffffffffe) + EXT( 0xa5a5a5a5a5a5a35d, 9, 53, 0x00096969696968d7) + EXTU(0xa5a5a5a5a5a5a35d, 9, 53, 0x00096969696968d7) + DEP( 0xa5a5a5a5a5a5a35d, 4503599627370495, 9, 53, 0xa5bffffffffffffd) + EXT( 0xa5a5a5a5a5a5a35c, 9, 54, 0x0012d2d2d2d2d1ae) + EXTU(0xa5a5a5a5a5a5a35c, 9, 54, 0x0012d2d2d2d2d1ae) + DEP( 0xa5a5a5a5a5a5a35c, 9007199254740991, 9, 54, 0xa5bffffffffffffe) + EXT( 0xa5a5a5a5a5a5a35b, 10, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a35b, 10, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a35b, 0, 10, 1, 0xa585a5a5a5a5a35b) + EXT( 0xa5a5a5a5a5a5a35a, 10, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a35a, 10, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a35a, 1, 10, 2, 0xa595a5a5a5a5a35a) + EXT( 0xa5a5a5a5a5a5a359, 10, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a359, 10, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a359, 3, 10, 3, 0xa59da5a5a5a5a359) + EXT( 0xa5a5a5a5a5a5a358, 10, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a358, 10, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a358, 7, 10, 4, 0xa59da5a5a5a5a358) + EXT( 0xa5a5a5a5a5a5a357, 10, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a357, 10, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a357, 15, 10, 5, 0xa59fa5a5a5a5a357) + EXT( 0xa5a5a5a5a5a5a356, 10, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a356, 10, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a356, 31, 10, 6, 0xa59fa5a5a5a5a356) + EXT( 0xa5a5a5a5a5a5a355, 10, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a355, 10, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a355, 63, 10, 7, 0xa59fa5a5a5a5a355) + EXT( 0xa5a5a5a5a5a5a354, 10, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a354, 10, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a354, 127, 10, 8, 0xa59fe5a5a5a5a354) + EXT( 0xa5a5a5a5a5a5a353, 10, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a353, 10, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a353, 255, 10, 9, 0xa59fe5a5a5a5a353) + EXT( 0xa5a5a5a5a5a5a352, 10, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a352, 10, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a352, 511, 10, 10, 0xa59ff5a5a5a5a352) + EXT( 0xa5a5a5a5a5a5a351, 10, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a351, 10, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a351, 1023, 10, 11, 0xa59ffda5a5a5a351) + EXT( 0xa5a5a5a5a5a5a350, 10, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a350, 10, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a350, 2047, 10, 12, 0xa59ffda5a5a5a350) + EXT( 0xa5a5a5a5a5a5a34f, 10, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a34f, 10, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a34f, 4095, 10, 13, 0xa59fffa5a5a5a34f) + EXT( 0xa5a5a5a5a5a5a34e, 10, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a34e, 10, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a34e, 8191, 10, 14, 0xa59fffa5a5a5a34e) + EXT( 0xa5a5a5a5a5a5a34d, 10, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a34d, 10, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a34d, 16383, 10, 15, 0xa59fffa5a5a5a34d) + EXT( 0xa5a5a5a5a5a5a34c, 10, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a34c, 10, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a34c, 32767, 10, 16, 0xa59fffe5a5a5a34c) + EXT( 0xa5a5a5a5a5a5a34b, 10, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a34b, 10, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a34b, 65535, 10, 17, 0xa59fffe5a5a5a34b) + EXT( 0xa5a5a5a5a5a5a34a, 10, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a34a, 10, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a34a, 131071, 10, 18, 0xa59ffff5a5a5a34a) + EXT( 0xa5a5a5a5a5a5a349, 10, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a349, 10, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a349, 262143, 10, 19, 0xa59ffffda5a5a349) + EXT( 0xa5a5a5a5a5a5a348, 10, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a348, 10, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a348, 524287, 10, 20, 0xa59ffffda5a5a348) + EXT( 0xa5a5a5a5a5a5a347, 10, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a347, 10, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a347, 1048575, 10, 21, 0xa59fffffa5a5a347) + EXT( 0xa5a5a5a5a5a5a346, 10, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a346, 10, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a346, 2097151, 10, 22, 0xa59fffffa5a5a346) + EXT( 0xa5a5a5a5a5a5a345, 10, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a345, 10, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a345, 4194303, 10, 23, 0xa59fffffa5a5a345) + EXT( 0xa5a5a5a5a5a5a344, 10, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a344, 10, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a344, 8388607, 10, 24, 0xa59fffffe5a5a344) + EXT( 0xa5a5a5a5a5a5a343, 10, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a343, 10, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a343, 16777215, 10, 25, 0xa59fffffe5a5a343) + EXT( 0xa5a5a5a5a5a5a342, 10, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a342, 10, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a342, 33554431, 10, 26, 0xa59ffffff5a5a342) + EXT( 0xa5a5a5a5a5a5a341, 10, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a341, 10, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a341, 67108863, 10, 27, 0xa59ffffffda5a341) + EXT( 0xa5a5a5a5a5a5a340, 10, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a5a340, 10, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a340, 134217727, 10, 28, 0xa59ffffffda5a340) + EXT( 0xa5a5a5a5a5a5a33f, 10, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a5a33f, 10, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a33f, 268435455, 10, 29, 0xa59fffffffa5a33f) + EXT( 0xa5a5a5a5a5a5a33e, 10, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a5a33e, 10, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a33e, 536870911, 10, 30, 0xa59fffffffa5a33e) + EXT( 0xa5a5a5a5a5a5a33d, 10, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a5a33d, 10, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a33d, 1073741823, 10, 31, 0xa59fffffffa5a33d) + EXT( 0xa5a5a5a5a5a5a33c, 10, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a5a33c, 10, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a33c, 2147483647, 10, 32, 0xa59fffffffe5a33c) + EXT( 0xa5a5a5a5a5a5a33b, 10, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a33b, 10, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a33b, 4294967295, 10, 33, 0xa59fffffffe5a33b) + EXT( 0xa5a5a5a5a5a5a33a, 10, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a33a, 10, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a33a, 8589934591, 10, 34, 0xa59ffffffff5a33a) + EXT( 0xa5a5a5a5a5a5a339, 10, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a339, 10, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a339, 17179869183, 10, 35, 0xa59ffffffffda339) + EXT( 0xa5a5a5a5a5a5a338, 10, 36, 0xfffffff969696969) + EXTU(0xa5a5a5a5a5a5a338, 10, 36, 0x0000000969696969) + DEP( 0xa5a5a5a5a5a5a338, 34359738367, 10, 36, 0xa59ffffffffda338) + EXT( 0xa5a5a5a5a5a5a337, 10, 37, 0xfffffff2d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a337, 10, 37, 0x00000012d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a337, 68719476735, 10, 37, 0xa59fffffffffa337) + EXT( 0xa5a5a5a5a5a5a336, 10, 38, 0xffffffe5a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a336, 10, 38, 0x00000025a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a336, 137438953471, 10, 38, 0xa59fffffffffa336) + EXT( 0xa5a5a5a5a5a5a335, 10, 39, 0xffffffcb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a335, 10, 39, 0x0000004b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a335, 274877906943, 10, 39, 0xa59fffffffffa335) + EXT( 0xa5a5a5a5a5a5a334, 10, 40, 0xffffff9696969696) + EXTU(0xa5a5a5a5a5a5a334, 10, 40, 0x0000009696969696) + DEP( 0xa5a5a5a5a5a5a334, 549755813887, 10, 40, 0xa59fffffffffe334) + EXT( 0xa5a5a5a5a5a5a333, 10, 41, 0xffffff2d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a333, 10, 41, 0x0000012d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a333, 1099511627775, 10, 41, 0xa59fffffffffe333) + EXT( 0xa5a5a5a5a5a5a332, 10, 42, 0xfffffe5a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a332, 10, 42, 0x0000025a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a332, 2199023255551, 10, 42, 0xa59ffffffffff332) + EXT( 0xa5a5a5a5a5a5a331, 10, 43, 0xfffffcb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a331, 10, 43, 0x000004b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a331, 4398046511103, 10, 43, 0xa59ffffffffffb31) + EXT( 0xa5a5a5a5a5a5a330, 10, 44, 0xfffff96969696968) + EXTU(0xa5a5a5a5a5a5a330, 10, 44, 0x0000096969696968) + DEP( 0xa5a5a5a5a5a5a330, 8796093022207, 10, 44, 0xa59fffffffffff30) + EXT( 0xa5a5a5a5a5a5a32f, 10, 45, 0xfffff2d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a32f, 10, 45, 0x000012d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a32f, 17592186044415, 10, 45, 0xa59fffffffffff2f) + EXT( 0xa5a5a5a5a5a5a32e, 10, 46, 0xffffe5a5a5a5a5a3) + EXTU(0xa5a5a5a5a5a5a32e, 10, 46, 0x000025a5a5a5a5a3) + DEP( 0xa5a5a5a5a5a5a32e, 35184372088831, 10, 46, 0xa59fffffffffff2e) + EXT( 0xa5a5a5a5a5a5a32d, 10, 47, 0xffffcb4b4b4b4b46) + EXTU(0xa5a5a5a5a5a5a32d, 10, 47, 0x00004b4b4b4b4b46) + DEP( 0xa5a5a5a5a5a5a32d, 70368744177663, 10, 47, 0xa59fffffffffffad) + EXT( 0xa5a5a5a5a5a5a32c, 10, 48, 0xffff96969696968c) + EXTU(0xa5a5a5a5a5a5a32c, 10, 48, 0x000096969696968c) + DEP( 0xa5a5a5a5a5a5a32c, 140737488355327, 10, 48, 0xa59fffffffffffec) + EXT( 0xa5a5a5a5a5a5a32b, 10, 49, 0xffff2d2d2d2d2d19) + EXTU(0xa5a5a5a5a5a5a32b, 10, 49, 0x00012d2d2d2d2d19) + DEP( 0xa5a5a5a5a5a5a32b, 281474976710655, 10, 49, 0xa59fffffffffffeb) + EXT( 0xa5a5a5a5a5a5a32a, 10, 50, 0xfffe5a5a5a5a5a32) + EXTU(0xa5a5a5a5a5a5a32a, 10, 50, 0x00025a5a5a5a5a32) + DEP( 0xa5a5a5a5a5a5a32a, 562949953421311, 10, 50, 0xa59ffffffffffffa) + EXT( 0xa5a5a5a5a5a5a329, 10, 51, 0xfffcb4b4b4b4b465) + EXTU(0xa5a5a5a5a5a5a329, 10, 51, 0x0004b4b4b4b4b465) + DEP( 0xa5a5a5a5a5a5a329, 1125899906842623, 10, 51, 0xa59ffffffffffff9) + EXT( 0xa5a5a5a5a5a5a328, 10, 52, 0xfff96969696968ca) + EXTU(0xa5a5a5a5a5a5a328, 10, 52, 0x00096969696968ca) + DEP( 0xa5a5a5a5a5a5a328, 2251799813685247, 10, 52, 0xa59ffffffffffffc) + EXT( 0xa5a5a5a5a5a5a327, 10, 53, 0xfff2d2d2d2d2d193) + EXTU(0xa5a5a5a5a5a5a327, 10, 53, 0x0012d2d2d2d2d193) + DEP( 0xa5a5a5a5a5a5a327, 4503599627370495, 10, 53, 0xa59fffffffffffff) + EXT( 0xa5a5a5a5a5a5a326, 11, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a326, 11, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a326, 0, 11, 1, 0xa5a5a5a5a5a5a326) + EXT( 0xa5a5a5a5a5a5a325, 11, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a325, 11, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a325, 1, 11, 2, 0xa5ada5a5a5a5a325) + EXT( 0xa5a5a5a5a5a5a324, 11, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a324, 11, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a324, 3, 11, 3, 0xa5ada5a5a5a5a324) + EXT( 0xa5a5a5a5a5a5a323, 11, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a323, 11, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a323, 7, 11, 4, 0xa5afa5a5a5a5a323) + EXT( 0xa5a5a5a5a5a5a322, 11, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a322, 11, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a322, 15, 11, 5, 0xa5afa5a5a5a5a322) + EXT( 0xa5a5a5a5a5a5a321, 11, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a321, 11, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a321, 31, 11, 6, 0xa5afa5a5a5a5a321) + EXT( 0xa5a5a5a5a5a5a320, 11, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a320, 11, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a320, 63, 11, 7, 0xa5afe5a5a5a5a320) + EXT( 0xa5a5a5a5a5a5a31f, 11, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a31f, 11, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a31f, 127, 11, 8, 0xa5afe5a5a5a5a31f) + EXT( 0xa5a5a5a5a5a5a31e, 11, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a31e, 11, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a31e, 255, 11, 9, 0xa5aff5a5a5a5a31e) + EXT( 0xa5a5a5a5a5a5a31d, 11, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a31d, 11, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a31d, 511, 11, 10, 0xa5affda5a5a5a31d) + EXT( 0xa5a5a5a5a5a5a31c, 11, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a31c, 11, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a31c, 1023, 11, 11, 0xa5affda5a5a5a31c) + EXT( 0xa5a5a5a5a5a5a31b, 11, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a31b, 11, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a31b, 2047, 11, 12, 0xa5afffa5a5a5a31b) + EXT( 0xa5a5a5a5a5a5a31a, 11, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a31a, 11, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a31a, 4095, 11, 13, 0xa5afffa5a5a5a31a) + EXT( 0xa5a5a5a5a5a5a319, 11, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a319, 11, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a319, 8191, 11, 14, 0xa5afffa5a5a5a319) + EXT( 0xa5a5a5a5a5a5a318, 11, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a318, 11, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a318, 16383, 11, 15, 0xa5afffe5a5a5a318) + EXT( 0xa5a5a5a5a5a5a317, 11, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a317, 11, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a317, 32767, 11, 16, 0xa5afffe5a5a5a317) + EXT( 0xa5a5a5a5a5a5a316, 11, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a316, 11, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a316, 65535, 11, 17, 0xa5affff5a5a5a316) + EXT( 0xa5a5a5a5a5a5a315, 11, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a315, 11, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a315, 131071, 11, 18, 0xa5affffda5a5a315) + EXT( 0xa5a5a5a5a5a5a314, 11, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a314, 11, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a314, 262143, 11, 19, 0xa5affffda5a5a314) + EXT( 0xa5a5a5a5a5a5a313, 11, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a313, 11, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a313, 524287, 11, 20, 0xa5afffffa5a5a313) + EXT( 0xa5a5a5a5a5a5a312, 11, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a312, 11, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a312, 1048575, 11, 21, 0xa5afffffa5a5a312) + EXT( 0xa5a5a5a5a5a5a311, 11, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a311, 11, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a311, 2097151, 11, 22, 0xa5afffffa5a5a311) + EXT( 0xa5a5a5a5a5a5a310, 11, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a310, 11, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a310, 4194303, 11, 23, 0xa5afffffe5a5a310) + EXT( 0xa5a5a5a5a5a5a30f, 11, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a30f, 11, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a30f, 8388607, 11, 24, 0xa5afffffe5a5a30f) + EXT( 0xa5a5a5a5a5a5a30e, 11, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a30e, 11, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a30e, 16777215, 11, 25, 0xa5affffff5a5a30e) + EXT( 0xa5a5a5a5a5a5a30d, 11, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a30d, 11, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a30d, 33554431, 11, 26, 0xa5affffffda5a30d) + EXT( 0xa5a5a5a5a5a5a30c, 11, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a30c, 11, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a30c, 67108863, 11, 27, 0xa5affffffda5a30c) + EXT( 0xa5a5a5a5a5a5a30b, 11, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a30b, 11, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a30b, 134217727, 11, 28, 0xa5afffffffa5a30b) + EXT( 0xa5a5a5a5a5a5a30a, 11, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a30a, 11, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a30a, 268435455, 11, 29, 0xa5afffffffa5a30a) + EXT( 0xa5a5a5a5a5a5a309, 11, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a309, 11, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a309, 536870911, 11, 30, 0xa5afffffffa5a309) + EXT( 0xa5a5a5a5a5a5a308, 11, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a308, 11, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a308, 1073741823, 11, 31, 0xa5afffffffe5a308) + EXT( 0xa5a5a5a5a5a5a307, 11, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a307, 11, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a307, 2147483647, 11, 32, 0xa5afffffffe5a307) + EXT( 0xa5a5a5a5a5a5a306, 11, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a306, 11, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a306, 4294967295, 11, 33, 0xa5affffffff5a306) + EXT( 0xa5a5a5a5a5a5a305, 11, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a305, 11, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a305, 8589934591, 11, 34, 0xa5affffffffda305) + EXT( 0xa5a5a5a5a5a5a304, 11, 35, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a304, 11, 35, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a304, 17179869183, 11, 35, 0xa5affffffffda304) + EXT( 0xa5a5a5a5a5a5a303, 11, 36, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a303, 11, 36, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a303, 34359738367, 11, 36, 0xa5afffffffffa303) + EXT( 0xa5a5a5a5a5a5a302, 11, 37, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a302, 11, 37, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a302, 68719476735, 11, 37, 0xa5afffffffffa302) + EXT( 0xa5a5a5a5a5a5a301, 11, 38, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a301, 11, 38, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a301, 137438953471, 11, 38, 0xa5afffffffffa301) + EXT( 0xa5a5a5a5a5a5a300, 11, 39, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a300, 11, 39, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a300, 274877906943, 11, 39, 0xa5afffffffffe300) + EXT( 0xa5a5a5a5a5a5a2ff, 11, 40, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2ff, 11, 40, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2ff, 549755813887, 11, 40, 0xa5afffffffffe2ff) + EXT( 0xa5a5a5a5a5a5a2fe, 11, 41, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2fe, 11, 41, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2fe, 1099511627775, 11, 41, 0xa5affffffffff2fe) + EXT( 0xa5a5a5a5a5a5a2fd, 11, 42, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2fd, 11, 42, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2fd, 2199023255551, 11, 42, 0xa5affffffffffafd) + EXT( 0xa5a5a5a5a5a5a2fc, 11, 43, 0x0000016969696968) + EXTU(0xa5a5a5a5a5a5a2fc, 11, 43, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a2fc, 4398046511103, 11, 43, 0xa5affffffffffefc) + EXT( 0xa5a5a5a5a5a5a2fb, 11, 44, 0x000002d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a2fb, 11, 44, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a2fb, 8796093022207, 11, 44, 0xa5affffffffffefb) + EXT( 0xa5a5a5a5a5a5a2fa, 11, 45, 0x000005a5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a2fa, 11, 45, 0x000005a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a2fa, 17592186044415, 11, 45, 0xa5affffffffffffa) + EXT( 0xa5a5a5a5a5a5a2f9, 11, 46, 0x00000b4b4b4b4b45) + EXTU(0xa5a5a5a5a5a5a2f9, 11, 46, 0x00000b4b4b4b4b45) + DEP( 0xa5a5a5a5a5a5a2f9, 35184372088831, 11, 46, 0xa5affffffffffff9) + EXT( 0xa5a5a5a5a5a5a2f8, 11, 47, 0x000016969696968b) + EXTU(0xa5a5a5a5a5a5a2f8, 11, 47, 0x000016969696968b) + DEP( 0xa5a5a5a5a5a5a2f8, 70368744177663, 11, 47, 0xa5affffffffffff8) + EXT( 0xa5a5a5a5a5a5a2f7, 11, 48, 0x00002d2d2d2d2d17) + EXTU(0xa5a5a5a5a5a5a2f7, 11, 48, 0x00002d2d2d2d2d17) + DEP( 0xa5a5a5a5a5a5a2f7, 140737488355327, 11, 48, 0xa5affffffffffff7) + EXT( 0xa5a5a5a5a5a5a2f6, 11, 49, 0x00005a5a5a5a5a2f) + EXTU(0xa5a5a5a5a5a5a2f6, 11, 49, 0x00005a5a5a5a5a2f) + DEP( 0xa5a5a5a5a5a5a2f6, 281474976710655, 11, 49, 0xa5affffffffffff6) + EXT( 0xa5a5a5a5a5a5a2f5, 11, 50, 0x0000b4b4b4b4b45e) + EXTU(0xa5a5a5a5a5a5a2f5, 11, 50, 0x0000b4b4b4b4b45e) + DEP( 0xa5a5a5a5a5a5a2f5, 562949953421311, 11, 50, 0xa5affffffffffffd) + EXT( 0xa5a5a5a5a5a5a2f4, 11, 51, 0x00016969696968bd) + EXTU(0xa5a5a5a5a5a5a2f4, 11, 51, 0x00016969696968bd) + DEP( 0xa5a5a5a5a5a5a2f4, 1125899906842623, 11, 51, 0xa5affffffffffffc) + EXT( 0xa5a5a5a5a5a5a2f3, 11, 52, 0x0002d2d2d2d2d179) + EXTU(0xa5a5a5a5a5a5a2f3, 11, 52, 0x0002d2d2d2d2d179) + DEP( 0xa5a5a5a5a5a5a2f3, 2251799813685247, 11, 52, 0xa5afffffffffffff) + EXT( 0xa5a5a5a5a5a5a2f2, 12, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a2f2, 12, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a2f2, 0, 12, 1, 0xa5a5a5a5a5a5a2f2) + EXT( 0xa5a5a5a5a5a5a2f1, 12, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a2f1, 12, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a2f1, 1, 12, 2, 0xa5a5a5a5a5a5a2f1) + EXT( 0xa5a5a5a5a5a5a2f0, 12, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a2f0, 12, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a2f0, 3, 12, 3, 0xa5a7a5a5a5a5a2f0) + EXT( 0xa5a5a5a5a5a5a2ef, 12, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a2ef, 12, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a2ef, 7, 12, 4, 0xa5a7a5a5a5a5a2ef) + EXT( 0xa5a5a5a5a5a5a2ee, 12, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a2ee, 12, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a2ee, 15, 12, 5, 0xa5a7a5a5a5a5a2ee) + EXT( 0xa5a5a5a5a5a5a2ed, 12, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a2ed, 12, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a2ed, 31, 12, 6, 0xa5a7e5a5a5a5a2ed) + EXT( 0xa5a5a5a5a5a5a2ec, 12, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a2ec, 12, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a2ec, 63, 12, 7, 0xa5a7e5a5a5a5a2ec) + EXT( 0xa5a5a5a5a5a5a2eb, 12, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a2eb, 12, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a2eb, 127, 12, 8, 0xa5a7f5a5a5a5a2eb) + EXT( 0xa5a5a5a5a5a5a2ea, 12, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a2ea, 12, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a2ea, 255, 12, 9, 0xa5a7fda5a5a5a2ea) + EXT( 0xa5a5a5a5a5a5a2e9, 12, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a2e9, 12, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a2e9, 511, 12, 10, 0xa5a7fda5a5a5a2e9) + EXT( 0xa5a5a5a5a5a5a2e8, 12, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a2e8, 12, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a2e8, 1023, 12, 11, 0xa5a7ffa5a5a5a2e8) + EXT( 0xa5a5a5a5a5a5a2e7, 12, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a2e7, 12, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a2e7, 2047, 12, 12, 0xa5a7ffa5a5a5a2e7) + EXT( 0xa5a5a5a5a5a5a2e6, 12, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a2e6, 12, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a2e6, 4095, 12, 13, 0xa5a7ffa5a5a5a2e6) + EXT( 0xa5a5a5a5a5a5a2e5, 12, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a2e5, 12, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a2e5, 8191, 12, 14, 0xa5a7ffe5a5a5a2e5) + EXT( 0xa5a5a5a5a5a5a2e4, 12, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a2e4, 12, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a2e4, 16383, 12, 15, 0xa5a7ffe5a5a5a2e4) + EXT( 0xa5a5a5a5a5a5a2e3, 12, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a2e3, 12, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a2e3, 32767, 12, 16, 0xa5a7fff5a5a5a2e3) + EXT( 0xa5a5a5a5a5a5a2e2, 12, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a2e2, 12, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a2e2, 65535, 12, 17, 0xa5a7fffda5a5a2e2) + EXT( 0xa5a5a5a5a5a5a2e1, 12, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a2e1, 12, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a2e1, 131071, 12, 18, 0xa5a7fffda5a5a2e1) + EXT( 0xa5a5a5a5a5a5a2e0, 12, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a2e0, 12, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a2e0, 262143, 12, 19, 0xa5a7ffffa5a5a2e0) + EXT( 0xa5a5a5a5a5a5a2df, 12, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a2df, 12, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a2df, 524287, 12, 20, 0xa5a7ffffa5a5a2df) + EXT( 0xa5a5a5a5a5a5a2de, 12, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a2de, 12, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a2de, 1048575, 12, 21, 0xa5a7ffffa5a5a2de) + EXT( 0xa5a5a5a5a5a5a2dd, 12, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a2dd, 12, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a2dd, 2097151, 12, 22, 0xa5a7ffffe5a5a2dd) + EXT( 0xa5a5a5a5a5a5a2dc, 12, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a2dc, 12, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a2dc, 4194303, 12, 23, 0xa5a7ffffe5a5a2dc) + EXT( 0xa5a5a5a5a5a5a2db, 12, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a2db, 12, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a2db, 8388607, 12, 24, 0xa5a7fffff5a5a2db) + EXT( 0xa5a5a5a5a5a5a2da, 12, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a2da, 12, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a2da, 16777215, 12, 25, 0xa5a7fffffda5a2da) + EXT( 0xa5a5a5a5a5a5a2d9, 12, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a2d9, 12, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a2d9, 33554431, 12, 26, 0xa5a7fffffda5a2d9) + EXT( 0xa5a5a5a5a5a5a2d8, 12, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a2d8, 12, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a2d8, 67108863, 12, 27, 0xa5a7ffffffa5a2d8) + EXT( 0xa5a5a5a5a5a5a2d7, 12, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a2d7, 12, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a2d7, 134217727, 12, 28, 0xa5a7ffffffa5a2d7) + EXT( 0xa5a5a5a5a5a5a2d6, 12, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a2d6, 12, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a2d6, 268435455, 12, 29, 0xa5a7ffffffa5a2d6) + EXT( 0xa5a5a5a5a5a5a2d5, 12, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a2d5, 12, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a2d5, 536870911, 12, 30, 0xa5a7ffffffe5a2d5) + EXT( 0xa5a5a5a5a5a5a2d4, 12, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2d4, 12, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2d4, 1073741823, 12, 31, 0xa5a7ffffffe5a2d4) + EXT( 0xa5a5a5a5a5a5a2d3, 12, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2d3, 12, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2d3, 2147483647, 12, 32, 0xa5a7fffffff5a2d3) + EXT( 0xa5a5a5a5a5a5a2d2, 12, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2d2, 12, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2d2, 4294967295, 12, 33, 0xa5a7fffffffda2d2) + EXT( 0xa5a5a5a5a5a5a2d1, 12, 34, 0x0000000169696969) + EXTU(0xa5a5a5a5a5a5a2d1, 12, 34, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a2d1, 8589934591, 12, 34, 0xa5a7fffffffda2d1) + EXT( 0xa5a5a5a5a5a5a2d0, 12, 35, 0x00000002d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a2d0, 12, 35, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a2d0, 17179869183, 12, 35, 0xa5a7ffffffffa2d0) + EXT( 0xa5a5a5a5a5a5a2cf, 12, 36, 0x00000005a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a2cf, 12, 36, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a2cf, 34359738367, 12, 36, 0xa5a7ffffffffa2cf) + EXT( 0xa5a5a5a5a5a5a2ce, 12, 37, 0x0000000b4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a2ce, 12, 37, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a2ce, 68719476735, 12, 37, 0xa5a7ffffffffa2ce) + EXT( 0xa5a5a5a5a5a5a2cd, 12, 38, 0x0000001696969696) + EXTU(0xa5a5a5a5a5a5a2cd, 12, 38, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a2cd, 137438953471, 12, 38, 0xa5a7ffffffffe2cd) + EXT( 0xa5a5a5a5a5a5a2cc, 12, 39, 0x0000002d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a2cc, 12, 39, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2cc, 274877906943, 12, 39, 0xa5a7ffffffffe2cc) + EXT( 0xa5a5a5a5a5a5a2cb, 12, 40, 0x0000005a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a2cb, 12, 40, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2cb, 549755813887, 12, 40, 0xa5a7fffffffff2cb) + EXT( 0xa5a5a5a5a5a5a2ca, 12, 41, 0x000000b4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2ca, 12, 41, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2ca, 1099511627775, 12, 41, 0xa5a7fffffffffaca) + EXT( 0xa5a5a5a5a5a5a2c9, 12, 42, 0x0000016969696968) + EXTU(0xa5a5a5a5a5a5a2c9, 12, 42, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a2c9, 2199023255551, 12, 42, 0xa5a7fffffffffec9) + EXT( 0xa5a5a5a5a5a5a2c8, 12, 43, 0x000002d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a2c8, 12, 43, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a2c8, 4398046511103, 12, 43, 0xa5a7fffffffffec8) + EXT( 0xa5a5a5a5a5a5a2c7, 12, 44, 0x000005a5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a2c7, 12, 44, 0x000005a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a2c7, 8796093022207, 12, 44, 0xa5a7ffffffffffc7) + EXT( 0xa5a5a5a5a5a5a2c6, 12, 45, 0x00000b4b4b4b4b45) + EXTU(0xa5a5a5a5a5a5a2c6, 12, 45, 0x00000b4b4b4b4b45) + DEP( 0xa5a5a5a5a5a5a2c6, 17592186044415, 12, 45, 0xa5a7ffffffffffc6) + EXT( 0xa5a5a5a5a5a5a2c5, 12, 46, 0x000016969696968b) + EXTU(0xa5a5a5a5a5a5a2c5, 12, 46, 0x000016969696968b) + DEP( 0xa5a5a5a5a5a5a2c5, 35184372088831, 12, 46, 0xa5a7ffffffffffc5) + EXT( 0xa5a5a5a5a5a5a2c4, 12, 47, 0x00002d2d2d2d2d16) + EXTU(0xa5a5a5a5a5a5a2c4, 12, 47, 0x00002d2d2d2d2d16) + DEP( 0xa5a5a5a5a5a5a2c4, 70368744177663, 12, 47, 0xa5a7ffffffffffe4) + EXT( 0xa5a5a5a5a5a5a2c3, 12, 48, 0x00005a5a5a5a5a2c) + EXTU(0xa5a5a5a5a5a5a2c3, 12, 48, 0x00005a5a5a5a5a2c) + DEP( 0xa5a5a5a5a5a5a2c3, 140737488355327, 12, 48, 0xa5a7fffffffffff3) + EXT( 0xa5a5a5a5a5a5a2c2, 12, 49, 0x0000b4b4b4b4b458) + EXTU(0xa5a5a5a5a5a5a2c2, 12, 49, 0x0000b4b4b4b4b458) + DEP( 0xa5a5a5a5a5a5a2c2, 281474976710655, 12, 49, 0xa5a7fffffffffffa) + EXT( 0xa5a5a5a5a5a5a2c1, 12, 50, 0x00016969696968b0) + EXTU(0xa5a5a5a5a5a5a2c1, 12, 50, 0x00016969696968b0) + DEP( 0xa5a5a5a5a5a5a2c1, 562949953421311, 12, 50, 0xa5a7fffffffffffd) + EXT( 0xa5a5a5a5a5a5a2c0, 12, 51, 0x0002d2d2d2d2d160) + EXTU(0xa5a5a5a5a5a5a2c0, 12, 51, 0x0002d2d2d2d2d160) + DEP( 0xa5a5a5a5a5a5a2c0, 1125899906842623, 12, 51, 0xa5a7fffffffffffe) + EXT( 0xa5a5a5a5a5a5a2bf, 13, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a2bf, 13, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a2bf, 0, 13, 1, 0xa5a1a5a5a5a5a2bf) + EXT( 0xa5a5a5a5a5a5a2be, 13, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a2be, 13, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a2be, 1, 13, 2, 0xa5a3a5a5a5a5a2be) + EXT( 0xa5a5a5a5a5a5a2bd, 13, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a2bd, 13, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a2bd, 3, 13, 3, 0xa5a3a5a5a5a5a2bd) + EXT( 0xa5a5a5a5a5a5a2bc, 13, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a2bc, 13, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a2bc, 7, 13, 4, 0xa5a3a5a5a5a5a2bc) + EXT( 0xa5a5a5a5a5a5a2bb, 13, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a2bb, 13, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a2bb, 15, 13, 5, 0xa5a3e5a5a5a5a2bb) + EXT( 0xa5a5a5a5a5a5a2ba, 13, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a2ba, 13, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a2ba, 31, 13, 6, 0xa5a3e5a5a5a5a2ba) + EXT( 0xa5a5a5a5a5a5a2b9, 13, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a2b9, 13, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a2b9, 63, 13, 7, 0xa5a3f5a5a5a5a2b9) + EXT( 0xa5a5a5a5a5a5a2b8, 13, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a2b8, 13, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a2b8, 127, 13, 8, 0xa5a3fda5a5a5a2b8) + EXT( 0xa5a5a5a5a5a5a2b7, 13, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a2b7, 13, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a2b7, 255, 13, 9, 0xa5a3fda5a5a5a2b7) + EXT( 0xa5a5a5a5a5a5a2b6, 13, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a2b6, 13, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a2b6, 511, 13, 10, 0xa5a3ffa5a5a5a2b6) + EXT( 0xa5a5a5a5a5a5a2b5, 13, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a2b5, 13, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a2b5, 1023, 13, 11, 0xa5a3ffa5a5a5a2b5) + EXT( 0xa5a5a5a5a5a5a2b4, 13, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a2b4, 13, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a2b4, 2047, 13, 12, 0xa5a3ffa5a5a5a2b4) + EXT( 0xa5a5a5a5a5a5a2b3, 13, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a2b3, 13, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a2b3, 4095, 13, 13, 0xa5a3ffe5a5a5a2b3) + EXT( 0xa5a5a5a5a5a5a2b2, 13, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a2b2, 13, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a2b2, 8191, 13, 14, 0xa5a3ffe5a5a5a2b2) + EXT( 0xa5a5a5a5a5a5a2b1, 13, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a2b1, 13, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a2b1, 16383, 13, 15, 0xa5a3fff5a5a5a2b1) + EXT( 0xa5a5a5a5a5a5a2b0, 13, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a2b0, 13, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a2b0, 32767, 13, 16, 0xa5a3fffda5a5a2b0) + EXT( 0xa5a5a5a5a5a5a2af, 13, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a2af, 13, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a2af, 65535, 13, 17, 0xa5a3fffda5a5a2af) + EXT( 0xa5a5a5a5a5a5a2ae, 13, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a2ae, 13, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a2ae, 131071, 13, 18, 0xa5a3ffffa5a5a2ae) + EXT( 0xa5a5a5a5a5a5a2ad, 13, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a2ad, 13, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a2ad, 262143, 13, 19, 0xa5a3ffffa5a5a2ad) + EXT( 0xa5a5a5a5a5a5a2ac, 13, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a2ac, 13, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a2ac, 524287, 13, 20, 0xa5a3ffffa5a5a2ac) + EXT( 0xa5a5a5a5a5a5a2ab, 13, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a2ab, 13, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a2ab, 1048575, 13, 21, 0xa5a3ffffe5a5a2ab) + EXT( 0xa5a5a5a5a5a5a2aa, 13, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a2aa, 13, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a2aa, 2097151, 13, 22, 0xa5a3ffffe5a5a2aa) + EXT( 0xa5a5a5a5a5a5a2a9, 13, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a2a9, 13, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a2a9, 4194303, 13, 23, 0xa5a3fffff5a5a2a9) + EXT( 0xa5a5a5a5a5a5a2a8, 13, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a2a8, 13, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a2a8, 8388607, 13, 24, 0xa5a3fffffda5a2a8) + EXT( 0xa5a5a5a5a5a5a2a7, 13, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a5a2a7, 13, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a2a7, 16777215, 13, 25, 0xa5a3fffffda5a2a7) + EXT( 0xa5a5a5a5a5a5a2a6, 13, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a5a2a6, 13, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a2a6, 33554431, 13, 26, 0xa5a3ffffffa5a2a6) + EXT( 0xa5a5a5a5a5a5a2a5, 13, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a5a2a5, 13, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a2a5, 67108863, 13, 27, 0xa5a3ffffffa5a2a5) + EXT( 0xa5a5a5a5a5a5a2a4, 13, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a5a2a4, 13, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a2a4, 134217727, 13, 28, 0xa5a3ffffffa5a2a4) + EXT( 0xa5a5a5a5a5a5a2a3, 13, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a5a2a3, 13, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a2a3, 268435455, 13, 29, 0xa5a3ffffffe5a2a3) + EXT( 0xa5a5a5a5a5a5a2a2, 13, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a5a2a2, 13, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a2a2, 536870911, 13, 30, 0xa5a3ffffffe5a2a2) + EXT( 0xa5a5a5a5a5a5a2a1, 13, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a2a1, 13, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a2a1, 1073741823, 13, 31, 0xa5a3fffffff5a2a1) + EXT( 0xa5a5a5a5a5a5a2a0, 13, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a2a0, 13, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a2a0, 2147483647, 13, 32, 0xa5a3fffffffda2a0) + EXT( 0xa5a5a5a5a5a5a29f, 13, 33, 0xffffffff69696969) + EXTU(0xa5a5a5a5a5a5a29f, 13, 33, 0x0000000169696969) + DEP( 0xa5a5a5a5a5a5a29f, 4294967295, 13, 33, 0xa5a3fffffffda29f) + EXT( 0xa5a5a5a5a5a5a29e, 13, 34, 0xfffffffed2d2d2d2) + EXTU(0xa5a5a5a5a5a5a29e, 13, 34, 0x00000002d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a29e, 8589934591, 13, 34, 0xa5a3ffffffffa29e) + EXT( 0xa5a5a5a5a5a5a29d, 13, 35, 0xfffffffda5a5a5a5) + EXTU(0xa5a5a5a5a5a5a29d, 13, 35, 0x00000005a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a29d, 17179869183, 13, 35, 0xa5a3ffffffffa29d) + EXT( 0xa5a5a5a5a5a5a29c, 13, 36, 0xfffffffb4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a29c, 13, 36, 0x0000000b4b4b4b4b) + DEP( 0xa5a5a5a5a5a5a29c, 34359738367, 13, 36, 0xa5a3ffffffffa29c) + EXT( 0xa5a5a5a5a5a5a29b, 13, 37, 0xfffffff696969696) + EXTU(0xa5a5a5a5a5a5a29b, 13, 37, 0x0000001696969696) + DEP( 0xa5a5a5a5a5a5a29b, 68719476735, 13, 37, 0xa5a3ffffffffe29b) + EXT( 0xa5a5a5a5a5a5a29a, 13, 38, 0xffffffed2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a29a, 13, 38, 0x0000002d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a29a, 137438953471, 13, 38, 0xa5a3ffffffffe29a) + EXT( 0xa5a5a5a5a5a5a299, 13, 39, 0xffffffda5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a299, 13, 39, 0x0000005a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a299, 274877906943, 13, 39, 0xa5a3fffffffff299) + EXT( 0xa5a5a5a5a5a5a298, 13, 40, 0xffffffb4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a298, 13, 40, 0x000000b4b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a298, 549755813887, 13, 40, 0xa5a3fffffffffa98) + EXT( 0xa5a5a5a5a5a5a297, 13, 41, 0xffffff6969696968) + EXTU(0xa5a5a5a5a5a5a297, 13, 41, 0x0000016969696968) + DEP( 0xa5a5a5a5a5a5a297, 1099511627775, 13, 41, 0xa5a3fffffffffe97) + EXT( 0xa5a5a5a5a5a5a296, 13, 42, 0xfffffed2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a296, 13, 42, 0x000002d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a296, 2199023255551, 13, 42, 0xa5a3fffffffffe96) + EXT( 0xa5a5a5a5a5a5a295, 13, 43, 0xfffffda5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a295, 13, 43, 0x000005a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a295, 4398046511103, 13, 43, 0xa5a3ffffffffff95) + EXT( 0xa5a5a5a5a5a5a294, 13, 44, 0xfffffb4b4b4b4b45) + EXTU(0xa5a5a5a5a5a5a294, 13, 44, 0x00000b4b4b4b4b45) + DEP( 0xa5a5a5a5a5a5a294, 8796093022207, 13, 44, 0xa5a3ffffffffff94) + EXT( 0xa5a5a5a5a5a5a293, 13, 45, 0xfffff6969696968a) + EXTU(0xa5a5a5a5a5a5a293, 13, 45, 0x000016969696968a) + DEP( 0xa5a5a5a5a5a5a293, 17592186044415, 13, 45, 0xa5a3ffffffffffd3) + EXT( 0xa5a5a5a5a5a5a292, 13, 46, 0xffffed2d2d2d2d14) + EXTU(0xa5a5a5a5a5a5a292, 13, 46, 0x00002d2d2d2d2d14) + DEP( 0xa5a5a5a5a5a5a292, 35184372088831, 13, 46, 0xa5a3fffffffffff2) + EXT( 0xa5a5a5a5a5a5a291, 13, 47, 0xffffda5a5a5a5a29) + EXTU(0xa5a5a5a5a5a5a291, 13, 47, 0x00005a5a5a5a5a29) + DEP( 0xa5a5a5a5a5a5a291, 70368744177663, 13, 47, 0xa5a3fffffffffff1) + EXT( 0xa5a5a5a5a5a5a290, 13, 48, 0xffffb4b4b4b4b452) + EXTU(0xa5a5a5a5a5a5a290, 13, 48, 0x0000b4b4b4b4b452) + DEP( 0xa5a5a5a5a5a5a290, 140737488355327, 13, 48, 0xa5a3fffffffffff8) + EXT( 0xa5a5a5a5a5a5a28f, 13, 49, 0xffff6969696968a3) + EXTU(0xa5a5a5a5a5a5a28f, 13, 49, 0x00016969696968a3) + DEP( 0xa5a5a5a5a5a5a28f, 281474976710655, 13, 49, 0xa5a3ffffffffffff) + EXT( 0xa5a5a5a5a5a5a28e, 13, 50, 0xfffed2d2d2d2d147) + EXTU(0xa5a5a5a5a5a5a28e, 13, 50, 0x0002d2d2d2d2d147) + DEP( 0xa5a5a5a5a5a5a28e, 562949953421311, 13, 50, 0xa5a3fffffffffffe) + EXT( 0xa5a5a5a5a5a5a28d, 14, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a28d, 14, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a28d, 0, 14, 1, 0xa5a5a5a5a5a5a28d) + EXT( 0xa5a5a5a5a5a5a28c, 14, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a28c, 14, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a28c, 1, 14, 2, 0xa5a5a5a5a5a5a28c) + EXT( 0xa5a5a5a5a5a5a28b, 14, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a28b, 14, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a28b, 3, 14, 3, 0xa5a5a5a5a5a5a28b) + EXT( 0xa5a5a5a5a5a5a28a, 14, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a5a28a, 14, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a28a, 7, 14, 4, 0xa5a5e5a5a5a5a28a) + EXT( 0xa5a5a5a5a5a5a289, 14, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a289, 14, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a289, 15, 14, 5, 0xa5a5e5a5a5a5a289) + EXT( 0xa5a5a5a5a5a5a288, 14, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a288, 14, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a288, 31, 14, 6, 0xa5a5f5a5a5a5a288) + EXT( 0xa5a5a5a5a5a5a287, 14, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a287, 14, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a287, 63, 14, 7, 0xa5a5fda5a5a5a287) + EXT( 0xa5a5a5a5a5a5a286, 14, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a5a286, 14, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a286, 127, 14, 8, 0xa5a5fda5a5a5a286) + EXT( 0xa5a5a5a5a5a5a285, 14, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a5a285, 14, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a285, 255, 14, 9, 0xa5a5ffa5a5a5a285) + EXT( 0xa5a5a5a5a5a5a284, 14, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a5a284, 14, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a284, 511, 14, 10, 0xa5a5ffa5a5a5a284) + EXT( 0xa5a5a5a5a5a5a283, 14, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a5a283, 14, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a283, 1023, 14, 11, 0xa5a5ffa5a5a5a283) + EXT( 0xa5a5a5a5a5a5a282, 14, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a5a282, 14, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a282, 2047, 14, 12, 0xa5a5ffe5a5a5a282) + EXT( 0xa5a5a5a5a5a5a281, 14, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a281, 14, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a281, 4095, 14, 13, 0xa5a5ffe5a5a5a281) + EXT( 0xa5a5a5a5a5a5a280, 14, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a280, 14, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a280, 8191, 14, 14, 0xa5a5fff5a5a5a280) + EXT( 0xa5a5a5a5a5a5a27f, 14, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a27f, 14, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a27f, 16383, 14, 15, 0xa5a5fffda5a5a27f) + EXT( 0xa5a5a5a5a5a5a27e, 14, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a5a27e, 14, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a27e, 32767, 14, 16, 0xa5a5fffda5a5a27e) + EXT( 0xa5a5a5a5a5a5a27d, 14, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a5a27d, 14, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a27d, 65535, 14, 17, 0xa5a5ffffa5a5a27d) + EXT( 0xa5a5a5a5a5a5a27c, 14, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a5a27c, 14, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a27c, 131071, 14, 18, 0xa5a5ffffa5a5a27c) + EXT( 0xa5a5a5a5a5a5a27b, 14, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a5a27b, 14, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a27b, 262143, 14, 19, 0xa5a5ffffa5a5a27b) + EXT( 0xa5a5a5a5a5a5a27a, 14, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a5a27a, 14, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a27a, 524287, 14, 20, 0xa5a5ffffe5a5a27a) + EXT( 0xa5a5a5a5a5a5a279, 14, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a279, 14, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a279, 1048575, 14, 21, 0xa5a5ffffe5a5a279) + EXT( 0xa5a5a5a5a5a5a278, 14, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a278, 14, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a278, 2097151, 14, 22, 0xa5a5fffff5a5a278) + EXT( 0xa5a5a5a5a5a5a277, 14, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a277, 14, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a277, 4194303, 14, 23, 0xa5a5fffffda5a277) + EXT( 0xa5a5a5a5a5a5a276, 14, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a5a276, 14, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a276, 8388607, 14, 24, 0xa5a5fffffda5a276) + EXT( 0xa5a5a5a5a5a5a275, 14, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a5a275, 14, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a275, 16777215, 14, 25, 0xa5a5ffffffa5a275) + EXT( 0xa5a5a5a5a5a5a274, 14, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a5a274, 14, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a274, 33554431, 14, 26, 0xa5a5ffffffa5a274) + EXT( 0xa5a5a5a5a5a5a273, 14, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a5a273, 14, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a273, 67108863, 14, 27, 0xa5a5ffffffa5a273) + EXT( 0xa5a5a5a5a5a5a272, 14, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a5a272, 14, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a272, 134217727, 14, 28, 0xa5a5ffffffe5a272) + EXT( 0xa5a5a5a5a5a5a271, 14, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a5a271, 14, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a271, 268435455, 14, 29, 0xa5a5ffffffe5a271) + EXT( 0xa5a5a5a5a5a5a270, 14, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a270, 14, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a270, 536870911, 14, 30, 0xa5a5fffffff5a270) + EXT( 0xa5a5a5a5a5a5a26f, 14, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a26f, 14, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a26f, 1073741823, 14, 31, 0xa5a5fffffffda26f) + EXT( 0xa5a5a5a5a5a5a26e, 14, 32, 0x0000000069696969) + EXTU(0xa5a5a5a5a5a5a26e, 14, 32, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a26e, 2147483647, 14, 32, 0xa5a5fffffffda26e) + EXT( 0xa5a5a5a5a5a5a26d, 14, 33, 0x00000000d2d2d2d2) + EXTU(0xa5a5a5a5a5a5a26d, 14, 33, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a26d, 4294967295, 14, 33, 0xa5a5ffffffffa26d) + EXT( 0xa5a5a5a5a5a5a26c, 14, 34, 0x00000001a5a5a5a5) + EXTU(0xa5a5a5a5a5a5a26c, 14, 34, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a26c, 8589934591, 14, 34, 0xa5a5ffffffffa26c) + EXT( 0xa5a5a5a5a5a5a26b, 14, 35, 0x000000034b4b4b4b) + EXTU(0xa5a5a5a5a5a5a26b, 14, 35, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a26b, 17179869183, 14, 35, 0xa5a5ffffffffa26b) + EXT( 0xa5a5a5a5a5a5a26a, 14, 36, 0x0000000696969696) + EXTU(0xa5a5a5a5a5a5a26a, 14, 36, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a26a, 34359738367, 14, 36, 0xa5a5ffffffffe26a) + EXT( 0xa5a5a5a5a5a5a269, 14, 37, 0x0000000d2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a269, 14, 37, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a269, 68719476735, 14, 37, 0xa5a5ffffffffe269) + EXT( 0xa5a5a5a5a5a5a268, 14, 38, 0x0000001a5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a268, 14, 38, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a268, 137438953471, 14, 38, 0xa5a5fffffffff268) + EXT( 0xa5a5a5a5a5a5a267, 14, 39, 0x00000034b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a267, 14, 39, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a267, 274877906943, 14, 39, 0xa5a5fffffffffa67) + EXT( 0xa5a5a5a5a5a5a266, 14, 40, 0x0000006969696968) + EXTU(0xa5a5a5a5a5a5a266, 14, 40, 0x0000006969696968) + DEP( 0xa5a5a5a5a5a5a266, 549755813887, 14, 40, 0xa5a5fffffffffe66) + EXT( 0xa5a5a5a5a5a5a265, 14, 41, 0x000000d2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a265, 14, 41, 0x000000d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a265, 1099511627775, 14, 41, 0xa5a5fffffffffe65) + EXT( 0xa5a5a5a5a5a5a264, 14, 42, 0x000001a5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a264, 14, 42, 0x000001a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a264, 2199023255551, 14, 42, 0xa5a5ffffffffff64) + EXT( 0xa5a5a5a5a5a5a263, 14, 43, 0x0000034b4b4b4b44) + EXTU(0xa5a5a5a5a5a5a263, 14, 43, 0x0000034b4b4b4b44) + DEP( 0xa5a5a5a5a5a5a263, 4398046511103, 14, 43, 0xa5a5ffffffffffe3) + EXT( 0xa5a5a5a5a5a5a262, 14, 44, 0x0000069696969689) + EXTU(0xa5a5a5a5a5a5a262, 14, 44, 0x0000069696969689) + DEP( 0xa5a5a5a5a5a5a262, 8796093022207, 14, 44, 0xa5a5ffffffffffe2) + EXT( 0xa5a5a5a5a5a5a261, 14, 45, 0x00000d2d2d2d2d13) + EXTU(0xa5a5a5a5a5a5a261, 14, 45, 0x00000d2d2d2d2d13) + DEP( 0xa5a5a5a5a5a5a261, 17592186044415, 14, 45, 0xa5a5ffffffffffe1) + EXT( 0xa5a5a5a5a5a5a260, 14, 46, 0x00001a5a5a5a5a26) + EXTU(0xa5a5a5a5a5a5a260, 14, 46, 0x00001a5a5a5a5a26) + DEP( 0xa5a5a5a5a5a5a260, 35184372088831, 14, 46, 0xa5a5fffffffffff0) + EXT( 0xa5a5a5a5a5a5a25f, 14, 47, 0x000034b4b4b4b44b) + EXTU(0xa5a5a5a5a5a5a25f, 14, 47, 0x000034b4b4b4b44b) + DEP( 0xa5a5a5a5a5a5a25f, 70368744177663, 14, 47, 0xa5a5ffffffffffff) + EXT( 0xa5a5a5a5a5a5a25e, 14, 48, 0x0000696969696897) + EXTU(0xa5a5a5a5a5a5a25e, 14, 48, 0x0000696969696897) + DEP( 0xa5a5a5a5a5a5a25e, 140737488355327, 14, 48, 0xa5a5fffffffffffe) + EXT( 0xa5a5a5a5a5a5a25d, 14, 49, 0x0000d2d2d2d2d12e) + EXTU(0xa5a5a5a5a5a5a25d, 14, 49, 0x0000d2d2d2d2d12e) + DEP( 0xa5a5a5a5a5a5a25d, 281474976710655, 14, 49, 0xa5a5ffffffffffff) + EXT( 0xa5a5a5a5a5a5a25c, 15, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a25c, 15, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a25c, 0, 15, 1, 0xa5a4a5a5a5a5a25c) + EXT( 0xa5a5a5a5a5a5a25b, 15, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a25b, 15, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a25b, 1, 15, 2, 0xa5a4a5a5a5a5a25b) + EXT( 0xa5a5a5a5a5a5a25a, 15, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a25a, 15, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a25a, 3, 15, 3, 0xa5a4e5a5a5a5a25a) + EXT( 0xa5a5a5a5a5a5a259, 15, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a259, 15, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a259, 7, 15, 4, 0xa5a4e5a5a5a5a259) + EXT( 0xa5a5a5a5a5a5a258, 15, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a258, 15, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a258, 15, 15, 5, 0xa5a4f5a5a5a5a258) + EXT( 0xa5a5a5a5a5a5a257, 15, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a257, 15, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a257, 31, 15, 6, 0xa5a4fda5a5a5a257) + EXT( 0xa5a5a5a5a5a5a256, 15, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a256, 15, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a256, 63, 15, 7, 0xa5a4fda5a5a5a256) + EXT( 0xa5a5a5a5a5a5a255, 15, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a255, 15, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a255, 127, 15, 8, 0xa5a4ffa5a5a5a255) + EXT( 0xa5a5a5a5a5a5a254, 15, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a254, 15, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a254, 255, 15, 9, 0xa5a4ffa5a5a5a254) + EXT( 0xa5a5a5a5a5a5a253, 15, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a253, 15, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a253, 511, 15, 10, 0xa5a4ffa5a5a5a253) + EXT( 0xa5a5a5a5a5a5a252, 15, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a252, 15, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a252, 1023, 15, 11, 0xa5a4ffe5a5a5a252) + EXT( 0xa5a5a5a5a5a5a251, 15, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a251, 15, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a251, 2047, 15, 12, 0xa5a4ffe5a5a5a251) + EXT( 0xa5a5a5a5a5a5a250, 15, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a250, 15, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a250, 4095, 15, 13, 0xa5a4fff5a5a5a250) + EXT( 0xa5a5a5a5a5a5a24f, 15, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a24f, 15, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a24f, 8191, 15, 14, 0xa5a4fffda5a5a24f) + EXT( 0xa5a5a5a5a5a5a24e, 15, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a24e, 15, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a24e, 16383, 15, 15, 0xa5a4fffda5a5a24e) + EXT( 0xa5a5a5a5a5a5a24d, 15, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a24d, 15, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a24d, 32767, 15, 16, 0xa5a4ffffa5a5a24d) + EXT( 0xa5a5a5a5a5a5a24c, 15, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a24c, 15, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a24c, 65535, 15, 17, 0xa5a4ffffa5a5a24c) + EXT( 0xa5a5a5a5a5a5a24b, 15, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a24b, 15, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a24b, 131071, 15, 18, 0xa5a4ffffa5a5a24b) + EXT( 0xa5a5a5a5a5a5a24a, 15, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a24a, 15, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a24a, 262143, 15, 19, 0xa5a4ffffe5a5a24a) + EXT( 0xa5a5a5a5a5a5a249, 15, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a249, 15, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a249, 524287, 15, 20, 0xa5a4ffffe5a5a249) + EXT( 0xa5a5a5a5a5a5a248, 15, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a248, 15, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a248, 1048575, 15, 21, 0xa5a4fffff5a5a248) + EXT( 0xa5a5a5a5a5a5a247, 15, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a247, 15, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a247, 2097151, 15, 22, 0xa5a4fffffda5a247) + EXT( 0xa5a5a5a5a5a5a246, 15, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a246, 15, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a246, 4194303, 15, 23, 0xa5a4fffffda5a246) + EXT( 0xa5a5a5a5a5a5a245, 15, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a245, 15, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a245, 8388607, 15, 24, 0xa5a4ffffffa5a245) + EXT( 0xa5a5a5a5a5a5a244, 15, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a244, 15, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a244, 16777215, 15, 25, 0xa5a4ffffffa5a244) + EXT( 0xa5a5a5a5a5a5a243, 15, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a243, 15, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a243, 33554431, 15, 26, 0xa5a4ffffffa5a243) + EXT( 0xa5a5a5a5a5a5a242, 15, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a242, 15, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a242, 67108863, 15, 27, 0xa5a4ffffffe5a242) + EXT( 0xa5a5a5a5a5a5a241, 15, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a241, 15, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a241, 134217727, 15, 28, 0xa5a4ffffffe5a241) + EXT( 0xa5a5a5a5a5a5a240, 15, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a240, 15, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a240, 268435455, 15, 29, 0xa5a4fffffff5a240) + EXT( 0xa5a5a5a5a5a5a23f, 15, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a23f, 15, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a23f, 536870911, 15, 30, 0xa5a4fffffffda23f) + EXT( 0xa5a5a5a5a5a5a23e, 15, 31, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a23e, 15, 31, 0x0000000069696969) + DEP( 0xa5a5a5a5a5a5a23e, 1073741823, 15, 31, 0xa5a4fffffffda23e) + EXT( 0xa5a5a5a5a5a5a23d, 15, 32, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a23d, 15, 32, 0x00000000d2d2d2d2) + DEP( 0xa5a5a5a5a5a5a23d, 2147483647, 15, 32, 0xa5a4ffffffffa23d) + EXT( 0xa5a5a5a5a5a5a23c, 15, 33, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a23c, 15, 33, 0x00000001a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a23c, 4294967295, 15, 33, 0xa5a4ffffffffa23c) + EXT( 0xa5a5a5a5a5a5a23b, 15, 34, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a23b, 15, 34, 0x000000034b4b4b4b) + DEP( 0xa5a5a5a5a5a5a23b, 8589934591, 15, 34, 0xa5a4ffffffffa23b) + EXT( 0xa5a5a5a5a5a5a23a, 15, 35, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a23a, 15, 35, 0x0000000696969696) + DEP( 0xa5a5a5a5a5a5a23a, 17179869183, 15, 35, 0xa5a4ffffffffe23a) + EXT( 0xa5a5a5a5a5a5a239, 15, 36, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a239, 15, 36, 0x0000000d2d2d2d2d) + DEP( 0xa5a5a5a5a5a5a239, 34359738367, 15, 36, 0xa5a4ffffffffe239) + EXT( 0xa5a5a5a5a5a5a238, 15, 37, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a238, 15, 37, 0x0000001a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a238, 68719476735, 15, 37, 0xa5a4fffffffff238) + EXT( 0xa5a5a5a5a5a5a237, 15, 38, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a237, 15, 38, 0x00000034b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a237, 137438953471, 15, 38, 0xa5a4fffffffffa37) + EXT( 0xa5a5a5a5a5a5a236, 15, 39, 0xffffffe969696968) + EXTU(0xa5a5a5a5a5a5a236, 15, 39, 0x0000006969696968) + DEP( 0xa5a5a5a5a5a5a236, 274877906943, 15, 39, 0xa5a4fffffffffe36) + EXT( 0xa5a5a5a5a5a5a235, 15, 40, 0xffffffd2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a235, 15, 40, 0x000000d2d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a235, 549755813887, 15, 40, 0xa5a4fffffffffe35) + EXT( 0xa5a5a5a5a5a5a234, 15, 41, 0xffffffa5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a234, 15, 41, 0x000001a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a234, 1099511627775, 15, 41, 0xa5a4ffffffffff34) + EXT( 0xa5a5a5a5a5a5a233, 15, 42, 0xffffff4b4b4b4b44) + EXTU(0xa5a5a5a5a5a5a233, 15, 42, 0x0000034b4b4b4b44) + DEP( 0xa5a5a5a5a5a5a233, 2199023255551, 15, 42, 0xa5a4ffffffffffb3) + EXT( 0xa5a5a5a5a5a5a232, 15, 43, 0xfffffe9696969688) + EXTU(0xa5a5a5a5a5a5a232, 15, 43, 0x0000069696969688) + DEP( 0xa5a5a5a5a5a5a232, 4398046511103, 15, 43, 0xa5a4fffffffffff2) + EXT( 0xa5a5a5a5a5a5a231, 15, 44, 0xfffffd2d2d2d2d11) + EXTU(0xa5a5a5a5a5a5a231, 15, 44, 0x00000d2d2d2d2d11) + DEP( 0xa5a5a5a5a5a5a231, 8796093022207, 15, 44, 0xa5a4fffffffffff1) + EXT( 0xa5a5a5a5a5a5a230, 15, 45, 0xfffffa5a5a5a5a23) + EXTU(0xa5a5a5a5a5a5a230, 15, 45, 0x00001a5a5a5a5a23) + DEP( 0xa5a5a5a5a5a5a230, 17592186044415, 15, 45, 0xa5a4fffffffffff0) + EXT( 0xa5a5a5a5a5a5a22f, 15, 46, 0xfffff4b4b4b4b445) + EXTU(0xa5a5a5a5a5a5a22f, 15, 46, 0x000034b4b4b4b445) + DEP( 0xa5a5a5a5a5a5a22f, 35184372088831, 15, 46, 0xa5a4ffffffffffff) + EXT( 0xa5a5a5a5a5a5a22e, 15, 47, 0xffffe9696969688b) + EXTU(0xa5a5a5a5a5a5a22e, 15, 47, 0x000069696969688b) + DEP( 0xa5a5a5a5a5a5a22e, 70368744177663, 15, 47, 0xa5a4fffffffffffe) + EXT( 0xa5a5a5a5a5a5a22d, 15, 48, 0xffffd2d2d2d2d116) + EXTU(0xa5a5a5a5a5a5a22d, 15, 48, 0x0000d2d2d2d2d116) + DEP( 0xa5a5a5a5a5a5a22d, 140737488355327, 15, 48, 0xa5a4ffffffffffff) + EXT( 0xa5a5a5a5a5a5a22c, 16, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a22c, 16, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a22c, 0, 16, 1, 0xa5a525a5a5a5a22c) + EXT( 0xa5a5a5a5a5a5a22b, 16, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a22b, 16, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a22b, 1, 16, 2, 0xa5a565a5a5a5a22b) + EXT( 0xa5a5a5a5a5a5a22a, 16, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a22a, 16, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a22a, 3, 16, 3, 0xa5a565a5a5a5a22a) + EXT( 0xa5a5a5a5a5a5a229, 16, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a229, 16, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a229, 7, 16, 4, 0xa5a575a5a5a5a229) + EXT( 0xa5a5a5a5a5a5a228, 16, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a228, 16, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a228, 15, 16, 5, 0xa5a57da5a5a5a228) + EXT( 0xa5a5a5a5a5a5a227, 16, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a227, 16, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a227, 31, 16, 6, 0xa5a57da5a5a5a227) + EXT( 0xa5a5a5a5a5a5a226, 16, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a226, 16, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a226, 63, 16, 7, 0xa5a57fa5a5a5a226) + EXT( 0xa5a5a5a5a5a5a225, 16, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a225, 16, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a225, 127, 16, 8, 0xa5a57fa5a5a5a225) + EXT( 0xa5a5a5a5a5a5a224, 16, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a224, 16, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a224, 255, 16, 9, 0xa5a57fa5a5a5a224) + EXT( 0xa5a5a5a5a5a5a223, 16, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a223, 16, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a223, 511, 16, 10, 0xa5a57fe5a5a5a223) + EXT( 0xa5a5a5a5a5a5a222, 16, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a222, 16, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a222, 1023, 16, 11, 0xa5a57fe5a5a5a222) + EXT( 0xa5a5a5a5a5a5a221, 16, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a221, 16, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a221, 2047, 16, 12, 0xa5a57ff5a5a5a221) + EXT( 0xa5a5a5a5a5a5a220, 16, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a220, 16, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a220, 4095, 16, 13, 0xa5a57ffda5a5a220) + EXT( 0xa5a5a5a5a5a5a21f, 16, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a21f, 16, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a21f, 8191, 16, 14, 0xa5a57ffda5a5a21f) + EXT( 0xa5a5a5a5a5a5a21e, 16, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a21e, 16, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a21e, 16383, 16, 15, 0xa5a57fffa5a5a21e) + EXT( 0xa5a5a5a5a5a5a21d, 16, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a21d, 16, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a21d, 32767, 16, 16, 0xa5a57fffa5a5a21d) + EXT( 0xa5a5a5a5a5a5a21c, 16, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a21c, 16, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a21c, 65535, 16, 17, 0xa5a57fffa5a5a21c) + EXT( 0xa5a5a5a5a5a5a21b, 16, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a21b, 16, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a21b, 131071, 16, 18, 0xa5a57fffe5a5a21b) + EXT( 0xa5a5a5a5a5a5a21a, 16, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a21a, 16, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a21a, 262143, 16, 19, 0xa5a57fffe5a5a21a) + EXT( 0xa5a5a5a5a5a5a219, 16, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a219, 16, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a219, 524287, 16, 20, 0xa5a57ffff5a5a219) + EXT( 0xa5a5a5a5a5a5a218, 16, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a218, 16, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a218, 1048575, 16, 21, 0xa5a57ffffda5a218) + EXT( 0xa5a5a5a5a5a5a217, 16, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a217, 16, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a217, 2097151, 16, 22, 0xa5a57ffffda5a217) + EXT( 0xa5a5a5a5a5a5a216, 16, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a216, 16, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a216, 4194303, 16, 23, 0xa5a57fffffa5a216) + EXT( 0xa5a5a5a5a5a5a215, 16, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a215, 16, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a215, 8388607, 16, 24, 0xa5a57fffffa5a215) + EXT( 0xa5a5a5a5a5a5a214, 16, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a214, 16, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a214, 16777215, 16, 25, 0xa5a57fffffa5a214) + EXT( 0xa5a5a5a5a5a5a213, 16, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a213, 16, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a213, 33554431, 16, 26, 0xa5a57fffffe5a213) + EXT( 0xa5a5a5a5a5a5a212, 16, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a212, 16, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a212, 67108863, 16, 27, 0xa5a57fffffe5a212) + EXT( 0xa5a5a5a5a5a5a211, 16, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a211, 16, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a211, 134217727, 16, 28, 0xa5a57ffffff5a211) + EXT( 0xa5a5a5a5a5a5a210, 16, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a210, 16, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a210, 268435455, 16, 29, 0xa5a57ffffffda210) + EXT( 0xa5a5a5a5a5a5a20f, 16, 30, 0xffffffffe9696969) + EXTU(0xa5a5a5a5a5a5a20f, 16, 30, 0x0000000029696969) + DEP( 0xa5a5a5a5a5a5a20f, 536870911, 16, 30, 0xa5a57ffffffda20f) + EXT( 0xa5a5a5a5a5a5a20e, 16, 31, 0xffffffffd2d2d2d2) + EXTU(0xa5a5a5a5a5a5a20e, 16, 31, 0x0000000052d2d2d2) + DEP( 0xa5a5a5a5a5a5a20e, 1073741823, 16, 31, 0xa5a57fffffffa20e) + EXT( 0xa5a5a5a5a5a5a20d, 16, 32, 0xffffffffa5a5a5a5) + EXTU(0xa5a5a5a5a5a5a20d, 16, 32, 0x00000000a5a5a5a5) + DEP( 0xa5a5a5a5a5a5a20d, 2147483647, 16, 32, 0xa5a57fffffffa20d) + EXT( 0xa5a5a5a5a5a5a20c, 16, 33, 0xffffffff4b4b4b4b) + EXTU(0xa5a5a5a5a5a5a20c, 16, 33, 0x000000014b4b4b4b) + DEP( 0xa5a5a5a5a5a5a20c, 4294967295, 16, 33, 0xa5a57fffffffa20c) + EXT( 0xa5a5a5a5a5a5a20b, 16, 34, 0xfffffffe96969696) + EXTU(0xa5a5a5a5a5a5a20b, 16, 34, 0x0000000296969696) + DEP( 0xa5a5a5a5a5a5a20b, 8589934591, 16, 34, 0xa5a57fffffffe20b) + EXT( 0xa5a5a5a5a5a5a20a, 16, 35, 0xfffffffd2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a20a, 16, 35, 0x000000052d2d2d2d) + DEP( 0xa5a5a5a5a5a5a20a, 17179869183, 16, 35, 0xa5a57fffffffe20a) + EXT( 0xa5a5a5a5a5a5a209, 16, 36, 0xfffffffa5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a209, 16, 36, 0x0000000a5a5a5a5a) + DEP( 0xa5a5a5a5a5a5a209, 34359738367, 16, 36, 0xa5a57ffffffff209) + EXT( 0xa5a5a5a5a5a5a208, 16, 37, 0xfffffff4b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a208, 16, 37, 0x00000014b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a208, 68719476735, 16, 37, 0xa5a57ffffffffa08) + EXT( 0xa5a5a5a5a5a5a207, 16, 38, 0xffffffe969696968) + EXTU(0xa5a5a5a5a5a5a207, 16, 38, 0x0000002969696968) + DEP( 0xa5a5a5a5a5a5a207, 137438953471, 16, 38, 0xa5a57ffffffffe07) + EXT( 0xa5a5a5a5a5a5a206, 16, 39, 0xffffffd2d2d2d2d1) + EXTU(0xa5a5a5a5a5a5a206, 16, 39, 0x00000052d2d2d2d1) + DEP( 0xa5a5a5a5a5a5a206, 274877906943, 16, 39, 0xa5a57ffffffffe06) + EXT( 0xa5a5a5a5a5a5a205, 16, 40, 0xffffffa5a5a5a5a2) + EXTU(0xa5a5a5a5a5a5a205, 16, 40, 0x000000a5a5a5a5a2) + DEP( 0xa5a5a5a5a5a5a205, 549755813887, 16, 40, 0xa5a57fffffffff05) + EXT( 0xa5a5a5a5a5a5a204, 16, 41, 0xffffff4b4b4b4b44) + EXTU(0xa5a5a5a5a5a5a204, 16, 41, 0x0000014b4b4b4b44) + DEP( 0xa5a5a5a5a5a5a204, 1099511627775, 16, 41, 0xa5a57fffffffff84) + EXT( 0xa5a5a5a5a5a5a203, 16, 42, 0xfffffe9696969688) + EXTU(0xa5a5a5a5a5a5a203, 16, 42, 0x0000029696969688) + DEP( 0xa5a5a5a5a5a5a203, 2199023255551, 16, 42, 0xa5a57fffffffffc3) + EXT( 0xa5a5a5a5a5a5a202, 16, 43, 0xfffffd2d2d2d2d10) + EXTU(0xa5a5a5a5a5a5a202, 16, 43, 0x0000052d2d2d2d10) + DEP( 0xa5a5a5a5a5a5a202, 4398046511103, 16, 43, 0xa5a57fffffffffe2) + EXT( 0xa5a5a5a5a5a5a201, 16, 44, 0xfffffa5a5a5a5a20) + EXTU(0xa5a5a5a5a5a5a201, 16, 44, 0x00000a5a5a5a5a20) + DEP( 0xa5a5a5a5a5a5a201, 8796093022207, 16, 44, 0xa5a57ffffffffff1) + EXT( 0xa5a5a5a5a5a5a200, 16, 45, 0xfffff4b4b4b4b440) + EXTU(0xa5a5a5a5a5a5a200, 16, 45, 0x000014b4b4b4b440) + DEP( 0xa5a5a5a5a5a5a200, 17592186044415, 16, 45, 0xa5a57ffffffffff8) + EXT( 0xa5a5a5a5a5a5a1ff, 16, 46, 0xffffe9696969687f) + EXTU(0xa5a5a5a5a5a5a1ff, 16, 46, 0x000029696969687f) + DEP( 0xa5a5a5a5a5a5a1ff, 35184372088831, 16, 46, 0xa5a57fffffffffff) + EXT( 0xa5a5a5a5a5a5a1fe, 16, 47, 0xffffd2d2d2d2d0ff) + EXTU(0xa5a5a5a5a5a5a1fe, 16, 47, 0x000052d2d2d2d0ff) + DEP( 0xa5a5a5a5a5a5a1fe, 70368744177663, 16, 47, 0xa5a57ffffffffffe) + EXT( 0xa5a5a5a5a5a5a1fd, 17, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1fd, 17, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1fd, 0, 17, 1, 0xa5a5a5a5a5a5a1fd) + EXT( 0xa5a5a5a5a5a5a1fc, 17, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a1fc, 17, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1fc, 1, 17, 2, 0xa5a5a5a5a5a5a1fc) + EXT( 0xa5a5a5a5a5a5a1fb, 17, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a1fb, 17, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a1fb, 3, 17, 3, 0xa5a5b5a5a5a5a1fb) + EXT( 0xa5a5a5a5a5a5a1fa, 17, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a1fa, 17, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a1fa, 7, 17, 4, 0xa5a5bda5a5a5a1fa) + EXT( 0xa5a5a5a5a5a5a1f9, 17, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a1f9, 17, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a1f9, 15, 17, 5, 0xa5a5bda5a5a5a1f9) + EXT( 0xa5a5a5a5a5a5a1f8, 17, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a1f8, 17, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a1f8, 31, 17, 6, 0xa5a5bfa5a5a5a1f8) + EXT( 0xa5a5a5a5a5a5a1f7, 17, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a1f7, 17, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a1f7, 63, 17, 7, 0xa5a5bfa5a5a5a1f7) + EXT( 0xa5a5a5a5a5a5a1f6, 17, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a1f6, 17, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a1f6, 127, 17, 8, 0xa5a5bfa5a5a5a1f6) + EXT( 0xa5a5a5a5a5a5a1f5, 17, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a1f5, 17, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a1f5, 255, 17, 9, 0xa5a5bfe5a5a5a1f5) + EXT( 0xa5a5a5a5a5a5a1f4, 17, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a1f4, 17, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a1f4, 511, 17, 10, 0xa5a5bfe5a5a5a1f4) + EXT( 0xa5a5a5a5a5a5a1f3, 17, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a1f3, 17, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a1f3, 1023, 17, 11, 0xa5a5bff5a5a5a1f3) + EXT( 0xa5a5a5a5a5a5a1f2, 17, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a1f2, 17, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a1f2, 2047, 17, 12, 0xa5a5bffda5a5a1f2) + EXT( 0xa5a5a5a5a5a5a1f1, 17, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a1f1, 17, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a1f1, 4095, 17, 13, 0xa5a5bffda5a5a1f1) + EXT( 0xa5a5a5a5a5a5a1f0, 17, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a1f0, 17, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a1f0, 8191, 17, 14, 0xa5a5bfffa5a5a1f0) + EXT( 0xa5a5a5a5a5a5a1ef, 17, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a1ef, 17, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a1ef, 16383, 17, 15, 0xa5a5bfffa5a5a1ef) + EXT( 0xa5a5a5a5a5a5a1ee, 17, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a1ee, 17, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a1ee, 32767, 17, 16, 0xa5a5bfffa5a5a1ee) + EXT( 0xa5a5a5a5a5a5a1ed, 17, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a1ed, 17, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a1ed, 65535, 17, 17, 0xa5a5bfffe5a5a1ed) + EXT( 0xa5a5a5a5a5a5a1ec, 17, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a1ec, 17, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a1ec, 131071, 17, 18, 0xa5a5bfffe5a5a1ec) + EXT( 0xa5a5a5a5a5a5a1eb, 17, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a1eb, 17, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a1eb, 262143, 17, 19, 0xa5a5bffff5a5a1eb) + EXT( 0xa5a5a5a5a5a5a1ea, 17, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a1ea, 17, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a1ea, 524287, 17, 20, 0xa5a5bffffda5a1ea) + EXT( 0xa5a5a5a5a5a5a1e9, 17, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a1e9, 17, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a1e9, 1048575, 17, 21, 0xa5a5bffffda5a1e9) + EXT( 0xa5a5a5a5a5a5a1e8, 17, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a1e8, 17, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a1e8, 2097151, 17, 22, 0xa5a5bfffffa5a1e8) + EXT( 0xa5a5a5a5a5a5a1e7, 17, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a1e7, 17, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a1e7, 4194303, 17, 23, 0xa5a5bfffffa5a1e7) + EXT( 0xa5a5a5a5a5a5a1e6, 17, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a1e6, 17, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a1e6, 8388607, 17, 24, 0xa5a5bfffffa5a1e6) + EXT( 0xa5a5a5a5a5a5a1e5, 17, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a1e5, 17, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a1e5, 16777215, 17, 25, 0xa5a5bfffffe5a1e5) + EXT( 0xa5a5a5a5a5a5a1e4, 17, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a1e4, 17, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a1e4, 33554431, 17, 26, 0xa5a5bfffffe5a1e4) + EXT( 0xa5a5a5a5a5a5a1e3, 17, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a1e3, 17, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a1e3, 67108863, 17, 27, 0xa5a5bffffff5a1e3) + EXT( 0xa5a5a5a5a5a5a1e2, 17, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a1e2, 17, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a1e2, 134217727, 17, 28, 0xa5a5bffffffda1e2) + EXT( 0xa5a5a5a5a5a5a1e1, 17, 29, 0x0000000009696969) + EXTU(0xa5a5a5a5a5a5a1e1, 17, 29, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a1e1, 268435455, 17, 29, 0xa5a5bffffffda1e1) + EXT( 0xa5a5a5a5a5a5a1e0, 17, 30, 0x0000000012d2d2d2) + EXTU(0xa5a5a5a5a5a5a1e0, 17, 30, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a1e0, 536870911, 17, 30, 0xa5a5bfffffffa1e0) + EXT( 0xa5a5a5a5a5a5a1df, 17, 31, 0x0000000025a5a5a5) + EXTU(0xa5a5a5a5a5a5a1df, 17, 31, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a1df, 1073741823, 17, 31, 0xa5a5bfffffffa1df) + EXT( 0xa5a5a5a5a5a5a1de, 17, 32, 0x000000004b4b4b4b) + EXTU(0xa5a5a5a5a5a5a1de, 17, 32, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a1de, 2147483647, 17, 32, 0xa5a5bfffffffa1de) + EXT( 0xa5a5a5a5a5a5a1dd, 17, 33, 0x0000000096969696) + EXTU(0xa5a5a5a5a5a5a1dd, 17, 33, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a1dd, 4294967295, 17, 33, 0xa5a5bfffffffe1dd) + EXT( 0xa5a5a5a5a5a5a1dc, 17, 34, 0x000000012d2d2d2d) + EXTU(0xa5a5a5a5a5a5a1dc, 17, 34, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a1dc, 8589934591, 17, 34, 0xa5a5bfffffffe1dc) + EXT( 0xa5a5a5a5a5a5a1db, 17, 35, 0x000000025a5a5a5a) + EXTU(0xa5a5a5a5a5a5a1db, 17, 35, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a1db, 17179869183, 17, 35, 0xa5a5bffffffff1db) + EXT( 0xa5a5a5a5a5a5a1da, 17, 36, 0x00000004b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a1da, 17, 36, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a1da, 34359738367, 17, 36, 0xa5a5bffffffff9da) + EXT( 0xa5a5a5a5a5a5a1d9, 17, 37, 0x0000000969696968) + EXTU(0xa5a5a5a5a5a5a1d9, 17, 37, 0x0000000969696968) + DEP( 0xa5a5a5a5a5a5a1d9, 68719476735, 17, 37, 0xa5a5bffffffffdd9) + EXT( 0xa5a5a5a5a5a5a1d8, 17, 38, 0x00000012d2d2d2d0) + EXTU(0xa5a5a5a5a5a5a1d8, 17, 38, 0x00000012d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a1d8, 137438953471, 17, 38, 0xa5a5bfffffffffd8) + EXT( 0xa5a5a5a5a5a5a1d7, 17, 39, 0x00000025a5a5a5a1) + EXTU(0xa5a5a5a5a5a5a1d7, 17, 39, 0x00000025a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a1d7, 274877906943, 17, 39, 0xa5a5bfffffffffd7) + EXT( 0xa5a5a5a5a5a5a1d6, 17, 40, 0x0000004b4b4b4b43) + EXTU(0xa5a5a5a5a5a5a1d6, 17, 40, 0x0000004b4b4b4b43) + DEP( 0xa5a5a5a5a5a5a1d6, 549755813887, 17, 40, 0xa5a5bfffffffffd6) + EXT( 0xa5a5a5a5a5a5a1d5, 17, 41, 0x0000009696969687) + EXTU(0xa5a5a5a5a5a5a1d5, 17, 41, 0x0000009696969687) + DEP( 0xa5a5a5a5a5a5a1d5, 1099511627775, 17, 41, 0xa5a5bfffffffffd5) + EXT( 0xa5a5a5a5a5a5a1d4, 17, 42, 0x0000012d2d2d2d0e) + EXTU(0xa5a5a5a5a5a5a1d4, 17, 42, 0x0000012d2d2d2d0e) + DEP( 0xa5a5a5a5a5a5a1d4, 2199023255551, 17, 42, 0xa5a5bffffffffff4) + EXT( 0xa5a5a5a5a5a5a1d3, 17, 43, 0x0000025a5a5a5a1d) + EXTU(0xa5a5a5a5a5a5a1d3, 17, 43, 0x0000025a5a5a5a1d) + DEP( 0xa5a5a5a5a5a5a1d3, 4398046511103, 17, 43, 0xa5a5bffffffffff3) + EXT( 0xa5a5a5a5a5a5a1d2, 17, 44, 0x000004b4b4b4b43a) + EXTU(0xa5a5a5a5a5a5a1d2, 17, 44, 0x000004b4b4b4b43a) + DEP( 0xa5a5a5a5a5a5a1d2, 8796093022207, 17, 44, 0xa5a5bffffffffffa) + EXT( 0xa5a5a5a5a5a5a1d1, 17, 45, 0x0000096969696874) + EXTU(0xa5a5a5a5a5a5a1d1, 17, 45, 0x0000096969696874) + DEP( 0xa5a5a5a5a5a5a1d1, 17592186044415, 17, 45, 0xa5a5bffffffffffd) + EXT( 0xa5a5a5a5a5a5a1d0, 17, 46, 0x000012d2d2d2d0e8) + EXTU(0xa5a5a5a5a5a5a1d0, 17, 46, 0x000012d2d2d2d0e8) + DEP( 0xa5a5a5a5a5a5a1d0, 35184372088831, 17, 46, 0xa5a5bffffffffffe) + EXT( 0xa5a5a5a5a5a5a1cf, 18, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a1cf, 18, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1cf, 0, 18, 1, 0xa5a585a5a5a5a1cf) + EXT( 0xa5a5a5a5a5a5a1ce, 18, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a1ce, 18, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a1ce, 1, 18, 2, 0xa5a595a5a5a5a1ce) + EXT( 0xa5a5a5a5a5a5a1cd, 18, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a1cd, 18, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a1cd, 3, 18, 3, 0xa5a59da5a5a5a1cd) + EXT( 0xa5a5a5a5a5a5a1cc, 18, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a1cc, 18, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a1cc, 7, 18, 4, 0xa5a59da5a5a5a1cc) + EXT( 0xa5a5a5a5a5a5a1cb, 18, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a1cb, 18, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a1cb, 15, 18, 5, 0xa5a59fa5a5a5a1cb) + EXT( 0xa5a5a5a5a5a5a1ca, 18, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a1ca, 18, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a1ca, 31, 18, 6, 0xa5a59fa5a5a5a1ca) + EXT( 0xa5a5a5a5a5a5a1c9, 18, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a1c9, 18, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a1c9, 63, 18, 7, 0xa5a59fa5a5a5a1c9) + EXT( 0xa5a5a5a5a5a5a1c8, 18, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a1c8, 18, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a1c8, 127, 18, 8, 0xa5a59fe5a5a5a1c8) + EXT( 0xa5a5a5a5a5a5a1c7, 18, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a1c7, 18, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a1c7, 255, 18, 9, 0xa5a59fe5a5a5a1c7) + EXT( 0xa5a5a5a5a5a5a1c6, 18, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a1c6, 18, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a1c6, 511, 18, 10, 0xa5a59ff5a5a5a1c6) + EXT( 0xa5a5a5a5a5a5a1c5, 18, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a1c5, 18, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a1c5, 1023, 18, 11, 0xa5a59ffda5a5a1c5) + EXT( 0xa5a5a5a5a5a5a1c4, 18, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a1c4, 18, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a1c4, 2047, 18, 12, 0xa5a59ffda5a5a1c4) + EXT( 0xa5a5a5a5a5a5a1c3, 18, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a1c3, 18, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a1c3, 4095, 18, 13, 0xa5a59fffa5a5a1c3) + EXT( 0xa5a5a5a5a5a5a1c2, 18, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a1c2, 18, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a1c2, 8191, 18, 14, 0xa5a59fffa5a5a1c2) + EXT( 0xa5a5a5a5a5a5a1c1, 18, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a1c1, 18, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a1c1, 16383, 18, 15, 0xa5a59fffa5a5a1c1) + EXT( 0xa5a5a5a5a5a5a1c0, 18, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a1c0, 18, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a1c0, 32767, 18, 16, 0xa5a59fffe5a5a1c0) + EXT( 0xa5a5a5a5a5a5a1bf, 18, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a1bf, 18, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a1bf, 65535, 18, 17, 0xa5a59fffe5a5a1bf) + EXT( 0xa5a5a5a5a5a5a1be, 18, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a1be, 18, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a1be, 131071, 18, 18, 0xa5a59ffff5a5a1be) + EXT( 0xa5a5a5a5a5a5a1bd, 18, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a1bd, 18, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a1bd, 262143, 18, 19, 0xa5a59ffffda5a1bd) + EXT( 0xa5a5a5a5a5a5a1bc, 18, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a1bc, 18, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a1bc, 524287, 18, 20, 0xa5a59ffffda5a1bc) + EXT( 0xa5a5a5a5a5a5a1bb, 18, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a1bb, 18, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a1bb, 1048575, 18, 21, 0xa5a59fffffa5a1bb) + EXT( 0xa5a5a5a5a5a5a1ba, 18, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a1ba, 18, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a1ba, 2097151, 18, 22, 0xa5a59fffffa5a1ba) + EXT( 0xa5a5a5a5a5a5a1b9, 18, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a1b9, 18, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a1b9, 4194303, 18, 23, 0xa5a59fffffa5a1b9) + EXT( 0xa5a5a5a5a5a5a1b8, 18, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a1b8, 18, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a1b8, 8388607, 18, 24, 0xa5a59fffffe5a1b8) + EXT( 0xa5a5a5a5a5a5a1b7, 18, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a1b7, 18, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a1b7, 16777215, 18, 25, 0xa5a59fffffe5a1b7) + EXT( 0xa5a5a5a5a5a5a1b6, 18, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a1b6, 18, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a1b6, 33554431, 18, 26, 0xa5a59ffffff5a1b6) + EXT( 0xa5a5a5a5a5a5a1b5, 18, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a1b5, 18, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a1b5, 67108863, 18, 27, 0xa5a59ffffffda1b5) + EXT( 0xa5a5a5a5a5a5a1b4, 18, 28, 0xfffffffff9696969) + EXTU(0xa5a5a5a5a5a5a1b4, 18, 28, 0x0000000009696969) + DEP( 0xa5a5a5a5a5a5a1b4, 134217727, 18, 28, 0xa5a59ffffffda1b4) + EXT( 0xa5a5a5a5a5a5a1b3, 18, 29, 0xfffffffff2d2d2d2) + EXTU(0xa5a5a5a5a5a5a1b3, 18, 29, 0x0000000012d2d2d2) + DEP( 0xa5a5a5a5a5a5a1b3, 268435455, 18, 29, 0xa5a59fffffffa1b3) + EXT( 0xa5a5a5a5a5a5a1b2, 18, 30, 0xffffffffe5a5a5a5) + EXTU(0xa5a5a5a5a5a5a1b2, 18, 30, 0x0000000025a5a5a5) + DEP( 0xa5a5a5a5a5a5a1b2, 536870911, 18, 30, 0xa5a59fffffffa1b2) + EXT( 0xa5a5a5a5a5a5a1b1, 18, 31, 0xffffffffcb4b4b4b) + EXTU(0xa5a5a5a5a5a5a1b1, 18, 31, 0x000000004b4b4b4b) + DEP( 0xa5a5a5a5a5a5a1b1, 1073741823, 18, 31, 0xa5a59fffffffa1b1) + EXT( 0xa5a5a5a5a5a5a1b0, 18, 32, 0xffffffff96969696) + EXTU(0xa5a5a5a5a5a5a1b0, 18, 32, 0x0000000096969696) + DEP( 0xa5a5a5a5a5a5a1b0, 2147483647, 18, 32, 0xa5a59fffffffe1b0) + EXT( 0xa5a5a5a5a5a5a1af, 18, 33, 0xffffffff2d2d2d2d) + EXTU(0xa5a5a5a5a5a5a1af, 18, 33, 0x000000012d2d2d2d) + DEP( 0xa5a5a5a5a5a5a1af, 4294967295, 18, 33, 0xa5a59fffffffe1af) + EXT( 0xa5a5a5a5a5a5a1ae, 18, 34, 0xfffffffe5a5a5a5a) + EXTU(0xa5a5a5a5a5a5a1ae, 18, 34, 0x000000025a5a5a5a) + DEP( 0xa5a5a5a5a5a5a1ae, 8589934591, 18, 34, 0xa5a59ffffffff1ae) + EXT( 0xa5a5a5a5a5a5a1ad, 18, 35, 0xfffffffcb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a1ad, 18, 35, 0x00000004b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a1ad, 17179869183, 18, 35, 0xa5a59ffffffff9ad) + EXT( 0xa5a5a5a5a5a5a1ac, 18, 36, 0xfffffff969696968) + EXTU(0xa5a5a5a5a5a5a1ac, 18, 36, 0x0000000969696968) + DEP( 0xa5a5a5a5a5a5a1ac, 34359738367, 18, 36, 0xa5a59ffffffffdac) + EXT( 0xa5a5a5a5a5a5a1ab, 18, 37, 0xfffffff2d2d2d2d0) + EXTU(0xa5a5a5a5a5a5a1ab, 18, 37, 0x00000012d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a1ab, 68719476735, 18, 37, 0xa5a59fffffffffab) + EXT( 0xa5a5a5a5a5a5a1aa, 18, 38, 0xffffffe5a5a5a5a1) + EXTU(0xa5a5a5a5a5a5a1aa, 18, 38, 0x00000025a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a1aa, 137438953471, 18, 38, 0xa5a59fffffffffaa) + EXT( 0xa5a5a5a5a5a5a1a9, 18, 39, 0xffffffcb4b4b4b43) + EXTU(0xa5a5a5a5a5a5a1a9, 18, 39, 0x0000004b4b4b4b43) + DEP( 0xa5a5a5a5a5a5a1a9, 274877906943, 18, 39, 0xa5a59fffffffffa9) + EXT( 0xa5a5a5a5a5a5a1a8, 18, 40, 0xffffff9696969686) + EXTU(0xa5a5a5a5a5a5a1a8, 18, 40, 0x0000009696969686) + DEP( 0xa5a5a5a5a5a5a1a8, 549755813887, 18, 40, 0xa5a59fffffffffe8) + EXT( 0xa5a5a5a5a5a5a1a7, 18, 41, 0xffffff2d2d2d2d0d) + EXTU(0xa5a5a5a5a5a5a1a7, 18, 41, 0x0000012d2d2d2d0d) + DEP( 0xa5a5a5a5a5a5a1a7, 1099511627775, 18, 41, 0xa5a59fffffffffe7) + EXT( 0xa5a5a5a5a5a5a1a6, 18, 42, 0xfffffe5a5a5a5a1a) + EXTU(0xa5a5a5a5a5a5a1a6, 18, 42, 0x0000025a5a5a5a1a) + DEP( 0xa5a5a5a5a5a5a1a6, 2199023255551, 18, 42, 0xa5a59ffffffffff6) + EXT( 0xa5a5a5a5a5a5a1a5, 18, 43, 0xfffffcb4b4b4b434) + EXTU(0xa5a5a5a5a5a5a1a5, 18, 43, 0x000004b4b4b4b434) + DEP( 0xa5a5a5a5a5a5a1a5, 4398046511103, 18, 43, 0xa5a59ffffffffffd) + EXT( 0xa5a5a5a5a5a5a1a4, 18, 44, 0xfffff96969696869) + EXTU(0xa5a5a5a5a5a5a1a4, 18, 44, 0x0000096969696869) + DEP( 0xa5a5a5a5a5a5a1a4, 8796093022207, 18, 44, 0xa5a59ffffffffffc) + EXT( 0xa5a5a5a5a5a5a1a3, 18, 45, 0xfffff2d2d2d2d0d1) + EXTU(0xa5a5a5a5a5a5a1a3, 18, 45, 0x000012d2d2d2d0d1) + DEP( 0xa5a5a5a5a5a5a1a3, 17592186044415, 18, 45, 0xa5a59fffffffffff) + EXT( 0xa5a5a5a5a5a5a1a2, 19, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1a2, 19, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1a2, 0, 19, 1, 0xa5a5a5a5a5a5a1a2) + EXT( 0xa5a5a5a5a5a5a1a1, 19, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a1a1, 19, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a1a1, 1, 19, 2, 0xa5a5ada5a5a5a1a1) + EXT( 0xa5a5a5a5a5a5a1a0, 19, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a1a0, 19, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a1a0, 3, 19, 3, 0xa5a5ada5a5a5a1a0) + EXT( 0xa5a5a5a5a5a5a19f, 19, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a19f, 19, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a19f, 7, 19, 4, 0xa5a5afa5a5a5a19f) + EXT( 0xa5a5a5a5a5a5a19e, 19, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a19e, 19, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a19e, 15, 19, 5, 0xa5a5afa5a5a5a19e) + EXT( 0xa5a5a5a5a5a5a19d, 19, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a19d, 19, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a19d, 31, 19, 6, 0xa5a5afa5a5a5a19d) + EXT( 0xa5a5a5a5a5a5a19c, 19, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a19c, 19, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a19c, 63, 19, 7, 0xa5a5afe5a5a5a19c) + EXT( 0xa5a5a5a5a5a5a19b, 19, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a19b, 19, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a19b, 127, 19, 8, 0xa5a5afe5a5a5a19b) + EXT( 0xa5a5a5a5a5a5a19a, 19, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a19a, 19, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a19a, 255, 19, 9, 0xa5a5aff5a5a5a19a) + EXT( 0xa5a5a5a5a5a5a199, 19, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a199, 19, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a199, 511, 19, 10, 0xa5a5affda5a5a199) + EXT( 0xa5a5a5a5a5a5a198, 19, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a198, 19, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a198, 1023, 19, 11, 0xa5a5affda5a5a198) + EXT( 0xa5a5a5a5a5a5a197, 19, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a197, 19, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a197, 2047, 19, 12, 0xa5a5afffa5a5a197) + EXT( 0xa5a5a5a5a5a5a196, 19, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a196, 19, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a196, 4095, 19, 13, 0xa5a5afffa5a5a196) + EXT( 0xa5a5a5a5a5a5a195, 19, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a195, 19, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a195, 8191, 19, 14, 0xa5a5afffa5a5a195) + EXT( 0xa5a5a5a5a5a5a194, 19, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a194, 19, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a194, 16383, 19, 15, 0xa5a5afffe5a5a194) + EXT( 0xa5a5a5a5a5a5a193, 19, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a193, 19, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a193, 32767, 19, 16, 0xa5a5afffe5a5a193) + EXT( 0xa5a5a5a5a5a5a192, 19, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a192, 19, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a192, 65535, 19, 17, 0xa5a5affff5a5a192) + EXT( 0xa5a5a5a5a5a5a191, 19, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a191, 19, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a191, 131071, 19, 18, 0xa5a5affffda5a191) + EXT( 0xa5a5a5a5a5a5a190, 19, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a190, 19, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a190, 262143, 19, 19, 0xa5a5affffda5a190) + EXT( 0xa5a5a5a5a5a5a18f, 19, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a18f, 19, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a18f, 524287, 19, 20, 0xa5a5afffffa5a18f) + EXT( 0xa5a5a5a5a5a5a18e, 19, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a18e, 19, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a18e, 1048575, 19, 21, 0xa5a5afffffa5a18e) + EXT( 0xa5a5a5a5a5a5a18d, 19, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a18d, 19, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a18d, 2097151, 19, 22, 0xa5a5afffffa5a18d) + EXT( 0xa5a5a5a5a5a5a18c, 19, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a18c, 19, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a18c, 4194303, 19, 23, 0xa5a5afffffe5a18c) + EXT( 0xa5a5a5a5a5a5a18b, 19, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a18b, 19, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a18b, 8388607, 19, 24, 0xa5a5afffffe5a18b) + EXT( 0xa5a5a5a5a5a5a18a, 19, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a18a, 19, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a18a, 16777215, 19, 25, 0xa5a5affffff5a18a) + EXT( 0xa5a5a5a5a5a5a189, 19, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a189, 19, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a189, 33554431, 19, 26, 0xa5a5affffffda189) + EXT( 0xa5a5a5a5a5a5a188, 19, 27, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a188, 19, 27, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a188, 67108863, 19, 27, 0xa5a5affffffda188) + EXT( 0xa5a5a5a5a5a5a187, 19, 28, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a187, 19, 28, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a187, 134217727, 19, 28, 0xa5a5afffffffa187) + EXT( 0xa5a5a5a5a5a5a186, 19, 29, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a186, 19, 29, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a186, 268435455, 19, 29, 0xa5a5afffffffa186) + EXT( 0xa5a5a5a5a5a5a185, 19, 30, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a185, 19, 30, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a185, 536870911, 19, 30, 0xa5a5afffffffa185) + EXT( 0xa5a5a5a5a5a5a184, 19, 31, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a184, 19, 31, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a184, 1073741823, 19, 31, 0xa5a5afffffffe184) + EXT( 0xa5a5a5a5a5a5a183, 19, 32, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a183, 19, 32, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a183, 2147483647, 19, 32, 0xa5a5afffffffe183) + EXT( 0xa5a5a5a5a5a5a182, 19, 33, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a182, 19, 33, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a182, 4294967295, 19, 33, 0xa5a5affffffff182) + EXT( 0xa5a5a5a5a5a5a181, 19, 34, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a181, 19, 34, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a181, 8589934591, 19, 34, 0xa5a5affffffff981) + EXT( 0xa5a5a5a5a5a5a180, 19, 35, 0x0000000169696968) + EXTU(0xa5a5a5a5a5a5a180, 19, 35, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a180, 17179869183, 19, 35, 0xa5a5affffffffd80) + EXT( 0xa5a5a5a5a5a5a17f, 19, 36, 0x00000002d2d2d2d0) + EXTU(0xa5a5a5a5a5a5a17f, 19, 36, 0x00000002d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a17f, 34359738367, 19, 36, 0xa5a5afffffffff7f) + EXT( 0xa5a5a5a5a5a5a17e, 19, 37, 0x00000005a5a5a5a1) + EXTU(0xa5a5a5a5a5a5a17e, 19, 37, 0x00000005a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a17e, 68719476735, 19, 37, 0xa5a5afffffffff7e) + EXT( 0xa5a5a5a5a5a5a17d, 19, 38, 0x0000000b4b4b4b42) + EXTU(0xa5a5a5a5a5a5a17d, 19, 38, 0x0000000b4b4b4b42) + DEP( 0xa5a5a5a5a5a5a17d, 137438953471, 19, 38, 0xa5a5affffffffffd) + EXT( 0xa5a5a5a5a5a5a17c, 19, 39, 0x0000001696969685) + EXTU(0xa5a5a5a5a5a5a17c, 19, 39, 0x0000001696969685) + DEP( 0xa5a5a5a5a5a5a17c, 274877906943, 19, 39, 0xa5a5affffffffffc) + EXT( 0xa5a5a5a5a5a5a17b, 19, 40, 0x0000002d2d2d2d0b) + EXTU(0xa5a5a5a5a5a5a17b, 19, 40, 0x0000002d2d2d2d0b) + DEP( 0xa5a5a5a5a5a5a17b, 549755813887, 19, 40, 0xa5a5affffffffffb) + EXT( 0xa5a5a5a5a5a5a17a, 19, 41, 0x0000005a5a5a5a17) + EXTU(0xa5a5a5a5a5a5a17a, 19, 41, 0x0000005a5a5a5a17) + DEP( 0xa5a5a5a5a5a5a17a, 1099511627775, 19, 41, 0xa5a5affffffffffa) + EXT( 0xa5a5a5a5a5a5a179, 19, 42, 0x000000b4b4b4b42f) + EXTU(0xa5a5a5a5a5a5a179, 19, 42, 0x000000b4b4b4b42f) + DEP( 0xa5a5a5a5a5a5a179, 2199023255551, 19, 42, 0xa5a5affffffffff9) + EXT( 0xa5a5a5a5a5a5a178, 19, 43, 0x000001696969685e) + EXTU(0xa5a5a5a5a5a5a178, 19, 43, 0x000001696969685e) + DEP( 0xa5a5a5a5a5a5a178, 4398046511103, 19, 43, 0xa5a5affffffffffc) + EXT( 0xa5a5a5a5a5a5a177, 19, 44, 0x000002d2d2d2d0bb) + EXTU(0xa5a5a5a5a5a5a177, 19, 44, 0x000002d2d2d2d0bb) + DEP( 0xa5a5a5a5a5a5a177, 8796093022207, 19, 44, 0xa5a5afffffffffff) + EXT( 0xa5a5a5a5a5a5a176, 20, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a176, 20, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a176, 0, 20, 1, 0xa5a5a5a5a5a5a176) + EXT( 0xa5a5a5a5a5a5a175, 20, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a175, 20, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a175, 1, 20, 2, 0xa5a5a5a5a5a5a175) + EXT( 0xa5a5a5a5a5a5a174, 20, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a174, 20, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a174, 3, 20, 3, 0xa5a5a7a5a5a5a174) + EXT( 0xa5a5a5a5a5a5a173, 20, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a173, 20, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a173, 7, 20, 4, 0xa5a5a7a5a5a5a173) + EXT( 0xa5a5a5a5a5a5a172, 20, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a172, 20, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a172, 15, 20, 5, 0xa5a5a7a5a5a5a172) + EXT( 0xa5a5a5a5a5a5a171, 20, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a171, 20, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a171, 31, 20, 6, 0xa5a5a7e5a5a5a171) + EXT( 0xa5a5a5a5a5a5a170, 20, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a170, 20, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a170, 63, 20, 7, 0xa5a5a7e5a5a5a170) + EXT( 0xa5a5a5a5a5a5a16f, 20, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a16f, 20, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a16f, 127, 20, 8, 0xa5a5a7f5a5a5a16f) + EXT( 0xa5a5a5a5a5a5a16e, 20, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a16e, 20, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a16e, 255, 20, 9, 0xa5a5a7fda5a5a16e) + EXT( 0xa5a5a5a5a5a5a16d, 20, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a16d, 20, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a16d, 511, 20, 10, 0xa5a5a7fda5a5a16d) + EXT( 0xa5a5a5a5a5a5a16c, 20, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a16c, 20, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a16c, 1023, 20, 11, 0xa5a5a7ffa5a5a16c) + EXT( 0xa5a5a5a5a5a5a16b, 20, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a16b, 20, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a16b, 2047, 20, 12, 0xa5a5a7ffa5a5a16b) + EXT( 0xa5a5a5a5a5a5a16a, 20, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a16a, 20, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a16a, 4095, 20, 13, 0xa5a5a7ffa5a5a16a) + EXT( 0xa5a5a5a5a5a5a169, 20, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a169, 20, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a169, 8191, 20, 14, 0xa5a5a7ffe5a5a169) + EXT( 0xa5a5a5a5a5a5a168, 20, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a168, 20, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a168, 16383, 20, 15, 0xa5a5a7ffe5a5a168) + EXT( 0xa5a5a5a5a5a5a167, 20, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a167, 20, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a167, 32767, 20, 16, 0xa5a5a7fff5a5a167) + EXT( 0xa5a5a5a5a5a5a166, 20, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a166, 20, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a166, 65535, 20, 17, 0xa5a5a7fffda5a166) + EXT( 0xa5a5a5a5a5a5a165, 20, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a165, 20, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a165, 131071, 20, 18, 0xa5a5a7fffda5a165) + EXT( 0xa5a5a5a5a5a5a164, 20, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a164, 20, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a164, 262143, 20, 19, 0xa5a5a7ffffa5a164) + EXT( 0xa5a5a5a5a5a5a163, 20, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a163, 20, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a163, 524287, 20, 20, 0xa5a5a7ffffa5a163) + EXT( 0xa5a5a5a5a5a5a162, 20, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a162, 20, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a162, 1048575, 20, 21, 0xa5a5a7ffffa5a162) + EXT( 0xa5a5a5a5a5a5a161, 20, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a161, 20, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a161, 2097151, 20, 22, 0xa5a5a7ffffe5a161) + EXT( 0xa5a5a5a5a5a5a160, 20, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a160, 20, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a160, 4194303, 20, 23, 0xa5a5a7ffffe5a160) + EXT( 0xa5a5a5a5a5a5a15f, 20, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a15f, 20, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a15f, 8388607, 20, 24, 0xa5a5a7fffff5a15f) + EXT( 0xa5a5a5a5a5a5a15e, 20, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a15e, 20, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a15e, 16777215, 20, 25, 0xa5a5a7fffffda15e) + EXT( 0xa5a5a5a5a5a5a15d, 20, 26, 0x0000000001696969) + EXTU(0xa5a5a5a5a5a5a15d, 20, 26, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a15d, 33554431, 20, 26, 0xa5a5a7fffffda15d) + EXT( 0xa5a5a5a5a5a5a15c, 20, 27, 0x0000000002d2d2d2) + EXTU(0xa5a5a5a5a5a5a15c, 20, 27, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a15c, 67108863, 20, 27, 0xa5a5a7ffffffa15c) + EXT( 0xa5a5a5a5a5a5a15b, 20, 28, 0x0000000005a5a5a5) + EXTU(0xa5a5a5a5a5a5a15b, 20, 28, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a15b, 134217727, 20, 28, 0xa5a5a7ffffffa15b) + EXT( 0xa5a5a5a5a5a5a15a, 20, 29, 0x000000000b4b4b4b) + EXTU(0xa5a5a5a5a5a5a15a, 20, 29, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a15a, 268435455, 20, 29, 0xa5a5a7ffffffa15a) + EXT( 0xa5a5a5a5a5a5a159, 20, 30, 0x0000000016969696) + EXTU(0xa5a5a5a5a5a5a159, 20, 30, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a159, 536870911, 20, 30, 0xa5a5a7ffffffe159) + EXT( 0xa5a5a5a5a5a5a158, 20, 31, 0x000000002d2d2d2d) + EXTU(0xa5a5a5a5a5a5a158, 20, 31, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a158, 1073741823, 20, 31, 0xa5a5a7ffffffe158) + EXT( 0xa5a5a5a5a5a5a157, 20, 32, 0x000000005a5a5a5a) + EXTU(0xa5a5a5a5a5a5a157, 20, 32, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a157, 2147483647, 20, 32, 0xa5a5a7fffffff157) + EXT( 0xa5a5a5a5a5a5a156, 20, 33, 0x00000000b4b4b4b4) + EXTU(0xa5a5a5a5a5a5a156, 20, 33, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a156, 4294967295, 20, 33, 0xa5a5a7fffffff956) + EXT( 0xa5a5a5a5a5a5a155, 20, 34, 0x0000000169696968) + EXTU(0xa5a5a5a5a5a5a155, 20, 34, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a155, 8589934591, 20, 34, 0xa5a5a7fffffffd55) + EXT( 0xa5a5a5a5a5a5a154, 20, 35, 0x00000002d2d2d2d0) + EXTU(0xa5a5a5a5a5a5a154, 20, 35, 0x00000002d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a154, 17179869183, 20, 35, 0xa5a5a7ffffffff54) + EXT( 0xa5a5a5a5a5a5a153, 20, 36, 0x00000005a5a5a5a1) + EXTU(0xa5a5a5a5a5a5a153, 20, 36, 0x00000005a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a153, 34359738367, 20, 36, 0xa5a5a7ffffffff53) + EXT( 0xa5a5a5a5a5a5a152, 20, 37, 0x0000000b4b4b4b42) + EXTU(0xa5a5a5a5a5a5a152, 20, 37, 0x0000000b4b4b4b42) + DEP( 0xa5a5a5a5a5a5a152, 68719476735, 20, 37, 0xa5a5a7ffffffffd2) + EXT( 0xa5a5a5a5a5a5a151, 20, 38, 0x0000001696969685) + EXTU(0xa5a5a5a5a5a5a151, 20, 38, 0x0000001696969685) + DEP( 0xa5a5a5a5a5a5a151, 137438953471, 20, 38, 0xa5a5a7ffffffffd1) + EXT( 0xa5a5a5a5a5a5a150, 20, 39, 0x0000002d2d2d2d0a) + EXTU(0xa5a5a5a5a5a5a150, 20, 39, 0x0000002d2d2d2d0a) + DEP( 0xa5a5a5a5a5a5a150, 274877906943, 20, 39, 0xa5a5a7fffffffff0) + EXT( 0xa5a5a5a5a5a5a14f, 20, 40, 0x0000005a5a5a5a14) + EXTU(0xa5a5a5a5a5a5a14f, 20, 40, 0x0000005a5a5a5a14) + DEP( 0xa5a5a5a5a5a5a14f, 549755813887, 20, 40, 0xa5a5a7ffffffffff) + EXT( 0xa5a5a5a5a5a5a14e, 20, 41, 0x000000b4b4b4b429) + EXTU(0xa5a5a5a5a5a5a14e, 20, 41, 0x000000b4b4b4b429) + DEP( 0xa5a5a5a5a5a5a14e, 1099511627775, 20, 41, 0xa5a5a7fffffffffe) + EXT( 0xa5a5a5a5a5a5a14d, 20, 42, 0x0000016969696853) + EXTU(0xa5a5a5a5a5a5a14d, 20, 42, 0x0000016969696853) + DEP( 0xa5a5a5a5a5a5a14d, 2199023255551, 20, 42, 0xa5a5a7fffffffffd) + EXT( 0xa5a5a5a5a5a5a14c, 20, 43, 0x000002d2d2d2d0a6) + EXTU(0xa5a5a5a5a5a5a14c, 20, 43, 0x000002d2d2d2d0a6) + DEP( 0xa5a5a5a5a5a5a14c, 4398046511103, 20, 43, 0xa5a5a7fffffffffe) + EXT( 0xa5a5a5a5a5a5a14b, 21, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a14b, 21, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a14b, 0, 21, 1, 0xa5a5a1a5a5a5a14b) + EXT( 0xa5a5a5a5a5a5a14a, 21, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a14a, 21, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a14a, 1, 21, 2, 0xa5a5a3a5a5a5a14a) + EXT( 0xa5a5a5a5a5a5a149, 21, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a149, 21, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a149, 3, 21, 3, 0xa5a5a3a5a5a5a149) + EXT( 0xa5a5a5a5a5a5a148, 21, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a148, 21, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a148, 7, 21, 4, 0xa5a5a3a5a5a5a148) + EXT( 0xa5a5a5a5a5a5a147, 21, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a147, 21, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a147, 15, 21, 5, 0xa5a5a3e5a5a5a147) + EXT( 0xa5a5a5a5a5a5a146, 21, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a146, 21, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a146, 31, 21, 6, 0xa5a5a3e5a5a5a146) + EXT( 0xa5a5a5a5a5a5a145, 21, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a145, 21, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a145, 63, 21, 7, 0xa5a5a3f5a5a5a145) + EXT( 0xa5a5a5a5a5a5a144, 21, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a144, 21, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a144, 127, 21, 8, 0xa5a5a3fda5a5a144) + EXT( 0xa5a5a5a5a5a5a143, 21, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a143, 21, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a143, 255, 21, 9, 0xa5a5a3fda5a5a143) + EXT( 0xa5a5a5a5a5a5a142, 21, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a142, 21, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a142, 511, 21, 10, 0xa5a5a3ffa5a5a142) + EXT( 0xa5a5a5a5a5a5a141, 21, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a141, 21, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a141, 1023, 21, 11, 0xa5a5a3ffa5a5a141) + EXT( 0xa5a5a5a5a5a5a140, 21, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a140, 21, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a140, 2047, 21, 12, 0xa5a5a3ffa5a5a140) + EXT( 0xa5a5a5a5a5a5a13f, 21, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a13f, 21, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a13f, 4095, 21, 13, 0xa5a5a3ffe5a5a13f) + EXT( 0xa5a5a5a5a5a5a13e, 21, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a13e, 21, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a13e, 8191, 21, 14, 0xa5a5a3ffe5a5a13e) + EXT( 0xa5a5a5a5a5a5a13d, 21, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a13d, 21, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a13d, 16383, 21, 15, 0xa5a5a3fff5a5a13d) + EXT( 0xa5a5a5a5a5a5a13c, 21, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a13c, 21, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a13c, 32767, 21, 16, 0xa5a5a3fffda5a13c) + EXT( 0xa5a5a5a5a5a5a13b, 21, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a13b, 21, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a13b, 65535, 21, 17, 0xa5a5a3fffda5a13b) + EXT( 0xa5a5a5a5a5a5a13a, 21, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a13a, 21, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a13a, 131071, 21, 18, 0xa5a5a3ffffa5a13a) + EXT( 0xa5a5a5a5a5a5a139, 21, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a139, 21, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a139, 262143, 21, 19, 0xa5a5a3ffffa5a139) + EXT( 0xa5a5a5a5a5a5a138, 21, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a138, 21, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a138, 524287, 21, 20, 0xa5a5a3ffffa5a138) + EXT( 0xa5a5a5a5a5a5a137, 21, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a137, 21, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a137, 1048575, 21, 21, 0xa5a5a3ffffe5a137) + EXT( 0xa5a5a5a5a5a5a136, 21, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a136, 21, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a136, 2097151, 21, 22, 0xa5a5a3ffffe5a136) + EXT( 0xa5a5a5a5a5a5a135, 21, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a135, 21, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a135, 4194303, 21, 23, 0xa5a5a3fffff5a135) + EXT( 0xa5a5a5a5a5a5a134, 21, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a134, 21, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a134, 8388607, 21, 24, 0xa5a5a3fffffda134) + EXT( 0xa5a5a5a5a5a5a133, 21, 25, 0xffffffffff696969) + EXTU(0xa5a5a5a5a5a5a133, 21, 25, 0x0000000001696969) + DEP( 0xa5a5a5a5a5a5a133, 16777215, 21, 25, 0xa5a5a3fffffda133) + EXT( 0xa5a5a5a5a5a5a132, 21, 26, 0xfffffffffed2d2d2) + EXTU(0xa5a5a5a5a5a5a132, 21, 26, 0x0000000002d2d2d2) + DEP( 0xa5a5a5a5a5a5a132, 33554431, 21, 26, 0xa5a5a3ffffffa132) + EXT( 0xa5a5a5a5a5a5a131, 21, 27, 0xfffffffffda5a5a5) + EXTU(0xa5a5a5a5a5a5a131, 21, 27, 0x0000000005a5a5a5) + DEP( 0xa5a5a5a5a5a5a131, 67108863, 21, 27, 0xa5a5a3ffffffa131) + EXT( 0xa5a5a5a5a5a5a130, 21, 28, 0xfffffffffb4b4b4b) + EXTU(0xa5a5a5a5a5a5a130, 21, 28, 0x000000000b4b4b4b) + DEP( 0xa5a5a5a5a5a5a130, 134217727, 21, 28, 0xa5a5a3ffffffa130) + EXT( 0xa5a5a5a5a5a5a12f, 21, 29, 0xfffffffff6969696) + EXTU(0xa5a5a5a5a5a5a12f, 21, 29, 0x0000000016969696) + DEP( 0xa5a5a5a5a5a5a12f, 268435455, 21, 29, 0xa5a5a3ffffffe12f) + EXT( 0xa5a5a5a5a5a5a12e, 21, 30, 0xffffffffed2d2d2d) + EXTU(0xa5a5a5a5a5a5a12e, 21, 30, 0x000000002d2d2d2d) + DEP( 0xa5a5a5a5a5a5a12e, 536870911, 21, 30, 0xa5a5a3ffffffe12e) + EXT( 0xa5a5a5a5a5a5a12d, 21, 31, 0xffffffffda5a5a5a) + EXTU(0xa5a5a5a5a5a5a12d, 21, 31, 0x000000005a5a5a5a) + DEP( 0xa5a5a5a5a5a5a12d, 1073741823, 21, 31, 0xa5a5a3fffffff12d) + EXT( 0xa5a5a5a5a5a5a12c, 21, 32, 0xffffffffb4b4b4b4) + EXTU(0xa5a5a5a5a5a5a12c, 21, 32, 0x00000000b4b4b4b4) + DEP( 0xa5a5a5a5a5a5a12c, 2147483647, 21, 32, 0xa5a5a3fffffff92c) + EXT( 0xa5a5a5a5a5a5a12b, 21, 33, 0xffffffff69696968) + EXTU(0xa5a5a5a5a5a5a12b, 21, 33, 0x0000000169696968) + DEP( 0xa5a5a5a5a5a5a12b, 4294967295, 21, 33, 0xa5a5a3fffffffd2b) + EXT( 0xa5a5a5a5a5a5a12a, 21, 34, 0xfffffffed2d2d2d0) + EXTU(0xa5a5a5a5a5a5a12a, 21, 34, 0x00000002d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a12a, 8589934591, 21, 34, 0xa5a5a3ffffffff2a) + EXT( 0xa5a5a5a5a5a5a129, 21, 35, 0xfffffffda5a5a5a1) + EXTU(0xa5a5a5a5a5a5a129, 21, 35, 0x00000005a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a129, 17179869183, 21, 35, 0xa5a5a3ffffffff29) + EXT( 0xa5a5a5a5a5a5a128, 21, 36, 0xfffffffb4b4b4b42) + EXTU(0xa5a5a5a5a5a5a128, 21, 36, 0x0000000b4b4b4b42) + DEP( 0xa5a5a5a5a5a5a128, 34359738367, 21, 36, 0xa5a5a3ffffffffa8) + EXT( 0xa5a5a5a5a5a5a127, 21, 37, 0xfffffff696969684) + EXTU(0xa5a5a5a5a5a5a127, 21, 37, 0x0000001696969684) + DEP( 0xa5a5a5a5a5a5a127, 68719476735, 21, 37, 0xa5a5a3ffffffffe7) + EXT( 0xa5a5a5a5a5a5a126, 21, 38, 0xffffffed2d2d2d09) + EXTU(0xa5a5a5a5a5a5a126, 21, 38, 0x0000002d2d2d2d09) + DEP( 0xa5a5a5a5a5a5a126, 137438953471, 21, 38, 0xa5a5a3ffffffffe6) + EXT( 0xa5a5a5a5a5a5a125, 21, 39, 0xffffffda5a5a5a12) + EXTU(0xa5a5a5a5a5a5a125, 21, 39, 0x0000005a5a5a5a12) + DEP( 0xa5a5a5a5a5a5a125, 274877906943, 21, 39, 0xa5a5a3fffffffff5) + EXT( 0xa5a5a5a5a5a5a124, 21, 40, 0xffffffb4b4b4b424) + EXTU(0xa5a5a5a5a5a5a124, 21, 40, 0x000000b4b4b4b424) + DEP( 0xa5a5a5a5a5a5a124, 549755813887, 21, 40, 0xa5a5a3fffffffffc) + EXT( 0xa5a5a5a5a5a5a123, 21, 41, 0xffffff6969696848) + EXTU(0xa5a5a5a5a5a5a123, 21, 41, 0x0000016969696848) + DEP( 0xa5a5a5a5a5a5a123, 1099511627775, 21, 41, 0xa5a5a3ffffffffff) + EXT( 0xa5a5a5a5a5a5a122, 21, 42, 0xfffffed2d2d2d091) + EXTU(0xa5a5a5a5a5a5a122, 21, 42, 0x000002d2d2d2d091) + DEP( 0xa5a5a5a5a5a5a122, 2199023255551, 21, 42, 0xa5a5a3fffffffffe) + EXT( 0xa5a5a5a5a5a5a121, 22, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a121, 22, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a121, 0, 22, 1, 0xa5a5a5a5a5a5a121) + EXT( 0xa5a5a5a5a5a5a120, 22, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a120, 22, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a120, 1, 22, 2, 0xa5a5a5a5a5a5a120) + EXT( 0xa5a5a5a5a5a5a11f, 22, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a5a11f, 22, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a11f, 3, 22, 3, 0xa5a5a5a5a5a5a11f) + EXT( 0xa5a5a5a5a5a5a11e, 22, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a5a11e, 22, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a11e, 7, 22, 4, 0xa5a5a5e5a5a5a11e) + EXT( 0xa5a5a5a5a5a5a11d, 22, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a5a11d, 22, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a11d, 15, 22, 5, 0xa5a5a5e5a5a5a11d) + EXT( 0xa5a5a5a5a5a5a11c, 22, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a5a11c, 22, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a11c, 31, 22, 6, 0xa5a5a5f5a5a5a11c) + EXT( 0xa5a5a5a5a5a5a11b, 22, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a5a11b, 22, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a11b, 63, 22, 7, 0xa5a5a5fda5a5a11b) + EXT( 0xa5a5a5a5a5a5a11a, 22, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a5a11a, 22, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a11a, 127, 22, 8, 0xa5a5a5fda5a5a11a) + EXT( 0xa5a5a5a5a5a5a119, 22, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a5a119, 22, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a119, 255, 22, 9, 0xa5a5a5ffa5a5a119) + EXT( 0xa5a5a5a5a5a5a118, 22, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a5a118, 22, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a118, 511, 22, 10, 0xa5a5a5ffa5a5a118) + EXT( 0xa5a5a5a5a5a5a117, 22, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a5a117, 22, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a117, 1023, 22, 11, 0xa5a5a5ffa5a5a117) + EXT( 0xa5a5a5a5a5a5a116, 22, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a5a116, 22, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a116, 2047, 22, 12, 0xa5a5a5ffe5a5a116) + EXT( 0xa5a5a5a5a5a5a115, 22, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a5a115, 22, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a115, 4095, 22, 13, 0xa5a5a5ffe5a5a115) + EXT( 0xa5a5a5a5a5a5a114, 22, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a5a114, 22, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a114, 8191, 22, 14, 0xa5a5a5fff5a5a114) + EXT( 0xa5a5a5a5a5a5a113, 22, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a5a113, 22, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a113, 16383, 22, 15, 0xa5a5a5fffda5a113) + EXT( 0xa5a5a5a5a5a5a112, 22, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a5a112, 22, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a112, 32767, 22, 16, 0xa5a5a5fffda5a112) + EXT( 0xa5a5a5a5a5a5a111, 22, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a5a111, 22, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a111, 65535, 22, 17, 0xa5a5a5ffffa5a111) + EXT( 0xa5a5a5a5a5a5a110, 22, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a5a110, 22, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a110, 131071, 22, 18, 0xa5a5a5ffffa5a110) + EXT( 0xa5a5a5a5a5a5a10f, 22, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a5a10f, 22, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a10f, 262143, 22, 19, 0xa5a5a5ffffa5a10f) + EXT( 0xa5a5a5a5a5a5a10e, 22, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a5a10e, 22, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a10e, 524287, 22, 20, 0xa5a5a5ffffe5a10e) + EXT( 0xa5a5a5a5a5a5a10d, 22, 21, 0x00000000000d2d2d) + EXTU(0xa5a5a5a5a5a5a10d, 22, 21, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a10d, 1048575, 22, 21, 0xa5a5a5ffffe5a10d) + EXT( 0xa5a5a5a5a5a5a10c, 22, 22, 0x00000000001a5a5a) + EXTU(0xa5a5a5a5a5a5a10c, 22, 22, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a10c, 2097151, 22, 22, 0xa5a5a5fffff5a10c) + EXT( 0xa5a5a5a5a5a5a10b, 22, 23, 0x000000000034b4b4) + EXTU(0xa5a5a5a5a5a5a10b, 22, 23, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a10b, 4194303, 22, 23, 0xa5a5a5fffffda10b) + EXT( 0xa5a5a5a5a5a5a10a, 22, 24, 0x0000000000696969) + EXTU(0xa5a5a5a5a5a5a10a, 22, 24, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a10a, 8388607, 22, 24, 0xa5a5a5fffffda10a) + EXT( 0xa5a5a5a5a5a5a109, 22, 25, 0x0000000000d2d2d2) + EXTU(0xa5a5a5a5a5a5a109, 22, 25, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a109, 16777215, 22, 25, 0xa5a5a5ffffffa109) + EXT( 0xa5a5a5a5a5a5a108, 22, 26, 0x0000000001a5a5a5) + EXTU(0xa5a5a5a5a5a5a108, 22, 26, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a108, 33554431, 22, 26, 0xa5a5a5ffffffa108) + EXT( 0xa5a5a5a5a5a5a107, 22, 27, 0x00000000034b4b4b) + EXTU(0xa5a5a5a5a5a5a107, 22, 27, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a107, 67108863, 22, 27, 0xa5a5a5ffffffa107) + EXT( 0xa5a5a5a5a5a5a106, 22, 28, 0x0000000006969696) + EXTU(0xa5a5a5a5a5a5a106, 22, 28, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a106, 134217727, 22, 28, 0xa5a5a5ffffffe106) + EXT( 0xa5a5a5a5a5a5a105, 22, 29, 0x000000000d2d2d2d) + EXTU(0xa5a5a5a5a5a5a105, 22, 29, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a105, 268435455, 22, 29, 0xa5a5a5ffffffe105) + EXT( 0xa5a5a5a5a5a5a104, 22, 30, 0x000000001a5a5a5a) + EXTU(0xa5a5a5a5a5a5a104, 22, 30, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a104, 536870911, 22, 30, 0xa5a5a5fffffff104) + EXT( 0xa5a5a5a5a5a5a103, 22, 31, 0x0000000034b4b4b4) + EXTU(0xa5a5a5a5a5a5a103, 22, 31, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a103, 1073741823, 22, 31, 0xa5a5a5fffffff903) + EXT( 0xa5a5a5a5a5a5a102, 22, 32, 0x0000000069696968) + EXTU(0xa5a5a5a5a5a5a102, 22, 32, 0x0000000069696968) + DEP( 0xa5a5a5a5a5a5a102, 2147483647, 22, 32, 0xa5a5a5fffffffd02) + EXT( 0xa5a5a5a5a5a5a101, 22, 33, 0x00000000d2d2d2d0) + EXTU(0xa5a5a5a5a5a5a101, 22, 33, 0x00000000d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a101, 4294967295, 22, 33, 0xa5a5a5ffffffff01) + EXT( 0xa5a5a5a5a5a5a100, 22, 34, 0x00000001a5a5a5a1) + EXTU(0xa5a5a5a5a5a5a100, 22, 34, 0x00000001a5a5a5a1) + DEP( 0xa5a5a5a5a5a5a100, 8589934591, 22, 34, 0xa5a5a5ffffffff00) + EXT( 0xa5a5a5a5a5a5a0ff, 22, 35, 0x000000034b4b4b41) + EXTU(0xa5a5a5a5a5a5a0ff, 22, 35, 0x000000034b4b4b41) + DEP( 0xa5a5a5a5a5a5a0ff, 17179869183, 22, 35, 0xa5a5a5ffffffffff) + EXT( 0xa5a5a5a5a5a5a0fe, 22, 36, 0x0000000696969683) + EXTU(0xa5a5a5a5a5a5a0fe, 22, 36, 0x0000000696969683) + DEP( 0xa5a5a5a5a5a5a0fe, 34359738367, 22, 36, 0xa5a5a5fffffffffe) + EXT( 0xa5a5a5a5a5a5a0fd, 22, 37, 0x0000000d2d2d2d07) + EXTU(0xa5a5a5a5a5a5a0fd, 22, 37, 0x0000000d2d2d2d07) + DEP( 0xa5a5a5a5a5a5a0fd, 68719476735, 22, 37, 0xa5a5a5fffffffffd) + EXT( 0xa5a5a5a5a5a5a0fc, 22, 38, 0x0000001a5a5a5a0f) + EXTU(0xa5a5a5a5a5a5a0fc, 22, 38, 0x0000001a5a5a5a0f) + DEP( 0xa5a5a5a5a5a5a0fc, 137438953471, 22, 38, 0xa5a5a5fffffffffc) + EXT( 0xa5a5a5a5a5a5a0fb, 22, 39, 0x00000034b4b4b41f) + EXTU(0xa5a5a5a5a5a5a0fb, 22, 39, 0x00000034b4b4b41f) + DEP( 0xa5a5a5a5a5a5a0fb, 274877906943, 22, 39, 0xa5a5a5fffffffffb) + EXT( 0xa5a5a5a5a5a5a0fa, 22, 40, 0x000000696969683e) + EXTU(0xa5a5a5a5a5a5a0fa, 22, 40, 0x000000696969683e) + DEP( 0xa5a5a5a5a5a5a0fa, 549755813887, 22, 40, 0xa5a5a5fffffffffe) + EXT( 0xa5a5a5a5a5a5a0f9, 22, 41, 0x000000d2d2d2d07c) + EXTU(0xa5a5a5a5a5a5a0f9, 22, 41, 0x000000d2d2d2d07c) + DEP( 0xa5a5a5a5a5a5a0f9, 1099511627775, 22, 41, 0xa5a5a5ffffffffff) + EXT( 0xa5a5a5a5a5a5a0f8, 23, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0f8, 23, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0f8, 0, 23, 1, 0xa5a5a4a5a5a5a0f8) + EXT( 0xa5a5a5a5a5a5a0f7, 23, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0f7, 23, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a5a0f7, 1, 23, 2, 0xa5a5a4a5a5a5a0f7) + EXT( 0xa5a5a5a5a5a5a0f6, 23, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a0f6, 23, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a5a0f6, 3, 23, 3, 0xa5a5a4e5a5a5a0f6) + EXT( 0xa5a5a5a5a5a5a0f5, 23, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a0f5, 23, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a5a0f5, 7, 23, 4, 0xa5a5a4e5a5a5a0f5) + EXT( 0xa5a5a5a5a5a5a0f4, 23, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a0f4, 23, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a5a0f4, 15, 23, 5, 0xa5a5a4f5a5a5a0f4) + EXT( 0xa5a5a5a5a5a5a0f3, 23, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a0f3, 23, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a5a0f3, 31, 23, 6, 0xa5a5a4fda5a5a0f3) + EXT( 0xa5a5a5a5a5a5a0f2, 23, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a0f2, 23, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a5a0f2, 63, 23, 7, 0xa5a5a4fda5a5a0f2) + EXT( 0xa5a5a5a5a5a5a0f1, 23, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a0f1, 23, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a5a0f1, 127, 23, 8, 0xa5a5a4ffa5a5a0f1) + EXT( 0xa5a5a5a5a5a5a0f0, 23, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a0f0, 23, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a5a0f0, 255, 23, 9, 0xa5a5a4ffa5a5a0f0) + EXT( 0xa5a5a5a5a5a5a0ef, 23, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a0ef, 23, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a5a0ef, 511, 23, 10, 0xa5a5a4ffa5a5a0ef) + EXT( 0xa5a5a5a5a5a5a0ee, 23, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a0ee, 23, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a5a0ee, 1023, 23, 11, 0xa5a5a4ffe5a5a0ee) + EXT( 0xa5a5a5a5a5a5a0ed, 23, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a0ed, 23, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a5a0ed, 2047, 23, 12, 0xa5a5a4ffe5a5a0ed) + EXT( 0xa5a5a5a5a5a5a0ec, 23, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a0ec, 23, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a5a0ec, 4095, 23, 13, 0xa5a5a4fff5a5a0ec) + EXT( 0xa5a5a5a5a5a5a0eb, 23, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a0eb, 23, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a5a0eb, 8191, 23, 14, 0xa5a5a4fffda5a0eb) + EXT( 0xa5a5a5a5a5a5a0ea, 23, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a0ea, 23, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a5a0ea, 16383, 23, 15, 0xa5a5a4fffda5a0ea) + EXT( 0xa5a5a5a5a5a5a0e9, 23, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a0e9, 23, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a5a0e9, 32767, 23, 16, 0xa5a5a4ffffa5a0e9) + EXT( 0xa5a5a5a5a5a5a0e8, 23, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a0e8, 23, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a5a0e8, 65535, 23, 17, 0xa5a5a4ffffa5a0e8) + EXT( 0xa5a5a5a5a5a5a0e7, 23, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a0e7, 23, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a5a0e7, 131071, 23, 18, 0xa5a5a4ffffa5a0e7) + EXT( 0xa5a5a5a5a5a5a0e6, 23, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a0e6, 23, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a5a0e6, 262143, 23, 19, 0xa5a5a4ffffe5a0e6) + EXT( 0xa5a5a5a5a5a5a0e5, 23, 20, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a0e5, 23, 20, 0x00000000000d2d2d) + DEP( 0xa5a5a5a5a5a5a0e5, 524287, 23, 20, 0xa5a5a4ffffe5a0e5) + EXT( 0xa5a5a5a5a5a5a0e4, 23, 21, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a0e4, 23, 21, 0x00000000001a5a5a) + DEP( 0xa5a5a5a5a5a5a0e4, 1048575, 23, 21, 0xa5a5a4fffff5a0e4) + EXT( 0xa5a5a5a5a5a5a0e3, 23, 22, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a0e3, 23, 22, 0x000000000034b4b4) + DEP( 0xa5a5a5a5a5a5a0e3, 2097151, 23, 22, 0xa5a5a4fffffda0e3) + EXT( 0xa5a5a5a5a5a5a0e2, 23, 23, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a0e2, 23, 23, 0x0000000000696969) + DEP( 0xa5a5a5a5a5a5a0e2, 4194303, 23, 23, 0xa5a5a4fffffda0e2) + EXT( 0xa5a5a5a5a5a5a0e1, 23, 24, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a0e1, 23, 24, 0x0000000000d2d2d2) + DEP( 0xa5a5a5a5a5a5a0e1, 8388607, 23, 24, 0xa5a5a4ffffffa0e1) + EXT( 0xa5a5a5a5a5a5a0e0, 23, 25, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a0e0, 23, 25, 0x0000000001a5a5a5) + DEP( 0xa5a5a5a5a5a5a0e0, 16777215, 23, 25, 0xa5a5a4ffffffa0e0) + EXT( 0xa5a5a5a5a5a5a0df, 23, 26, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a0df, 23, 26, 0x00000000034b4b4b) + DEP( 0xa5a5a5a5a5a5a0df, 33554431, 23, 26, 0xa5a5a4ffffffa0df) + EXT( 0xa5a5a5a5a5a5a0de, 23, 27, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a0de, 23, 27, 0x0000000006969696) + DEP( 0xa5a5a5a5a5a5a0de, 67108863, 23, 27, 0xa5a5a4ffffffe0de) + EXT( 0xa5a5a5a5a5a5a0dd, 23, 28, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a0dd, 23, 28, 0x000000000d2d2d2d) + DEP( 0xa5a5a5a5a5a5a0dd, 134217727, 23, 28, 0xa5a5a4ffffffe0dd) + EXT( 0xa5a5a5a5a5a5a0dc, 23, 29, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a0dc, 23, 29, 0x000000001a5a5a5a) + DEP( 0xa5a5a5a5a5a5a0dc, 268435455, 23, 29, 0xa5a5a4fffffff0dc) + EXT( 0xa5a5a5a5a5a5a0db, 23, 30, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a0db, 23, 30, 0x0000000034b4b4b4) + DEP( 0xa5a5a5a5a5a5a0db, 536870911, 23, 30, 0xa5a5a4fffffff8db) + EXT( 0xa5a5a5a5a5a5a0da, 23, 31, 0xffffffffe9696968) + EXTU(0xa5a5a5a5a5a5a0da, 23, 31, 0x0000000069696968) + DEP( 0xa5a5a5a5a5a5a0da, 1073741823, 23, 31, 0xa5a5a4fffffffcda) + EXT( 0xa5a5a5a5a5a5a0d9, 23, 32, 0xffffffffd2d2d2d0) + EXTU(0xa5a5a5a5a5a5a0d9, 23, 32, 0x00000000d2d2d2d0) + DEP( 0xa5a5a5a5a5a5a0d9, 2147483647, 23, 32, 0xa5a5a4fffffffed9) + EXT( 0xa5a5a5a5a5a5a0d8, 23, 33, 0xffffffffa5a5a5a0) + EXTU(0xa5a5a5a5a5a5a0d8, 23, 33, 0x00000001a5a5a5a0) + DEP( 0xa5a5a5a5a5a5a0d8, 4294967295, 23, 33, 0xa5a5a4ffffffffd8) + EXT( 0xa5a5a5a5a5a5a0d7, 23, 34, 0xffffffff4b4b4b41) + EXTU(0xa5a5a5a5a5a5a0d7, 23, 34, 0x000000034b4b4b41) + DEP( 0xa5a5a5a5a5a5a0d7, 8589934591, 23, 34, 0xa5a5a4ffffffffd7) + EXT( 0xa5a5a5a5a5a5a0d6, 23, 35, 0xfffffffe96969683) + EXTU(0xa5a5a5a5a5a5a0d6, 23, 35, 0x0000000696969683) + DEP( 0xa5a5a5a5a5a5a0d6, 17179869183, 23, 35, 0xa5a5a4ffffffffd6) + EXT( 0xa5a5a5a5a5a5a0d5, 23, 36, 0xfffffffd2d2d2d06) + EXTU(0xa5a5a5a5a5a5a0d5, 23, 36, 0x0000000d2d2d2d06) + DEP( 0xa5a5a5a5a5a5a0d5, 34359738367, 23, 36, 0xa5a5a4fffffffff5) + EXT( 0xa5a5a5a5a5a5a0d4, 23, 37, 0xfffffffa5a5a5a0d) + EXTU(0xa5a5a5a5a5a5a0d4, 23, 37, 0x0000001a5a5a5a0d) + DEP( 0xa5a5a5a5a5a5a0d4, 68719476735, 23, 37, 0xa5a5a4fffffffff4) + EXT( 0xa5a5a5a5a5a5a0d3, 23, 38, 0xfffffff4b4b4b41a) + EXTU(0xa5a5a5a5a5a5a0d3, 23, 38, 0x00000034b4b4b41a) + DEP( 0xa5a5a5a5a5a5a0d3, 137438953471, 23, 38, 0xa5a5a4fffffffffb) + EXT( 0xa5a5a5a5a5a5a0d2, 23, 39, 0xffffffe969696834) + EXTU(0xa5a5a5a5a5a5a0d2, 23, 39, 0x0000006969696834) + DEP( 0xa5a5a5a5a5a5a0d2, 274877906943, 23, 39, 0xa5a5a4fffffffffe) + EXT( 0xa5a5a5a5a5a5a0d1, 23, 40, 0xffffffd2d2d2d068) + EXTU(0xa5a5a5a5a5a5a0d1, 23, 40, 0x000000d2d2d2d068) + DEP( 0xa5a5a5a5a5a5a0d1, 549755813887, 23, 40, 0xa5a5a4ffffffffff) + EXT( 0xa5a5a5a5a5a5a0d0, 24, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a0d0, 24, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0d0, 0, 24, 1, 0xa5a5a525a5a5a0d0) + EXT( 0xa5a5a5a5a5a5a0cf, 24, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a0cf, 24, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a0cf, 1, 24, 2, 0xa5a5a565a5a5a0cf) + EXT( 0xa5a5a5a5a5a5a0ce, 24, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a0ce, 24, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a0ce, 3, 24, 3, 0xa5a5a565a5a5a0ce) + EXT( 0xa5a5a5a5a5a5a0cd, 24, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a5a0cd, 24, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a5a0cd, 7, 24, 4, 0xa5a5a575a5a5a0cd) + EXT( 0xa5a5a5a5a5a5a0cc, 24, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a5a0cc, 24, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a5a0cc, 15, 24, 5, 0xa5a5a57da5a5a0cc) + EXT( 0xa5a5a5a5a5a5a0cb, 24, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a5a0cb, 24, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a5a0cb, 31, 24, 6, 0xa5a5a57da5a5a0cb) + EXT( 0xa5a5a5a5a5a5a0ca, 24, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a5a0ca, 24, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a5a0ca, 63, 24, 7, 0xa5a5a57fa5a5a0ca) + EXT( 0xa5a5a5a5a5a5a0c9, 24, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a5a0c9, 24, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a5a0c9, 127, 24, 8, 0xa5a5a57fa5a5a0c9) + EXT( 0xa5a5a5a5a5a5a0c8, 24, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a5a0c8, 24, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a5a0c8, 255, 24, 9, 0xa5a5a57fa5a5a0c8) + EXT( 0xa5a5a5a5a5a5a0c7, 24, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a5a0c7, 24, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a5a0c7, 511, 24, 10, 0xa5a5a57fe5a5a0c7) + EXT( 0xa5a5a5a5a5a5a0c6, 24, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a5a0c6, 24, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a5a0c6, 1023, 24, 11, 0xa5a5a57fe5a5a0c6) + EXT( 0xa5a5a5a5a5a5a0c5, 24, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a5a0c5, 24, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a5a0c5, 2047, 24, 12, 0xa5a5a57ff5a5a0c5) + EXT( 0xa5a5a5a5a5a5a0c4, 24, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a5a0c4, 24, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a5a0c4, 4095, 24, 13, 0xa5a5a57ffda5a0c4) + EXT( 0xa5a5a5a5a5a5a0c3, 24, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a5a0c3, 24, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a5a0c3, 8191, 24, 14, 0xa5a5a57ffda5a0c3) + EXT( 0xa5a5a5a5a5a5a0c2, 24, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a5a0c2, 24, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a5a0c2, 16383, 24, 15, 0xa5a5a57fffa5a0c2) + EXT( 0xa5a5a5a5a5a5a0c1, 24, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a5a0c1, 24, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a5a0c1, 32767, 24, 16, 0xa5a5a57fffa5a0c1) + EXT( 0xa5a5a5a5a5a5a0c0, 24, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a5a0c0, 24, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a5a0c0, 65535, 24, 17, 0xa5a5a57fffa5a0c0) + EXT( 0xa5a5a5a5a5a5a0bf, 24, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a5a0bf, 24, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a5a0bf, 131071, 24, 18, 0xa5a5a57fffe5a0bf) + EXT( 0xa5a5a5a5a5a5a0be, 24, 19, 0xfffffffffffd2d2d) + EXTU(0xa5a5a5a5a5a5a0be, 24, 19, 0x0000000000052d2d) + DEP( 0xa5a5a5a5a5a5a0be, 262143, 24, 19, 0xa5a5a57fffe5a0be) + EXT( 0xa5a5a5a5a5a5a0bd, 24, 20, 0xfffffffffffa5a5a) + EXTU(0xa5a5a5a5a5a5a0bd, 24, 20, 0x00000000000a5a5a) + DEP( 0xa5a5a5a5a5a5a0bd, 524287, 24, 20, 0xa5a5a57ffff5a0bd) + EXT( 0xa5a5a5a5a5a5a0bc, 24, 21, 0xfffffffffff4b4b4) + EXTU(0xa5a5a5a5a5a5a0bc, 24, 21, 0x000000000014b4b4) + DEP( 0xa5a5a5a5a5a5a0bc, 1048575, 24, 21, 0xa5a5a57ffffda0bc) + EXT( 0xa5a5a5a5a5a5a0bb, 24, 22, 0xffffffffffe96969) + EXTU(0xa5a5a5a5a5a5a0bb, 24, 22, 0x0000000000296969) + DEP( 0xa5a5a5a5a5a5a0bb, 2097151, 24, 22, 0xa5a5a57ffffda0bb) + EXT( 0xa5a5a5a5a5a5a0ba, 24, 23, 0xffffffffffd2d2d2) + EXTU(0xa5a5a5a5a5a5a0ba, 24, 23, 0x000000000052d2d2) + DEP( 0xa5a5a5a5a5a5a0ba, 4194303, 24, 23, 0xa5a5a57fffffa0ba) + EXT( 0xa5a5a5a5a5a5a0b9, 24, 24, 0xffffffffffa5a5a5) + EXTU(0xa5a5a5a5a5a5a0b9, 24, 24, 0x0000000000a5a5a5) + DEP( 0xa5a5a5a5a5a5a0b9, 8388607, 24, 24, 0xa5a5a57fffffa0b9) + EXT( 0xa5a5a5a5a5a5a0b8, 24, 25, 0xffffffffff4b4b4b) + EXTU(0xa5a5a5a5a5a5a0b8, 24, 25, 0x00000000014b4b4b) + DEP( 0xa5a5a5a5a5a5a0b8, 16777215, 24, 25, 0xa5a5a57fffffa0b8) + EXT( 0xa5a5a5a5a5a5a0b7, 24, 26, 0xfffffffffe969696) + EXTU(0xa5a5a5a5a5a5a0b7, 24, 26, 0x0000000002969696) + DEP( 0xa5a5a5a5a5a5a0b7, 33554431, 24, 26, 0xa5a5a57fffffe0b7) + EXT( 0xa5a5a5a5a5a5a0b6, 24, 27, 0xfffffffffd2d2d2d) + EXTU(0xa5a5a5a5a5a5a0b6, 24, 27, 0x00000000052d2d2d) + DEP( 0xa5a5a5a5a5a5a0b6, 67108863, 24, 27, 0xa5a5a57fffffe0b6) + EXT( 0xa5a5a5a5a5a5a0b5, 24, 28, 0xfffffffffa5a5a5a) + EXTU(0xa5a5a5a5a5a5a0b5, 24, 28, 0x000000000a5a5a5a) + DEP( 0xa5a5a5a5a5a5a0b5, 134217727, 24, 28, 0xa5a5a57ffffff0b5) + EXT( 0xa5a5a5a5a5a5a0b4, 24, 29, 0xfffffffff4b4b4b4) + EXTU(0xa5a5a5a5a5a5a0b4, 24, 29, 0x0000000014b4b4b4) + DEP( 0xa5a5a5a5a5a5a0b4, 268435455, 24, 29, 0xa5a5a57ffffff8b4) + EXT( 0xa5a5a5a5a5a5a0b3, 24, 30, 0xffffffffe9696968) + EXTU(0xa5a5a5a5a5a5a0b3, 24, 30, 0x0000000029696968) + DEP( 0xa5a5a5a5a5a5a0b3, 536870911, 24, 30, 0xa5a5a57ffffffcb3) + EXT( 0xa5a5a5a5a5a5a0b2, 24, 31, 0xffffffffd2d2d2d0) + EXTU(0xa5a5a5a5a5a5a0b2, 24, 31, 0x0000000052d2d2d0) + DEP( 0xa5a5a5a5a5a5a0b2, 1073741823, 24, 31, 0xa5a5a57ffffffeb2) + EXT( 0xa5a5a5a5a5a5a0b1, 24, 32, 0xffffffffa5a5a5a0) + EXTU(0xa5a5a5a5a5a5a0b1, 24, 32, 0x00000000a5a5a5a0) + DEP( 0xa5a5a5a5a5a5a0b1, 2147483647, 24, 32, 0xa5a5a57fffffffb1) + EXT( 0xa5a5a5a5a5a5a0b0, 24, 33, 0xffffffff4b4b4b41) + EXTU(0xa5a5a5a5a5a5a0b0, 24, 33, 0x000000014b4b4b41) + DEP( 0xa5a5a5a5a5a5a0b0, 4294967295, 24, 33, 0xa5a5a57fffffffb0) + EXT( 0xa5a5a5a5a5a5a0af, 24, 34, 0xfffffffe96969682) + EXTU(0xa5a5a5a5a5a5a0af, 24, 34, 0x0000000296969682) + DEP( 0xa5a5a5a5a5a5a0af, 8589934591, 24, 34, 0xa5a5a57fffffffef) + EXT( 0xa5a5a5a5a5a5a0ae, 24, 35, 0xfffffffd2d2d2d05) + EXTU(0xa5a5a5a5a5a5a0ae, 24, 35, 0x000000052d2d2d05) + DEP( 0xa5a5a5a5a5a5a0ae, 17179869183, 24, 35, 0xa5a5a57fffffffee) + EXT( 0xa5a5a5a5a5a5a0ad, 24, 36, 0xfffffffa5a5a5a0a) + EXTU(0xa5a5a5a5a5a5a0ad, 24, 36, 0x0000000a5a5a5a0a) + DEP( 0xa5a5a5a5a5a5a0ad, 34359738367, 24, 36, 0xa5a5a57ffffffffd) + EXT( 0xa5a5a5a5a5a5a0ac, 24, 37, 0xfffffff4b4b4b415) + EXTU(0xa5a5a5a5a5a5a0ac, 24, 37, 0x00000014b4b4b415) + DEP( 0xa5a5a5a5a5a5a0ac, 68719476735, 24, 37, 0xa5a5a57ffffffffc) + EXT( 0xa5a5a5a5a5a5a0ab, 24, 38, 0xffffffe96969682a) + EXTU(0xa5a5a5a5a5a5a0ab, 24, 38, 0x000000296969682a) + DEP( 0xa5a5a5a5a5a5a0ab, 137438953471, 24, 38, 0xa5a5a57fffffffff) + EXT( 0xa5a5a5a5a5a5a0aa, 24, 39, 0xffffffd2d2d2d055) + EXTU(0xa5a5a5a5a5a5a0aa, 24, 39, 0x00000052d2d2d055) + DEP( 0xa5a5a5a5a5a5a0aa, 274877906943, 24, 39, 0xa5a5a57ffffffffe) + EXT( 0xa5a5a5a5a5a5a0a9, 25, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a0a9, 25, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a0a9, 0, 25, 1, 0xa5a5a5a5a5a5a0a9) + EXT( 0xa5a5a5a5a5a5a0a8, 25, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a0a8, 25, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a0a8, 1, 25, 2, 0xa5a5a5a5a5a5a0a8) + EXT( 0xa5a5a5a5a5a5a0a7, 25, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a0a7, 25, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a0a7, 3, 25, 3, 0xa5a5a5b5a5a5a0a7) + EXT( 0xa5a5a5a5a5a5a0a6, 25, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a5a0a6, 25, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a0a6, 7, 25, 4, 0xa5a5a5bda5a5a0a6) + EXT( 0xa5a5a5a5a5a5a0a5, 25, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a5a0a5, 25, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a0a5, 15, 25, 5, 0xa5a5a5bda5a5a0a5) + EXT( 0xa5a5a5a5a5a5a0a4, 25, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a5a0a4, 25, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a0a4, 31, 25, 6, 0xa5a5a5bfa5a5a0a4) + EXT( 0xa5a5a5a5a5a5a0a3, 25, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a5a0a3, 25, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a0a3, 63, 25, 7, 0xa5a5a5bfa5a5a0a3) + EXT( 0xa5a5a5a5a5a5a0a2, 25, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a5a0a2, 25, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a0a2, 127, 25, 8, 0xa5a5a5bfa5a5a0a2) + EXT( 0xa5a5a5a5a5a5a0a1, 25, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a5a0a1, 25, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a0a1, 255, 25, 9, 0xa5a5a5bfe5a5a0a1) + EXT( 0xa5a5a5a5a5a5a0a0, 25, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a5a0a0, 25, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a0a0, 511, 25, 10, 0xa5a5a5bfe5a5a0a0) + EXT( 0xa5a5a5a5a5a5a09f, 25, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a5a09f, 25, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a09f, 1023, 25, 11, 0xa5a5a5bff5a5a09f) + EXT( 0xa5a5a5a5a5a5a09e, 25, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a5a09e, 25, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a09e, 2047, 25, 12, 0xa5a5a5bffda5a09e) + EXT( 0xa5a5a5a5a5a5a09d, 25, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a5a09d, 25, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a09d, 4095, 25, 13, 0xa5a5a5bffda5a09d) + EXT( 0xa5a5a5a5a5a5a09c, 25, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a5a09c, 25, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a09c, 8191, 25, 14, 0xa5a5a5bfffa5a09c) + EXT( 0xa5a5a5a5a5a5a09b, 25, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a5a09b, 25, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a09b, 16383, 25, 15, 0xa5a5a5bfffa5a09b) + EXT( 0xa5a5a5a5a5a5a09a, 25, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a5a09a, 25, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a09a, 32767, 25, 16, 0xa5a5a5bfffa5a09a) + EXT( 0xa5a5a5a5a5a5a099, 25, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a5a099, 25, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a099, 65535, 25, 17, 0xa5a5a5bfffe5a099) + EXT( 0xa5a5a5a5a5a5a098, 25, 18, 0x0000000000012d2d) + EXTU(0xa5a5a5a5a5a5a098, 25, 18, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a098, 131071, 25, 18, 0xa5a5a5bfffe5a098) + EXT( 0xa5a5a5a5a5a5a097, 25, 19, 0x0000000000025a5a) + EXTU(0xa5a5a5a5a5a5a097, 25, 19, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a097, 262143, 25, 19, 0xa5a5a5bffff5a097) + EXT( 0xa5a5a5a5a5a5a096, 25, 20, 0x000000000004b4b4) + EXTU(0xa5a5a5a5a5a5a096, 25, 20, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a096, 524287, 25, 20, 0xa5a5a5bffffda096) + EXT( 0xa5a5a5a5a5a5a095, 25, 21, 0x0000000000096969) + EXTU(0xa5a5a5a5a5a5a095, 25, 21, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a095, 1048575, 25, 21, 0xa5a5a5bffffda095) + EXT( 0xa5a5a5a5a5a5a094, 25, 22, 0x000000000012d2d2) + EXTU(0xa5a5a5a5a5a5a094, 25, 22, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a094, 2097151, 25, 22, 0xa5a5a5bfffffa094) + EXT( 0xa5a5a5a5a5a5a093, 25, 23, 0x000000000025a5a5) + EXTU(0xa5a5a5a5a5a5a093, 25, 23, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a093, 4194303, 25, 23, 0xa5a5a5bfffffa093) + EXT( 0xa5a5a5a5a5a5a092, 25, 24, 0x00000000004b4b4b) + EXTU(0xa5a5a5a5a5a5a092, 25, 24, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a092, 8388607, 25, 24, 0xa5a5a5bfffffa092) + EXT( 0xa5a5a5a5a5a5a091, 25, 25, 0x0000000000969696) + EXTU(0xa5a5a5a5a5a5a091, 25, 25, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a091, 16777215, 25, 25, 0xa5a5a5bfffffe091) + EXT( 0xa5a5a5a5a5a5a090, 25, 26, 0x00000000012d2d2d) + EXTU(0xa5a5a5a5a5a5a090, 25, 26, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a090, 33554431, 25, 26, 0xa5a5a5bfffffe090) + EXT( 0xa5a5a5a5a5a5a08f, 25, 27, 0x00000000025a5a5a) + EXTU(0xa5a5a5a5a5a5a08f, 25, 27, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a08f, 67108863, 25, 27, 0xa5a5a5bffffff08f) + EXT( 0xa5a5a5a5a5a5a08e, 25, 28, 0x0000000004b4b4b4) + EXTU(0xa5a5a5a5a5a5a08e, 25, 28, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a08e, 134217727, 25, 28, 0xa5a5a5bffffff88e) + EXT( 0xa5a5a5a5a5a5a08d, 25, 29, 0x0000000009696968) + EXTU(0xa5a5a5a5a5a5a08d, 25, 29, 0x0000000009696968) + DEP( 0xa5a5a5a5a5a5a08d, 268435455, 25, 29, 0xa5a5a5bffffffc8d) + EXT( 0xa5a5a5a5a5a5a08c, 25, 30, 0x0000000012d2d2d0) + EXTU(0xa5a5a5a5a5a5a08c, 25, 30, 0x0000000012d2d2d0) + DEP( 0xa5a5a5a5a5a5a08c, 536870911, 25, 30, 0xa5a5a5bffffffe8c) + EXT( 0xa5a5a5a5a5a5a08b, 25, 31, 0x0000000025a5a5a0) + EXTU(0xa5a5a5a5a5a5a08b, 25, 31, 0x0000000025a5a5a0) + DEP( 0xa5a5a5a5a5a5a08b, 1073741823, 25, 31, 0xa5a5a5bfffffff8b) + EXT( 0xa5a5a5a5a5a5a08a, 25, 32, 0x000000004b4b4b41) + EXTU(0xa5a5a5a5a5a5a08a, 25, 32, 0x000000004b4b4b41) + DEP( 0xa5a5a5a5a5a5a08a, 2147483647, 25, 32, 0xa5a5a5bfffffff8a) + EXT( 0xa5a5a5a5a5a5a089, 25, 33, 0x0000000096969682) + EXTU(0xa5a5a5a5a5a5a089, 25, 33, 0x0000000096969682) + DEP( 0xa5a5a5a5a5a5a089, 4294967295, 25, 33, 0xa5a5a5bfffffffc9) + EXT( 0xa5a5a5a5a5a5a088, 25, 34, 0x000000012d2d2d04) + EXTU(0xa5a5a5a5a5a5a088, 25, 34, 0x000000012d2d2d04) + DEP( 0xa5a5a5a5a5a5a088, 8589934591, 25, 34, 0xa5a5a5bfffffffe8) + EXT( 0xa5a5a5a5a5a5a087, 25, 35, 0x000000025a5a5a08) + EXTU(0xa5a5a5a5a5a5a087, 25, 35, 0x000000025a5a5a08) + DEP( 0xa5a5a5a5a5a5a087, 17179869183, 25, 35, 0xa5a5a5bffffffff7) + EXT( 0xa5a5a5a5a5a5a086, 25, 36, 0x00000004b4b4b410) + EXTU(0xa5a5a5a5a5a5a086, 25, 36, 0x00000004b4b4b410) + DEP( 0xa5a5a5a5a5a5a086, 34359738367, 25, 36, 0xa5a5a5bffffffffe) + EXT( 0xa5a5a5a5a5a5a085, 25, 37, 0x0000000969696821) + EXTU(0xa5a5a5a5a5a5a085, 25, 37, 0x0000000969696821) + DEP( 0xa5a5a5a5a5a5a085, 68719476735, 25, 37, 0xa5a5a5bffffffffd) + EXT( 0xa5a5a5a5a5a5a084, 25, 38, 0x00000012d2d2d042) + EXTU(0xa5a5a5a5a5a5a084, 25, 38, 0x00000012d2d2d042) + DEP( 0xa5a5a5a5a5a5a084, 137438953471, 25, 38, 0xa5a5a5bffffffffe) + EXT( 0xa5a5a5a5a5a5a083, 26, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a083, 26, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a083, 0, 26, 1, 0xa5a5a585a5a5a083) + EXT( 0xa5a5a5a5a5a5a082, 26, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a082, 26, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a082, 1, 26, 2, 0xa5a5a595a5a5a082) + EXT( 0xa5a5a5a5a5a5a081, 26, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a5a081, 26, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a5a081, 3, 26, 3, 0xa5a5a59da5a5a081) + EXT( 0xa5a5a5a5a5a5a080, 26, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a5a080, 26, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a5a080, 7, 26, 4, 0xa5a5a59da5a5a080) + EXT( 0xa5a5a5a5a5a5a07f, 26, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a5a07f, 26, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a5a07f, 15, 26, 5, 0xa5a5a59fa5a5a07f) + EXT( 0xa5a5a5a5a5a5a07e, 26, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a5a07e, 26, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a5a07e, 31, 26, 6, 0xa5a5a59fa5a5a07e) + EXT( 0xa5a5a5a5a5a5a07d, 26, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a5a07d, 26, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a5a07d, 63, 26, 7, 0xa5a5a59fa5a5a07d) + EXT( 0xa5a5a5a5a5a5a07c, 26, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a5a07c, 26, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a5a07c, 127, 26, 8, 0xa5a5a59fe5a5a07c) + EXT( 0xa5a5a5a5a5a5a07b, 26, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a5a07b, 26, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a5a07b, 255, 26, 9, 0xa5a5a59fe5a5a07b) + EXT( 0xa5a5a5a5a5a5a07a, 26, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a5a07a, 26, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a5a07a, 511, 26, 10, 0xa5a5a59ff5a5a07a) + EXT( 0xa5a5a5a5a5a5a079, 26, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a5a079, 26, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a5a079, 1023, 26, 11, 0xa5a5a59ffda5a079) + EXT( 0xa5a5a5a5a5a5a078, 26, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a5a078, 26, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a5a078, 2047, 26, 12, 0xa5a5a59ffda5a078) + EXT( 0xa5a5a5a5a5a5a077, 26, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a5a077, 26, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a5a077, 4095, 26, 13, 0xa5a5a59fffa5a077) + EXT( 0xa5a5a5a5a5a5a076, 26, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a5a076, 26, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a5a076, 8191, 26, 14, 0xa5a5a59fffa5a076) + EXT( 0xa5a5a5a5a5a5a075, 26, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a5a075, 26, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a5a075, 16383, 26, 15, 0xa5a5a59fffa5a075) + EXT( 0xa5a5a5a5a5a5a074, 26, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a5a074, 26, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a5a074, 32767, 26, 16, 0xa5a5a59fffe5a074) + EXT( 0xa5a5a5a5a5a5a073, 26, 17, 0xffffffffffff2d2d) + EXTU(0xa5a5a5a5a5a5a073, 26, 17, 0x0000000000012d2d) + DEP( 0xa5a5a5a5a5a5a073, 65535, 26, 17, 0xa5a5a59fffe5a073) + EXT( 0xa5a5a5a5a5a5a072, 26, 18, 0xfffffffffffe5a5a) + EXTU(0xa5a5a5a5a5a5a072, 26, 18, 0x0000000000025a5a) + DEP( 0xa5a5a5a5a5a5a072, 131071, 26, 18, 0xa5a5a59ffff5a072) + EXT( 0xa5a5a5a5a5a5a071, 26, 19, 0xfffffffffffcb4b4) + EXTU(0xa5a5a5a5a5a5a071, 26, 19, 0x000000000004b4b4) + DEP( 0xa5a5a5a5a5a5a071, 262143, 26, 19, 0xa5a5a59ffffda071) + EXT( 0xa5a5a5a5a5a5a070, 26, 20, 0xfffffffffff96969) + EXTU(0xa5a5a5a5a5a5a070, 26, 20, 0x0000000000096969) + DEP( 0xa5a5a5a5a5a5a070, 524287, 26, 20, 0xa5a5a59ffffda070) + EXT( 0xa5a5a5a5a5a5a06f, 26, 21, 0xfffffffffff2d2d2) + EXTU(0xa5a5a5a5a5a5a06f, 26, 21, 0x000000000012d2d2) + DEP( 0xa5a5a5a5a5a5a06f, 1048575, 26, 21, 0xa5a5a59fffffa06f) + EXT( 0xa5a5a5a5a5a5a06e, 26, 22, 0xffffffffffe5a5a5) + EXTU(0xa5a5a5a5a5a5a06e, 26, 22, 0x000000000025a5a5) + DEP( 0xa5a5a5a5a5a5a06e, 2097151, 26, 22, 0xa5a5a59fffffa06e) + EXT( 0xa5a5a5a5a5a5a06d, 26, 23, 0xffffffffffcb4b4b) + EXTU(0xa5a5a5a5a5a5a06d, 26, 23, 0x00000000004b4b4b) + DEP( 0xa5a5a5a5a5a5a06d, 4194303, 26, 23, 0xa5a5a59fffffa06d) + EXT( 0xa5a5a5a5a5a5a06c, 26, 24, 0xffffffffff969696) + EXTU(0xa5a5a5a5a5a5a06c, 26, 24, 0x0000000000969696) + DEP( 0xa5a5a5a5a5a5a06c, 8388607, 26, 24, 0xa5a5a59fffffe06c) + EXT( 0xa5a5a5a5a5a5a06b, 26, 25, 0xffffffffff2d2d2d) + EXTU(0xa5a5a5a5a5a5a06b, 26, 25, 0x00000000012d2d2d) + DEP( 0xa5a5a5a5a5a5a06b, 16777215, 26, 25, 0xa5a5a59fffffe06b) + EXT( 0xa5a5a5a5a5a5a06a, 26, 26, 0xfffffffffe5a5a5a) + EXTU(0xa5a5a5a5a5a5a06a, 26, 26, 0x00000000025a5a5a) + DEP( 0xa5a5a5a5a5a5a06a, 33554431, 26, 26, 0xa5a5a59ffffff06a) + EXT( 0xa5a5a5a5a5a5a069, 26, 27, 0xfffffffffcb4b4b4) + EXTU(0xa5a5a5a5a5a5a069, 26, 27, 0x0000000004b4b4b4) + DEP( 0xa5a5a5a5a5a5a069, 67108863, 26, 27, 0xa5a5a59ffffff869) + EXT( 0xa5a5a5a5a5a5a068, 26, 28, 0xfffffffff9696968) + EXTU(0xa5a5a5a5a5a5a068, 26, 28, 0x0000000009696968) + DEP( 0xa5a5a5a5a5a5a068, 134217727, 26, 28, 0xa5a5a59ffffffc68) + EXT( 0xa5a5a5a5a5a5a067, 26, 29, 0xfffffffff2d2d2d0) + EXTU(0xa5a5a5a5a5a5a067, 26, 29, 0x0000000012d2d2d0) + DEP( 0xa5a5a5a5a5a5a067, 268435455, 26, 29, 0xa5a5a59ffffffe67) + EXT( 0xa5a5a5a5a5a5a066, 26, 30, 0xffffffffe5a5a5a0) + EXTU(0xa5a5a5a5a5a5a066, 26, 30, 0x0000000025a5a5a0) + DEP( 0xa5a5a5a5a5a5a066, 536870911, 26, 30, 0xa5a5a59fffffff66) + EXT( 0xa5a5a5a5a5a5a065, 26, 31, 0xffffffffcb4b4b40) + EXTU(0xa5a5a5a5a5a5a065, 26, 31, 0x000000004b4b4b40) + DEP( 0xa5a5a5a5a5a5a065, 1073741823, 26, 31, 0xa5a5a59fffffffe5) + EXT( 0xa5a5a5a5a5a5a064, 26, 32, 0xffffffff96969681) + EXTU(0xa5a5a5a5a5a5a064, 26, 32, 0x0000000096969681) + DEP( 0xa5a5a5a5a5a5a064, 2147483647, 26, 32, 0xa5a5a59fffffffe4) + EXT( 0xa5a5a5a5a5a5a063, 26, 33, 0xffffffff2d2d2d03) + EXTU(0xa5a5a5a5a5a5a063, 26, 33, 0x000000012d2d2d03) + DEP( 0xa5a5a5a5a5a5a063, 4294967295, 26, 33, 0xa5a5a59fffffffe3) + EXT( 0xa5a5a5a5a5a5a062, 26, 34, 0xfffffffe5a5a5a06) + EXTU(0xa5a5a5a5a5a5a062, 26, 34, 0x000000025a5a5a06) + DEP( 0xa5a5a5a5a5a5a062, 8589934591, 26, 34, 0xa5a5a59ffffffff2) + EXT( 0xa5a5a5a5a5a5a061, 26, 35, 0xfffffffcb4b4b40c) + EXTU(0xa5a5a5a5a5a5a061, 26, 35, 0x00000004b4b4b40c) + DEP( 0xa5a5a5a5a5a5a061, 17179869183, 26, 35, 0xa5a5a59ffffffff9) + EXT( 0xa5a5a5a5a5a5a060, 26, 36, 0xfffffff969696818) + EXTU(0xa5a5a5a5a5a5a060, 26, 36, 0x0000000969696818) + DEP( 0xa5a5a5a5a5a5a060, 34359738367, 26, 36, 0xa5a5a59ffffffffc) + EXT( 0xa5a5a5a5a5a5a05f, 26, 37, 0xfffffff2d2d2d02f) + EXTU(0xa5a5a5a5a5a5a05f, 26, 37, 0x00000012d2d2d02f) + DEP( 0xa5a5a5a5a5a5a05f, 68719476735, 26, 37, 0xa5a5a59fffffffff) + EXT( 0xa5a5a5a5a5a5a05e, 27, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a05e, 27, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a05e, 0, 27, 1, 0xa5a5a5a5a5a5a05e) + EXT( 0xa5a5a5a5a5a5a05d, 27, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a05d, 27, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a05d, 1, 27, 2, 0xa5a5a5ada5a5a05d) + EXT( 0xa5a5a5a5a5a5a05c, 27, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a05c, 27, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a05c, 3, 27, 3, 0xa5a5a5ada5a5a05c) + EXT( 0xa5a5a5a5a5a5a05b, 27, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a05b, 27, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a05b, 7, 27, 4, 0xa5a5a5afa5a5a05b) + EXT( 0xa5a5a5a5a5a5a05a, 27, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a05a, 27, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a05a, 15, 27, 5, 0xa5a5a5afa5a5a05a) + EXT( 0xa5a5a5a5a5a5a059, 27, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a059, 27, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a059, 31, 27, 6, 0xa5a5a5afa5a5a059) + EXT( 0xa5a5a5a5a5a5a058, 27, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a058, 27, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a058, 63, 27, 7, 0xa5a5a5afe5a5a058) + EXT( 0xa5a5a5a5a5a5a057, 27, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a057, 27, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a057, 127, 27, 8, 0xa5a5a5afe5a5a057) + EXT( 0xa5a5a5a5a5a5a056, 27, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a056, 27, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a056, 255, 27, 9, 0xa5a5a5aff5a5a056) + EXT( 0xa5a5a5a5a5a5a055, 27, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a055, 27, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a055, 511, 27, 10, 0xa5a5a5affda5a055) + EXT( 0xa5a5a5a5a5a5a054, 27, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a054, 27, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a054, 1023, 27, 11, 0xa5a5a5affda5a054) + EXT( 0xa5a5a5a5a5a5a053, 27, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a053, 27, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a053, 2047, 27, 12, 0xa5a5a5afffa5a053) + EXT( 0xa5a5a5a5a5a5a052, 27, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a052, 27, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a052, 4095, 27, 13, 0xa5a5a5afffa5a052) + EXT( 0xa5a5a5a5a5a5a051, 27, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a051, 27, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a051, 8191, 27, 14, 0xa5a5a5afffa5a051) + EXT( 0xa5a5a5a5a5a5a050, 27, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a050, 27, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a050, 16383, 27, 15, 0xa5a5a5afffe5a050) + EXT( 0xa5a5a5a5a5a5a04f, 27, 16, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a04f, 27, 16, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a04f, 32767, 27, 16, 0xa5a5a5afffe5a04f) + EXT( 0xa5a5a5a5a5a5a04e, 27, 17, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a04e, 27, 17, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a04e, 65535, 27, 17, 0xa5a5a5affff5a04e) + EXT( 0xa5a5a5a5a5a5a04d, 27, 18, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a04d, 27, 18, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a04d, 131071, 27, 18, 0xa5a5a5affffda04d) + EXT( 0xa5a5a5a5a5a5a04c, 27, 19, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a04c, 27, 19, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a04c, 262143, 27, 19, 0xa5a5a5affffda04c) + EXT( 0xa5a5a5a5a5a5a04b, 27, 20, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a04b, 27, 20, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a04b, 524287, 27, 20, 0xa5a5a5afffffa04b) + EXT( 0xa5a5a5a5a5a5a04a, 27, 21, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a04a, 27, 21, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a04a, 1048575, 27, 21, 0xa5a5a5afffffa04a) + EXT( 0xa5a5a5a5a5a5a049, 27, 22, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a049, 27, 22, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a049, 2097151, 27, 22, 0xa5a5a5afffffa049) + EXT( 0xa5a5a5a5a5a5a048, 27, 23, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a048, 27, 23, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a048, 4194303, 27, 23, 0xa5a5a5afffffe048) + EXT( 0xa5a5a5a5a5a5a047, 27, 24, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a047, 27, 24, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a047, 8388607, 27, 24, 0xa5a5a5afffffe047) + EXT( 0xa5a5a5a5a5a5a046, 27, 25, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a046, 27, 25, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a046, 16777215, 27, 25, 0xa5a5a5affffff046) + EXT( 0xa5a5a5a5a5a5a045, 27, 26, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a045, 27, 26, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a045, 33554431, 27, 26, 0xa5a5a5affffff845) + EXT( 0xa5a5a5a5a5a5a044, 27, 27, 0x0000000001696968) + EXTU(0xa5a5a5a5a5a5a044, 27, 27, 0x0000000001696968) + DEP( 0xa5a5a5a5a5a5a044, 67108863, 27, 27, 0xa5a5a5affffffc44) + EXT( 0xa5a5a5a5a5a5a043, 27, 28, 0x0000000002d2d2d0) + EXTU(0xa5a5a5a5a5a5a043, 27, 28, 0x0000000002d2d2d0) + DEP( 0xa5a5a5a5a5a5a043, 134217727, 27, 28, 0xa5a5a5affffffe43) + EXT( 0xa5a5a5a5a5a5a042, 27, 29, 0x0000000005a5a5a0) + EXTU(0xa5a5a5a5a5a5a042, 27, 29, 0x0000000005a5a5a0) + DEP( 0xa5a5a5a5a5a5a042, 268435455, 27, 29, 0xa5a5a5afffffff42) + EXT( 0xa5a5a5a5a5a5a041, 27, 30, 0x000000000b4b4b40) + EXTU(0xa5a5a5a5a5a5a041, 27, 30, 0x000000000b4b4b40) + DEP( 0xa5a5a5a5a5a5a041, 536870911, 27, 30, 0xa5a5a5afffffffc1) + EXT( 0xa5a5a5a5a5a5a040, 27, 31, 0x0000000016969681) + EXTU(0xa5a5a5a5a5a5a040, 27, 31, 0x0000000016969681) + DEP( 0xa5a5a5a5a5a5a040, 1073741823, 27, 31, 0xa5a5a5afffffffc0) + EXT( 0xa5a5a5a5a5a5a03f, 27, 32, 0x000000002d2d2d01) + EXTU(0xa5a5a5a5a5a5a03f, 27, 32, 0x000000002d2d2d01) + DEP( 0xa5a5a5a5a5a5a03f, 2147483647, 27, 32, 0xa5a5a5afffffffff) + EXT( 0xa5a5a5a5a5a5a03e, 27, 33, 0x000000005a5a5a03) + EXTU(0xa5a5a5a5a5a5a03e, 27, 33, 0x000000005a5a5a03) + DEP( 0xa5a5a5a5a5a5a03e, 4294967295, 27, 33, 0xa5a5a5affffffffe) + EXT( 0xa5a5a5a5a5a5a03d, 27, 34, 0x00000000b4b4b407) + EXTU(0xa5a5a5a5a5a5a03d, 27, 34, 0x00000000b4b4b407) + DEP( 0xa5a5a5a5a5a5a03d, 8589934591, 27, 34, 0xa5a5a5affffffffd) + EXT( 0xa5a5a5a5a5a5a03c, 27, 35, 0x000000016969680f) + EXTU(0xa5a5a5a5a5a5a03c, 27, 35, 0x000000016969680f) + DEP( 0xa5a5a5a5a5a5a03c, 17179869183, 27, 35, 0xa5a5a5affffffffc) + EXT( 0xa5a5a5a5a5a5a03b, 27, 36, 0x00000002d2d2d01d) + EXTU(0xa5a5a5a5a5a5a03b, 27, 36, 0x00000002d2d2d01d) + DEP( 0xa5a5a5a5a5a5a03b, 34359738367, 27, 36, 0xa5a5a5afffffffff) + EXT( 0xa5a5a5a5a5a5a03a, 28, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a5a03a, 28, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a5a03a, 0, 28, 1, 0xa5a5a5a5a5a5a03a) + EXT( 0xa5a5a5a5a5a5a039, 28, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a5a039, 28, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a039, 1, 28, 2, 0xa5a5a5a5a5a5a039) + EXT( 0xa5a5a5a5a5a5a038, 28, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a5a038, 28, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a038, 3, 28, 3, 0xa5a5a5a7a5a5a038) + EXT( 0xa5a5a5a5a5a5a037, 28, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a5a037, 28, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a037, 7, 28, 4, 0xa5a5a5a7a5a5a037) + EXT( 0xa5a5a5a5a5a5a036, 28, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a5a036, 28, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a036, 15, 28, 5, 0xa5a5a5a7a5a5a036) + EXT( 0xa5a5a5a5a5a5a035, 28, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a5a035, 28, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a035, 31, 28, 6, 0xa5a5a5a7e5a5a035) + EXT( 0xa5a5a5a5a5a5a034, 28, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a5a034, 28, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a034, 63, 28, 7, 0xa5a5a5a7e5a5a034) + EXT( 0xa5a5a5a5a5a5a033, 28, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a5a033, 28, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a033, 127, 28, 8, 0xa5a5a5a7f5a5a033) + EXT( 0xa5a5a5a5a5a5a032, 28, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a5a032, 28, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a032, 255, 28, 9, 0xa5a5a5a7fda5a032) + EXT( 0xa5a5a5a5a5a5a031, 28, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a5a031, 28, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a031, 511, 28, 10, 0xa5a5a5a7fda5a031) + EXT( 0xa5a5a5a5a5a5a030, 28, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a5a030, 28, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a030, 1023, 28, 11, 0xa5a5a5a7ffa5a030) + EXT( 0xa5a5a5a5a5a5a02f, 28, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a5a02f, 28, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a02f, 2047, 28, 12, 0xa5a5a5a7ffa5a02f) + EXT( 0xa5a5a5a5a5a5a02e, 28, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a5a02e, 28, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a02e, 4095, 28, 13, 0xa5a5a5a7ffa5a02e) + EXT( 0xa5a5a5a5a5a5a02d, 28, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a5a02d, 28, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a02d, 8191, 28, 14, 0xa5a5a5a7ffe5a02d) + EXT( 0xa5a5a5a5a5a5a02c, 28, 15, 0x0000000000002d2d) + EXTU(0xa5a5a5a5a5a5a02c, 28, 15, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a02c, 16383, 28, 15, 0xa5a5a5a7ffe5a02c) + EXT( 0xa5a5a5a5a5a5a02b, 28, 16, 0x0000000000005a5a) + EXTU(0xa5a5a5a5a5a5a02b, 28, 16, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a02b, 32767, 28, 16, 0xa5a5a5a7fff5a02b) + EXT( 0xa5a5a5a5a5a5a02a, 28, 17, 0x000000000000b4b4) + EXTU(0xa5a5a5a5a5a5a02a, 28, 17, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a02a, 65535, 28, 17, 0xa5a5a5a7fffda02a) + EXT( 0xa5a5a5a5a5a5a029, 28, 18, 0x0000000000016969) + EXTU(0xa5a5a5a5a5a5a029, 28, 18, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a029, 131071, 28, 18, 0xa5a5a5a7fffda029) + EXT( 0xa5a5a5a5a5a5a028, 28, 19, 0x000000000002d2d2) + EXTU(0xa5a5a5a5a5a5a028, 28, 19, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a028, 262143, 28, 19, 0xa5a5a5a7ffffa028) + EXT( 0xa5a5a5a5a5a5a027, 28, 20, 0x000000000005a5a5) + EXTU(0xa5a5a5a5a5a5a027, 28, 20, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a027, 524287, 28, 20, 0xa5a5a5a7ffffa027) + EXT( 0xa5a5a5a5a5a5a026, 28, 21, 0x00000000000b4b4b) + EXTU(0xa5a5a5a5a5a5a026, 28, 21, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a026, 1048575, 28, 21, 0xa5a5a5a7ffffa026) + EXT( 0xa5a5a5a5a5a5a025, 28, 22, 0x0000000000169696) + EXTU(0xa5a5a5a5a5a5a025, 28, 22, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a025, 2097151, 28, 22, 0xa5a5a5a7ffffe025) + EXT( 0xa5a5a5a5a5a5a024, 28, 23, 0x00000000002d2d2d) + EXTU(0xa5a5a5a5a5a5a024, 28, 23, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a024, 4194303, 28, 23, 0xa5a5a5a7ffffe024) + EXT( 0xa5a5a5a5a5a5a023, 28, 24, 0x00000000005a5a5a) + EXTU(0xa5a5a5a5a5a5a023, 28, 24, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a023, 8388607, 28, 24, 0xa5a5a5a7fffff023) + EXT( 0xa5a5a5a5a5a5a022, 28, 25, 0x0000000000b4b4b4) + EXTU(0xa5a5a5a5a5a5a022, 28, 25, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a022, 16777215, 28, 25, 0xa5a5a5a7fffff822) + EXT( 0xa5a5a5a5a5a5a021, 28, 26, 0x0000000001696968) + EXTU(0xa5a5a5a5a5a5a021, 28, 26, 0x0000000001696968) + DEP( 0xa5a5a5a5a5a5a021, 33554431, 28, 26, 0xa5a5a5a7fffffc21) + EXT( 0xa5a5a5a5a5a5a020, 28, 27, 0x0000000002d2d2d0) + EXTU(0xa5a5a5a5a5a5a020, 28, 27, 0x0000000002d2d2d0) + DEP( 0xa5a5a5a5a5a5a020, 67108863, 28, 27, 0xa5a5a5a7fffffe20) + EXT( 0xa5a5a5a5a5a5a01f, 28, 28, 0x0000000005a5a5a0) + EXTU(0xa5a5a5a5a5a5a01f, 28, 28, 0x0000000005a5a5a0) + DEP( 0xa5a5a5a5a5a5a01f, 134217727, 28, 28, 0xa5a5a5a7ffffff1f) + EXT( 0xa5a5a5a5a5a5a01e, 28, 29, 0x000000000b4b4b40) + EXTU(0xa5a5a5a5a5a5a01e, 28, 29, 0x000000000b4b4b40) + DEP( 0xa5a5a5a5a5a5a01e, 268435455, 28, 29, 0xa5a5a5a7ffffff9e) + EXT( 0xa5a5a5a5a5a5a01d, 28, 30, 0x0000000016969680) + EXTU(0xa5a5a5a5a5a5a01d, 28, 30, 0x0000000016969680) + DEP( 0xa5a5a5a5a5a5a01d, 536870911, 28, 30, 0xa5a5a5a7ffffffdd) + EXT( 0xa5a5a5a5a5a5a01c, 28, 31, 0x000000002d2d2d00) + EXTU(0xa5a5a5a5a5a5a01c, 28, 31, 0x000000002d2d2d00) + DEP( 0xa5a5a5a5a5a5a01c, 1073741823, 28, 31, 0xa5a5a5a7fffffffc) + EXT( 0xa5a5a5a5a5a5a01b, 28, 32, 0x000000005a5a5a01) + EXTU(0xa5a5a5a5a5a5a01b, 28, 32, 0x000000005a5a5a01) + DEP( 0xa5a5a5a5a5a5a01b, 2147483647, 28, 32, 0xa5a5a5a7fffffffb) + EXT( 0xa5a5a5a5a5a5a01a, 28, 33, 0x00000000b4b4b403) + EXTU(0xa5a5a5a5a5a5a01a, 28, 33, 0x00000000b4b4b403) + DEP( 0xa5a5a5a5a5a5a01a, 4294967295, 28, 33, 0xa5a5a5a7fffffffa) + EXT( 0xa5a5a5a5a5a5a019, 28, 34, 0x0000000169696806) + EXTU(0xa5a5a5a5a5a5a019, 28, 34, 0x0000000169696806) + DEP( 0xa5a5a5a5a5a5a019, 8589934591, 28, 34, 0xa5a5a5a7fffffffd) + EXT( 0xa5a5a5a5a5a5a018, 28, 35, 0x00000002d2d2d00c) + EXTU(0xa5a5a5a5a5a5a018, 28, 35, 0x00000002d2d2d00c) + DEP( 0xa5a5a5a5a5a5a018, 17179869183, 28, 35, 0xa5a5a5a7fffffffe) + EXT( 0xa5a5a5a5a5a5a017, 29, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a5a017, 29, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a5a017, 0, 29, 1, 0xa5a5a5a1a5a5a017) + EXT( 0xa5a5a5a5a5a5a016, 29, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a5a016, 29, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a5a016, 1, 29, 2, 0xa5a5a5a3a5a5a016) + EXT( 0xa5a5a5a5a5a5a015, 29, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a5a015, 29, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a5a015, 3, 29, 3, 0xa5a5a5a3a5a5a015) + EXT( 0xa5a5a5a5a5a5a014, 29, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a5a014, 29, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a5a014, 7, 29, 4, 0xa5a5a5a3a5a5a014) + EXT( 0xa5a5a5a5a5a5a013, 29, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a5a013, 29, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a5a013, 15, 29, 5, 0xa5a5a5a3e5a5a013) + EXT( 0xa5a5a5a5a5a5a012, 29, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a5a012, 29, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a5a012, 31, 29, 6, 0xa5a5a5a3e5a5a012) + EXT( 0xa5a5a5a5a5a5a011, 29, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a5a011, 29, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a5a011, 63, 29, 7, 0xa5a5a5a3f5a5a011) + EXT( 0xa5a5a5a5a5a5a010, 29, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a5a010, 29, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a5a010, 127, 29, 8, 0xa5a5a5a3fda5a010) + EXT( 0xa5a5a5a5a5a5a00f, 29, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a5a00f, 29, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a5a00f, 255, 29, 9, 0xa5a5a5a3fda5a00f) + EXT( 0xa5a5a5a5a5a5a00e, 29, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a5a00e, 29, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a5a00e, 511, 29, 10, 0xa5a5a5a3ffa5a00e) + EXT( 0xa5a5a5a5a5a5a00d, 29, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a5a00d, 29, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a5a00d, 1023, 29, 11, 0xa5a5a5a3ffa5a00d) + EXT( 0xa5a5a5a5a5a5a00c, 29, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a5a00c, 29, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a5a00c, 2047, 29, 12, 0xa5a5a5a3ffa5a00c) + EXT( 0xa5a5a5a5a5a5a00b, 29, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a5a00b, 29, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a5a00b, 4095, 29, 13, 0xa5a5a5a3ffe5a00b) + EXT( 0xa5a5a5a5a5a5a00a, 29, 14, 0xffffffffffffed2d) + EXTU(0xa5a5a5a5a5a5a00a, 29, 14, 0x0000000000002d2d) + DEP( 0xa5a5a5a5a5a5a00a, 8191, 29, 14, 0xa5a5a5a3ffe5a00a) + EXT( 0xa5a5a5a5a5a5a009, 29, 15, 0xffffffffffffda5a) + EXTU(0xa5a5a5a5a5a5a009, 29, 15, 0x0000000000005a5a) + DEP( 0xa5a5a5a5a5a5a009, 16383, 29, 15, 0xa5a5a5a3fff5a009) + EXT( 0xa5a5a5a5a5a5a008, 29, 16, 0xffffffffffffb4b4) + EXTU(0xa5a5a5a5a5a5a008, 29, 16, 0x000000000000b4b4) + DEP( 0xa5a5a5a5a5a5a008, 32767, 29, 16, 0xa5a5a5a3fffda008) + EXT( 0xa5a5a5a5a5a5a007, 29, 17, 0xffffffffffff6969) + EXTU(0xa5a5a5a5a5a5a007, 29, 17, 0x0000000000016969) + DEP( 0xa5a5a5a5a5a5a007, 65535, 29, 17, 0xa5a5a5a3fffda007) + EXT( 0xa5a5a5a5a5a5a006, 29, 18, 0xfffffffffffed2d2) + EXTU(0xa5a5a5a5a5a5a006, 29, 18, 0x000000000002d2d2) + DEP( 0xa5a5a5a5a5a5a006, 131071, 29, 18, 0xa5a5a5a3ffffa006) + EXT( 0xa5a5a5a5a5a5a005, 29, 19, 0xfffffffffffda5a5) + EXTU(0xa5a5a5a5a5a5a005, 29, 19, 0x000000000005a5a5) + DEP( 0xa5a5a5a5a5a5a005, 262143, 29, 19, 0xa5a5a5a3ffffa005) + EXT( 0xa5a5a5a5a5a5a004, 29, 20, 0xfffffffffffb4b4b) + EXTU(0xa5a5a5a5a5a5a004, 29, 20, 0x00000000000b4b4b) + DEP( 0xa5a5a5a5a5a5a004, 524287, 29, 20, 0xa5a5a5a3ffffa004) + EXT( 0xa5a5a5a5a5a5a003, 29, 21, 0xfffffffffff69696) + EXTU(0xa5a5a5a5a5a5a003, 29, 21, 0x0000000000169696) + DEP( 0xa5a5a5a5a5a5a003, 1048575, 29, 21, 0xa5a5a5a3ffffe003) + EXT( 0xa5a5a5a5a5a5a002, 29, 22, 0xffffffffffed2d2d) + EXTU(0xa5a5a5a5a5a5a002, 29, 22, 0x00000000002d2d2d) + DEP( 0xa5a5a5a5a5a5a002, 2097151, 29, 22, 0xa5a5a5a3ffffe002) + EXT( 0xa5a5a5a5a5a5a001, 29, 23, 0xffffffffffda5a5a) + EXTU(0xa5a5a5a5a5a5a001, 29, 23, 0x00000000005a5a5a) + DEP( 0xa5a5a5a5a5a5a001, 4194303, 29, 23, 0xa5a5a5a3fffff001) + EXT( 0xa5a5a5a5a5a5a000, 29, 24, 0xffffffffffb4b4b4) + EXTU(0xa5a5a5a5a5a5a000, 29, 24, 0x0000000000b4b4b4) + DEP( 0xa5a5a5a5a5a5a000, 8388607, 29, 24, 0xa5a5a5a3fffff800) + EXT( 0xa5a5a5a5a5a59fff, 29, 25, 0xffffffffff696967) + EXTU(0xa5a5a5a5a5a59fff, 29, 25, 0x0000000001696967) + DEP( 0xa5a5a5a5a5a59fff, 16777215, 29, 25, 0xa5a5a5a3ffffffff) + EXT( 0xa5a5a5a5a5a59ffe, 29, 26, 0xfffffffffed2d2cf) + EXTU(0xa5a5a5a5a5a59ffe, 29, 26, 0x0000000002d2d2cf) + DEP( 0xa5a5a5a5a5a59ffe, 33554431, 29, 26, 0xa5a5a5a3fffffffe) + EXT( 0xa5a5a5a5a5a59ffd, 29, 27, 0xfffffffffda5a59f) + EXTU(0xa5a5a5a5a5a59ffd, 29, 27, 0x0000000005a5a59f) + DEP( 0xa5a5a5a5a5a59ffd, 67108863, 29, 27, 0xa5a5a5a3fffffffd) + EXT( 0xa5a5a5a5a5a59ffc, 29, 28, 0xfffffffffb4b4b3f) + EXTU(0xa5a5a5a5a5a59ffc, 29, 28, 0x000000000b4b4b3f) + DEP( 0xa5a5a5a5a5a59ffc, 134217727, 29, 28, 0xa5a5a5a3fffffffc) + EXT( 0xa5a5a5a5a5a59ffb, 29, 29, 0xfffffffff696967f) + EXTU(0xa5a5a5a5a5a59ffb, 29, 29, 0x000000001696967f) + DEP( 0xa5a5a5a5a5a59ffb, 268435455, 29, 29, 0xa5a5a5a3fffffffb) + EXT( 0xa5a5a5a5a5a59ffa, 29, 30, 0xffffffffed2d2cff) + EXTU(0xa5a5a5a5a5a59ffa, 29, 30, 0x000000002d2d2cff) + DEP( 0xa5a5a5a5a5a59ffa, 536870911, 29, 30, 0xa5a5a5a3fffffffa) + EXT( 0xa5a5a5a5a5a59ff9, 29, 31, 0xffffffffda5a59ff) + EXTU(0xa5a5a5a5a5a59ff9, 29, 31, 0x000000005a5a59ff) + DEP( 0xa5a5a5a5a5a59ff9, 1073741823, 29, 31, 0xa5a5a5a3fffffff9) + EXT( 0xa5a5a5a5a5a59ff8, 29, 32, 0xffffffffb4b4b3ff) + EXTU(0xa5a5a5a5a5a59ff8, 29, 32, 0x00000000b4b4b3ff) + DEP( 0xa5a5a5a5a5a59ff8, 2147483647, 29, 32, 0xa5a5a5a3fffffff8) + EXT( 0xa5a5a5a5a5a59ff7, 29, 33, 0xffffffff696967fd) + EXTU(0xa5a5a5a5a5a59ff7, 29, 33, 0x00000001696967fd) + DEP( 0xa5a5a5a5a5a59ff7, 4294967295, 29, 33, 0xa5a5a5a3ffffffff) + EXT( 0xa5a5a5a5a5a59ff6, 29, 34, 0xfffffffed2d2cffb) + EXTU(0xa5a5a5a5a5a59ff6, 29, 34, 0x00000002d2d2cffb) + DEP( 0xa5a5a5a5a5a59ff6, 8589934591, 29, 34, 0xa5a5a5a3fffffffe) + EXT( 0xa5a5a5a5a5a59ff5, 30, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59ff5, 30, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59ff5, 0, 30, 1, 0xa5a5a5a5a5a59ff5) + EXT( 0xa5a5a5a5a5a59ff4, 30, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59ff4, 30, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ff4, 1, 30, 2, 0xa5a5a5a5a5a59ff4) + EXT( 0xa5a5a5a5a5a59ff3, 30, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59ff3, 30, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59ff3, 3, 30, 3, 0xa5a5a5a5a5a59ff3) + EXT( 0xa5a5a5a5a5a59ff2, 30, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59ff2, 30, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59ff2, 7, 30, 4, 0xa5a5a5a5e5a59ff2) + EXT( 0xa5a5a5a5a5a59ff1, 30, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a59ff1, 30, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59ff1, 15, 30, 5, 0xa5a5a5a5e5a59ff1) + EXT( 0xa5a5a5a5a5a59ff0, 30, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a59ff0, 30, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59ff0, 31, 30, 6, 0xa5a5a5a5f5a59ff0) + EXT( 0xa5a5a5a5a5a59fef, 30, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a59fef, 30, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59fef, 63, 30, 7, 0xa5a5a5a5fda59fef) + EXT( 0xa5a5a5a5a5a59fee, 30, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a59fee, 30, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59fee, 127, 30, 8, 0xa5a5a5a5fda59fee) + EXT( 0xa5a5a5a5a5a59fed, 30, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a59fed, 30, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59fed, 255, 30, 9, 0xa5a5a5a5ffa59fed) + EXT( 0xa5a5a5a5a5a59fec, 30, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a59fec, 30, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59fec, 511, 30, 10, 0xa5a5a5a5ffa59fec) + EXT( 0xa5a5a5a5a5a59feb, 30, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a59feb, 30, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59feb, 1023, 30, 11, 0xa5a5a5a5ffa59feb) + EXT( 0xa5a5a5a5a5a59fea, 30, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a59fea, 30, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59fea, 2047, 30, 12, 0xa5a5a5a5ffe59fea) + EXT( 0xa5a5a5a5a5a59fe9, 30, 13, 0x0000000000000d2d) + EXTU(0xa5a5a5a5a5a59fe9, 30, 13, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59fe9, 4095, 30, 13, 0xa5a5a5a5ffe59fe9) + EXT( 0xa5a5a5a5a5a59fe8, 30, 14, 0x0000000000001a5a) + EXTU(0xa5a5a5a5a5a59fe8, 30, 14, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59fe8, 8191, 30, 14, 0xa5a5a5a5fff59fe8) + EXT( 0xa5a5a5a5a5a59fe7, 30, 15, 0x00000000000034b4) + EXTU(0xa5a5a5a5a5a59fe7, 30, 15, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59fe7, 16383, 30, 15, 0xa5a5a5a5fffd9fe7) + EXT( 0xa5a5a5a5a5a59fe6, 30, 16, 0x0000000000006969) + EXTU(0xa5a5a5a5a5a59fe6, 30, 16, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59fe6, 32767, 30, 16, 0xa5a5a5a5fffd9fe6) + EXT( 0xa5a5a5a5a5a59fe5, 30, 17, 0x000000000000d2d2) + EXTU(0xa5a5a5a5a5a59fe5, 30, 17, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59fe5, 65535, 30, 17, 0xa5a5a5a5ffff9fe5) + EXT( 0xa5a5a5a5a5a59fe4, 30, 18, 0x000000000001a5a5) + EXTU(0xa5a5a5a5a5a59fe4, 30, 18, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59fe4, 131071, 30, 18, 0xa5a5a5a5ffff9fe4) + EXT( 0xa5a5a5a5a5a59fe3, 30, 19, 0x0000000000034b4b) + EXTU(0xa5a5a5a5a5a59fe3, 30, 19, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59fe3, 262143, 30, 19, 0xa5a5a5a5ffff9fe3) + EXT( 0xa5a5a5a5a5a59fe2, 30, 20, 0x0000000000069696) + EXTU(0xa5a5a5a5a5a59fe2, 30, 20, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59fe2, 524287, 30, 20, 0xa5a5a5a5ffffdfe2) + EXT( 0xa5a5a5a5a5a59fe1, 30, 21, 0x00000000000d2d2c) + EXTU(0xa5a5a5a5a5a59fe1, 30, 21, 0x00000000000d2d2c) + DEP( 0xa5a5a5a5a5a59fe1, 1048575, 30, 21, 0xa5a5a5a5ffffffe1) + EXT( 0xa5a5a5a5a5a59fe0, 30, 22, 0x00000000001a5a59) + EXTU(0xa5a5a5a5a5a59fe0, 30, 22, 0x00000000001a5a59) + DEP( 0xa5a5a5a5a5a59fe0, 2097151, 30, 22, 0xa5a5a5a5ffffffe0) + EXT( 0xa5a5a5a5a5a59fdf, 30, 23, 0x000000000034b4b3) + EXTU(0xa5a5a5a5a5a59fdf, 30, 23, 0x000000000034b4b3) + DEP( 0xa5a5a5a5a5a59fdf, 4194303, 30, 23, 0xa5a5a5a5ffffffdf) + EXT( 0xa5a5a5a5a5a59fde, 30, 24, 0x0000000000696967) + EXTU(0xa5a5a5a5a5a59fde, 30, 24, 0x0000000000696967) + DEP( 0xa5a5a5a5a5a59fde, 8388607, 30, 24, 0xa5a5a5a5ffffffde) + EXT( 0xa5a5a5a5a5a59fdd, 30, 25, 0x0000000000d2d2cf) + EXTU(0xa5a5a5a5a5a59fdd, 30, 25, 0x0000000000d2d2cf) + DEP( 0xa5a5a5a5a5a59fdd, 16777215, 30, 25, 0xa5a5a5a5ffffffdd) + EXT( 0xa5a5a5a5a5a59fdc, 30, 26, 0x0000000001a5a59f) + EXTU(0xa5a5a5a5a5a59fdc, 30, 26, 0x0000000001a5a59f) + DEP( 0xa5a5a5a5a5a59fdc, 33554431, 30, 26, 0xa5a5a5a5ffffffdc) + EXT( 0xa5a5a5a5a5a59fdb, 30, 27, 0x00000000034b4b3f) + EXTU(0xa5a5a5a5a5a59fdb, 30, 27, 0x00000000034b4b3f) + DEP( 0xa5a5a5a5a5a59fdb, 67108863, 30, 27, 0xa5a5a5a5ffffffdb) + EXT( 0xa5a5a5a5a5a59fda, 30, 28, 0x000000000696967f) + EXTU(0xa5a5a5a5a5a59fda, 30, 28, 0x000000000696967f) + DEP( 0xa5a5a5a5a5a59fda, 134217727, 30, 28, 0xa5a5a5a5ffffffda) + EXT( 0xa5a5a5a5a5a59fd9, 30, 29, 0x000000000d2d2cfe) + EXTU(0xa5a5a5a5a5a59fd9, 30, 29, 0x000000000d2d2cfe) + DEP( 0xa5a5a5a5a5a59fd9, 268435455, 30, 29, 0xa5a5a5a5fffffff9) + EXT( 0xa5a5a5a5a5a59fd8, 30, 30, 0x000000001a5a59fd) + EXTU(0xa5a5a5a5a5a59fd8, 30, 30, 0x000000001a5a59fd) + DEP( 0xa5a5a5a5a5a59fd8, 536870911, 30, 30, 0xa5a5a5a5fffffff8) + EXT( 0xa5a5a5a5a5a59fd7, 30, 31, 0x0000000034b4b3fa) + EXTU(0xa5a5a5a5a5a59fd7, 30, 31, 0x0000000034b4b3fa) + DEP( 0xa5a5a5a5a5a59fd7, 1073741823, 30, 31, 0xa5a5a5a5ffffffff) + EXT( 0xa5a5a5a5a5a59fd6, 30, 32, 0x00000000696967f5) + EXTU(0xa5a5a5a5a5a59fd6, 30, 32, 0x00000000696967f5) + DEP( 0xa5a5a5a5a5a59fd6, 2147483647, 30, 32, 0xa5a5a5a5fffffffe) + EXT( 0xa5a5a5a5a5a59fd5, 30, 33, 0x00000000d2d2cfea) + EXTU(0xa5a5a5a5a5a59fd5, 30, 33, 0x00000000d2d2cfea) + DEP( 0xa5a5a5a5a5a59fd5, 4294967295, 30, 33, 0xa5a5a5a5ffffffff) + EXT( 0xa5a5a5a5a5a59fd4, 31, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fd4, 31, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59fd4, 0, 31, 1, 0xa5a5a5a4a5a59fd4) + EXT( 0xa5a5a5a5a5a59fd3, 31, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fd3, 31, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59fd3, 1, 31, 2, 0xa5a5a5a4a5a59fd3) + EXT( 0xa5a5a5a5a5a59fd2, 31, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59fd2, 31, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59fd2, 3, 31, 3, 0xa5a5a5a4e5a59fd2) + EXT( 0xa5a5a5a5a5a59fd1, 31, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59fd1, 31, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59fd1, 7, 31, 4, 0xa5a5a5a4e5a59fd1) + EXT( 0xa5a5a5a5a5a59fd0, 31, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59fd0, 31, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59fd0, 15, 31, 5, 0xa5a5a5a4f5a59fd0) + EXT( 0xa5a5a5a5a5a59fcf, 31, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59fcf, 31, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59fcf, 31, 31, 6, 0xa5a5a5a4fda59fcf) + EXT( 0xa5a5a5a5a5a59fce, 31, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59fce, 31, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59fce, 63, 31, 7, 0xa5a5a5a4fda59fce) + EXT( 0xa5a5a5a5a5a59fcd, 31, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59fcd, 31, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59fcd, 127, 31, 8, 0xa5a5a5a4ffa59fcd) + EXT( 0xa5a5a5a5a5a59fcc, 31, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59fcc, 31, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59fcc, 255, 31, 9, 0xa5a5a5a4ffa59fcc) + EXT( 0xa5a5a5a5a5a59fcb, 31, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59fcb, 31, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59fcb, 511, 31, 10, 0xa5a5a5a4ffa59fcb) + EXT( 0xa5a5a5a5a5a59fca, 31, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59fca, 31, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59fca, 1023, 31, 11, 0xa5a5a5a4ffe59fca) + EXT( 0xa5a5a5a5a5a59fc9, 31, 12, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59fc9, 31, 12, 0x0000000000000d2d) + DEP( 0xa5a5a5a5a5a59fc9, 2047, 31, 12, 0xa5a5a5a4ffe59fc9) + EXT( 0xa5a5a5a5a5a59fc8, 31, 13, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59fc8, 31, 13, 0x0000000000001a5a) + DEP( 0xa5a5a5a5a5a59fc8, 4095, 31, 13, 0xa5a5a5a4fff59fc8) + EXT( 0xa5a5a5a5a5a59fc7, 31, 14, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59fc7, 31, 14, 0x00000000000034b4) + DEP( 0xa5a5a5a5a5a59fc7, 8191, 31, 14, 0xa5a5a5a4fffd9fc7) + EXT( 0xa5a5a5a5a5a59fc6, 31, 15, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59fc6, 31, 15, 0x0000000000006969) + DEP( 0xa5a5a5a5a5a59fc6, 16383, 31, 15, 0xa5a5a5a4fffd9fc6) + EXT( 0xa5a5a5a5a5a59fc5, 31, 16, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59fc5, 31, 16, 0x000000000000d2d2) + DEP( 0xa5a5a5a5a5a59fc5, 32767, 31, 16, 0xa5a5a5a4ffff9fc5) + EXT( 0xa5a5a5a5a5a59fc4, 31, 17, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59fc4, 31, 17, 0x000000000001a5a5) + DEP( 0xa5a5a5a5a5a59fc4, 65535, 31, 17, 0xa5a5a5a4ffff9fc4) + EXT( 0xa5a5a5a5a5a59fc3, 31, 18, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59fc3, 31, 18, 0x0000000000034b4b) + DEP( 0xa5a5a5a5a5a59fc3, 131071, 31, 18, 0xa5a5a5a4ffff9fc3) + EXT( 0xa5a5a5a5a5a59fc2, 31, 19, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59fc2, 31, 19, 0x0000000000069696) + DEP( 0xa5a5a5a5a5a59fc2, 262143, 31, 19, 0xa5a5a5a4ffffdfc2) + EXT( 0xa5a5a5a5a5a59fc1, 31, 20, 0xfffffffffffd2d2c) + EXTU(0xa5a5a5a5a5a59fc1, 31, 20, 0x00000000000d2d2c) + DEP( 0xa5a5a5a5a5a59fc1, 524287, 31, 20, 0xa5a5a5a4ffffffc1) + EXT( 0xa5a5a5a5a5a59fc0, 31, 21, 0xfffffffffffa5a59) + EXTU(0xa5a5a5a5a5a59fc0, 31, 21, 0x00000000001a5a59) + DEP( 0xa5a5a5a5a5a59fc0, 1048575, 31, 21, 0xa5a5a5a4ffffffc0) + EXT( 0xa5a5a5a5a5a59fbf, 31, 22, 0xfffffffffff4b4b3) + EXTU(0xa5a5a5a5a5a59fbf, 31, 22, 0x000000000034b4b3) + DEP( 0xa5a5a5a5a5a59fbf, 2097151, 31, 22, 0xa5a5a5a4ffffffbf) + EXT( 0xa5a5a5a5a5a59fbe, 31, 23, 0xffffffffffe96967) + EXTU(0xa5a5a5a5a5a59fbe, 31, 23, 0x0000000000696967) + DEP( 0xa5a5a5a5a5a59fbe, 4194303, 31, 23, 0xa5a5a5a4ffffffbe) + EXT( 0xa5a5a5a5a5a59fbd, 31, 24, 0xffffffffffd2d2cf) + EXTU(0xa5a5a5a5a5a59fbd, 31, 24, 0x0000000000d2d2cf) + DEP( 0xa5a5a5a5a5a59fbd, 8388607, 31, 24, 0xa5a5a5a4ffffffbd) + EXT( 0xa5a5a5a5a5a59fbc, 31, 25, 0xffffffffffa5a59f) + EXTU(0xa5a5a5a5a5a59fbc, 31, 25, 0x0000000001a5a59f) + DEP( 0xa5a5a5a5a5a59fbc, 16777215, 31, 25, 0xa5a5a5a4ffffffbc) + EXT( 0xa5a5a5a5a5a59fbb, 31, 26, 0xffffffffff4b4b3f) + EXTU(0xa5a5a5a5a5a59fbb, 31, 26, 0x00000000034b4b3f) + DEP( 0xa5a5a5a5a5a59fbb, 33554431, 31, 26, 0xa5a5a5a4ffffffbb) + EXT( 0xa5a5a5a5a5a59fba, 31, 27, 0xfffffffffe96967e) + EXTU(0xa5a5a5a5a5a59fba, 31, 27, 0x000000000696967e) + DEP( 0xa5a5a5a5a5a59fba, 67108863, 31, 27, 0xa5a5a5a4fffffffa) + EXT( 0xa5a5a5a5a5a59fb9, 31, 28, 0xfffffffffd2d2cfd) + EXTU(0xa5a5a5a5a5a59fb9, 31, 28, 0x000000000d2d2cfd) + DEP( 0xa5a5a5a5a5a59fb9, 134217727, 31, 28, 0xa5a5a5a4fffffff9) + EXT( 0xa5a5a5a5a5a59fb8, 31, 29, 0xfffffffffa5a59fb) + EXTU(0xa5a5a5a5a5a59fb8, 31, 29, 0x000000001a5a59fb) + DEP( 0xa5a5a5a5a5a59fb8, 268435455, 31, 29, 0xa5a5a5a4fffffff8) + EXT( 0xa5a5a5a5a5a59fb7, 31, 30, 0xfffffffff4b4b3f6) + EXTU(0xa5a5a5a5a5a59fb7, 31, 30, 0x0000000034b4b3f6) + DEP( 0xa5a5a5a5a5a59fb7, 536870911, 31, 30, 0xa5a5a5a4ffffffff) + EXT( 0xa5a5a5a5a5a59fb6, 31, 31, 0xffffffffe96967ed) + EXTU(0xa5a5a5a5a5a59fb6, 31, 31, 0x00000000696967ed) + DEP( 0xa5a5a5a5a5a59fb6, 1073741823, 31, 31, 0xa5a5a5a4fffffffe) + EXT( 0xa5a5a5a5a5a59fb5, 31, 32, 0xffffffffd2d2cfda) + EXTU(0xa5a5a5a5a5a59fb5, 31, 32, 0x00000000d2d2cfda) + DEP( 0xa5a5a5a5a5a59fb5, 2147483647, 31, 32, 0xa5a5a5a4ffffffff) + EXT( 0xa5a5a5a5a5a59fb4, 32, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59fb4, 32, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59fb4, 0, 32, 1, 0xa5a5a5a525a59fb4) + EXT( 0xa5a5a5a5a5a59fb3, 32, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59fb3, 32, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59fb3, 1, 32, 2, 0xa5a5a5a565a59fb3) + EXT( 0xa5a5a5a5a5a59fb2, 32, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59fb2, 32, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59fb2, 3, 32, 3, 0xa5a5a5a565a59fb2) + EXT( 0xa5a5a5a5a5a59fb1, 32, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59fb1, 32, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59fb1, 7, 32, 4, 0xa5a5a5a575a59fb1) + EXT( 0xa5a5a5a5a5a59fb0, 32, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59fb0, 32, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a59fb0, 15, 32, 5, 0xa5a5a5a57da59fb0) + EXT( 0xa5a5a5a5a5a59faf, 32, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59faf, 32, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a59faf, 31, 32, 6, 0xa5a5a5a57da59faf) + EXT( 0xa5a5a5a5a5a59fae, 32, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59fae, 32, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a59fae, 63, 32, 7, 0xa5a5a5a57fa59fae) + EXT( 0xa5a5a5a5a5a59fad, 32, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59fad, 32, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a59fad, 127, 32, 8, 0xa5a5a5a57fa59fad) + EXT( 0xa5a5a5a5a5a59fac, 32, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59fac, 32, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a59fac, 255, 32, 9, 0xa5a5a5a57fa59fac) + EXT( 0xa5a5a5a5a5a59fab, 32, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59fab, 32, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a59fab, 511, 32, 10, 0xa5a5a5a57fe59fab) + EXT( 0xa5a5a5a5a5a59faa, 32, 11, 0xfffffffffffffd2d) + EXTU(0xa5a5a5a5a5a59faa, 32, 11, 0x000000000000052d) + DEP( 0xa5a5a5a5a5a59faa, 1023, 32, 11, 0xa5a5a5a57fe59faa) + EXT( 0xa5a5a5a5a5a59fa9, 32, 12, 0xfffffffffffffa5a) + EXTU(0xa5a5a5a5a5a59fa9, 32, 12, 0x0000000000000a5a) + DEP( 0xa5a5a5a5a5a59fa9, 2047, 32, 12, 0xa5a5a5a57ff59fa9) + EXT( 0xa5a5a5a5a5a59fa8, 32, 13, 0xfffffffffffff4b4) + EXTU(0xa5a5a5a5a5a59fa8, 32, 13, 0x00000000000014b4) + DEP( 0xa5a5a5a5a5a59fa8, 4095, 32, 13, 0xa5a5a5a57ffd9fa8) + EXT( 0xa5a5a5a5a5a59fa7, 32, 14, 0xffffffffffffe969) + EXTU(0xa5a5a5a5a5a59fa7, 32, 14, 0x0000000000002969) + DEP( 0xa5a5a5a5a5a59fa7, 8191, 32, 14, 0xa5a5a5a57ffd9fa7) + EXT( 0xa5a5a5a5a5a59fa6, 32, 15, 0xffffffffffffd2d2) + EXTU(0xa5a5a5a5a5a59fa6, 32, 15, 0x00000000000052d2) + DEP( 0xa5a5a5a5a5a59fa6, 16383, 32, 15, 0xa5a5a5a57fff9fa6) + EXT( 0xa5a5a5a5a5a59fa5, 32, 16, 0xffffffffffffa5a5) + EXTU(0xa5a5a5a5a5a59fa5, 32, 16, 0x000000000000a5a5) + DEP( 0xa5a5a5a5a5a59fa5, 32767, 32, 16, 0xa5a5a5a57fff9fa5) + EXT( 0xa5a5a5a5a5a59fa4, 32, 17, 0xffffffffffff4b4b) + EXTU(0xa5a5a5a5a5a59fa4, 32, 17, 0x0000000000014b4b) + DEP( 0xa5a5a5a5a5a59fa4, 65535, 32, 17, 0xa5a5a5a57fff9fa4) + EXT( 0xa5a5a5a5a5a59fa3, 32, 18, 0xfffffffffffe9696) + EXTU(0xa5a5a5a5a5a59fa3, 32, 18, 0x0000000000029696) + DEP( 0xa5a5a5a5a5a59fa3, 131071, 32, 18, 0xa5a5a5a57fffdfa3) + EXT( 0xa5a5a5a5a5a59fa2, 32, 19, 0xfffffffffffd2d2c) + EXTU(0xa5a5a5a5a5a59fa2, 32, 19, 0x0000000000052d2c) + DEP( 0xa5a5a5a5a5a59fa2, 262143, 32, 19, 0xa5a5a5a57fffffa2) + EXT( 0xa5a5a5a5a5a59fa1, 32, 20, 0xfffffffffffa5a59) + EXTU(0xa5a5a5a5a5a59fa1, 32, 20, 0x00000000000a5a59) + DEP( 0xa5a5a5a5a5a59fa1, 524287, 32, 20, 0xa5a5a5a57fffffa1) + EXT( 0xa5a5a5a5a5a59fa0, 32, 21, 0xfffffffffff4b4b3) + EXTU(0xa5a5a5a5a5a59fa0, 32, 21, 0x000000000014b4b3) + DEP( 0xa5a5a5a5a5a59fa0, 1048575, 32, 21, 0xa5a5a5a57fffffa0) + EXT( 0xa5a5a5a5a5a59f9f, 32, 22, 0xffffffffffe96967) + EXTU(0xa5a5a5a5a5a59f9f, 32, 22, 0x0000000000296967) + DEP( 0xa5a5a5a5a5a59f9f, 2097151, 32, 22, 0xa5a5a5a57fffff9f) + EXT( 0xa5a5a5a5a5a59f9e, 32, 23, 0xffffffffffd2d2cf) + EXTU(0xa5a5a5a5a5a59f9e, 32, 23, 0x000000000052d2cf) + DEP( 0xa5a5a5a5a5a59f9e, 4194303, 32, 23, 0xa5a5a5a57fffff9e) + EXT( 0xa5a5a5a5a5a59f9d, 32, 24, 0xffffffffffa5a59f) + EXTU(0xa5a5a5a5a5a59f9d, 32, 24, 0x0000000000a5a59f) + DEP( 0xa5a5a5a5a5a59f9d, 8388607, 32, 24, 0xa5a5a5a57fffff9d) + EXT( 0xa5a5a5a5a5a59f9c, 32, 25, 0xffffffffff4b4b3f) + EXTU(0xa5a5a5a5a5a59f9c, 32, 25, 0x00000000014b4b3f) + DEP( 0xa5a5a5a5a5a59f9c, 16777215, 32, 25, 0xa5a5a5a57fffff9c) + EXT( 0xa5a5a5a5a5a59f9b, 32, 26, 0xfffffffffe96967e) + EXTU(0xa5a5a5a5a5a59f9b, 32, 26, 0x000000000296967e) + DEP( 0xa5a5a5a5a5a59f9b, 33554431, 32, 26, 0xa5a5a5a57fffffdb) + EXT( 0xa5a5a5a5a5a59f9a, 32, 27, 0xfffffffffd2d2cfc) + EXTU(0xa5a5a5a5a5a59f9a, 32, 27, 0x00000000052d2cfc) + DEP( 0xa5a5a5a5a5a59f9a, 67108863, 32, 27, 0xa5a5a5a57ffffffa) + EXT( 0xa5a5a5a5a5a59f99, 32, 28, 0xfffffffffa5a59f9) + EXTU(0xa5a5a5a5a5a59f99, 32, 28, 0x000000000a5a59f9) + DEP( 0xa5a5a5a5a5a59f99, 134217727, 32, 28, 0xa5a5a5a57ffffff9) + EXT( 0xa5a5a5a5a5a59f98, 32, 29, 0xfffffffff4b4b3f3) + EXTU(0xa5a5a5a5a5a59f98, 32, 29, 0x0000000014b4b3f3) + DEP( 0xa5a5a5a5a5a59f98, 268435455, 32, 29, 0xa5a5a5a57ffffff8) + EXT( 0xa5a5a5a5a5a59f97, 32, 30, 0xffffffffe96967e5) + EXTU(0xa5a5a5a5a5a59f97, 32, 30, 0x00000000296967e5) + DEP( 0xa5a5a5a5a5a59f97, 536870911, 32, 30, 0xa5a5a5a57fffffff) + EXT( 0xa5a5a5a5a5a59f96, 32, 31, 0xffffffffd2d2cfcb) + EXTU(0xa5a5a5a5a5a59f96, 32, 31, 0x0000000052d2cfcb) + DEP( 0xa5a5a5a5a5a59f96, 1073741823, 32, 31, 0xa5a5a5a57ffffffe) + EXT( 0xa5a5a5a5a5a59f95, 33, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f95, 33, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f95, 0, 33, 1, 0xa5a5a5a5a5a59f95) + EXT( 0xa5a5a5a5a5a59f94, 33, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f94, 33, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f94, 1, 33, 2, 0xa5a5a5a5a5a59f94) + EXT( 0xa5a5a5a5a5a59f93, 33, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f93, 33, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f93, 3, 33, 3, 0xa5a5a5a5b5a59f93) + EXT( 0xa5a5a5a5a5a59f92, 33, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59f92, 33, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59f92, 7, 33, 4, 0xa5a5a5a5bda59f92) + EXT( 0xa5a5a5a5a5a59f91, 33, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59f91, 33, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59f91, 15, 33, 5, 0xa5a5a5a5bda59f91) + EXT( 0xa5a5a5a5a5a59f90, 33, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59f90, 33, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59f90, 31, 33, 6, 0xa5a5a5a5bfa59f90) + EXT( 0xa5a5a5a5a5a59f8f, 33, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59f8f, 33, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59f8f, 63, 33, 7, 0xa5a5a5a5bfa59f8f) + EXT( 0xa5a5a5a5a5a59f8e, 33, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59f8e, 33, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59f8e, 127, 33, 8, 0xa5a5a5a5bfa59f8e) + EXT( 0xa5a5a5a5a5a59f8d, 33, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59f8d, 33, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59f8d, 255, 33, 9, 0xa5a5a5a5bfe59f8d) + EXT( 0xa5a5a5a5a5a59f8c, 33, 10, 0x000000000000012d) + EXTU(0xa5a5a5a5a5a59f8c, 33, 10, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59f8c, 511, 33, 10, 0xa5a5a5a5bfe59f8c) + EXT( 0xa5a5a5a5a5a59f8b, 33, 11, 0x000000000000025a) + EXTU(0xa5a5a5a5a5a59f8b, 33, 11, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59f8b, 1023, 33, 11, 0xa5a5a5a5bff59f8b) + EXT( 0xa5a5a5a5a5a59f8a, 33, 12, 0x00000000000004b4) + EXTU(0xa5a5a5a5a5a59f8a, 33, 12, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59f8a, 2047, 33, 12, 0xa5a5a5a5bffd9f8a) + EXT( 0xa5a5a5a5a5a59f89, 33, 13, 0x0000000000000969) + EXTU(0xa5a5a5a5a5a59f89, 33, 13, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59f89, 4095, 33, 13, 0xa5a5a5a5bffd9f89) + EXT( 0xa5a5a5a5a5a59f88, 33, 14, 0x00000000000012d2) + EXTU(0xa5a5a5a5a5a59f88, 33, 14, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59f88, 8191, 33, 14, 0xa5a5a5a5bfff9f88) + EXT( 0xa5a5a5a5a5a59f87, 33, 15, 0x00000000000025a5) + EXTU(0xa5a5a5a5a5a59f87, 33, 15, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59f87, 16383, 33, 15, 0xa5a5a5a5bfff9f87) + EXT( 0xa5a5a5a5a5a59f86, 33, 16, 0x0000000000004b4b) + EXTU(0xa5a5a5a5a5a59f86, 33, 16, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59f86, 32767, 33, 16, 0xa5a5a5a5bfff9f86) + EXT( 0xa5a5a5a5a5a59f85, 33, 17, 0x0000000000009696) + EXTU(0xa5a5a5a5a5a59f85, 33, 17, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59f85, 65535, 33, 17, 0xa5a5a5a5bfffdf85) + EXT( 0xa5a5a5a5a5a59f84, 33, 18, 0x0000000000012d2c) + EXTU(0xa5a5a5a5a5a59f84, 33, 18, 0x0000000000012d2c) + DEP( 0xa5a5a5a5a5a59f84, 131071, 33, 18, 0xa5a5a5a5bfffff84) + EXT( 0xa5a5a5a5a5a59f83, 33, 19, 0x0000000000025a59) + EXTU(0xa5a5a5a5a5a59f83, 33, 19, 0x0000000000025a59) + DEP( 0xa5a5a5a5a5a59f83, 262143, 33, 19, 0xa5a5a5a5bfffff83) + EXT( 0xa5a5a5a5a5a59f82, 33, 20, 0x000000000004b4b3) + EXTU(0xa5a5a5a5a5a59f82, 33, 20, 0x000000000004b4b3) + DEP( 0xa5a5a5a5a5a59f82, 524287, 33, 20, 0xa5a5a5a5bfffff82) + EXT( 0xa5a5a5a5a5a59f81, 33, 21, 0x0000000000096967) + EXTU(0xa5a5a5a5a5a59f81, 33, 21, 0x0000000000096967) + DEP( 0xa5a5a5a5a5a59f81, 1048575, 33, 21, 0xa5a5a5a5bfffff81) + EXT( 0xa5a5a5a5a5a59f80, 33, 22, 0x000000000012d2cf) + EXTU(0xa5a5a5a5a5a59f80, 33, 22, 0x000000000012d2cf) + DEP( 0xa5a5a5a5a5a59f80, 2097151, 33, 22, 0xa5a5a5a5bfffff80) + EXT( 0xa5a5a5a5a5a59f7f, 33, 23, 0x000000000025a59f) + EXTU(0xa5a5a5a5a5a59f7f, 33, 23, 0x000000000025a59f) + DEP( 0xa5a5a5a5a5a59f7f, 4194303, 33, 23, 0xa5a5a5a5bfffff7f) + EXT( 0xa5a5a5a5a5a59f7e, 33, 24, 0x00000000004b4b3e) + EXTU(0xa5a5a5a5a5a59f7e, 33, 24, 0x00000000004b4b3e) + DEP( 0xa5a5a5a5a5a59f7e, 8388607, 33, 24, 0xa5a5a5a5bffffffe) + EXT( 0xa5a5a5a5a5a59f7d, 33, 25, 0x000000000096967d) + EXTU(0xa5a5a5a5a5a59f7d, 33, 25, 0x000000000096967d) + DEP( 0xa5a5a5a5a5a59f7d, 16777215, 33, 25, 0xa5a5a5a5bffffffd) + EXT( 0xa5a5a5a5a5a59f7c, 33, 26, 0x00000000012d2cfb) + EXTU(0xa5a5a5a5a5a59f7c, 33, 26, 0x00000000012d2cfb) + DEP( 0xa5a5a5a5a5a59f7c, 33554431, 33, 26, 0xa5a5a5a5bffffffc) + EXT( 0xa5a5a5a5a5a59f7b, 33, 27, 0x00000000025a59f7) + EXTU(0xa5a5a5a5a5a59f7b, 33, 27, 0x00000000025a59f7) + DEP( 0xa5a5a5a5a5a59f7b, 67108863, 33, 27, 0xa5a5a5a5bffffffb) + EXT( 0xa5a5a5a5a5a59f7a, 33, 28, 0x0000000004b4b3ef) + EXTU(0xa5a5a5a5a5a59f7a, 33, 28, 0x0000000004b4b3ef) + DEP( 0xa5a5a5a5a5a59f7a, 134217727, 33, 28, 0xa5a5a5a5bffffffa) + EXT( 0xa5a5a5a5a5a59f79, 33, 29, 0x00000000096967de) + EXTU(0xa5a5a5a5a5a59f79, 33, 29, 0x00000000096967de) + DEP( 0xa5a5a5a5a5a59f79, 268435455, 33, 29, 0xa5a5a5a5bffffffd) + EXT( 0xa5a5a5a5a5a59f78, 33, 30, 0x0000000012d2cfbc) + EXTU(0xa5a5a5a5a5a59f78, 33, 30, 0x0000000012d2cfbc) + DEP( 0xa5a5a5a5a5a59f78, 536870911, 33, 30, 0xa5a5a5a5bffffffe) + EXT( 0xa5a5a5a5a5a59f77, 34, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59f77, 34, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f77, 0, 34, 1, 0xa5a5a5a585a59f77) + EXT( 0xa5a5a5a5a5a59f76, 34, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f76, 34, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f76, 1, 34, 2, 0xa5a5a5a595a59f76) + EXT( 0xa5a5a5a5a5a59f75, 34, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59f75, 34, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59f75, 3, 34, 3, 0xa5a5a5a59da59f75) + EXT( 0xa5a5a5a5a5a59f74, 34, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59f74, 34, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59f74, 7, 34, 4, 0xa5a5a5a59da59f74) + EXT( 0xa5a5a5a5a5a59f73, 34, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59f73, 34, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59f73, 15, 34, 5, 0xa5a5a5a59fa59f73) + EXT( 0xa5a5a5a5a5a59f72, 34, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59f72, 34, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59f72, 31, 34, 6, 0xa5a5a5a59fa59f72) + EXT( 0xa5a5a5a5a5a59f71, 34, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59f71, 34, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59f71, 63, 34, 7, 0xa5a5a5a59fa59f71) + EXT( 0xa5a5a5a5a5a59f70, 34, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59f70, 34, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59f70, 127, 34, 8, 0xa5a5a5a59fe59f70) + EXT( 0xa5a5a5a5a5a59f6f, 34, 9, 0xffffffffffffff2d) + EXTU(0xa5a5a5a5a5a59f6f, 34, 9, 0x000000000000012d) + DEP( 0xa5a5a5a5a5a59f6f, 255, 34, 9, 0xa5a5a5a59fe59f6f) + EXT( 0xa5a5a5a5a5a59f6e, 34, 10, 0xfffffffffffffe5a) + EXTU(0xa5a5a5a5a5a59f6e, 34, 10, 0x000000000000025a) + DEP( 0xa5a5a5a5a5a59f6e, 511, 34, 10, 0xa5a5a5a59ff59f6e) + EXT( 0xa5a5a5a5a5a59f6d, 34, 11, 0xfffffffffffffcb4) + EXTU(0xa5a5a5a5a5a59f6d, 34, 11, 0x00000000000004b4) + DEP( 0xa5a5a5a5a5a59f6d, 1023, 34, 11, 0xa5a5a5a59ffd9f6d) + EXT( 0xa5a5a5a5a5a59f6c, 34, 12, 0xfffffffffffff969) + EXTU(0xa5a5a5a5a5a59f6c, 34, 12, 0x0000000000000969) + DEP( 0xa5a5a5a5a5a59f6c, 2047, 34, 12, 0xa5a5a5a59ffd9f6c) + EXT( 0xa5a5a5a5a5a59f6b, 34, 13, 0xfffffffffffff2d2) + EXTU(0xa5a5a5a5a5a59f6b, 34, 13, 0x00000000000012d2) + DEP( 0xa5a5a5a5a5a59f6b, 4095, 34, 13, 0xa5a5a5a59fff9f6b) + EXT( 0xa5a5a5a5a5a59f6a, 34, 14, 0xffffffffffffe5a5) + EXTU(0xa5a5a5a5a5a59f6a, 34, 14, 0x00000000000025a5) + DEP( 0xa5a5a5a5a5a59f6a, 8191, 34, 14, 0xa5a5a5a59fff9f6a) + EXT( 0xa5a5a5a5a5a59f69, 34, 15, 0xffffffffffffcb4b) + EXTU(0xa5a5a5a5a5a59f69, 34, 15, 0x0000000000004b4b) + DEP( 0xa5a5a5a5a5a59f69, 16383, 34, 15, 0xa5a5a5a59fff9f69) + EXT( 0xa5a5a5a5a5a59f68, 34, 16, 0xffffffffffff9696) + EXTU(0xa5a5a5a5a5a59f68, 34, 16, 0x0000000000009696) + DEP( 0xa5a5a5a5a5a59f68, 32767, 34, 16, 0xa5a5a5a59fffdf68) + EXT( 0xa5a5a5a5a5a59f67, 34, 17, 0xffffffffffff2d2c) + EXTU(0xa5a5a5a5a5a59f67, 34, 17, 0x0000000000012d2c) + DEP( 0xa5a5a5a5a5a59f67, 65535, 34, 17, 0xa5a5a5a59fffff67) + EXT( 0xa5a5a5a5a5a59f66, 34, 18, 0xfffffffffffe5a59) + EXTU(0xa5a5a5a5a5a59f66, 34, 18, 0x0000000000025a59) + DEP( 0xa5a5a5a5a5a59f66, 131071, 34, 18, 0xa5a5a5a59fffff66) + EXT( 0xa5a5a5a5a5a59f65, 34, 19, 0xfffffffffffcb4b3) + EXTU(0xa5a5a5a5a5a59f65, 34, 19, 0x000000000004b4b3) + DEP( 0xa5a5a5a5a5a59f65, 262143, 34, 19, 0xa5a5a5a59fffff65) + EXT( 0xa5a5a5a5a5a59f64, 34, 20, 0xfffffffffff96967) + EXTU(0xa5a5a5a5a5a59f64, 34, 20, 0x0000000000096967) + DEP( 0xa5a5a5a5a5a59f64, 524287, 34, 20, 0xa5a5a5a59fffff64) + EXT( 0xa5a5a5a5a5a59f63, 34, 21, 0xfffffffffff2d2cf) + EXTU(0xa5a5a5a5a5a59f63, 34, 21, 0x000000000012d2cf) + DEP( 0xa5a5a5a5a5a59f63, 1048575, 34, 21, 0xa5a5a5a59fffff63) + EXT( 0xa5a5a5a5a5a59f62, 34, 22, 0xffffffffffe5a59f) + EXTU(0xa5a5a5a5a5a59f62, 34, 22, 0x000000000025a59f) + DEP( 0xa5a5a5a5a5a59f62, 2097151, 34, 22, 0xa5a5a5a59fffff62) + EXT( 0xa5a5a5a5a5a59f61, 34, 23, 0xffffffffffcb4b3e) + EXTU(0xa5a5a5a5a5a59f61, 34, 23, 0x00000000004b4b3e) + DEP( 0xa5a5a5a5a5a59f61, 4194303, 34, 23, 0xa5a5a5a59fffffe1) + EXT( 0xa5a5a5a5a5a59f60, 34, 24, 0xffffffffff96967d) + EXTU(0xa5a5a5a5a5a59f60, 34, 24, 0x000000000096967d) + DEP( 0xa5a5a5a5a5a59f60, 8388607, 34, 24, 0xa5a5a5a59fffffe0) + EXT( 0xa5a5a5a5a5a59f5f, 34, 25, 0xffffffffff2d2cfa) + EXTU(0xa5a5a5a5a5a59f5f, 34, 25, 0x00000000012d2cfa) + DEP( 0xa5a5a5a5a5a59f5f, 16777215, 34, 25, 0xa5a5a5a59fffffff) + EXT( 0xa5a5a5a5a5a59f5e, 34, 26, 0xfffffffffe5a59f5) + EXTU(0xa5a5a5a5a5a59f5e, 34, 26, 0x00000000025a59f5) + DEP( 0xa5a5a5a5a5a59f5e, 33554431, 34, 26, 0xa5a5a5a59ffffffe) + EXT( 0xa5a5a5a5a5a59f5d, 34, 27, 0xfffffffffcb4b3eb) + EXTU(0xa5a5a5a5a5a59f5d, 34, 27, 0x0000000004b4b3eb) + DEP( 0xa5a5a5a5a5a59f5d, 67108863, 34, 27, 0xa5a5a5a59ffffffd) + EXT( 0xa5a5a5a5a5a59f5c, 34, 28, 0xfffffffff96967d7) + EXTU(0xa5a5a5a5a5a59f5c, 34, 28, 0x00000000096967d7) + DEP( 0xa5a5a5a5a5a59f5c, 134217727, 34, 28, 0xa5a5a5a59ffffffc) + EXT( 0xa5a5a5a5a5a59f5b, 34, 29, 0xfffffffff2d2cfad) + EXTU(0xa5a5a5a5a5a59f5b, 34, 29, 0x0000000012d2cfad) + DEP( 0xa5a5a5a5a5a59f5b, 268435455, 34, 29, 0xa5a5a5a59fffffff) + EXT( 0xa5a5a5a5a5a59f5a, 35, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f5a, 35, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f5a, 0, 35, 1, 0xa5a5a5a5a5a59f5a) + EXT( 0xa5a5a5a5a5a59f59, 35, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f59, 35, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f59, 1, 35, 2, 0xa5a5a5a5ada59f59) + EXT( 0xa5a5a5a5a5a59f58, 35, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f58, 35, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f58, 3, 35, 3, 0xa5a5a5a5ada59f58) + EXT( 0xa5a5a5a5a5a59f57, 35, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f57, 35, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f57, 7, 35, 4, 0xa5a5a5a5afa59f57) + EXT( 0xa5a5a5a5a5a59f56, 35, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59f56, 35, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59f56, 15, 35, 5, 0xa5a5a5a5afa59f56) + EXT( 0xa5a5a5a5a5a59f55, 35, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59f55, 35, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59f55, 31, 35, 6, 0xa5a5a5a5afa59f55) + EXT( 0xa5a5a5a5a5a59f54, 35, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59f54, 35, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f54, 63, 35, 7, 0xa5a5a5a5afe59f54) + EXT( 0xa5a5a5a5a5a59f53, 35, 8, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59f53, 35, 8, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f53, 127, 35, 8, 0xa5a5a5a5afe59f53) + EXT( 0xa5a5a5a5a5a59f52, 35, 9, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59f52, 35, 9, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f52, 255, 35, 9, 0xa5a5a5a5aff59f52) + EXT( 0xa5a5a5a5a5a59f51, 35, 10, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59f51, 35, 10, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f51, 511, 35, 10, 0xa5a5a5a5affd9f51) + EXT( 0xa5a5a5a5a5a59f50, 35, 11, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59f50, 35, 11, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f50, 1023, 35, 11, 0xa5a5a5a5affd9f50) + EXT( 0xa5a5a5a5a5a59f4f, 35, 12, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59f4f, 35, 12, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f4f, 2047, 35, 12, 0xa5a5a5a5afff9f4f) + EXT( 0xa5a5a5a5a5a59f4e, 35, 13, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59f4e, 35, 13, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59f4e, 4095, 35, 13, 0xa5a5a5a5afff9f4e) + EXT( 0xa5a5a5a5a5a59f4d, 35, 14, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59f4d, 35, 14, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59f4d, 8191, 35, 14, 0xa5a5a5a5afff9f4d) + EXT( 0xa5a5a5a5a5a59f4c, 35, 15, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59f4c, 35, 15, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59f4c, 16383, 35, 15, 0xa5a5a5a5afffdf4c) + EXT( 0xa5a5a5a5a5a59f4b, 35, 16, 0x0000000000002d2c) + EXTU(0xa5a5a5a5a5a59f4b, 35, 16, 0x0000000000002d2c) + DEP( 0xa5a5a5a5a5a59f4b, 32767, 35, 16, 0xa5a5a5a5afffff4b) + EXT( 0xa5a5a5a5a5a59f4a, 35, 17, 0x0000000000005a59) + EXTU(0xa5a5a5a5a5a59f4a, 35, 17, 0x0000000000005a59) + DEP( 0xa5a5a5a5a5a59f4a, 65535, 35, 17, 0xa5a5a5a5afffff4a) + EXT( 0xa5a5a5a5a5a59f49, 35, 18, 0x000000000000b4b3) + EXTU(0xa5a5a5a5a5a59f49, 35, 18, 0x000000000000b4b3) + DEP( 0xa5a5a5a5a5a59f49, 131071, 35, 18, 0xa5a5a5a5afffff49) + EXT( 0xa5a5a5a5a5a59f48, 35, 19, 0x0000000000016967) + EXTU(0xa5a5a5a5a5a59f48, 35, 19, 0x0000000000016967) + DEP( 0xa5a5a5a5a5a59f48, 262143, 35, 19, 0xa5a5a5a5afffff48) + EXT( 0xa5a5a5a5a5a59f47, 35, 20, 0x000000000002d2cf) + EXTU(0xa5a5a5a5a5a59f47, 35, 20, 0x000000000002d2cf) + DEP( 0xa5a5a5a5a5a59f47, 524287, 35, 20, 0xa5a5a5a5afffff47) + EXT( 0xa5a5a5a5a5a59f46, 35, 21, 0x000000000005a59f) + EXTU(0xa5a5a5a5a5a59f46, 35, 21, 0x000000000005a59f) + DEP( 0xa5a5a5a5a5a59f46, 1048575, 35, 21, 0xa5a5a5a5afffff46) + EXT( 0xa5a5a5a5a5a59f45, 35, 22, 0x00000000000b4b3e) + EXTU(0xa5a5a5a5a5a59f45, 35, 22, 0x00000000000b4b3e) + DEP( 0xa5a5a5a5a5a59f45, 2097151, 35, 22, 0xa5a5a5a5afffffc5) + EXT( 0xa5a5a5a5a5a59f44, 35, 23, 0x000000000016967d) + EXTU(0xa5a5a5a5a5a59f44, 35, 23, 0x000000000016967d) + DEP( 0xa5a5a5a5a5a59f44, 4194303, 35, 23, 0xa5a5a5a5afffffc4) + EXT( 0xa5a5a5a5a5a59f43, 35, 24, 0x00000000002d2cfa) + EXTU(0xa5a5a5a5a5a59f43, 35, 24, 0x00000000002d2cfa) + DEP( 0xa5a5a5a5a5a59f43, 8388607, 35, 24, 0xa5a5a5a5afffffe3) + EXT( 0xa5a5a5a5a5a59f42, 35, 25, 0x00000000005a59f4) + EXTU(0xa5a5a5a5a5a59f42, 35, 25, 0x00000000005a59f4) + DEP( 0xa5a5a5a5a5a59f42, 16777215, 35, 25, 0xa5a5a5a5affffff2) + EXT( 0xa5a5a5a5a5a59f41, 35, 26, 0x0000000000b4b3e8) + EXTU(0xa5a5a5a5a5a59f41, 35, 26, 0x0000000000b4b3e8) + DEP( 0xa5a5a5a5a5a59f41, 33554431, 35, 26, 0xa5a5a5a5affffff9) + EXT( 0xa5a5a5a5a5a59f40, 35, 27, 0x00000000016967d0) + EXTU(0xa5a5a5a5a5a59f40, 35, 27, 0x00000000016967d0) + DEP( 0xa5a5a5a5a5a59f40, 67108863, 35, 27, 0xa5a5a5a5affffffc) + EXT( 0xa5a5a5a5a5a59f3f, 35, 28, 0x0000000002d2cf9f) + EXTU(0xa5a5a5a5a5a59f3f, 35, 28, 0x0000000002d2cf9f) + DEP( 0xa5a5a5a5a5a59f3f, 134217727, 35, 28, 0xa5a5a5a5afffffff) + EXT( 0xa5a5a5a5a5a59f3e, 36, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f3e, 36, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f3e, 0, 36, 1, 0xa5a5a5a5a5a59f3e) + EXT( 0xa5a5a5a5a5a59f3d, 36, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f3d, 36, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f3d, 1, 36, 2, 0xa5a5a5a5a5a59f3d) + EXT( 0xa5a5a5a5a5a59f3c, 36, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59f3c, 36, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f3c, 3, 36, 3, 0xa5a5a5a5a7a59f3c) + EXT( 0xa5a5a5a5a5a59f3b, 36, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59f3b, 36, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59f3b, 7, 36, 4, 0xa5a5a5a5a7a59f3b) + EXT( 0xa5a5a5a5a5a59f3a, 36, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59f3a, 36, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59f3a, 15, 36, 5, 0xa5a5a5a5a7a59f3a) + EXT( 0xa5a5a5a5a5a59f39, 36, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59f39, 36, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f39, 31, 36, 6, 0xa5a5a5a5a7e59f39) + EXT( 0xa5a5a5a5a5a59f38, 36, 7, 0x000000000000002d) + EXTU(0xa5a5a5a5a5a59f38, 36, 7, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f38, 63, 36, 7, 0xa5a5a5a5a7e59f38) + EXT( 0xa5a5a5a5a5a59f37, 36, 8, 0x000000000000005a) + EXTU(0xa5a5a5a5a5a59f37, 36, 8, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f37, 127, 36, 8, 0xa5a5a5a5a7f59f37) + EXT( 0xa5a5a5a5a5a59f36, 36, 9, 0x00000000000000b4) + EXTU(0xa5a5a5a5a5a59f36, 36, 9, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f36, 255, 36, 9, 0xa5a5a5a5a7fd9f36) + EXT( 0xa5a5a5a5a5a59f35, 36, 10, 0x0000000000000169) + EXTU(0xa5a5a5a5a5a59f35, 36, 10, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f35, 511, 36, 10, 0xa5a5a5a5a7fd9f35) + EXT( 0xa5a5a5a5a5a59f34, 36, 11, 0x00000000000002d2) + EXTU(0xa5a5a5a5a5a59f34, 36, 11, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f34, 1023, 36, 11, 0xa5a5a5a5a7ff9f34) + EXT( 0xa5a5a5a5a5a59f33, 36, 12, 0x00000000000005a5) + EXTU(0xa5a5a5a5a5a59f33, 36, 12, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59f33, 2047, 36, 12, 0xa5a5a5a5a7ff9f33) + EXT( 0xa5a5a5a5a5a59f32, 36, 13, 0x0000000000000b4b) + EXTU(0xa5a5a5a5a5a59f32, 36, 13, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59f32, 4095, 36, 13, 0xa5a5a5a5a7ff9f32) + EXT( 0xa5a5a5a5a5a59f31, 36, 14, 0x0000000000001696) + EXTU(0xa5a5a5a5a5a59f31, 36, 14, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59f31, 8191, 36, 14, 0xa5a5a5a5a7ffdf31) + EXT( 0xa5a5a5a5a5a59f30, 36, 15, 0x0000000000002d2c) + EXTU(0xa5a5a5a5a5a59f30, 36, 15, 0x0000000000002d2c) + DEP( 0xa5a5a5a5a5a59f30, 16383, 36, 15, 0xa5a5a5a5a7ffff30) + EXT( 0xa5a5a5a5a5a59f2f, 36, 16, 0x0000000000005a59) + EXTU(0xa5a5a5a5a5a59f2f, 36, 16, 0x0000000000005a59) + DEP( 0xa5a5a5a5a5a59f2f, 32767, 36, 16, 0xa5a5a5a5a7ffff2f) + EXT( 0xa5a5a5a5a5a59f2e, 36, 17, 0x000000000000b4b3) + EXTU(0xa5a5a5a5a5a59f2e, 36, 17, 0x000000000000b4b3) + DEP( 0xa5a5a5a5a5a59f2e, 65535, 36, 17, 0xa5a5a5a5a7ffff2e) + EXT( 0xa5a5a5a5a5a59f2d, 36, 18, 0x0000000000016967) + EXTU(0xa5a5a5a5a5a59f2d, 36, 18, 0x0000000000016967) + DEP( 0xa5a5a5a5a5a59f2d, 131071, 36, 18, 0xa5a5a5a5a7ffff2d) + EXT( 0xa5a5a5a5a5a59f2c, 36, 19, 0x000000000002d2cf) + EXTU(0xa5a5a5a5a5a59f2c, 36, 19, 0x000000000002d2cf) + DEP( 0xa5a5a5a5a5a59f2c, 262143, 36, 19, 0xa5a5a5a5a7ffff2c) + EXT( 0xa5a5a5a5a5a59f2b, 36, 20, 0x000000000005a59f) + EXTU(0xa5a5a5a5a5a59f2b, 36, 20, 0x000000000005a59f) + DEP( 0xa5a5a5a5a5a59f2b, 524287, 36, 20, 0xa5a5a5a5a7ffff2b) + EXT( 0xa5a5a5a5a5a59f2a, 36, 21, 0x00000000000b4b3e) + EXTU(0xa5a5a5a5a5a59f2a, 36, 21, 0x00000000000b4b3e) + DEP( 0xa5a5a5a5a5a59f2a, 1048575, 36, 21, 0xa5a5a5a5a7ffffaa) + EXT( 0xa5a5a5a5a5a59f29, 36, 22, 0x000000000016967c) + EXTU(0xa5a5a5a5a5a59f29, 36, 22, 0x000000000016967c) + DEP( 0xa5a5a5a5a5a59f29, 2097151, 36, 22, 0xa5a5a5a5a7ffffe9) + EXT( 0xa5a5a5a5a5a59f28, 36, 23, 0x00000000002d2cf9) + EXTU(0xa5a5a5a5a5a59f28, 36, 23, 0x00000000002d2cf9) + DEP( 0xa5a5a5a5a5a59f28, 4194303, 36, 23, 0xa5a5a5a5a7ffffe8) + EXT( 0xa5a5a5a5a5a59f27, 36, 24, 0x00000000005a59f2) + EXTU(0xa5a5a5a5a5a59f27, 36, 24, 0x00000000005a59f2) + DEP( 0xa5a5a5a5a5a59f27, 8388607, 36, 24, 0xa5a5a5a5a7fffff7) + EXT( 0xa5a5a5a5a5a59f26, 36, 25, 0x0000000000b4b3e4) + EXTU(0xa5a5a5a5a5a59f26, 36, 25, 0x0000000000b4b3e4) + DEP( 0xa5a5a5a5a5a59f26, 16777215, 36, 25, 0xa5a5a5a5a7fffffe) + EXT( 0xa5a5a5a5a5a59f25, 36, 26, 0x00000000016967c9) + EXTU(0xa5a5a5a5a5a59f25, 36, 26, 0x00000000016967c9) + DEP( 0xa5a5a5a5a5a59f25, 33554431, 36, 26, 0xa5a5a5a5a7fffffd) + EXT( 0xa5a5a5a5a5a59f24, 36, 27, 0x0000000002d2cf92) + EXTU(0xa5a5a5a5a5a59f24, 36, 27, 0x0000000002d2cf92) + DEP( 0xa5a5a5a5a5a59f24, 67108863, 36, 27, 0xa5a5a5a5a7fffffe) + EXT( 0xa5a5a5a5a5a59f23, 37, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59f23, 37, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f23, 0, 37, 1, 0xa5a5a5a5a1a59f23) + EXT( 0xa5a5a5a5a5a59f22, 37, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59f22, 37, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59f22, 1, 37, 2, 0xa5a5a5a5a3a59f22) + EXT( 0xa5a5a5a5a5a59f21, 37, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59f21, 37, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59f21, 3, 37, 3, 0xa5a5a5a5a3a59f21) + EXT( 0xa5a5a5a5a5a59f20, 37, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59f20, 37, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59f20, 7, 37, 4, 0xa5a5a5a5a3a59f20) + EXT( 0xa5a5a5a5a5a59f1f, 37, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59f1f, 37, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59f1f, 15, 37, 5, 0xa5a5a5a5a3e59f1f) + EXT( 0xa5a5a5a5a5a59f1e, 37, 6, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a59f1e, 37, 6, 0x000000000000002d) + DEP( 0xa5a5a5a5a5a59f1e, 31, 37, 6, 0xa5a5a5a5a3e59f1e) + EXT( 0xa5a5a5a5a5a59f1d, 37, 7, 0xffffffffffffffda) + EXTU(0xa5a5a5a5a5a59f1d, 37, 7, 0x000000000000005a) + DEP( 0xa5a5a5a5a5a59f1d, 63, 37, 7, 0xa5a5a5a5a3f59f1d) + EXT( 0xa5a5a5a5a5a59f1c, 37, 8, 0xffffffffffffffb4) + EXTU(0xa5a5a5a5a5a59f1c, 37, 8, 0x00000000000000b4) + DEP( 0xa5a5a5a5a5a59f1c, 127, 37, 8, 0xa5a5a5a5a3fd9f1c) + EXT( 0xa5a5a5a5a5a59f1b, 37, 9, 0xffffffffffffff69) + EXTU(0xa5a5a5a5a5a59f1b, 37, 9, 0x0000000000000169) + DEP( 0xa5a5a5a5a5a59f1b, 255, 37, 9, 0xa5a5a5a5a3fd9f1b) + EXT( 0xa5a5a5a5a5a59f1a, 37, 10, 0xfffffffffffffed2) + EXTU(0xa5a5a5a5a5a59f1a, 37, 10, 0x00000000000002d2) + DEP( 0xa5a5a5a5a5a59f1a, 511, 37, 10, 0xa5a5a5a5a3ff9f1a) + EXT( 0xa5a5a5a5a5a59f19, 37, 11, 0xfffffffffffffda5) + EXTU(0xa5a5a5a5a5a59f19, 37, 11, 0x00000000000005a5) + DEP( 0xa5a5a5a5a5a59f19, 1023, 37, 11, 0xa5a5a5a5a3ff9f19) + EXT( 0xa5a5a5a5a5a59f18, 37, 12, 0xfffffffffffffb4b) + EXTU(0xa5a5a5a5a5a59f18, 37, 12, 0x0000000000000b4b) + DEP( 0xa5a5a5a5a5a59f18, 2047, 37, 12, 0xa5a5a5a5a3ff9f18) + EXT( 0xa5a5a5a5a5a59f17, 37, 13, 0xfffffffffffff696) + EXTU(0xa5a5a5a5a5a59f17, 37, 13, 0x0000000000001696) + DEP( 0xa5a5a5a5a5a59f17, 4095, 37, 13, 0xa5a5a5a5a3ffdf17) + EXT( 0xa5a5a5a5a5a59f16, 37, 14, 0xffffffffffffed2c) + EXTU(0xa5a5a5a5a5a59f16, 37, 14, 0x0000000000002d2c) + DEP( 0xa5a5a5a5a5a59f16, 8191, 37, 14, 0xa5a5a5a5a3ffff16) + EXT( 0xa5a5a5a5a5a59f15, 37, 15, 0xffffffffffffda59) + EXTU(0xa5a5a5a5a5a59f15, 37, 15, 0x0000000000005a59) + DEP( 0xa5a5a5a5a5a59f15, 16383, 37, 15, 0xa5a5a5a5a3ffff15) + EXT( 0xa5a5a5a5a5a59f14, 37, 16, 0xffffffffffffb4b3) + EXTU(0xa5a5a5a5a5a59f14, 37, 16, 0x000000000000b4b3) + DEP( 0xa5a5a5a5a5a59f14, 32767, 37, 16, 0xa5a5a5a5a3ffff14) + EXT( 0xa5a5a5a5a5a59f13, 37, 17, 0xffffffffffff6967) + EXTU(0xa5a5a5a5a5a59f13, 37, 17, 0x0000000000016967) + DEP( 0xa5a5a5a5a5a59f13, 65535, 37, 17, 0xa5a5a5a5a3ffff13) + EXT( 0xa5a5a5a5a5a59f12, 37, 18, 0xfffffffffffed2cf) + EXTU(0xa5a5a5a5a5a59f12, 37, 18, 0x000000000002d2cf) + DEP( 0xa5a5a5a5a5a59f12, 131071, 37, 18, 0xa5a5a5a5a3ffff12) + EXT( 0xa5a5a5a5a5a59f11, 37, 19, 0xfffffffffffda59f) + EXTU(0xa5a5a5a5a5a59f11, 37, 19, 0x000000000005a59f) + DEP( 0xa5a5a5a5a5a59f11, 262143, 37, 19, 0xa5a5a5a5a3ffff11) + EXT( 0xa5a5a5a5a5a59f10, 37, 20, 0xfffffffffffb4b3e) + EXTU(0xa5a5a5a5a5a59f10, 37, 20, 0x00000000000b4b3e) + DEP( 0xa5a5a5a5a5a59f10, 524287, 37, 20, 0xa5a5a5a5a3ffff90) + EXT( 0xa5a5a5a5a5a59f0f, 37, 21, 0xfffffffffff6967c) + EXTU(0xa5a5a5a5a5a59f0f, 37, 21, 0x000000000016967c) + DEP( 0xa5a5a5a5a5a59f0f, 1048575, 37, 21, 0xa5a5a5a5a3ffffcf) + EXT( 0xa5a5a5a5a5a59f0e, 37, 22, 0xffffffffffed2cf8) + EXTU(0xa5a5a5a5a5a59f0e, 37, 22, 0x00000000002d2cf8) + DEP( 0xa5a5a5a5a5a59f0e, 2097151, 37, 22, 0xa5a5a5a5a3ffffee) + EXT( 0xa5a5a5a5a5a59f0d, 37, 23, 0xffffffffffda59f0) + EXTU(0xa5a5a5a5a5a59f0d, 37, 23, 0x00000000005a59f0) + DEP( 0xa5a5a5a5a5a59f0d, 4194303, 37, 23, 0xa5a5a5a5a3fffffd) + EXT( 0xa5a5a5a5a5a59f0c, 37, 24, 0xffffffffffb4b3e1) + EXTU(0xa5a5a5a5a5a59f0c, 37, 24, 0x0000000000b4b3e1) + DEP( 0xa5a5a5a5a5a59f0c, 8388607, 37, 24, 0xa5a5a5a5a3fffffc) + EXT( 0xa5a5a5a5a5a59f0b, 37, 25, 0xffffffffff6967c2) + EXTU(0xa5a5a5a5a5a59f0b, 37, 25, 0x00000000016967c2) + DEP( 0xa5a5a5a5a5a59f0b, 16777215, 37, 25, 0xa5a5a5a5a3ffffff) + EXT( 0xa5a5a5a5a5a59f0a, 37, 26, 0xfffffffffed2cf85) + EXTU(0xa5a5a5a5a5a59f0a, 37, 26, 0x0000000002d2cf85) + DEP( 0xa5a5a5a5a5a59f0a, 33554431, 37, 26, 0xa5a5a5a5a3fffffe) + EXT( 0xa5a5a5a5a5a59f09, 38, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59f09, 38, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59f09, 0, 38, 1, 0xa5a5a5a5a5a59f09) + EXT( 0xa5a5a5a5a5a59f08, 38, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59f08, 38, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59f08, 1, 38, 2, 0xa5a5a5a5a5a59f08) + EXT( 0xa5a5a5a5a5a59f07, 38, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59f07, 38, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59f07, 3, 38, 3, 0xa5a5a5a5a5a59f07) + EXT( 0xa5a5a5a5a5a59f06, 38, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59f06, 38, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59f06, 7, 38, 4, 0xa5a5a5a5a5e59f06) + EXT( 0xa5a5a5a5a5a59f05, 38, 5, 0x000000000000000d) + EXTU(0xa5a5a5a5a5a59f05, 38, 5, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59f05, 15, 38, 5, 0xa5a5a5a5a5e59f05) + EXT( 0xa5a5a5a5a5a59f04, 38, 6, 0x000000000000001a) + EXTU(0xa5a5a5a5a5a59f04, 38, 6, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59f04, 31, 38, 6, 0xa5a5a5a5a5f59f04) + EXT( 0xa5a5a5a5a5a59f03, 38, 7, 0x0000000000000034) + EXTU(0xa5a5a5a5a5a59f03, 38, 7, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59f03, 63, 38, 7, 0xa5a5a5a5a5fd9f03) + EXT( 0xa5a5a5a5a5a59f02, 38, 8, 0x0000000000000069) + EXTU(0xa5a5a5a5a5a59f02, 38, 8, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59f02, 127, 38, 8, 0xa5a5a5a5a5fd9f02) + EXT( 0xa5a5a5a5a5a59f01, 38, 9, 0x00000000000000d2) + EXTU(0xa5a5a5a5a5a59f01, 38, 9, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59f01, 255, 38, 9, 0xa5a5a5a5a5ff9f01) + EXT( 0xa5a5a5a5a5a59f00, 38, 10, 0x00000000000001a5) + EXTU(0xa5a5a5a5a5a59f00, 38, 10, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59f00, 511, 38, 10, 0xa5a5a5a5a5ff9f00) + EXT( 0xa5a5a5a5a5a59eff, 38, 11, 0x000000000000034b) + EXTU(0xa5a5a5a5a5a59eff, 38, 11, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59eff, 1023, 38, 11, 0xa5a5a5a5a5ff9eff) + EXT( 0xa5a5a5a5a5a59efe, 38, 12, 0x0000000000000696) + EXTU(0xa5a5a5a5a5a59efe, 38, 12, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59efe, 2047, 38, 12, 0xa5a5a5a5a5ffdefe) + EXT( 0xa5a5a5a5a5a59efd, 38, 13, 0x0000000000000d2c) + EXTU(0xa5a5a5a5a5a59efd, 38, 13, 0x0000000000000d2c) + DEP( 0xa5a5a5a5a5a59efd, 4095, 38, 13, 0xa5a5a5a5a5fffefd) + EXT( 0xa5a5a5a5a5a59efc, 38, 14, 0x0000000000001a59) + EXTU(0xa5a5a5a5a5a59efc, 38, 14, 0x0000000000001a59) + DEP( 0xa5a5a5a5a5a59efc, 8191, 38, 14, 0xa5a5a5a5a5fffefc) + EXT( 0xa5a5a5a5a5a59efb, 38, 15, 0x00000000000034b3) + EXTU(0xa5a5a5a5a5a59efb, 38, 15, 0x00000000000034b3) + DEP( 0xa5a5a5a5a5a59efb, 16383, 38, 15, 0xa5a5a5a5a5fffefb) + EXT( 0xa5a5a5a5a5a59efa, 38, 16, 0x0000000000006967) + EXTU(0xa5a5a5a5a5a59efa, 38, 16, 0x0000000000006967) + DEP( 0xa5a5a5a5a5a59efa, 32767, 38, 16, 0xa5a5a5a5a5fffefa) + EXT( 0xa5a5a5a5a5a59ef9, 38, 17, 0x000000000000d2cf) + EXTU(0xa5a5a5a5a5a59ef9, 38, 17, 0x000000000000d2cf) + DEP( 0xa5a5a5a5a5a59ef9, 65535, 38, 17, 0xa5a5a5a5a5fffef9) + EXT( 0xa5a5a5a5a5a59ef8, 38, 18, 0x000000000001a59e) + EXTU(0xa5a5a5a5a5a59ef8, 38, 18, 0x000000000001a59e) + DEP( 0xa5a5a5a5a5a59ef8, 131071, 38, 18, 0xa5a5a5a5a5fffff8) + EXT( 0xa5a5a5a5a5a59ef7, 38, 19, 0x0000000000034b3d) + EXTU(0xa5a5a5a5a5a59ef7, 38, 19, 0x0000000000034b3d) + DEP( 0xa5a5a5a5a5a59ef7, 262143, 38, 19, 0xa5a5a5a5a5fffff7) + EXT( 0xa5a5a5a5a5a59ef6, 38, 20, 0x000000000006967b) + EXTU(0xa5a5a5a5a5a59ef6, 38, 20, 0x000000000006967b) + DEP( 0xa5a5a5a5a5a59ef6, 524287, 38, 20, 0xa5a5a5a5a5fffff6) + EXT( 0xa5a5a5a5a5a59ef5, 38, 21, 0x00000000000d2cf7) + EXTU(0xa5a5a5a5a5a59ef5, 38, 21, 0x00000000000d2cf7) + DEP( 0xa5a5a5a5a5a59ef5, 1048575, 38, 21, 0xa5a5a5a5a5fffff5) + EXT( 0xa5a5a5a5a5a59ef4, 38, 22, 0x00000000001a59ef) + EXTU(0xa5a5a5a5a5a59ef4, 38, 22, 0x00000000001a59ef) + DEP( 0xa5a5a5a5a5a59ef4, 2097151, 38, 22, 0xa5a5a5a5a5fffff4) + EXT( 0xa5a5a5a5a5a59ef3, 38, 23, 0x000000000034b3de) + EXTU(0xa5a5a5a5a5a59ef3, 38, 23, 0x000000000034b3de) + DEP( 0xa5a5a5a5a5a59ef3, 4194303, 38, 23, 0xa5a5a5a5a5fffffb) + EXT( 0xa5a5a5a5a5a59ef2, 38, 24, 0x00000000006967bc) + EXTU(0xa5a5a5a5a5a59ef2, 38, 24, 0x00000000006967bc) + DEP( 0xa5a5a5a5a5a59ef2, 8388607, 38, 24, 0xa5a5a5a5a5fffffe) + EXT( 0xa5a5a5a5a5a59ef1, 38, 25, 0x0000000000d2cf78) + EXTU(0xa5a5a5a5a5a59ef1, 38, 25, 0x0000000000d2cf78) + DEP( 0xa5a5a5a5a5a59ef1, 16777215, 38, 25, 0xa5a5a5a5a5ffffff) + EXT( 0xa5a5a5a5a5a59ef0, 39, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59ef0, 39, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ef0, 0, 39, 1, 0xa5a5a5a5a4a59ef0) + EXT( 0xa5a5a5a5a5a59eef, 39, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59eef, 39, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59eef, 1, 39, 2, 0xa5a5a5a5a4a59eef) + EXT( 0xa5a5a5a5a5a59eee, 39, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59eee, 39, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59eee, 3, 39, 3, 0xa5a5a5a5a4e59eee) + EXT( 0xa5a5a5a5a5a59eed, 39, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59eed, 39, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59eed, 7, 39, 4, 0xa5a5a5a5a4e59eed) + EXT( 0xa5a5a5a5a5a59eec, 39, 5, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59eec, 39, 5, 0x000000000000001a) + DEP( 0xa5a5a5a5a5a59eec, 15, 39, 5, 0xa5a5a5a5a4f59eec) + EXT( 0xa5a5a5a5a5a59eeb, 39, 6, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59eeb, 39, 6, 0x0000000000000034) + DEP( 0xa5a5a5a5a5a59eeb, 31, 39, 6, 0xa5a5a5a5a4fd9eeb) + EXT( 0xa5a5a5a5a5a59eea, 39, 7, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59eea, 39, 7, 0x0000000000000069) + DEP( 0xa5a5a5a5a5a59eea, 63, 39, 7, 0xa5a5a5a5a4fd9eea) + EXT( 0xa5a5a5a5a5a59ee9, 39, 8, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59ee9, 39, 8, 0x00000000000000d2) + DEP( 0xa5a5a5a5a5a59ee9, 127, 39, 8, 0xa5a5a5a5a4ff9ee9) + EXT( 0xa5a5a5a5a5a59ee8, 39, 9, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59ee8, 39, 9, 0x00000000000001a5) + DEP( 0xa5a5a5a5a5a59ee8, 255, 39, 9, 0xa5a5a5a5a4ff9ee8) + EXT( 0xa5a5a5a5a5a59ee7, 39, 10, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59ee7, 39, 10, 0x000000000000034b) + DEP( 0xa5a5a5a5a5a59ee7, 511, 39, 10, 0xa5a5a5a5a4ff9ee7) + EXT( 0xa5a5a5a5a5a59ee6, 39, 11, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59ee6, 39, 11, 0x0000000000000696) + DEP( 0xa5a5a5a5a5a59ee6, 1023, 39, 11, 0xa5a5a5a5a4ffdee6) + EXT( 0xa5a5a5a5a5a59ee5, 39, 12, 0xfffffffffffffd2c) + EXTU(0xa5a5a5a5a5a59ee5, 39, 12, 0x0000000000000d2c) + DEP( 0xa5a5a5a5a5a59ee5, 2047, 39, 12, 0xa5a5a5a5a4fffee5) + EXT( 0xa5a5a5a5a5a59ee4, 39, 13, 0xfffffffffffffa59) + EXTU(0xa5a5a5a5a5a59ee4, 39, 13, 0x0000000000001a59) + DEP( 0xa5a5a5a5a5a59ee4, 4095, 39, 13, 0xa5a5a5a5a4fffee4) + EXT( 0xa5a5a5a5a5a59ee3, 39, 14, 0xfffffffffffff4b3) + EXTU(0xa5a5a5a5a5a59ee3, 39, 14, 0x00000000000034b3) + DEP( 0xa5a5a5a5a5a59ee3, 8191, 39, 14, 0xa5a5a5a5a4fffee3) + EXT( 0xa5a5a5a5a5a59ee2, 39, 15, 0xffffffffffffe967) + EXTU(0xa5a5a5a5a5a59ee2, 39, 15, 0x0000000000006967) + DEP( 0xa5a5a5a5a5a59ee2, 16383, 39, 15, 0xa5a5a5a5a4fffee2) + EXT( 0xa5a5a5a5a5a59ee1, 39, 16, 0xffffffffffffd2cf) + EXTU(0xa5a5a5a5a5a59ee1, 39, 16, 0x000000000000d2cf) + DEP( 0xa5a5a5a5a5a59ee1, 32767, 39, 16, 0xa5a5a5a5a4fffee1) + EXT( 0xa5a5a5a5a5a59ee0, 39, 17, 0xffffffffffffa59e) + EXTU(0xa5a5a5a5a5a59ee0, 39, 17, 0x000000000001a59e) + DEP( 0xa5a5a5a5a5a59ee0, 65535, 39, 17, 0xa5a5a5a5a4ffffe0) + EXT( 0xa5a5a5a5a5a59edf, 39, 18, 0xffffffffffff4b3d) + EXTU(0xa5a5a5a5a5a59edf, 39, 18, 0x0000000000034b3d) + DEP( 0xa5a5a5a5a5a59edf, 131071, 39, 18, 0xa5a5a5a5a4ffffdf) + EXT( 0xa5a5a5a5a5a59ede, 39, 19, 0xfffffffffffe967b) + EXTU(0xa5a5a5a5a5a59ede, 39, 19, 0x000000000006967b) + DEP( 0xa5a5a5a5a5a59ede, 262143, 39, 19, 0xa5a5a5a5a4ffffde) + EXT( 0xa5a5a5a5a5a59edd, 39, 20, 0xfffffffffffd2cf6) + EXTU(0xa5a5a5a5a5a59edd, 39, 20, 0x00000000000d2cf6) + DEP( 0xa5a5a5a5a5a59edd, 524287, 39, 20, 0xa5a5a5a5a4fffffd) + EXT( 0xa5a5a5a5a5a59edc, 39, 21, 0xfffffffffffa59ed) + EXTU(0xa5a5a5a5a5a59edc, 39, 21, 0x00000000001a59ed) + DEP( 0xa5a5a5a5a5a59edc, 1048575, 39, 21, 0xa5a5a5a5a4fffffc) + EXT( 0xa5a5a5a5a5a59edb, 39, 22, 0xfffffffffff4b3db) + EXTU(0xa5a5a5a5a5a59edb, 39, 22, 0x000000000034b3db) + DEP( 0xa5a5a5a5a5a59edb, 2097151, 39, 22, 0xa5a5a5a5a4fffffb) + EXT( 0xa5a5a5a5a5a59eda, 39, 23, 0xffffffffffe967b6) + EXTU(0xa5a5a5a5a5a59eda, 39, 23, 0x00000000006967b6) + DEP( 0xa5a5a5a5a5a59eda, 4194303, 39, 23, 0xa5a5a5a5a4fffffe) + EXT( 0xa5a5a5a5a5a59ed9, 39, 24, 0xffffffffffd2cf6c) + EXTU(0xa5a5a5a5a5a59ed9, 39, 24, 0x0000000000d2cf6c) + DEP( 0xa5a5a5a5a5a59ed9, 8388607, 39, 24, 0xa5a5a5a5a4ffffff) + EXT( 0xa5a5a5a5a5a59ed8, 40, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59ed8, 40, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ed8, 0, 40, 1, 0xa5a5a5a5a5259ed8) + EXT( 0xa5a5a5a5a5a59ed7, 40, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59ed7, 40, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ed7, 1, 40, 2, 0xa5a5a5a5a5659ed7) + EXT( 0xa5a5a5a5a5a59ed6, 40, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59ed6, 40, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59ed6, 3, 40, 3, 0xa5a5a5a5a5659ed6) + EXT( 0xa5a5a5a5a5a59ed5, 40, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59ed5, 40, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59ed5, 7, 40, 4, 0xa5a5a5a5a5759ed5) + EXT( 0xa5a5a5a5a5a59ed4, 40, 5, 0xfffffffffffffff4) + EXTU(0xa5a5a5a5a5a59ed4, 40, 5, 0x0000000000000014) + DEP( 0xa5a5a5a5a5a59ed4, 15, 40, 5, 0xa5a5a5a5a57d9ed4) + EXT( 0xa5a5a5a5a5a59ed3, 40, 6, 0xffffffffffffffe9) + EXTU(0xa5a5a5a5a5a59ed3, 40, 6, 0x0000000000000029) + DEP( 0xa5a5a5a5a5a59ed3, 31, 40, 6, 0xa5a5a5a5a57d9ed3) + EXT( 0xa5a5a5a5a5a59ed2, 40, 7, 0xffffffffffffffd2) + EXTU(0xa5a5a5a5a5a59ed2, 40, 7, 0x0000000000000052) + DEP( 0xa5a5a5a5a5a59ed2, 63, 40, 7, 0xa5a5a5a5a57f9ed2) + EXT( 0xa5a5a5a5a5a59ed1, 40, 8, 0xffffffffffffffa5) + EXTU(0xa5a5a5a5a5a59ed1, 40, 8, 0x00000000000000a5) + DEP( 0xa5a5a5a5a5a59ed1, 127, 40, 8, 0xa5a5a5a5a57f9ed1) + EXT( 0xa5a5a5a5a5a59ed0, 40, 9, 0xffffffffffffff4b) + EXTU(0xa5a5a5a5a5a59ed0, 40, 9, 0x000000000000014b) + DEP( 0xa5a5a5a5a5a59ed0, 255, 40, 9, 0xa5a5a5a5a57f9ed0) + EXT( 0xa5a5a5a5a5a59ecf, 40, 10, 0xfffffffffffffe96) + EXTU(0xa5a5a5a5a5a59ecf, 40, 10, 0x0000000000000296) + DEP( 0xa5a5a5a5a5a59ecf, 511, 40, 10, 0xa5a5a5a5a57fdecf) + EXT( 0xa5a5a5a5a5a59ece, 40, 11, 0xfffffffffffffd2c) + EXTU(0xa5a5a5a5a5a59ece, 40, 11, 0x000000000000052c) + DEP( 0xa5a5a5a5a5a59ece, 1023, 40, 11, 0xa5a5a5a5a57ffece) + EXT( 0xa5a5a5a5a5a59ecd, 40, 12, 0xfffffffffffffa59) + EXTU(0xa5a5a5a5a5a59ecd, 40, 12, 0x0000000000000a59) + DEP( 0xa5a5a5a5a5a59ecd, 2047, 40, 12, 0xa5a5a5a5a57ffecd) + EXT( 0xa5a5a5a5a5a59ecc, 40, 13, 0xfffffffffffff4b3) + EXTU(0xa5a5a5a5a5a59ecc, 40, 13, 0x00000000000014b3) + DEP( 0xa5a5a5a5a5a59ecc, 4095, 40, 13, 0xa5a5a5a5a57ffecc) + EXT( 0xa5a5a5a5a5a59ecb, 40, 14, 0xffffffffffffe967) + EXTU(0xa5a5a5a5a5a59ecb, 40, 14, 0x0000000000002967) + DEP( 0xa5a5a5a5a5a59ecb, 8191, 40, 14, 0xa5a5a5a5a57ffecb) + EXT( 0xa5a5a5a5a5a59eca, 40, 15, 0xffffffffffffd2cf) + EXTU(0xa5a5a5a5a5a59eca, 40, 15, 0x00000000000052cf) + DEP( 0xa5a5a5a5a5a59eca, 16383, 40, 15, 0xa5a5a5a5a57ffeca) + EXT( 0xa5a5a5a5a5a59ec9, 40, 16, 0xffffffffffffa59e) + EXTU(0xa5a5a5a5a5a59ec9, 40, 16, 0x000000000000a59e) + DEP( 0xa5a5a5a5a5a59ec9, 32767, 40, 16, 0xa5a5a5a5a57fffc9) + EXT( 0xa5a5a5a5a5a59ec8, 40, 17, 0xffffffffffff4b3d) + EXTU(0xa5a5a5a5a5a59ec8, 40, 17, 0x0000000000014b3d) + DEP( 0xa5a5a5a5a5a59ec8, 65535, 40, 17, 0xa5a5a5a5a57fffc8) + EXT( 0xa5a5a5a5a5a59ec7, 40, 18, 0xfffffffffffe967b) + EXTU(0xa5a5a5a5a5a59ec7, 40, 18, 0x000000000002967b) + DEP( 0xa5a5a5a5a5a59ec7, 131071, 40, 18, 0xa5a5a5a5a57fffc7) + EXT( 0xa5a5a5a5a5a59ec6, 40, 19, 0xfffffffffffd2cf6) + EXTU(0xa5a5a5a5a5a59ec6, 40, 19, 0x0000000000052cf6) + DEP( 0xa5a5a5a5a5a59ec6, 262143, 40, 19, 0xa5a5a5a5a57fffe6) + EXT( 0xa5a5a5a5a5a59ec5, 40, 20, 0xfffffffffffa59ec) + EXTU(0xa5a5a5a5a5a59ec5, 40, 20, 0x00000000000a59ec) + DEP( 0xa5a5a5a5a5a59ec5, 524287, 40, 20, 0xa5a5a5a5a57ffff5) + EXT( 0xa5a5a5a5a5a59ec4, 40, 21, 0xfffffffffff4b3d8) + EXTU(0xa5a5a5a5a5a59ec4, 40, 21, 0x000000000014b3d8) + DEP( 0xa5a5a5a5a5a59ec4, 1048575, 40, 21, 0xa5a5a5a5a57ffffc) + EXT( 0xa5a5a5a5a5a59ec3, 40, 22, 0xffffffffffe967b0) + EXTU(0xa5a5a5a5a5a59ec3, 40, 22, 0x00000000002967b0) + DEP( 0xa5a5a5a5a5a59ec3, 2097151, 40, 22, 0xa5a5a5a5a57fffff) + EXT( 0xa5a5a5a5a5a59ec2, 40, 23, 0xffffffffffd2cf61) + EXTU(0xa5a5a5a5a5a59ec2, 40, 23, 0x000000000052cf61) + DEP( 0xa5a5a5a5a5a59ec2, 4194303, 40, 23, 0xa5a5a5a5a57ffffe) + EXT( 0xa5a5a5a5a5a59ec1, 41, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59ec1, 41, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59ec1, 0, 41, 1, 0xa5a5a5a5a5a59ec1) + EXT( 0xa5a5a5a5a5a59ec0, 41, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59ec0, 41, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59ec0, 1, 41, 2, 0xa5a5a5a5a5a59ec0) + EXT( 0xa5a5a5a5a5a59ebf, 41, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59ebf, 41, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59ebf, 3, 41, 3, 0xa5a5a5a5a5b59ebf) + EXT( 0xa5a5a5a5a5a59ebe, 41, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59ebe, 41, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59ebe, 7, 41, 4, 0xa5a5a5a5a5bd9ebe) + EXT( 0xa5a5a5a5a5a59ebd, 41, 5, 0x0000000000000009) + EXTU(0xa5a5a5a5a5a59ebd, 41, 5, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59ebd, 15, 41, 5, 0xa5a5a5a5a5bd9ebd) + EXT( 0xa5a5a5a5a5a59ebc, 41, 6, 0x0000000000000012) + EXTU(0xa5a5a5a5a5a59ebc, 41, 6, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59ebc, 31, 41, 6, 0xa5a5a5a5a5bf9ebc) + EXT( 0xa5a5a5a5a5a59ebb, 41, 7, 0x0000000000000025) + EXTU(0xa5a5a5a5a5a59ebb, 41, 7, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59ebb, 63, 41, 7, 0xa5a5a5a5a5bf9ebb) + EXT( 0xa5a5a5a5a5a59eba, 41, 8, 0x000000000000004b) + EXTU(0xa5a5a5a5a5a59eba, 41, 8, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59eba, 127, 41, 8, 0xa5a5a5a5a5bf9eba) + EXT( 0xa5a5a5a5a5a59eb9, 41, 9, 0x0000000000000096) + EXTU(0xa5a5a5a5a5a59eb9, 41, 9, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59eb9, 255, 41, 9, 0xa5a5a5a5a5bfdeb9) + EXT( 0xa5a5a5a5a5a59eb8, 41, 10, 0x000000000000012c) + EXTU(0xa5a5a5a5a5a59eb8, 41, 10, 0x000000000000012c) + DEP( 0xa5a5a5a5a5a59eb8, 511, 41, 10, 0xa5a5a5a5a5bffeb8) + EXT( 0xa5a5a5a5a5a59eb7, 41, 11, 0x0000000000000259) + EXTU(0xa5a5a5a5a5a59eb7, 41, 11, 0x0000000000000259) + DEP( 0xa5a5a5a5a5a59eb7, 1023, 41, 11, 0xa5a5a5a5a5bffeb7) + EXT( 0xa5a5a5a5a5a59eb6, 41, 12, 0x00000000000004b3) + EXTU(0xa5a5a5a5a5a59eb6, 41, 12, 0x00000000000004b3) + DEP( 0xa5a5a5a5a5a59eb6, 2047, 41, 12, 0xa5a5a5a5a5bffeb6) + EXT( 0xa5a5a5a5a5a59eb5, 41, 13, 0x0000000000000967) + EXTU(0xa5a5a5a5a5a59eb5, 41, 13, 0x0000000000000967) + DEP( 0xa5a5a5a5a5a59eb5, 4095, 41, 13, 0xa5a5a5a5a5bffeb5) + EXT( 0xa5a5a5a5a5a59eb4, 41, 14, 0x00000000000012cf) + EXTU(0xa5a5a5a5a5a59eb4, 41, 14, 0x00000000000012cf) + DEP( 0xa5a5a5a5a5a59eb4, 8191, 41, 14, 0xa5a5a5a5a5bffeb4) + EXT( 0xa5a5a5a5a5a59eb3, 41, 15, 0x000000000000259e) + EXTU(0xa5a5a5a5a5a59eb3, 41, 15, 0x000000000000259e) + DEP( 0xa5a5a5a5a5a59eb3, 16383, 41, 15, 0xa5a5a5a5a5bfffb3) + EXT( 0xa5a5a5a5a5a59eb2, 41, 16, 0x0000000000004b3d) + EXTU(0xa5a5a5a5a5a59eb2, 41, 16, 0x0000000000004b3d) + DEP( 0xa5a5a5a5a5a59eb2, 32767, 41, 16, 0xa5a5a5a5a5bfffb2) + EXT( 0xa5a5a5a5a5a59eb1, 41, 17, 0x000000000000967a) + EXTU(0xa5a5a5a5a5a59eb1, 41, 17, 0x000000000000967a) + DEP( 0xa5a5a5a5a5a59eb1, 65535, 41, 17, 0xa5a5a5a5a5bffff1) + EXT( 0xa5a5a5a5a5a59eb0, 41, 18, 0x0000000000012cf5) + EXTU(0xa5a5a5a5a5a59eb0, 41, 18, 0x0000000000012cf5) + DEP( 0xa5a5a5a5a5a59eb0, 131071, 41, 18, 0xa5a5a5a5a5bffff0) + EXT( 0xa5a5a5a5a5a59eaf, 41, 19, 0x00000000000259ea) + EXTU(0xa5a5a5a5a5a59eaf, 41, 19, 0x00000000000259ea) + DEP( 0xa5a5a5a5a5a59eaf, 262143, 41, 19, 0xa5a5a5a5a5bfffff) + EXT( 0xa5a5a5a5a5a59eae, 41, 20, 0x000000000004b3d5) + EXTU(0xa5a5a5a5a5a59eae, 41, 20, 0x000000000004b3d5) + DEP( 0xa5a5a5a5a5a59eae, 524287, 41, 20, 0xa5a5a5a5a5bffffe) + EXT( 0xa5a5a5a5a5a59ead, 41, 21, 0x00000000000967ab) + EXTU(0xa5a5a5a5a5a59ead, 41, 21, 0x00000000000967ab) + DEP( 0xa5a5a5a5a5a59ead, 1048575, 41, 21, 0xa5a5a5a5a5bffffd) + EXT( 0xa5a5a5a5a5a59eac, 41, 22, 0x000000000012cf56) + EXTU(0xa5a5a5a5a5a59eac, 41, 22, 0x000000000012cf56) + DEP( 0xa5a5a5a5a5a59eac, 2097151, 41, 22, 0xa5a5a5a5a5bffffe) + EXT( 0xa5a5a5a5a5a59eab, 42, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59eab, 42, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59eab, 0, 42, 1, 0xa5a5a5a5a5859eab) + EXT( 0xa5a5a5a5a5a59eaa, 42, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59eaa, 42, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59eaa, 1, 42, 2, 0xa5a5a5a5a5959eaa) + EXT( 0xa5a5a5a5a5a59ea9, 42, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59ea9, 42, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59ea9, 3, 42, 3, 0xa5a5a5a5a59d9ea9) + EXT( 0xa5a5a5a5a5a59ea8, 42, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59ea8, 42, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59ea8, 7, 42, 4, 0xa5a5a5a5a59d9ea8) + EXT( 0xa5a5a5a5a5a59ea7, 42, 5, 0xfffffffffffffff2) + EXTU(0xa5a5a5a5a5a59ea7, 42, 5, 0x0000000000000012) + DEP( 0xa5a5a5a5a5a59ea7, 15, 42, 5, 0xa5a5a5a5a59f9ea7) + EXT( 0xa5a5a5a5a5a59ea6, 42, 6, 0xffffffffffffffe5) + EXTU(0xa5a5a5a5a5a59ea6, 42, 6, 0x0000000000000025) + DEP( 0xa5a5a5a5a5a59ea6, 31, 42, 6, 0xa5a5a5a5a59f9ea6) + EXT( 0xa5a5a5a5a5a59ea5, 42, 7, 0xffffffffffffffcb) + EXTU(0xa5a5a5a5a5a59ea5, 42, 7, 0x000000000000004b) + DEP( 0xa5a5a5a5a5a59ea5, 63, 42, 7, 0xa5a5a5a5a59f9ea5) + EXT( 0xa5a5a5a5a5a59ea4, 42, 8, 0xffffffffffffff96) + EXTU(0xa5a5a5a5a5a59ea4, 42, 8, 0x0000000000000096) + DEP( 0xa5a5a5a5a5a59ea4, 127, 42, 8, 0xa5a5a5a5a59fdea4) + EXT( 0xa5a5a5a5a5a59ea3, 42, 9, 0xffffffffffffff2c) + EXTU(0xa5a5a5a5a5a59ea3, 42, 9, 0x000000000000012c) + DEP( 0xa5a5a5a5a5a59ea3, 255, 42, 9, 0xa5a5a5a5a59ffea3) + EXT( 0xa5a5a5a5a5a59ea2, 42, 10, 0xfffffffffffffe59) + EXTU(0xa5a5a5a5a5a59ea2, 42, 10, 0x0000000000000259) + DEP( 0xa5a5a5a5a5a59ea2, 511, 42, 10, 0xa5a5a5a5a59ffea2) + EXT( 0xa5a5a5a5a5a59ea1, 42, 11, 0xfffffffffffffcb3) + EXTU(0xa5a5a5a5a5a59ea1, 42, 11, 0x00000000000004b3) + DEP( 0xa5a5a5a5a5a59ea1, 1023, 42, 11, 0xa5a5a5a5a59ffea1) + EXT( 0xa5a5a5a5a5a59ea0, 42, 12, 0xfffffffffffff967) + EXTU(0xa5a5a5a5a5a59ea0, 42, 12, 0x0000000000000967) + DEP( 0xa5a5a5a5a5a59ea0, 2047, 42, 12, 0xa5a5a5a5a59ffea0) + EXT( 0xa5a5a5a5a5a59e9f, 42, 13, 0xfffffffffffff2cf) + EXTU(0xa5a5a5a5a5a59e9f, 42, 13, 0x00000000000012cf) + DEP( 0xa5a5a5a5a5a59e9f, 4095, 42, 13, 0xa5a5a5a5a59ffe9f) + EXT( 0xa5a5a5a5a5a59e9e, 42, 14, 0xffffffffffffe59e) + EXTU(0xa5a5a5a5a5a59e9e, 42, 14, 0x000000000000259e) + DEP( 0xa5a5a5a5a5a59e9e, 8191, 42, 14, 0xa5a5a5a5a59fff9e) + EXT( 0xa5a5a5a5a5a59e9d, 42, 15, 0xffffffffffffcb3d) + EXTU(0xa5a5a5a5a5a59e9d, 42, 15, 0x0000000000004b3d) + DEP( 0xa5a5a5a5a5a59e9d, 16383, 42, 15, 0xa5a5a5a5a59fff9d) + EXT( 0xa5a5a5a5a5a59e9c, 42, 16, 0xffffffffffff967a) + EXTU(0xa5a5a5a5a5a59e9c, 42, 16, 0x000000000000967a) + DEP( 0xa5a5a5a5a5a59e9c, 32767, 42, 16, 0xa5a5a5a5a59fffdc) + EXT( 0xa5a5a5a5a5a59e9b, 42, 17, 0xffffffffffff2cf4) + EXTU(0xa5a5a5a5a5a59e9b, 42, 17, 0x0000000000012cf4) + DEP( 0xa5a5a5a5a5a59e9b, 65535, 42, 17, 0xa5a5a5a5a59ffffb) + EXT( 0xa5a5a5a5a5a59e9a, 42, 18, 0xfffffffffffe59e9) + EXTU(0xa5a5a5a5a5a59e9a, 42, 18, 0x00000000000259e9) + DEP( 0xa5a5a5a5a5a59e9a, 131071, 42, 18, 0xa5a5a5a5a59ffffa) + EXT( 0xa5a5a5a5a5a59e99, 42, 19, 0xfffffffffffcb3d3) + EXTU(0xa5a5a5a5a5a59e99, 42, 19, 0x000000000004b3d3) + DEP( 0xa5a5a5a5a5a59e99, 262143, 42, 19, 0xa5a5a5a5a59ffff9) + EXT( 0xa5a5a5a5a5a59e98, 42, 20, 0xfffffffffff967a6) + EXTU(0xa5a5a5a5a5a59e98, 42, 20, 0x00000000000967a6) + DEP( 0xa5a5a5a5a5a59e98, 524287, 42, 20, 0xa5a5a5a5a59ffffc) + EXT( 0xa5a5a5a5a5a59e97, 42, 21, 0xfffffffffff2cf4b) + EXTU(0xa5a5a5a5a5a59e97, 42, 21, 0x000000000012cf4b) + DEP( 0xa5a5a5a5a5a59e97, 1048575, 42, 21, 0xa5a5a5a5a59fffff) + EXT( 0xa5a5a5a5a5a59e96, 43, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e96, 43, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e96, 0, 43, 1, 0xa5a5a5a5a5a59e96) + EXT( 0xa5a5a5a5a5a59e95, 43, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e95, 43, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e95, 1, 43, 2, 0xa5a5a5a5a5ad9e95) + EXT( 0xa5a5a5a5a5a59e94, 43, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e94, 43, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e94, 3, 43, 3, 0xa5a5a5a5a5ad9e94) + EXT( 0xa5a5a5a5a5a59e93, 43, 4, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e93, 43, 4, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e93, 7, 43, 4, 0xa5a5a5a5a5af9e93) + EXT( 0xa5a5a5a5a5a59e92, 43, 5, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59e92, 43, 5, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e92, 15, 43, 5, 0xa5a5a5a5a5af9e92) + EXT( 0xa5a5a5a5a5a59e91, 43, 6, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59e91, 43, 6, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e91, 31, 43, 6, 0xa5a5a5a5a5af9e91) + EXT( 0xa5a5a5a5a5a59e90, 43, 7, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59e90, 43, 7, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e90, 63, 43, 7, 0xa5a5a5a5a5afde90) + EXT( 0xa5a5a5a5a5a59e8f, 43, 8, 0x000000000000002c) + EXTU(0xa5a5a5a5a5a59e8f, 43, 8, 0x000000000000002c) + DEP( 0xa5a5a5a5a5a59e8f, 127, 43, 8, 0xa5a5a5a5a5affe8f) + EXT( 0xa5a5a5a5a5a59e8e, 43, 9, 0x0000000000000059) + EXTU(0xa5a5a5a5a5a59e8e, 43, 9, 0x0000000000000059) + DEP( 0xa5a5a5a5a5a59e8e, 255, 43, 9, 0xa5a5a5a5a5affe8e) + EXT( 0xa5a5a5a5a5a59e8d, 43, 10, 0x00000000000000b3) + EXTU(0xa5a5a5a5a5a59e8d, 43, 10, 0x00000000000000b3) + DEP( 0xa5a5a5a5a5a59e8d, 511, 43, 10, 0xa5a5a5a5a5affe8d) + EXT( 0xa5a5a5a5a5a59e8c, 43, 11, 0x0000000000000167) + EXTU(0xa5a5a5a5a5a59e8c, 43, 11, 0x0000000000000167) + DEP( 0xa5a5a5a5a5a59e8c, 1023, 43, 11, 0xa5a5a5a5a5affe8c) + EXT( 0xa5a5a5a5a5a59e8b, 43, 12, 0x00000000000002cf) + EXTU(0xa5a5a5a5a5a59e8b, 43, 12, 0x00000000000002cf) + DEP( 0xa5a5a5a5a5a59e8b, 2047, 43, 12, 0xa5a5a5a5a5affe8b) + EXT( 0xa5a5a5a5a5a59e8a, 43, 13, 0x000000000000059e) + EXTU(0xa5a5a5a5a5a59e8a, 43, 13, 0x000000000000059e) + DEP( 0xa5a5a5a5a5a59e8a, 4095, 43, 13, 0xa5a5a5a5a5afff8a) + EXT( 0xa5a5a5a5a5a59e89, 43, 14, 0x0000000000000b3d) + EXTU(0xa5a5a5a5a5a59e89, 43, 14, 0x0000000000000b3d) + DEP( 0xa5a5a5a5a5a59e89, 8191, 43, 14, 0xa5a5a5a5a5afff89) + EXT( 0xa5a5a5a5a5a59e88, 43, 15, 0x000000000000167a) + EXTU(0xa5a5a5a5a5a59e88, 43, 15, 0x000000000000167a) + DEP( 0xa5a5a5a5a5a59e88, 16383, 43, 15, 0xa5a5a5a5a5afffc8) + EXT( 0xa5a5a5a5a5a59e87, 43, 16, 0x0000000000002cf4) + EXTU(0xa5a5a5a5a5a59e87, 43, 16, 0x0000000000002cf4) + DEP( 0xa5a5a5a5a5a59e87, 32767, 43, 16, 0xa5a5a5a5a5afffe7) + EXT( 0xa5a5a5a5a5a59e86, 43, 17, 0x00000000000059e8) + EXTU(0xa5a5a5a5a5a59e86, 43, 17, 0x00000000000059e8) + DEP( 0xa5a5a5a5a5a59e86, 65535, 43, 17, 0xa5a5a5a5a5affff6) + EXT( 0xa5a5a5a5a5a59e85, 43, 18, 0x000000000000b3d0) + EXTU(0xa5a5a5a5a5a59e85, 43, 18, 0x000000000000b3d0) + DEP( 0xa5a5a5a5a5a59e85, 131071, 43, 18, 0xa5a5a5a5a5affffd) + EXT( 0xa5a5a5a5a5a59e84, 43, 19, 0x00000000000167a1) + EXTU(0xa5a5a5a5a5a59e84, 43, 19, 0x00000000000167a1) + DEP( 0xa5a5a5a5a5a59e84, 262143, 43, 19, 0xa5a5a5a5a5affffc) + EXT( 0xa5a5a5a5a5a59e83, 43, 20, 0x000000000002cf41) + EXTU(0xa5a5a5a5a5a59e83, 43, 20, 0x000000000002cf41) + DEP( 0xa5a5a5a5a5a59e83, 524287, 43, 20, 0xa5a5a5a5a5afffff) + EXT( 0xa5a5a5a5a5a59e82, 44, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e82, 44, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e82, 0, 44, 1, 0xa5a5a5a5a5a59e82) + EXT( 0xa5a5a5a5a5a59e81, 44, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e81, 44, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e81, 1, 44, 2, 0xa5a5a5a5a5a59e81) + EXT( 0xa5a5a5a5a5a59e80, 44, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59e80, 44, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e80, 3, 44, 3, 0xa5a5a5a5a5a79e80) + EXT( 0xa5a5a5a5a5a59e7f, 44, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59e7f, 44, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e7f, 7, 44, 4, 0xa5a5a5a5a5a79e7f) + EXT( 0xa5a5a5a5a5a59e7e, 44, 5, 0x000000000000000b) + EXTU(0xa5a5a5a5a5a59e7e, 44, 5, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e7e, 15, 44, 5, 0xa5a5a5a5a5a79e7e) + EXT( 0xa5a5a5a5a5a59e7d, 44, 6, 0x0000000000000016) + EXTU(0xa5a5a5a5a5a59e7d, 44, 6, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e7d, 31, 44, 6, 0xa5a5a5a5a5a7de7d) + EXT( 0xa5a5a5a5a5a59e7c, 44, 7, 0x000000000000002c) + EXTU(0xa5a5a5a5a5a59e7c, 44, 7, 0x000000000000002c) + DEP( 0xa5a5a5a5a5a59e7c, 63, 44, 7, 0xa5a5a5a5a5a7fe7c) + EXT( 0xa5a5a5a5a5a59e7b, 44, 8, 0x0000000000000059) + EXTU(0xa5a5a5a5a5a59e7b, 44, 8, 0x0000000000000059) + DEP( 0xa5a5a5a5a5a59e7b, 127, 44, 8, 0xa5a5a5a5a5a7fe7b) + EXT( 0xa5a5a5a5a5a59e7a, 44, 9, 0x00000000000000b3) + EXTU(0xa5a5a5a5a5a59e7a, 44, 9, 0x00000000000000b3) + DEP( 0xa5a5a5a5a5a59e7a, 255, 44, 9, 0xa5a5a5a5a5a7fe7a) + EXT( 0xa5a5a5a5a5a59e79, 44, 10, 0x0000000000000167) + EXTU(0xa5a5a5a5a5a59e79, 44, 10, 0x0000000000000167) + DEP( 0xa5a5a5a5a5a59e79, 511, 44, 10, 0xa5a5a5a5a5a7fe79) + EXT( 0xa5a5a5a5a5a59e78, 44, 11, 0x00000000000002cf) + EXTU(0xa5a5a5a5a5a59e78, 44, 11, 0x00000000000002cf) + DEP( 0xa5a5a5a5a5a59e78, 1023, 44, 11, 0xa5a5a5a5a5a7fe78) + EXT( 0xa5a5a5a5a5a59e77, 44, 12, 0x000000000000059e) + EXTU(0xa5a5a5a5a5a59e77, 44, 12, 0x000000000000059e) + DEP( 0xa5a5a5a5a5a59e77, 2047, 44, 12, 0xa5a5a5a5a5a7ff77) + EXT( 0xa5a5a5a5a5a59e76, 44, 13, 0x0000000000000b3c) + EXTU(0xa5a5a5a5a5a59e76, 44, 13, 0x0000000000000b3c) + DEP( 0xa5a5a5a5a5a59e76, 4095, 44, 13, 0xa5a5a5a5a5a7fff6) + EXT( 0xa5a5a5a5a5a59e75, 44, 14, 0x0000000000001679) + EXTU(0xa5a5a5a5a5a59e75, 44, 14, 0x0000000000001679) + DEP( 0xa5a5a5a5a5a59e75, 8191, 44, 14, 0xa5a5a5a5a5a7fff5) + EXT( 0xa5a5a5a5a5a59e74, 44, 15, 0x0000000000002cf3) + EXTU(0xa5a5a5a5a5a59e74, 44, 15, 0x0000000000002cf3) + DEP( 0xa5a5a5a5a5a59e74, 16383, 44, 15, 0xa5a5a5a5a5a7fff4) + EXT( 0xa5a5a5a5a5a59e73, 44, 16, 0x00000000000059e7) + EXTU(0xa5a5a5a5a5a59e73, 44, 16, 0x00000000000059e7) + DEP( 0xa5a5a5a5a5a59e73, 32767, 44, 16, 0xa5a5a5a5a5a7fff3) + EXT( 0xa5a5a5a5a5a59e72, 44, 17, 0x000000000000b3ce) + EXTU(0xa5a5a5a5a5a59e72, 44, 17, 0x000000000000b3ce) + DEP( 0xa5a5a5a5a5a59e72, 65535, 44, 17, 0xa5a5a5a5a5a7fffa) + EXT( 0xa5a5a5a5a5a59e71, 44, 18, 0x000000000001679c) + EXTU(0xa5a5a5a5a5a59e71, 44, 18, 0x000000000001679c) + DEP( 0xa5a5a5a5a5a59e71, 131071, 44, 18, 0xa5a5a5a5a5a7fffd) + EXT( 0xa5a5a5a5a5a59e70, 44, 19, 0x000000000002cf38) + EXTU(0xa5a5a5a5a5a59e70, 44, 19, 0x000000000002cf38) + DEP( 0xa5a5a5a5a5a59e70, 262143, 44, 19, 0xa5a5a5a5a5a7fffe) + EXT( 0xa5a5a5a5a5a59e6f, 45, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e6f, 45, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e6f, 0, 45, 1, 0xa5a5a5a5a5a19e6f) + EXT( 0xa5a5a5a5a5a59e6e, 45, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e6e, 45, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e6e, 1, 45, 2, 0xa5a5a5a5a5a39e6e) + EXT( 0xa5a5a5a5a5a59e6d, 45, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59e6d, 45, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59e6d, 3, 45, 3, 0xa5a5a5a5a5a39e6d) + EXT( 0xa5a5a5a5a5a59e6c, 45, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59e6c, 45, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59e6c, 7, 45, 4, 0xa5a5a5a5a5a39e6c) + EXT( 0xa5a5a5a5a5a59e6b, 45, 5, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59e6b, 45, 5, 0x0000000000000016) + DEP( 0xa5a5a5a5a5a59e6b, 15, 45, 5, 0xa5a5a5a5a5a3de6b) + EXT( 0xa5a5a5a5a5a59e6a, 45, 6, 0xffffffffffffffec) + EXTU(0xa5a5a5a5a5a59e6a, 45, 6, 0x000000000000002c) + DEP( 0xa5a5a5a5a5a59e6a, 31, 45, 6, 0xa5a5a5a5a5a3fe6a) + EXT( 0xa5a5a5a5a5a59e69, 45, 7, 0xffffffffffffffd9) + EXTU(0xa5a5a5a5a5a59e69, 45, 7, 0x0000000000000059) + DEP( 0xa5a5a5a5a5a59e69, 63, 45, 7, 0xa5a5a5a5a5a3fe69) + EXT( 0xa5a5a5a5a5a59e68, 45, 8, 0xffffffffffffffb3) + EXTU(0xa5a5a5a5a5a59e68, 45, 8, 0x00000000000000b3) + DEP( 0xa5a5a5a5a5a59e68, 127, 45, 8, 0xa5a5a5a5a5a3fe68) + EXT( 0xa5a5a5a5a5a59e67, 45, 9, 0xffffffffffffff67) + EXTU(0xa5a5a5a5a5a59e67, 45, 9, 0x0000000000000167) + DEP( 0xa5a5a5a5a5a59e67, 255, 45, 9, 0xa5a5a5a5a5a3fe67) + EXT( 0xa5a5a5a5a5a59e66, 45, 10, 0xfffffffffffffecf) + EXTU(0xa5a5a5a5a5a59e66, 45, 10, 0x00000000000002cf) + DEP( 0xa5a5a5a5a5a59e66, 511, 45, 10, 0xa5a5a5a5a5a3fe66) + EXT( 0xa5a5a5a5a5a59e65, 45, 11, 0xfffffffffffffd9e) + EXTU(0xa5a5a5a5a5a59e65, 45, 11, 0x000000000000059e) + DEP( 0xa5a5a5a5a5a59e65, 1023, 45, 11, 0xa5a5a5a5a5a3ff65) + EXT( 0xa5a5a5a5a5a59e64, 45, 12, 0xfffffffffffffb3c) + EXTU(0xa5a5a5a5a5a59e64, 45, 12, 0x0000000000000b3c) + DEP( 0xa5a5a5a5a5a59e64, 2047, 45, 12, 0xa5a5a5a5a5a3ffe4) + EXT( 0xa5a5a5a5a5a59e63, 45, 13, 0xfffffffffffff679) + EXTU(0xa5a5a5a5a5a59e63, 45, 13, 0x0000000000001679) + DEP( 0xa5a5a5a5a5a59e63, 4095, 45, 13, 0xa5a5a5a5a5a3ffe3) + EXT( 0xa5a5a5a5a5a59e62, 45, 14, 0xffffffffffffecf3) + EXTU(0xa5a5a5a5a5a59e62, 45, 14, 0x0000000000002cf3) + DEP( 0xa5a5a5a5a5a59e62, 8191, 45, 14, 0xa5a5a5a5a5a3ffe2) + EXT( 0xa5a5a5a5a5a59e61, 45, 15, 0xffffffffffffd9e6) + EXTU(0xa5a5a5a5a5a59e61, 45, 15, 0x00000000000059e6) + DEP( 0xa5a5a5a5a5a59e61, 16383, 45, 15, 0xa5a5a5a5a5a3fff1) + EXT( 0xa5a5a5a5a5a59e60, 45, 16, 0xffffffffffffb3cc) + EXTU(0xa5a5a5a5a5a59e60, 45, 16, 0x000000000000b3cc) + DEP( 0xa5a5a5a5a5a59e60, 32767, 45, 16, 0xa5a5a5a5a5a3fff8) + EXT( 0xa5a5a5a5a5a59e5f, 45, 17, 0xffffffffffff6797) + EXTU(0xa5a5a5a5a5a59e5f, 45, 17, 0x0000000000016797) + DEP( 0xa5a5a5a5a5a59e5f, 65535, 45, 17, 0xa5a5a5a5a5a3ffff) + EXT( 0xa5a5a5a5a5a59e5e, 45, 18, 0xfffffffffffecf2f) + EXTU(0xa5a5a5a5a5a59e5e, 45, 18, 0x000000000002cf2f) + DEP( 0xa5a5a5a5a5a59e5e, 131071, 45, 18, 0xa5a5a5a5a5a3fffe) + EXT( 0xa5a5a5a5a5a59e5d, 46, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e5d, 46, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e5d, 0, 46, 1, 0xa5a5a5a5a5a59e5d) + EXT( 0xa5a5a5a5a5a59e5c, 46, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e5c, 46, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e5c, 1, 46, 2, 0xa5a5a5a5a5a59e5c) + EXT( 0xa5a5a5a5a5a59e5b, 46, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59e5b, 46, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e5b, 3, 46, 3, 0xa5a5a5a5a5a59e5b) + EXT( 0xa5a5a5a5a5a59e5a, 46, 4, 0x0000000000000006) + EXTU(0xa5a5a5a5a5a59e5a, 46, 4, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59e5a, 7, 46, 4, 0xa5a5a5a5a5a5de5a) + EXT( 0xa5a5a5a5a5a59e59, 46, 5, 0x000000000000000c) + EXTU(0xa5a5a5a5a5a59e59, 46, 5, 0x000000000000000c) + DEP( 0xa5a5a5a5a5a59e59, 15, 46, 5, 0xa5a5a5a5a5a5fe59) + EXT( 0xa5a5a5a5a5a59e58, 46, 6, 0x0000000000000019) + EXTU(0xa5a5a5a5a5a59e58, 46, 6, 0x0000000000000019) + DEP( 0xa5a5a5a5a5a59e58, 31, 46, 6, 0xa5a5a5a5a5a5fe58) + EXT( 0xa5a5a5a5a5a59e57, 46, 7, 0x0000000000000033) + EXTU(0xa5a5a5a5a5a59e57, 46, 7, 0x0000000000000033) + DEP( 0xa5a5a5a5a5a59e57, 63, 46, 7, 0xa5a5a5a5a5a5fe57) + EXT( 0xa5a5a5a5a5a59e56, 46, 8, 0x0000000000000067) + EXTU(0xa5a5a5a5a5a59e56, 46, 8, 0x0000000000000067) + DEP( 0xa5a5a5a5a5a59e56, 127, 46, 8, 0xa5a5a5a5a5a5fe56) + EXT( 0xa5a5a5a5a5a59e55, 46, 9, 0x00000000000000cf) + EXTU(0xa5a5a5a5a5a59e55, 46, 9, 0x00000000000000cf) + DEP( 0xa5a5a5a5a5a59e55, 255, 46, 9, 0xa5a5a5a5a5a5fe55) + EXT( 0xa5a5a5a5a5a59e54, 46, 10, 0x000000000000019e) + EXTU(0xa5a5a5a5a5a59e54, 46, 10, 0x000000000000019e) + DEP( 0xa5a5a5a5a5a59e54, 511, 46, 10, 0xa5a5a5a5a5a5ff54) + EXT( 0xa5a5a5a5a5a59e53, 46, 11, 0x000000000000033c) + EXTU(0xa5a5a5a5a5a59e53, 46, 11, 0x000000000000033c) + DEP( 0xa5a5a5a5a5a59e53, 1023, 46, 11, 0xa5a5a5a5a5a5ffd3) + EXT( 0xa5a5a5a5a5a59e52, 46, 12, 0x0000000000000679) + EXTU(0xa5a5a5a5a5a59e52, 46, 12, 0x0000000000000679) + DEP( 0xa5a5a5a5a5a59e52, 2047, 46, 12, 0xa5a5a5a5a5a5ffd2) + EXT( 0xa5a5a5a5a5a59e51, 46, 13, 0x0000000000000cf2) + EXTU(0xa5a5a5a5a5a59e51, 46, 13, 0x0000000000000cf2) + DEP( 0xa5a5a5a5a5a59e51, 4095, 46, 13, 0xa5a5a5a5a5a5fff1) + EXT( 0xa5a5a5a5a5a59e50, 46, 14, 0x00000000000019e5) + EXTU(0xa5a5a5a5a5a59e50, 46, 14, 0x00000000000019e5) + DEP( 0xa5a5a5a5a5a59e50, 8191, 46, 14, 0xa5a5a5a5a5a5fff0) + EXT( 0xa5a5a5a5a5a59e4f, 46, 15, 0x00000000000033c9) + EXTU(0xa5a5a5a5a5a59e4f, 46, 15, 0x00000000000033c9) + DEP( 0xa5a5a5a5a5a59e4f, 16383, 46, 15, 0xa5a5a5a5a5a5ffff) + EXT( 0xa5a5a5a5a5a59e4e, 46, 16, 0x0000000000006793) + EXTU(0xa5a5a5a5a5a59e4e, 46, 16, 0x0000000000006793) + DEP( 0xa5a5a5a5a5a59e4e, 32767, 46, 16, 0xa5a5a5a5a5a5fffe) + EXT( 0xa5a5a5a5a5a59e4d, 46, 17, 0x000000000000cf26) + EXTU(0xa5a5a5a5a5a59e4d, 46, 17, 0x000000000000cf26) + DEP( 0xa5a5a5a5a5a59e4d, 65535, 46, 17, 0xa5a5a5a5a5a5ffff) + EXT( 0xa5a5a5a5a5a59e4c, 47, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e4c, 47, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e4c, 0, 47, 1, 0xa5a5a5a5a5a49e4c) + EXT( 0xa5a5a5a5a5a59e4b, 47, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e4b, 47, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e4b, 1, 47, 2, 0xa5a5a5a5a5a49e4b) + EXT( 0xa5a5a5a5a5a59e4a, 47, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e4a, 47, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59e4a, 3, 47, 3, 0xa5a5a5a5a5a4de4a) + EXT( 0xa5a5a5a5a5a59e49, 47, 4, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e49, 47, 4, 0x000000000000000c) + DEP( 0xa5a5a5a5a5a59e49, 7, 47, 4, 0xa5a5a5a5a5a4fe49) + EXT( 0xa5a5a5a5a5a59e48, 47, 5, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59e48, 47, 5, 0x0000000000000019) + DEP( 0xa5a5a5a5a5a59e48, 15, 47, 5, 0xa5a5a5a5a5a4fe48) + EXT( 0xa5a5a5a5a5a59e47, 47, 6, 0xfffffffffffffff3) + EXTU(0xa5a5a5a5a5a59e47, 47, 6, 0x0000000000000033) + DEP( 0xa5a5a5a5a5a59e47, 31, 47, 6, 0xa5a5a5a5a5a4fe47) + EXT( 0xa5a5a5a5a5a59e46, 47, 7, 0xffffffffffffffe7) + EXTU(0xa5a5a5a5a5a59e46, 47, 7, 0x0000000000000067) + DEP( 0xa5a5a5a5a5a59e46, 63, 47, 7, 0xa5a5a5a5a5a4fe46) + EXT( 0xa5a5a5a5a5a59e45, 47, 8, 0xffffffffffffffcf) + EXTU(0xa5a5a5a5a5a59e45, 47, 8, 0x00000000000000cf) + DEP( 0xa5a5a5a5a5a59e45, 127, 47, 8, 0xa5a5a5a5a5a4fe45) + EXT( 0xa5a5a5a5a5a59e44, 47, 9, 0xffffffffffffff9e) + EXTU(0xa5a5a5a5a5a59e44, 47, 9, 0x000000000000019e) + DEP( 0xa5a5a5a5a5a59e44, 255, 47, 9, 0xa5a5a5a5a5a4ff44) + EXT( 0xa5a5a5a5a5a59e43, 47, 10, 0xffffffffffffff3c) + EXTU(0xa5a5a5a5a5a59e43, 47, 10, 0x000000000000033c) + DEP( 0xa5a5a5a5a5a59e43, 511, 47, 10, 0xa5a5a5a5a5a4ffc3) + EXT( 0xa5a5a5a5a5a59e42, 47, 11, 0xfffffffffffffe79) + EXTU(0xa5a5a5a5a5a59e42, 47, 11, 0x0000000000000679) + DEP( 0xa5a5a5a5a5a59e42, 1023, 47, 11, 0xa5a5a5a5a5a4ffc2) + EXT( 0xa5a5a5a5a5a59e41, 47, 12, 0xfffffffffffffcf2) + EXTU(0xa5a5a5a5a5a59e41, 47, 12, 0x0000000000000cf2) + DEP( 0xa5a5a5a5a5a59e41, 2047, 47, 12, 0xa5a5a5a5a5a4ffe1) + EXT( 0xa5a5a5a5a5a59e40, 47, 13, 0xfffffffffffff9e4) + EXTU(0xa5a5a5a5a5a59e40, 47, 13, 0x00000000000019e4) + DEP( 0xa5a5a5a5a5a59e40, 4095, 47, 13, 0xa5a5a5a5a5a4fff0) + EXT( 0xa5a5a5a5a5a59e3f, 47, 14, 0xfffffffffffff3c7) + EXTU(0xa5a5a5a5a5a59e3f, 47, 14, 0x00000000000033c7) + DEP( 0xa5a5a5a5a5a59e3f, 8191, 47, 14, 0xa5a5a5a5a5a4ffff) + EXT( 0xa5a5a5a5a5a59e3e, 47, 15, 0xffffffffffffe78f) + EXTU(0xa5a5a5a5a5a59e3e, 47, 15, 0x000000000000678f) + DEP( 0xa5a5a5a5a5a59e3e, 16383, 47, 15, 0xa5a5a5a5a5a4fffe) + EXT( 0xa5a5a5a5a5a59e3d, 47, 16, 0xffffffffffffcf1e) + EXTU(0xa5a5a5a5a5a59e3d, 47, 16, 0x000000000000cf1e) + DEP( 0xa5a5a5a5a5a59e3d, 32767, 47, 16, 0xa5a5a5a5a5a4ffff) + EXT( 0xa5a5a5a5a5a59e3c, 48, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e3c, 48, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e3c, 0, 48, 1, 0xa5a5a5a5a5a51e3c) + EXT( 0xa5a5a5a5a5a59e3b, 48, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e3b, 48, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59e3b, 1, 48, 2, 0xa5a5a5a5a5a55e3b) + EXT( 0xa5a5a5a5a5a59e3a, 48, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e3a, 48, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59e3a, 3, 48, 3, 0xa5a5a5a5a5a57e3a) + EXT( 0xa5a5a5a5a5a59e39, 48, 4, 0xfffffffffffffff9) + EXTU(0xa5a5a5a5a5a59e39, 48, 4, 0x0000000000000009) + DEP( 0xa5a5a5a5a5a59e39, 7, 48, 4, 0xa5a5a5a5a5a57e39) + EXT( 0xa5a5a5a5a5a59e38, 48, 5, 0xfffffffffffffff3) + EXTU(0xa5a5a5a5a5a59e38, 48, 5, 0x0000000000000013) + DEP( 0xa5a5a5a5a5a59e38, 15, 48, 5, 0xa5a5a5a5a5a57e38) + EXT( 0xa5a5a5a5a5a59e37, 48, 6, 0xffffffffffffffe7) + EXTU(0xa5a5a5a5a5a59e37, 48, 6, 0x0000000000000027) + DEP( 0xa5a5a5a5a5a59e37, 31, 48, 6, 0xa5a5a5a5a5a57e37) + EXT( 0xa5a5a5a5a5a59e36, 48, 7, 0xffffffffffffffcf) + EXTU(0xa5a5a5a5a5a59e36, 48, 7, 0x000000000000004f) + DEP( 0xa5a5a5a5a5a59e36, 63, 48, 7, 0xa5a5a5a5a5a57e36) + EXT( 0xa5a5a5a5a5a59e35, 48, 8, 0xffffffffffffff9e) + EXTU(0xa5a5a5a5a5a59e35, 48, 8, 0x000000000000009e) + DEP( 0xa5a5a5a5a5a59e35, 127, 48, 8, 0xa5a5a5a5a5a57f35) + EXT( 0xa5a5a5a5a5a59e34, 48, 9, 0xffffffffffffff3c) + EXTU(0xa5a5a5a5a5a59e34, 48, 9, 0x000000000000013c) + DEP( 0xa5a5a5a5a5a59e34, 255, 48, 9, 0xa5a5a5a5a5a57fb4) + EXT( 0xa5a5a5a5a5a59e33, 48, 10, 0xfffffffffffffe78) + EXTU(0xa5a5a5a5a5a59e33, 48, 10, 0x0000000000000278) + DEP( 0xa5a5a5a5a5a59e33, 511, 48, 10, 0xa5a5a5a5a5a57ff3) + EXT( 0xa5a5a5a5a5a59e32, 48, 11, 0xfffffffffffffcf1) + EXTU(0xa5a5a5a5a5a59e32, 48, 11, 0x00000000000004f1) + DEP( 0xa5a5a5a5a5a59e32, 1023, 48, 11, 0xa5a5a5a5a5a57ff2) + EXT( 0xa5a5a5a5a5a59e31, 48, 12, 0xfffffffffffff9e3) + EXTU(0xa5a5a5a5a5a59e31, 48, 12, 0x00000000000009e3) + DEP( 0xa5a5a5a5a5a59e31, 2047, 48, 12, 0xa5a5a5a5a5a57ff1) + EXT( 0xa5a5a5a5a5a59e30, 48, 13, 0xfffffffffffff3c6) + EXTU(0xa5a5a5a5a5a59e30, 48, 13, 0x00000000000013c6) + DEP( 0xa5a5a5a5a5a59e30, 4095, 48, 13, 0xa5a5a5a5a5a57ff8) + EXT( 0xa5a5a5a5a5a59e2f, 48, 14, 0xffffffffffffe78b) + EXTU(0xa5a5a5a5a5a59e2f, 48, 14, 0x000000000000278b) + DEP( 0xa5a5a5a5a5a59e2f, 8191, 48, 14, 0xa5a5a5a5a5a57fff) + EXT( 0xa5a5a5a5a5a59e2e, 48, 15, 0xffffffffffffcf17) + EXTU(0xa5a5a5a5a5a59e2e, 48, 15, 0x0000000000004f17) + DEP( 0xa5a5a5a5a5a59e2e, 16383, 48, 15, 0xa5a5a5a5a5a57ffe) + EXT( 0xa5a5a5a5a5a59e2d, 49, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e2d, 49, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e2d, 0, 49, 1, 0xa5a5a5a5a5a59e2d) + EXT( 0xa5a5a5a5a5a59e2c, 49, 2, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e2c, 49, 2, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e2c, 1, 49, 2, 0xa5a5a5a5a5a5be2c) + EXT( 0xa5a5a5a5a5a59e2b, 49, 3, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e2b, 49, 3, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e2b, 3, 49, 3, 0xa5a5a5a5a5a5be2b) + EXT( 0xa5a5a5a5a5a59e2a, 49, 4, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59e2a, 49, 4, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e2a, 7, 49, 4, 0xa5a5a5a5a5a5be2a) + EXT( 0xa5a5a5a5a5a59e29, 49, 5, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a59e29, 49, 5, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59e29, 15, 49, 5, 0xa5a5a5a5a5a5be29) + EXT( 0xa5a5a5a5a5a59e28, 49, 6, 0x000000000000000f) + EXTU(0xa5a5a5a5a5a59e28, 49, 6, 0x000000000000000f) + DEP( 0xa5a5a5a5a5a59e28, 31, 49, 6, 0xa5a5a5a5a5a5be28) + EXT( 0xa5a5a5a5a5a59e27, 49, 7, 0x000000000000001e) + EXTU(0xa5a5a5a5a5a59e27, 49, 7, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a59e27, 63, 49, 7, 0xa5a5a5a5a5a5bf27) + EXT( 0xa5a5a5a5a5a59e26, 49, 8, 0x000000000000003c) + EXTU(0xa5a5a5a5a5a59e26, 49, 8, 0x000000000000003c) + DEP( 0xa5a5a5a5a5a59e26, 127, 49, 8, 0xa5a5a5a5a5a5bfa6) + EXT( 0xa5a5a5a5a5a59e25, 49, 9, 0x0000000000000078) + EXTU(0xa5a5a5a5a5a59e25, 49, 9, 0x0000000000000078) + DEP( 0xa5a5a5a5a5a59e25, 255, 49, 9, 0xa5a5a5a5a5a5bfe5) + EXT( 0xa5a5a5a5a5a59e24, 49, 10, 0x00000000000000f1) + EXTU(0xa5a5a5a5a5a59e24, 49, 10, 0x00000000000000f1) + DEP( 0xa5a5a5a5a5a59e24, 511, 49, 10, 0xa5a5a5a5a5a5bfe4) + EXT( 0xa5a5a5a5a5a59e23, 49, 11, 0x00000000000001e2) + EXTU(0xa5a5a5a5a5a59e23, 49, 11, 0x00000000000001e2) + DEP( 0xa5a5a5a5a5a59e23, 1023, 49, 11, 0xa5a5a5a5a5a5bff3) + EXT( 0xa5a5a5a5a5a59e22, 49, 12, 0x00000000000003c4) + EXTU(0xa5a5a5a5a5a59e22, 49, 12, 0x00000000000003c4) + DEP( 0xa5a5a5a5a5a59e22, 2047, 49, 12, 0xa5a5a5a5a5a5bffa) + EXT( 0xa5a5a5a5a5a59e21, 49, 13, 0x0000000000000788) + EXTU(0xa5a5a5a5a5a59e21, 49, 13, 0x0000000000000788) + DEP( 0xa5a5a5a5a5a59e21, 4095, 49, 13, 0xa5a5a5a5a5a5bffd) + EXT( 0xa5a5a5a5a5a59e20, 49, 14, 0x0000000000000f10) + EXTU(0xa5a5a5a5a5a59e20, 49, 14, 0x0000000000000f10) + DEP( 0xa5a5a5a5a5a59e20, 8191, 49, 14, 0xa5a5a5a5a5a5bffe) + EXT( 0xa5a5a5a5a5a59e1f, 50, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59e1f, 50, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59e1f, 0, 50, 1, 0xa5a5a5a5a5a59e1f) + EXT( 0xa5a5a5a5a5a59e1e, 50, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59e1e, 50, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e1e, 1, 50, 2, 0xa5a5a5a5a5a59e1e) + EXT( 0xa5a5a5a5a5a59e1d, 50, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59e1d, 50, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e1d, 3, 50, 3, 0xa5a5a5a5a5a59e1d) + EXT( 0xa5a5a5a5a5a59e1c, 50, 4, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a59e1c, 50, 4, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59e1c, 7, 50, 4, 0xa5a5a5a5a5a59e1c) + EXT( 0xa5a5a5a5a5a59e1b, 50, 5, 0x000000000000000f) + EXTU(0xa5a5a5a5a5a59e1b, 50, 5, 0x000000000000000f) + DEP( 0xa5a5a5a5a5a59e1b, 15, 50, 5, 0xa5a5a5a5a5a59e1b) + EXT( 0xa5a5a5a5a5a59e1a, 50, 6, 0x000000000000001e) + EXTU(0xa5a5a5a5a5a59e1a, 50, 6, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a59e1a, 31, 50, 6, 0xa5a5a5a5a5a59f1a) + EXT( 0xa5a5a5a5a5a59e19, 50, 7, 0x000000000000003c) + EXTU(0xa5a5a5a5a5a59e19, 50, 7, 0x000000000000003c) + DEP( 0xa5a5a5a5a5a59e19, 63, 50, 7, 0xa5a5a5a5a5a59f99) + EXT( 0xa5a5a5a5a5a59e18, 50, 8, 0x0000000000000078) + EXTU(0xa5a5a5a5a5a59e18, 50, 8, 0x0000000000000078) + DEP( 0xa5a5a5a5a5a59e18, 127, 50, 8, 0xa5a5a5a5a5a59fd8) + EXT( 0xa5a5a5a5a5a59e17, 50, 9, 0x00000000000000f0) + EXTU(0xa5a5a5a5a5a59e17, 50, 9, 0x00000000000000f0) + DEP( 0xa5a5a5a5a5a59e17, 255, 50, 9, 0xa5a5a5a5a5a59ff7) + EXT( 0xa5a5a5a5a5a59e16, 50, 10, 0x00000000000001e1) + EXTU(0xa5a5a5a5a5a59e16, 50, 10, 0x00000000000001e1) + DEP( 0xa5a5a5a5a5a59e16, 511, 50, 10, 0xa5a5a5a5a5a59ff6) + EXT( 0xa5a5a5a5a5a59e15, 50, 11, 0x00000000000003c2) + EXTU(0xa5a5a5a5a5a59e15, 50, 11, 0x00000000000003c2) + DEP( 0xa5a5a5a5a5a59e15, 1023, 50, 11, 0xa5a5a5a5a5a59ffd) + EXT( 0xa5a5a5a5a5a59e14, 50, 12, 0x0000000000000785) + EXTU(0xa5a5a5a5a5a59e14, 50, 12, 0x0000000000000785) + DEP( 0xa5a5a5a5a5a59e14, 2047, 50, 12, 0xa5a5a5a5a5a59ffc) + EXT( 0xa5a5a5a5a5a59e13, 50, 13, 0x0000000000000f09) + EXTU(0xa5a5a5a5a5a59e13, 50, 13, 0x0000000000000f09) + DEP( 0xa5a5a5a5a5a59e13, 4095, 50, 13, 0xa5a5a5a5a5a59fff) + EXT( 0xa5a5a5a5a5a59e12, 51, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e12, 51, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e12, 0, 51, 1, 0xa5a5a5a5a5a58e12) + EXT( 0xa5a5a5a5a5a59e11, 51, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e11, 51, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e11, 1, 51, 2, 0xa5a5a5a5a5a58e11) + EXT( 0xa5a5a5a5a5a59e10, 51, 3, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e10, 51, 3, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59e10, 3, 51, 3, 0xa5a5a5a5a5a58e10) + EXT( 0xa5a5a5a5a5a59e0f, 51, 4, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e0f, 51, 4, 0x000000000000000f) + DEP( 0xa5a5a5a5a5a59e0f, 7, 51, 4, 0xa5a5a5a5a5a58e0f) + EXT( 0xa5a5a5a5a5a59e0e, 51, 5, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e0e, 51, 5, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a59e0e, 15, 51, 5, 0xa5a5a5a5a5a58f0e) + EXT( 0xa5a5a5a5a5a59e0d, 51, 6, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e0d, 51, 6, 0x000000000000003c) + DEP( 0xa5a5a5a5a5a59e0d, 31, 51, 6, 0xa5a5a5a5a5a58f8d) + EXT( 0xa5a5a5a5a5a59e0c, 51, 7, 0xfffffffffffffff8) + EXTU(0xa5a5a5a5a5a59e0c, 51, 7, 0x0000000000000078) + DEP( 0xa5a5a5a5a5a59e0c, 63, 51, 7, 0xa5a5a5a5a5a58fcc) + EXT( 0xa5a5a5a5a5a59e0b, 51, 8, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a59e0b, 51, 8, 0x00000000000000f0) + DEP( 0xa5a5a5a5a5a59e0b, 127, 51, 8, 0xa5a5a5a5a5a58feb) + EXT( 0xa5a5a5a5a5a59e0a, 51, 9, 0xffffffffffffffe0) + EXTU(0xa5a5a5a5a5a59e0a, 51, 9, 0x00000000000001e0) + DEP( 0xa5a5a5a5a5a59e0a, 255, 51, 9, 0xa5a5a5a5a5a58ffa) + EXT( 0xa5a5a5a5a5a59e09, 51, 10, 0xffffffffffffffc1) + EXTU(0xa5a5a5a5a5a59e09, 51, 10, 0x00000000000003c1) + DEP( 0xa5a5a5a5a5a59e09, 511, 51, 10, 0xa5a5a5a5a5a58ff9) + EXT( 0xa5a5a5a5a5a59e08, 51, 11, 0xffffffffffffff82) + EXTU(0xa5a5a5a5a5a59e08, 51, 11, 0x0000000000000782) + DEP( 0xa5a5a5a5a5a59e08, 1023, 51, 11, 0xa5a5a5a5a5a58ffc) + EXT( 0xa5a5a5a5a5a59e07, 51, 12, 0xffffffffffffff03) + EXTU(0xa5a5a5a5a5a59e07, 51, 12, 0x0000000000000f03) + DEP( 0xa5a5a5a5a5a59e07, 2047, 51, 12, 0xa5a5a5a5a5a58fff) + EXT( 0xa5a5a5a5a5a59e06, 52, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e06, 52, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59e06, 0, 52, 1, 0xa5a5a5a5a5a59606) + EXT( 0xa5a5a5a5a5a59e05, 52, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e05, 52, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59e05, 1, 52, 2, 0xa5a5a5a5a5a59605) + EXT( 0xa5a5a5a5a5a59e04, 52, 3, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59e04, 52, 3, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59e04, 3, 52, 3, 0xa5a5a5a5a5a59604) + EXT( 0xa5a5a5a5a5a59e03, 52, 4, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59e03, 52, 4, 0x000000000000000e) + DEP( 0xa5a5a5a5a5a59e03, 7, 52, 4, 0xa5a5a5a5a5a59703) + EXT( 0xa5a5a5a5a5a59e02, 52, 5, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59e02, 52, 5, 0x000000000000001c) + DEP( 0xa5a5a5a5a5a59e02, 15, 52, 5, 0xa5a5a5a5a5a59782) + EXT( 0xa5a5a5a5a5a59e01, 52, 6, 0xfffffffffffffff8) + EXTU(0xa5a5a5a5a5a59e01, 52, 6, 0x0000000000000038) + DEP( 0xa5a5a5a5a5a59e01, 31, 52, 6, 0xa5a5a5a5a5a597c1) + EXT( 0xa5a5a5a5a5a59e00, 52, 7, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a59e00, 52, 7, 0x0000000000000070) + DEP( 0xa5a5a5a5a5a59e00, 63, 52, 7, 0xa5a5a5a5a5a597e0) + EXT( 0xa5a5a5a5a5a59dff, 52, 8, 0xffffffffffffffdf) + EXTU(0xa5a5a5a5a5a59dff, 52, 8, 0x00000000000000df) + DEP( 0xa5a5a5a5a5a59dff, 127, 52, 8, 0xa5a5a5a5a5a597ff) + EXT( 0xa5a5a5a5a5a59dfe, 52, 9, 0xffffffffffffffbf) + EXTU(0xa5a5a5a5a5a59dfe, 52, 9, 0x00000000000001bf) + DEP( 0xa5a5a5a5a5a59dfe, 255, 52, 9, 0xa5a5a5a5a5a597fe) + EXT( 0xa5a5a5a5a5a59dfd, 52, 10, 0xffffffffffffff7f) + EXTU(0xa5a5a5a5a5a59dfd, 52, 10, 0x000000000000037f) + DEP( 0xa5a5a5a5a5a59dfd, 511, 52, 10, 0xa5a5a5a5a5a597fd) + EXT( 0xa5a5a5a5a5a59dfc, 52, 11, 0xfffffffffffffefe) + EXTU(0xa5a5a5a5a5a59dfc, 52, 11, 0x00000000000006fe) + DEP( 0xa5a5a5a5a5a59dfc, 1023, 52, 11, 0xa5a5a5a5a5a597fe) + EXT( 0xa5a5a5a5a5a59dfb, 53, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dfb, 53, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dfb, 0, 53, 1, 0xa5a5a5a5a5a599fb) + EXT( 0xa5a5a5a5a5a59dfa, 53, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dfa, 53, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dfa, 1, 53, 2, 0xa5a5a5a5a5a59bfa) + EXT( 0xa5a5a5a5a5a59df9, 53, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59df9, 53, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59df9, 3, 53, 3, 0xa5a5a5a5a5a59bf9) + EXT( 0xa5a5a5a5a5a59df8, 53, 4, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59df8, 53, 4, 0x000000000000000b) + DEP( 0xa5a5a5a5a5a59df8, 7, 53, 4, 0xa5a5a5a5a5a59bf8) + EXT( 0xa5a5a5a5a5a59df7, 53, 5, 0xfffffffffffffff7) + EXTU(0xa5a5a5a5a5a59df7, 53, 5, 0x0000000000000017) + DEP( 0xa5a5a5a5a5a59df7, 15, 53, 5, 0xa5a5a5a5a5a59bf7) + EXT( 0xa5a5a5a5a5a59df6, 53, 6, 0xffffffffffffffef) + EXTU(0xa5a5a5a5a5a59df6, 53, 6, 0x000000000000002f) + DEP( 0xa5a5a5a5a5a59df6, 31, 53, 6, 0xa5a5a5a5a5a59bf6) + EXT( 0xa5a5a5a5a5a59df5, 53, 7, 0xffffffffffffffdf) + EXTU(0xa5a5a5a5a5a59df5, 53, 7, 0x000000000000005f) + DEP( 0xa5a5a5a5a5a59df5, 63, 53, 7, 0xa5a5a5a5a5a59bf5) + EXT( 0xa5a5a5a5a5a59df4, 53, 8, 0xffffffffffffffbe) + EXTU(0xa5a5a5a5a5a59df4, 53, 8, 0x00000000000000be) + DEP( 0xa5a5a5a5a5a59df4, 127, 53, 8, 0xa5a5a5a5a5a59bfc) + EXT( 0xa5a5a5a5a5a59df3, 53, 9, 0xffffffffffffff7c) + EXTU(0xa5a5a5a5a5a59df3, 53, 9, 0x000000000000017c) + DEP( 0xa5a5a5a5a5a59df3, 255, 53, 9, 0xa5a5a5a5a5a59bff) + EXT( 0xa5a5a5a5a5a59df2, 53, 10, 0xfffffffffffffef9) + EXTU(0xa5a5a5a5a5a59df2, 53, 10, 0x00000000000002f9) + DEP( 0xa5a5a5a5a5a59df2, 511, 53, 10, 0xa5a5a5a5a5a59bfe) + EXT( 0xa5a5a5a5a5a59df1, 54, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59df1, 54, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59df1, 0, 54, 1, 0xa5a5a5a5a5a59df1) + EXT( 0xa5a5a5a5a5a59df0, 54, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59df0, 54, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59df0, 1, 54, 2, 0xa5a5a5a5a5a59df0) + EXT( 0xa5a5a5a5a5a59def, 54, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59def, 54, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59def, 3, 54, 3, 0xa5a5a5a5a5a59def) + EXT( 0xa5a5a5a5a5a59dee, 54, 4, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a59dee, 54, 4, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59dee, 7, 54, 4, 0xa5a5a5a5a5a59dee) + EXT( 0xa5a5a5a5a5a59ded, 54, 5, 0x000000000000000f) + EXTU(0xa5a5a5a5a5a59ded, 54, 5, 0x000000000000000f) + DEP( 0xa5a5a5a5a5a59ded, 15, 54, 5, 0xa5a5a5a5a5a59ded) + EXT( 0xa5a5a5a5a5a59dec, 54, 6, 0x000000000000001e) + EXTU(0xa5a5a5a5a5a59dec, 54, 6, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a59dec, 31, 54, 6, 0xa5a5a5a5a5a59dfc) + EXT( 0xa5a5a5a5a5a59deb, 54, 7, 0x000000000000003d) + EXTU(0xa5a5a5a5a5a59deb, 54, 7, 0x000000000000003d) + DEP( 0xa5a5a5a5a5a59deb, 63, 54, 7, 0xa5a5a5a5a5a59dfb) + EXT( 0xa5a5a5a5a5a59dea, 54, 8, 0x000000000000007a) + EXTU(0xa5a5a5a5a5a59dea, 54, 8, 0x000000000000007a) + DEP( 0xa5a5a5a5a5a59dea, 127, 54, 8, 0xa5a5a5a5a5a59dfe) + EXT( 0xa5a5a5a5a5a59de9, 54, 9, 0x00000000000000f4) + EXTU(0xa5a5a5a5a5a59de9, 54, 9, 0x00000000000000f4) + DEP( 0xa5a5a5a5a5a59de9, 255, 54, 9, 0xa5a5a5a5a5a59dff) + EXT( 0xa5a5a5a5a5a59de8, 55, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de8, 55, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59de8, 0, 55, 1, 0xa5a5a5a5a5a59ce8) + EXT( 0xa5a5a5a5a5a59de7, 55, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de7, 55, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59de7, 1, 55, 2, 0xa5a5a5a5a5a59ce7) + EXT( 0xa5a5a5a5a5a59de6, 55, 3, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de6, 55, 3, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59de6, 3, 55, 3, 0xa5a5a5a5a5a59ce6) + EXT( 0xa5a5a5a5a5a59de5, 55, 4, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de5, 55, 4, 0x000000000000000f) + DEP( 0xa5a5a5a5a5a59de5, 7, 55, 4, 0xa5a5a5a5a5a59ce5) + EXT( 0xa5a5a5a5a5a59de4, 55, 5, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59de4, 55, 5, 0x000000000000001e) + DEP( 0xa5a5a5a5a5a59de4, 15, 55, 5, 0xa5a5a5a5a5a59cf4) + EXT( 0xa5a5a5a5a5a59de3, 55, 6, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59de3, 55, 6, 0x000000000000003c) + DEP( 0xa5a5a5a5a5a59de3, 31, 55, 6, 0xa5a5a5a5a5a59cfb) + EXT( 0xa5a5a5a5a5a59de2, 55, 7, 0xfffffffffffffff8) + EXTU(0xa5a5a5a5a5a59de2, 55, 7, 0x0000000000000078) + DEP( 0xa5a5a5a5a5a59de2, 63, 55, 7, 0xa5a5a5a5a5a59cfe) + EXT( 0xa5a5a5a5a5a59de1, 55, 8, 0xfffffffffffffff0) + EXTU(0xa5a5a5a5a5a59de1, 55, 8, 0x00000000000000f0) + DEP( 0xa5a5a5a5a5a59de1, 127, 55, 8, 0xa5a5a5a5a5a59cff) + EXT( 0xa5a5a5a5a5a59de0, 56, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59de0, 56, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59de0, 0, 56, 1, 0xa5a5a5a5a5a59d60) + EXT( 0xa5a5a5a5a5a59ddf, 56, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59ddf, 56, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59ddf, 1, 56, 2, 0xa5a5a5a5a5a59d5f) + EXT( 0xa5a5a5a5a5a59dde, 56, 3, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dde, 56, 3, 0x0000000000000006) + DEP( 0xa5a5a5a5a5a59dde, 3, 56, 3, 0xa5a5a5a5a5a59d7e) + EXT( 0xa5a5a5a5a5a59ddd, 56, 4, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59ddd, 56, 4, 0x000000000000000d) + DEP( 0xa5a5a5a5a5a59ddd, 7, 56, 4, 0xa5a5a5a5a5a59d7d) + EXT( 0xa5a5a5a5a5a59ddc, 56, 5, 0xfffffffffffffffb) + EXTU(0xa5a5a5a5a5a59ddc, 56, 5, 0x000000000000001b) + DEP( 0xa5a5a5a5a5a59ddc, 15, 56, 5, 0xa5a5a5a5a5a59d7c) + EXT( 0xa5a5a5a5a5a59ddb, 56, 6, 0xfffffffffffffff6) + EXTU(0xa5a5a5a5a5a59ddb, 56, 6, 0x0000000000000036) + DEP( 0xa5a5a5a5a5a59ddb, 31, 56, 6, 0xa5a5a5a5a5a59d7f) + EXT( 0xa5a5a5a5a5a59dda, 56, 7, 0xffffffffffffffed) + EXTU(0xa5a5a5a5a5a59dda, 56, 7, 0x000000000000006d) + DEP( 0xa5a5a5a5a5a59dda, 63, 56, 7, 0xa5a5a5a5a5a59d7e) + EXT( 0xa5a5a5a5a5a59dd9, 57, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dd9, 57, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dd9, 0, 57, 1, 0xa5a5a5a5a5a59d99) + EXT( 0xa5a5a5a5a5a59dd8, 57, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dd8, 57, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dd8, 1, 57, 2, 0xa5a5a5a5a5a59db8) + EXT( 0xa5a5a5a5a5a59dd7, 57, 3, 0xfffffffffffffffd) + EXTU(0xa5a5a5a5a5a59dd7, 57, 3, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59dd7, 3, 57, 3, 0xa5a5a5a5a5a59db7) + EXT( 0xa5a5a5a5a5a59dd6, 57, 4, 0xfffffffffffffffa) + EXTU(0xa5a5a5a5a5a59dd6, 57, 4, 0x000000000000000a) + DEP( 0xa5a5a5a5a5a59dd6, 7, 57, 4, 0xa5a5a5a5a5a59dbe) + EXT( 0xa5a5a5a5a5a59dd5, 57, 5, 0xfffffffffffffff5) + EXTU(0xa5a5a5a5a5a59dd5, 57, 5, 0x0000000000000015) + DEP( 0xa5a5a5a5a5a59dd5, 15, 57, 5, 0xa5a5a5a5a5a59dbd) + EXT( 0xa5a5a5a5a5a59dd4, 57, 6, 0xffffffffffffffea) + EXTU(0xa5a5a5a5a5a59dd4, 57, 6, 0x000000000000002a) + DEP( 0xa5a5a5a5a5a59dd4, 31, 57, 6, 0xa5a5a5a5a5a59dbe) + EXT( 0xa5a5a5a5a5a59dd3, 58, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dd3, 58, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dd3, 0, 58, 1, 0xa5a5a5a5a5a59dd3) + EXT( 0xa5a5a5a5a5a59dd2, 58, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dd2, 58, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dd2, 1, 58, 2, 0xa5a5a5a5a5a59dd2) + EXT( 0xa5a5a5a5a5a59dd1, 58, 3, 0x0000000000000002) + EXTU(0xa5a5a5a5a5a59dd1, 58, 3, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dd1, 3, 58, 3, 0xa5a5a5a5a5a59dd9) + EXT( 0xa5a5a5a5a5a59dd0, 58, 4, 0x0000000000000004) + EXTU(0xa5a5a5a5a5a59dd0, 58, 4, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59dd0, 7, 58, 4, 0xa5a5a5a5a5a59ddc) + EXT( 0xa5a5a5a5a5a59dcf, 58, 5, 0x0000000000000007) + EXTU(0xa5a5a5a5a5a59dcf, 58, 5, 0x0000000000000007) + DEP( 0xa5a5a5a5a5a59dcf, 15, 58, 5, 0xa5a5a5a5a5a59ddf) + EXT( 0xa5a5a5a5a5a59dce, 59, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dce, 59, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dce, 0, 59, 1, 0xa5a5a5a5a5a59dce) + EXT( 0xa5a5a5a5a5a59dcd, 59, 2, 0x0000000000000001) + EXTU(0xa5a5a5a5a5a59dcd, 59, 2, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dcd, 1, 59, 2, 0xa5a5a5a5a5a59dcd) + EXT( 0xa5a5a5a5a5a59dcc, 59, 3, 0x0000000000000003) + EXTU(0xa5a5a5a5a5a59dcc, 59, 3, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59dcc, 3, 59, 3, 0xa5a5a5a5a5a59dcc) + EXT( 0xa5a5a5a5a5a59dcb, 59, 4, 0x0000000000000005) + EXTU(0xa5a5a5a5a5a59dcb, 59, 4, 0x0000000000000005) + DEP( 0xa5a5a5a5a5a59dcb, 7, 59, 4, 0xa5a5a5a5a5a59dcf) + EXT( 0xa5a5a5a5a5a59dca, 60, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dca, 60, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dca, 0, 60, 1, 0xa5a5a5a5a5a59dc2) + EXT( 0xa5a5a5a5a5a59dc9, 60, 2, 0xfffffffffffffffe) + EXTU(0xa5a5a5a5a5a59dc9, 60, 2, 0x0000000000000002) + DEP( 0xa5a5a5a5a5a59dc9, 1, 60, 2, 0xa5a5a5a5a5a59dc5) + EXT( 0xa5a5a5a5a5a59dc8, 60, 3, 0xfffffffffffffffc) + EXTU(0xa5a5a5a5a5a59dc8, 60, 3, 0x0000000000000004) + DEP( 0xa5a5a5a5a5a59dc8, 3, 60, 3, 0xa5a5a5a5a5a59dc6) + EXT( 0xa5a5a5a5a5a59dc7, 61, 1, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dc7, 61, 1, 0x0000000000000001) + DEP( 0xa5a5a5a5a5a59dc7, 0, 61, 1, 0xa5a5a5a5a5a59dc3) + EXT( 0xa5a5a5a5a5a59dc6, 61, 2, 0xffffffffffffffff) + EXTU(0xa5a5a5a5a5a59dc6, 61, 2, 0x0000000000000003) + DEP( 0xa5a5a5a5a5a59dc6, 1, 61, 2, 0xa5a5a5a5a5a59dc2) + EXT( 0xa5a5a5a5a5a59dc5, 62, 1, 0x0000000000000000) + EXTU(0xa5a5a5a5a5a59dc5, 62, 1, 0x0000000000000000) + DEP( 0xa5a5a5a5a5a59dc5, 0, 62, 1, 0xa5a5a5a5a5a59dc5) +# endif +# endif +#endif + prepare + pushargi ok + finishi @printf + ret + epilog +#endif diff --git a/deps/lightning/check/fma.ok b/deps/lightning/check/fma.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/fma.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/fma.tst b/deps/lightning/check/fma.tst new file mode 100644 index 00000000..f87f7098 --- /dev/null +++ b/deps/lightning/check/fma.tst @@ -0,0 +1,425 @@ +.data 32 +ok: +.c "ok" + +.code + prolog + + /* Simple encoding test for all different registers */ + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmar_f %f0 %f1 %f2 %f3 + beqi_f fa0 %f0 10.0 + calli @abort +fa0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmar_d %f0 %f1 %f2 %f3 + beqi_d da0 %f0 26.0 + calli @abort +da0: + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmsr_f %f0 %f1 %f2 %f3 + beqi_f fs0 %f0 2.0 + calli @abort +fs0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmsr_d %f0 %f1 %f2 %f3 + beqi_d ds0 %f0 14.0 + calli @abort +ds0: + + /* Simple encoding test for result also first argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmar_f %f1 %f1 %f2 %f3 + beqi_f fa1 %f1 10.0 + calli @abort +fa1: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmar_d %f1 %f1 %f2 %f3 + beqi_d da1 %f1 26.0 + calli @abort +da1: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmsr_f %f1 %f1 %f2 %f3 + beqi_f fs1 %f1 2.0 + calli @abort +fs1: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmsr_d %f1 %f1 %f2 %f3 + beqi_d ds1 %f1 14.0 + calli @abort +ds1: + + /* Simple encoding test for result also second argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmar_f %f2 %f1 %f2 %f3 + beqi_f fa2 %f2 10.0 + calli @abort +fa2: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmar_d %f2 %f1 %f2 %f3 + beqi_d da2 %f2 26.0 + calli @abort +da2: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmsr_f %f2 %f1 %f2 %f3 + beqi_f fs2 %f2 2.0 + calli @abort +fs2: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmsr_d %f2 %f1 %f2 %f3 + beqi_d ds2 %f2 14.0 + calli @abort +ds2: + + /* Simple encoding test for result also third argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmar_f %f3 %f1 %f2 %f3 + beqi_f fa3 %f3 10.0 + calli @abort +fa3: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmar_d %f3 %f1 %f2 %f3 + beqi_d da3 %f3 26.0 + calli @abort +da3: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fmsr_f %f3 %f1 %f2 %f3 + beqi_f fs3 %f3 2.0 + calli @abort +fs3: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fmsr_d %f3 %f1 %f2 %f3 + beqi_d ds3 %f3 14.0 + calli @abort +ds3: + + /* Simple encoding test for all different registers */ + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + fmai_f %f0 %f1 %f2 4.0 + beqi_f fai0 %f0 10.0 + calli @abort +fai0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + fmai_d %f0 %f1 %f2 6.0 + beqi_d dai0 %f0 26.0 + calli @abort +dai0: + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + fmsi_f %f0 %f1 %f2 4.0 + beqi_f fsi0 %f0 2.0 + calli @abort +fsi0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + fmsi_d %f0 %f1 %f2 6.0 + beqi_d dsi0 %f0 14.0 + calli @abort +dsi0: + + /* Simple encoding test for result also first argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + fmai_f %f1 %f1 %f2 4.0 + beqi_f fai1 %f1 10.0 + calli @abort +fai1: + movi_d %f1 4.0 + movi_d %f2 5.0 + fmai_d %f1 %f1 %f2 6.0 + beqi_d dai1 %f1 26.0 + calli @abort +dai1: + movi_f %f1 2.0 + movi_f %f2 3.0 + fmsi_f %f1 %f1 %f2 4.0 + beqi_f fsi1 %f1 2.0 + calli @abort +fsi1: + movi_d %f1 4.0 + movi_d %f2 5.0 + fmsi_d %f1 %f1 %f2 6.0 + beqi_d dsi1 %f1 14.0 + calli @abort +dsi1: + + /* Simple encoding test for result also second argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + fmai_f %f2 %f1 %f2 4.0 + beqi_f fai2 %f2 10.0 + calli @abort +fai2: + movi_d %f1 4.0 + movi_d %f2 5.0 + fmai_d %f2 %f1 %f2 6.0 + beqi_d dai2 %f2 26.0 + calli @abort +dai2: + movi_f %f1 2.0 + movi_f %f2 3.0 + fmsi_f %f2 %f1 %f2 4.0 + beqi_f fsi2 %f2 2.0 + calli @abort +fsi2: + movi_d %f1 4.0 + movi_d %f2 5.0 + fmsi_d %f2 %f1 %f2 6.0 + beqi_d dsi2 %f2 14.0 + calli @abort +dsi2: + + /* Simple encoding test for all different registers */ + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmar_f %f0 %f1 %f2 %f3 + beqi_f fna0 %f0 -10.0 + calli @abort +fna0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmar_d %f0 %f1 %f2 %f3 + beqi_d dna0 %f0 -26.0 + calli @abort +dna0: + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmsr_f %f0 %f1 %f2 %f3 + beqi_f fns0 %f0 -2.0 + calli @abort +fns0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmsr_d %f0 %f1 %f2 %f3 + beqi_d dns0 %f0 -14.0 + calli @abort +dns0: + + /* Simple encoding test for result also first argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmar_f %f1 %f1 %f2 %f3 + beqi_f fna1 %f1 -10.0 + calli @abort +fna1: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmar_d %f1 %f1 %f2 %f3 + beqi_d dna1 %f1 -26.0 + calli @abort +dna1: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmsr_f %f1 %f1 %f2 %f3 + beqi_f fns1 %f1 -2.0 + calli @abort +fns1: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmsr_d %f1 %f1 %f2 %f3 + beqi_d dns1 %f1 -14.0 + calli @abort +dns1: + + /* Simple encoding test for result also second argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmar_f %f2 %f1 %f2 %f3 + beqi_f fna2 %f2 -10.0 + calli @abort +fna2: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmar_d %f2 %f1 %f2 %f3 + beqi_d dna2 %f2 -26.0 + calli @abort +dna2: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmsr_f %f2 %f1 %f2 %f3 + beqi_f fns2 %f2 -2.0 + calli @abort +fns2: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmsr_d %f2 %f1 %f2 %f3 + beqi_d dns2 %f2 -14.0 + calli @abort +dns2: + + /* Simple encoding test for result also third argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmsr_f %f3 %f1 %f2 %f3 + beqi_f fns3 %f3 -2.0 + calli @abort +fns3: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmsr_d %f3 %f1 %f2 %f3 + beqi_d dns3 %f3 -14.0 + calli @abort +dns3: + movi_f %f1 2.0 + movi_f %f2 3.0 + movi_f %f3 4.0 + fnmar_f %f3 %f1 %f2 %f3 + beqi_f fna3 %f3 -10.0 + calli @abort +fna3: + movi_d %f1 4.0 + movi_d %f2 5.0 + movi_d %f3 6.0 + fnmar_d %f3 %f1 %f2 %f3 + beqi_d dna3 %f3 -26.0 + calli @abort +dna3: + + /* Simple encoding test for all different registers */ + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmai_f %f0 %f1 %f2 4.0 + beqi_f fnai0 %f0 -10.0 + calli @abort +fnai0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmai_d %f0 %f1 %f2 6.0 + beqi_d dnai0 %f0 -26.0 + calli @abort +dnai0: + movi_f %f0 0.0 + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmsi_f %f0 %f1 %f2 4.0 + beqi_f fnsi0 %f0 -2.0 + calli @abort +fnsi0: + movi_d %f0 0.0 + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmsi_d %f0 %f1 %f2 6.0 + beqi_d dnsi0 %f0 -14.0 + calli @abort +dnsi0: + + /* Simple encoding test for result also first argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmai_f %f1 %f1 %f2 4.0 + beqi_f fnai1 %f1 -10.0 + calli @abort +fnai1: + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmai_d %f1 %f1 %f2 6.0 + beqi_d dnai1 %f1 -26.0 + calli @abort +dnai1: + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmsi_f %f1 %f1 %f2 4.0 + beqi_f fnsi1 %f1 -2.0 + calli @abort +fnsi1: + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmsi_d %f1 %f1 %f2 6.0 + beqi_d dnsi1 %f1 -14.0 + calli @abort +dnsi1: + + /* Simple encoding test for result also second argument */ + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmai_f %f2 %f1 %f2 4.0 + beqi_f fnai2 %f2 -10.0 + calli @abort +fnai2: + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmai_d %f2 %f1 %f2 6.0 + beqi_d dnai2 %f2 -26.0 + calli @abort +dnai2: + movi_f %f1 2.0 + movi_f %f2 3.0 + fnmsi_f %f2 %f1 %f2 4.0 + beqi_f fnsi2 %f2 -2.0 + calli @abort +fnsi2: + movi_d %f1 4.0 + movi_d %f2 5.0 + fnmsi_d %f2 %f1 %f2 6.0 + beqi_d dnsi2 %f2 -14.0 + calli @abort +dnsi2: + + prepare + pushargi ok + finishi @puts + + ret + epilog diff --git a/deps/lightning/check/gen_cbit.c b/deps/lightning/check/gen_cbit.c new file mode 100644 index 00000000..05ebd7a7 --- /dev/null +++ b/deps/lightning/check/gen_cbit.c @@ -0,0 +1,603 @@ +#include + +/* Test that jit_extr(), jit_extr_u() and jit_depr() work correctly with + * C bitfields. + * Note that to be compatible with C bitfields, behavior is different + * for big endian and little endian. For big endian, the bitfield + * offset is changed to (__WORDSIZE - offset). + * The logic is to create a C function that receives a pointer to + * a single word union (that has a bitfield and a word) and a jit function + * pointer that knows about the bitfield. The C function calls the jit + * function passing the pointer to the bitfield, and the jit function + * changes the bitfield with a computed known value specific for the test. + * After calling the jit function, the C function validates that the + * bitfield has the expected value, and also validates no bits outside of + * the bitfield were modified. + * The test is done for signed and unsigned bitfields. + * The test does a brute force validation that all possible bitfields + * using a machine word work as expected. + * Tests for possible register clobber is done in check/ext.tst. + * The test is dynamically generated because the generated source file + * is too large to be kept under version control. + */ + +int +main(int argc, char *argv[]) +{ + int i, j; + puts("\ +#include \n\ +#include \n\ +\n\ +# if __WORDSIZE == 64 && _WIN32\n\ +# define ONE 1LL\n\ +# else\n\ +# define ONE 1L\n\ +# endif\n\ +/* Avoid clang running out of memory on OpenBSD mips64 */\n\ +#define SKIP_64_BITS (__mips__ && __clang__)\n\ +\n\ +#define GENMASK1() GENMASK(1)\n\ +#define GENMASK2() GENMASK(2)\n\ +#define GENMASK3() GENMASK(3)\n\ +#define GENMASK4() GENMASK(4)\n\ +#define GENMASK5() GENMASK(5)\n\ +#define GENMASK6() GENMASK(6)\n\ +#define GENMASK7() GENMASK(7)\n\ +#define GENMASK8() GENMASK(8)\n\ +#define GENMASK9() GENMASK(9)\n\ +#define GENMASK10() GENMASK(10)\n\ +#define GENMASK11() GENMASK(11)\n\ +#define GENMASK12() GENMASK(12)\n\ +#define GENMASK13() GENMASK(13)\n\ +#define GENMASK14() GENMASK(14)\n\ +#define GENMASK15() GENMASK(15)\n\ +#define GENMASK16() GENMASK(16)\n\ +#define GENMASK17() GENMASK(17)\n\ +#define GENMASK18() GENMASK(18)\n\ +#define GENMASK19() GENMASK(19)\n\ +#define GENMASK20() GENMASK(20)\n\ +#define GENMASK21() GENMASK(21)\n\ +#define GENMASK22() GENMASK(22)\n\ +#define GENMASK23() GENMASK(23)\n\ +#define GENMASK24() GENMASK(24)\n\ +#define GENMASK25() GENMASK(25)\n\ +#define GENMASK26() GENMASK(26)\n\ +#define GENMASK27() GENMASK(27)\n\ +#define GENMASK28() GENMASK(28)\n\ +#define GENMASK29() GENMASK(29)\n\ +#define GENMASK30() GENMASK(30)\n\ +#define GENMASK31() GENMASK(31)\n\ +#if __WORDSIZE == 32\n\ +# define MININT 0x80000000L\n\ +# define GENMASK32() \\\n\ + do { \\\n\ + m = -1; \\\n\ + t = 0; \\\n\ + } while (0)\n\ +#else\n\ +# define GENMASK32() GENMASK(32)\n\ +# define GENMASK33() GENMASK(33)\n\ +# define GENMASK34() GENMASK(34)\n\ +# define GENMASK35() GENMASK(35)\n\ +# define GENMASK36() GENMASK(36)\n\ +# define GENMASK37() GENMASK(37)\n\ +# define GENMASK38() GENMASK(38)\n\ +# define GENMASK39() GENMASK(39)\n\ +# define GENMASK40() GENMASK(40)\n\ +# define GENMASK41() GENMASK(41)\n\ +# define GENMASK42() GENMASK(42)\n\ +# define GENMASK43() GENMASK(43)\n\ +# define GENMASK44() GENMASK(44)\n\ +# define GENMASK45() GENMASK(45)\n\ +# define GENMASK46() GENMASK(46)\n\ +# define GENMASK47() GENMASK(47)\n\ +# define GENMASK48() GENMASK(48)\n\ +# define GENMASK49() GENMASK(49)\n\ +# define GENMASK50() GENMASK(50)\n\ +# define GENMASK51() GENMASK(51)\n\ +# define GENMASK52() GENMASK(52)\n\ +# define GENMASK53() GENMASK(53)\n\ +# define GENMASK54() GENMASK(54)\n\ +# define GENMASK55() GENMASK(55)\n\ +# define GENMASK56() GENMASK(56)\n\ +# define GENMASK57() GENMASK(57)\n\ +# define GENMASK58() GENMASK(58)\n\ +# define GENMASK59() GENMASK(59)\n\ +# define GENMASK60() GENMASK(60)\n\ +# define GENMASK61() GENMASK(61)\n\ +# define GENMASK62() GENMASK(62)\n\ +# define GENMASK63() GENMASK(63)\n\ +# if _WIN32\n\ +# define MININT 0x8000000000000000LL\n\ +# else\n\ +# define MININT 0x8000000000000000L\n\ +# endif\n\ +# define GENMASK64() \\\n\ + do { \\\n\ + m = -1; \\\n\ + t = 0; \\\n\ + } while (0)\n\ +#endif\n\ +#if __BYTE_ORDER == __LITTLE_ENDIAN\n\ +# define GENMASK(L) \\\n\ + do { \\\n\ + m = (ONE << L) - 1; \\\n\ + t = m ^ 1; \\\n\ + } while (0)\n\ +# define SHIFTMASK(B) m = ~(m << (B))\n\ +#else\n\ +# define GENMASK(L) \\\n\ + do { \\\n\ + m = (ONE << L) - 1; \\\n\ + t = m ^ 1; \\\n\ + m = ((jit_word_t)MININT >> (L - 1)); \\\n\ + } while (0)\n\ +# define SHIFTMASK(B) m = ~(m >> ((B) - 1))\n\ +#endif\n\ +\n\ +#define S jit_word_t\n\ +#define U jit_uword_t\n\ +\n\ +#define deftypeSL(L) \\\n\ +typedef union { \\\n\ + struct { \\\n\ + S f: L; \\\n\ + } b; \\\n\ + S s; \\\n\ +} S##L; \\\n\ +static void \\\n\ +CS##L(S##L *u, S (*JS##L)(S##L*)) { \\\n\ + S t, j, m; \\\n\ + GENMASK##L(); \\\n\ + m = ~m; \\\n\ + t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\ + u->s = 0; \\\n\ + j = (*JS##L)(u); \\\n\ + if (u->b.f != t || t != j || (u->s & m)) \\\n\ + abort(); \\\n\ +}\n\ +\n\ +#define deftypeSBL(B, L) \\\n\ +typedef union { \\\n\ + struct { \\\n\ + S _: B; \\\n\ + S f: L; \\\n\ + } b; \\\n\ + S s; \\\n\ +} S##B##_##L; \\\n\ +static void \\\n\ +CS##B##_##L(S##B##_##L *u, S (*JS##B##_##L)(S##B##_##L*)) { \\\n\ + S t, j, m; \\\n\ + GENMASK##L(); \\\n\ + SHIFTMASK(B); \\\n\ + t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\ + u->s = 0; \\\n\ + j = (*JS##B##_##L)(u); \\\n\ + if (u->b.f != t || t != j || (u->s & m)) \\\n\ + abort(); \\\n\ +}\n\ +\n\ +#define deftypeUL(L) \\\n\ +typedef union { \\\n\ + struct { \\\n\ + U f: L; \\\n\ + } b; \\\n\ + U u; \\\n\ +} U##L; \\\n\ +static void \\\n\ +CU##L(U##L *u, U (*JU##L)(U##L*)) { \\\n\ + U t, j, m; \\\n\ + GENMASK##L(); \\\n\ + m = ~m; \\\n\ + t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\ + u->u = 0; \\\n\ + j = (*JU##L)(u); \\\n\ + if (u->b.f != t || t != j || (u->u & m)) \\\n\ + abort(); \\\n\ +}\n\ +\n\ +#define deftypeUBL(B, L) \\\n\ +typedef union { \\\n\ + struct { \\\n\ + U _: B; \\\n\ + U f: L; \\\n\ + } b; \\\n\ + U u; \\\n\ +} U##B##_##L; \\\n\ +static void \\\n\ +CU##B##_##L(U##B##_##L *u, U (*JU##B##_##L)(U##B##_##L*)) { \\\n\ + U t, j, m; \\\n\ + GENMASK##L(); \\\n\ + SHIFTMASK(B); \\\n\ + t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\ + u->u = 0; \\\n\ + j = (*JU##B##_##L)(u); \\\n\ + if (u->b.f != t || t != j || (u->u & m)) \\\n\ + abort(); \\\n\ +}"); + puts("\n/* Define signed bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) + printf("deftypeSL(%d)\n", i); + /* Avoid clang running out of memory on OpenBSD mips64 */ + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) + printf("deftypeSL(%d)\n", i); + puts("#endif"); + puts("/* Define unsigned bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) + printf("deftypeUL(%d)\n", i); + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) + printf("deftypeUL(%d)\n", i); + puts("#endif"); + for (i = 1; i <= 31; i++) { + printf("/* Define signed bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) + printf("deftypeSBL(%d, %d)\n", i, j); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf("/* Define signed bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("deftypeSBL(%d, %d)\n", i, j); + } + } + puts("#endif"); + for (i = 1; i <= 31; i++) { + printf("/* Define unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) + printf("deftypeUBL(%d, %d)\n", i, j); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf("/* Define unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("deftypeUBL(%d, %d)\n", i, j); + } + } + puts("#endif"); + + puts("\n\ +int\n\ +main(int argc, char *argv[])\n\ +{\n\ + jit_node_t *arg;\n\ + jit_node_t *jmpi_main;\n\ + jit_state_t *_jit;\n\ + void (*code)(void);"); + puts(" /* Declare signed bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) { + printf(" S%d pS%d;\n", i, i); + printf(" jit_node_t *nS%d;\n", i); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) { + printf(" S%d pS%d;\n", i, i); + printf(" jit_node_t *nS%d;\n", i); + } + puts("#endif"); + puts(" /* Declare unsigned bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) { + printf(" U%d pU%d;\n", i, i); + printf(" jit_node_t *nU%d;\n", i); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) { + printf(" U%d pU%d;\n", i, i); + printf(" jit_node_t *nU%d;\n", i); + } + puts("#endif"); + + for (i = 1; i <= 31; i++) { + printf(" /* Declare signed bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf(" S%d_%d pS%d_%d;\n", i, j, i, j); + printf(" jit_node_t\t *nS%d_%d;\n", i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Declare signed bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) { + printf(" S%d_%d pS%d_%d;\n", i, j, i, j); + printf(" jit_node_t\t *nS%d_%d;\n", i, j); + } + } + } + puts("#endif"); + for (i = 1; i <= 31; i++) { + printf(" /* Declare unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf(" U%d_%d pU%d_%d;\n", i, j, i, j); + printf(" jit_node_t\t *nU%d_%d;\n", i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Declare unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) { + printf(" U%d_%d pU%d_%d;\n", i, j, i, j); + printf(" jit_node_t\t *nU%d_%d;\n", i, j); + } + } + } + puts("#endif\n"); + + puts("\ + init_jit(argv[0]);\n\ + _jit = jit_new_state();\n\ +\n\ + jmpi_main = jit_jmpi();\n"); + + puts(" /* Define jit functions for signed bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) { + printf("\ + nS%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n", i); + if ((i >> 3) < sizeof(void*)) + printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i); + else + printf("jit_movi(JIT_R1, 0);\n"); + printf("\ + jit_depr(JIT_R2, JIT_R1, 0, %d);\n\ + jit_extr(JIT_R1, JIT_R2, 0, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, i); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) { + printf("\ + nS%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n", i); + if ((i >> 3) < sizeof(void*)) + printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i); + else + printf("jit_movi(JIT_R1, 0);\n"); + printf("\ + jit_depr(JIT_R2, JIT_R1, 0, %d);\n\ + jit_extr(JIT_R1, JIT_R2, 0, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, i); + } + puts("#endif"); + + puts(" /* Define jit functions for unsigned bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) { + printf("\ + nU%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n", i); + if ((i >> 3) < sizeof(void*)) + printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i); + else + printf("jit_movi(JIT_R1, 0);\n"); + printf("\ + jit_depr(JIT_R2, JIT_R1, 0, %d);\n\ + jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, i); + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) { + printf("\ + nU%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n", i); + if ((i >> 3) < sizeof(void*)) + printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i); + else + printf("jit_movi(JIT_R1, 0);\n"); + printf("\ + jit_depr(JIT_R2, JIT_R1, 0, %d);\n\ + jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, i); + } + puts("#endif"); + + for (i = 1; i <= 31; i++) { + printf(" /* Define jit functions for signed bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf("\ + nS%d_%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n\ + jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\ + jit_depr(JIT_R2, JIT_R1, %d, %d);\n\ + jit_extr(JIT_R1, JIT_R2, %d, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, j, j, i, j, i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Declare jit functions for signed bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("\ + nS%d_%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n\ + jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\ + jit_depr(JIT_R2, JIT_R1, %d, %d);\n\ + jit_extr(JIT_R1, JIT_R2, %d, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, j, j, i, j, i, j); + } + } + puts("#endif"); + + for (i = 1; i <= 31; i++) { + printf(" /* Define jit functions for unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf("\ + nU%d_%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n\ + jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\ + jit_depr(JIT_R2, JIT_R1, %d, %d);\n\ + jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, j, j, i, j, i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Declare jit functions for unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("\ + nU%d_%d = jit_label();\n\ + jit_prolog();\n\ + arg = jit_arg();\n\ + jit_getarg(JIT_R0, arg);\n\ + jit_ldr(JIT_R2, JIT_R0);\n\ + jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\ + jit_depr(JIT_R2, JIT_R1, %d, %d);\n\ + jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\ + jit_str(JIT_R0, JIT_R2);\n\ + jit_retr(JIT_R1);\n\ + jit_epilog();\n", i, j, j, i, j, i, j); + } + } + puts("#endif"); + + puts("\n\ + jit_patch(jmpi_main);\n\ + jit_name(\"main\");\n\ + jit_note(\"cbit.c\", __LINE__);\n\ + jit_prolog();\n"); + + puts(" /* Call C functions for signed bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pS%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CS%d);\n", i, i, i); + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pS%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CS%d);\n", i, i, i); + puts("#endif"); + puts(" /* Call C functions for unsigned bitfields at offset 0 */"); + for (i = 1; i <= 32; i++) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pU%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CU%d);\n", i, i, i); + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (; i <= 64; i++) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pU%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CU%d);\n", i, i, i); + puts("#endif"); + + for (i = 1; i <= 31; i++) { + printf(" /* Call C functions for signed bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pS%d_%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Call C functions for signed bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pS%d_%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j); + } + } + puts("#endif"); + + for (i = 1; i <= 31; i++) { + printf(" /* Call C functions for unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 32 - i; j++) { + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pU%d_%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j); + } + } + puts("#if __WORDSIZE == 64 && !SKIP_64_BITS"); + for (i = 1; i < 64; i++) { + printf(" /* Call C functions for unsigned bitfields at offset %d */\n", i); + for (j = 1; j <= 64 - i; j++) { + if (i + j > 32) + printf("\ + jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\ + jit_prepare();\n\ + jit_pushargi((jit_word_t)&pU%d_%d);\n\ + jit_pushargr(JIT_R0);\n\ + jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j); + } + } + puts("#endif"); + + puts("\n\ + jit_ret();\n\ + jit_epilog();\n\ +\n\ + code = jit_emit();\n\ +\n\ + jit_clear_state();\n\ +\n\ + (*code)();\n\ + jit_destroy_state();\n\ +\n\ + finish_jit();\n\ +\n\ + return (0);\n\ +}"); + + return (0); +} diff --git a/deps/lightning/check/imm.ok b/deps/lightning/check/imm.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/imm.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/imm.tst b/deps/lightning/check/imm.tst new file mode 100644 index 00000000..217e6c06 --- /dev/null +++ b/deps/lightning/check/imm.tst @@ -0,0 +1,239 @@ +.data 4096 +#if __WORDSIZE == 32 +fmt_i: +.c "%s 0x%x = 0x%x (expected 0x%x)\n" +fmt_ext: +.c "%s 0x%x %d %d = 0x%x (expected 0x%x)\n" +fmt_dep: +.c "depi 0x%x 0x%x %d %d = 0x%x (expected 0x%x)\n" +#else +fmt_i: +.c "%s 0x%lx = 0x%lx (expected 0x%lx)\n" +fmt_ext: +.c "%s 0x%lx %ld %ld = 0x%lx (expected 0x%lx)\n" +fmt_dep: +.c "depi 0x%lx 0x%lx %ld %ld = 0x%lx (expected 0x%lx)\n" +#endif +fmt_d: +.c "%s %.12f = %.12f (expected %.12f)\n" +#define DEF(str) \ +S##str: \ +.c #str +DEF(negi) +DEF(comi) +DEF(exti_c) +DEF(exti_uc) +DEF(exti_s) +DEF(exti_us) +DEF(exti_i) +DEF(exti_ui) +DEF(htoni_us) +DEF(ntohi_us) +DEF(htoni_ui) +DEF(ntohi_ui) +DEF(htoni_ul) +DEF(ntohi_ul) +DEF(htoni) +DEF(ntohi) +DEF(bswapi_us) +DEF(bswapi_ui) +DEF(bswapi_ul) +DEF(bswapi) +DEF(cloi) +DEF(clzi) +DEF(ctoi) +DEF(ctzi) +DEF(rbiti) +DEF(popcnti) +DEF(exti) +DEF(exti_u) +DEF(negi_f) +DEF(absi_f) +DEF(sqrti_f) +DEF(negi_d) +DEF(absi_d) +DEF(sqrti_d) +ok: +.c "ok" + +#define CHECKI(OP, I0, I1) \ + OP %r0 I0 \ + beqi OP##_ok %r0 I1 \ + prepare \ + pushargi fmt_i \ + ellipsis \ + pushargi S##OP \ + pushargi I0 \ + pushargr %r0 \ + pushargi I1 \ + finishi @printf \ + calli @abort \ +OP##_ok: +#define CHECKEXT(OP, I0, I1, I2, I3) \ + OP %r0 I0 I1 I2 \ + beqi OP##_ok %r0 I3 \ + prepare \ + pushargi fmt_ext \ + ellipsis \ + pushargi S##OP \ + pushargi I0 \ + pushargi I1 \ + pushargi I2 \ + pushargr %r0 \ + pushargi I3 \ + finishi @printf \ + calli @abort \ +OP##_ok: +#define CHECKDEP(I0, I1, I2, I3, I4) \ + movi %r0 I0 \ + depi %r0 I1 I2 I3 \ + beqi dep_ok %r0 I4 \ + prepare \ + pushargi fmt_dep \ + ellipsis \ + pushargi I0 \ + pushargi I1 \ + pushargi I2 \ + pushargi I3 \ + pushargr %r0 \ + pushargi I4 \ + finishi @printf \ + calli @abort \ +dep_ok: +#define CHECKD(OP, I0, I1) \ + OP %f0 I0 \ + beqi_d OP##_ok %f0 I1 \ + prepare \ + pushargi fmt_d \ + ellipsis \ + pushargi S##OP \ + pushargi_d I0 \ + pushargr_d %f0 \ + pushargi_d I1 \ + finishi @printf \ + calli @abort \ +OP##_ok: +#define CHECKF(OP, I0, I1) \ + OP %f0 I0 \ + beqi_f OP##_ok %f0 I1 \ + extr_f_d %f0 %f0 \ + prepare \ + pushargi fmt_d \ + ellipsis \ + pushargi S##OP \ + pushargi_d I0 \ + pushargr_d %f0 \ + pushargi_d I1 \ + finishi @printf \ + calli @abort \ +OP##_ok: + +.code + prolog + + CHECKI(negi, 1, -1) + CHECKI(comi, 0, -1) + CHECKI(exti_c, 0xfff, -1) + CHECKI(exti_uc, 0xfff, 0xff) + CHECKI(exti_s, 0xfffff, -1) + CHECKI(exti_us, 0xfffff, 0xffff) +#if __BYTE_ORDER == __BIG_ENDIAN + CHECKI(htoni_us, 0xff1234, 0x1234) + CHECKI(ntohi_us, 0x7ffff, 0xffff) +#else + CHECKI(htoni_us, 0xff1234, 0x3412) + CHECKI(ntohi_us, 0x7ffff, 0xffff) +#endif +#if __BYTE_ORDER == __BIG_ENDIAN +# if __WORDSIZE == 32 + CHECKI(htoni_ui, 0x12345678, 0x12345678) + CHECKI(ntohi_ui, 0x78563412, 0x78563412) +# else + CHECKI(htoni_ui, 0x7f12345678, 0x12345678) + CHECKI(ntohi_ui, 0xf778563412, 0x78563412) +# endif +#else +# if __WORDSIZE == 32 + CHECKI(htoni_ui, 0x12345678, 0x78563412) + CHECKI(ntohi_ui, 0x78563412, 0x12345678) +# else + CHECKI(htoni_ui, 0x7f12345678, 0x78563412) + CHECKI(ntohi_ui, 0xf778563412, 0x12345678) +# endif +#endif + CHECKI(bswapi_us, 0x1234, 0x3412) + CHECKI(bswapi_ui, 0x12345678, 0x78563412) +#if __WORDSIZE == 32 +# if __BYTE_ORDER == __BIG_ENDIAN + CHECKI(htoni, 0x78563412, 0x78563412) + CHECKI(ntohi, 0x12345678, 0x12345678) +# else + CHECKI(htoni, 0x78563412, 0x12345678) + CHECKI(ntohi, 0x12345678, 0x78563412) +# endif + CHECKI(bswapi, 0x78563412, 0x12345678) +#else +# if __BYTE_ORDER == __BIG_ENDIAN + CHECKI(htoni_ul, 0xf0debc9a78563412, 0xf0debc9a78563412) + CHECKI(ntohi_ul, 0x123456789abcdef0, 0x123456789abcdef0) + CHECKI(htoni, 0x123456789abcdef0, 0x123456789abcdef0) + CHECKI(ntohi, 0xf0debc9a78563412, 0xf0debc9a78563412) +# else + CHECKI(htoni_ul, 0x123456789abcdef0, 0xf0debc9a78563412) + CHECKI(ntohi_ul, 0xf0debc9a78563412, 0x123456789abcdef0) + CHECKI(htoni, 0xf0debc9a78563412, 0x123456789abcdef0) + CHECKI(ntohi, 0x123456789abcdef0, 0xf0debc9a78563412) +# endif + CHECKI(exti_i, 0x80000000, 0xffffffff80000000) + CHECKI(exti_ui, 0x80000000, 0x80000000) + CHECKI(bswapi_ul, 0x123456789abcdef0, 0xf0debc9a78563412) + CHECKI(bswapi, 0xf0debc9a78563412, 0x123456789abcdef0) +#endif +#if __WORDSIZE == 32 + CHECKI(cloi, 0xfffffffe, 31) + CHECKI(clzi, 1, 31) + CHECKI(ctoi, 0x7fffffff, 31) + CHECKI(ctzi, 0x80000000, 31) + CHECKI(rbiti, 0x02468ace, 0x73516240) + CHECKI(popcnti, 0x8a13c851, 12) +#else + CHECKI(cloi, 0xfffffffffffffffe, 63) + CHECKI(clzi, 1, 63) + CHECKI(ctoi, 0x7fffffffffffffff, 63) + CHECKI(ctzi, 0x8000000000000000, 63) + CHECKI(rbiti, 0x02468ace013579bd, 0xbd9eac8073516240) + CHECKI(popcnti, 0x02468ace013579bd, 28) +#endif +#if __WORDSIZE == 32 +# if __BYTE_ORDER == __LITTLE_ENDIAN + CHECKEXT(exti, 0xa5a5a584, 1, 2, 0xfffffffe) + CHECKEXT(exti_u, 0xa5a5a584, 1, 2, 0x00000002) + CHECKDEP(0xa5a5a584, 1, 1, 2, 0xa5a5a582) +# else + CHECKEXT(exti, 0xa5a5a3b7, 29, 1, 0xffffffff) + CHECKEXT(exti_u, 0xa5a5a3b7, 29, 1, 0x00000001) + CHECKDEP(0xa5a5a3b7, 0, 29, 1, 0xa5a5a3b3) +# endif +#else +# if __BYTE_ORDER == __LITTLE_ENDIAN + CHECKEXT(exti, 0xa5a5a5a5a5a5a564, 1, 2, 0xfffffffffffffffe) + CHECKEXT(exti_u, 0xa5a5a5a5a5a5a564, 1, 2, 0x0000000000000002) + CHECKDEP(0xa5a5a5a5a5a5a564, 1, 1, 2, 0xa5a5a5a5a5a5a562) +# else + CHECKEXT(exti, 0xa5a5a5a5a5a59dc8, 60, 3, 0xfffffffffffffffc) + CHECKEXT(exti_u, 0xa5a5a5a5a5a59dc6, 61, 2, 0x0000000000000002) + CHECKDEP(0xa5a5a5a5a5a59dc6, 1, 61, 2, 0xa5a5a5a5a5a59dc2) +# endif +#endif + CHECKF(negi_f, 2.0, -2.0) + CHECKF(absi_f, -3.0, 3.0) + CHECKF(sqrti_f, 81.0, 9.0) + CHECKD(negi_d, -2.0, 2.0) + CHECKD(absi_d, -1.0, 1.0) + CHECKD(sqrti_d, 9.0, 3.0) + + prepare + pushargi ok + finishi @puts + ret + epilog diff --git a/deps/lightning/check/lightning.c b/deps/lightning/check/lightning.c index 80ea0816..42a6ed8b 100644 --- a/deps/lightning/check/lightning.c +++ b/deps/lightning/check/lightning.c @@ -306,6 +306,8 @@ static void subxr(void); static void subxi(void); static void subcr(void); static void subci(void); static void rsbr(void); static void rsbi(void); static void mulr(void); static void muli(void); +static void hmulr(void); static void hmuli(void); +static void hmulr_u(void); static void hmuli_u(void); static void qmulr(void); static void qmuli(void); static void qmulr_u(void); static void qmuli_u(void); static void divr(void); static void divi(void); @@ -318,11 +320,22 @@ static void andr(void); static void andi(void); static void orr(void); static void ori(void); static void xorr(void); static void xori(void); static void lshr(void); static void lshi(void); +static void qlshr(void); static void qlshi(void); +static void qlshr_u(void); static void qlshi_u(void); static void rshr(void); static void rshi(void); +static void qrshr(void); static void qrshi(void); static void rshr_u(void); static void rshi_u(void); -static void negr(void); static void comr(void); +static void qrshr_u(void); static void qrshi_u(void); +static void lrotr(void); static void lroti(void); +static void rrotr(void); static void rroti(void); +static void negr(void); static void negi(void); +static void comr(void); static void comi(void); static void clor(void); static void clzr(void); +static void cloi(void); static void clzi(void); static void ctor(void); static void ctzr(void); +static void ctoi(void); static void ctzi(void); +static void rbitr(void); static void rbiti(void); +static void popcntr(void); static void popcnti(void); static void ltr(void); static void lti(void); static void ltr_u(void); static void lti_u(void); static void ler(void); static void lei(void); @@ -335,22 +348,33 @@ static void gtr_u(void); static void gti_u(void); static void ner(void); static void nei(void); static void casr(void); static void casi(void); static void movr(void); static void movi(void); -static void extr_c(void); static void extr_uc(void); -static void extr_s(void); static void extr_us(void); +static void extr(void); static void exti(void); +static void extr_u(void); static void exti_u(void); +static void depr(void); static void depi(void); +static void extr_c(void); static void exti_c(void); +static void extr_uc(void); static void exti_uc(void); +static void extr_s(void); static void exti_s(void); +static void extr_us(void); static void exti_us(void); #if __WORDSIZE == 64 -static void extr_i(void); static void extr_ui(void); +static void extr_i(void); static void exti_i(void); +static void extr_ui(void); static void exti_ui(void); #endif -static void htonr_us(void); static void ntohr_us(void); -static void htonr_ui(void); static void ntohr_ui(void); +static void htonr_us(void); static void htoni_us(void); +static void ntohr_us(void); static void ntohi_us(void); +static void htonr_ui(void); static void htoni_ui(void); +static void ntohr_ui(void); static void ntohi_ui(void); #if __WORDSIZE == 64 -static void htonr_ul(void); static void ntohr_ul(void); +static void htonr_ul(void); static void htoni_ul(void); +static void ntohr_ul(void); static void ntohi_ul(void); #endif -static void htonr(void); static void ntohr(void); -static void bswapr_us(void); static void bswapr_ui(void); +static void htonr(void); static void htoni(void); +static void ntohr(void); static void ntohi(void); +static void bswapr_us(void); static void bswapi_us(void); +static void bswapr_ui(void); static void bswapi_ui(void); #if __WORDSIZE == 64 -static void bswapr_ul(void); +static void bswapr_ul(void); static void bswapi_ul(void); #endif -static void bswapr(void); +static void bswapr(void); static void bswapi(void); static void movnr(void); static void movzr(void); static void ldr_c(void); static void ldi_c(void); static void ldr_uc(void); static void ldi_uc(void); @@ -372,6 +396,8 @@ static void ldxr_ui(void); static void ldxi_ui(void); static void ldxr_l(void); static void ldxi_l(void); #endif static void ldxr(void); static void ldxi(void); +static void unldr(void); static void unldi(void); +static void unldr_u(void); static void unldi_u(void); static void str_c(void); static void sti_c(void); static void str_s(void); static void sti_s(void); static void str_i(void); static void sti_i(void); @@ -386,6 +412,7 @@ static void stxr_i(void); static void stxi_i(void); static void stxr_l(void); static void stxi_l(void); #endif static void stxr(void); static void stxi(void); +static void unstr(void); static void unsti(void); static void bltr(void); static void blti(void); static void bltr_u(void); static void blti_u(void); static void bler(void); static void blei(void); @@ -409,7 +436,6 @@ static void bxsubr_u(void); static void bxsubi_u(void); static void jmpr(void); static void jmpi(void); static void callr(void); static void calli(void); static void prepare(void); - static void pushargr_c(void); static void pushargi_c(void); static void pushargr_uc(void); static void pushargi_uc(void); static void pushargr_s(void); static void pushargi_s(void); @@ -420,10 +446,8 @@ static void pushargr_ui(void); static void pushargi_ui(void); static void pushargr_l(void); static void pushargi_l(void); #endif static void pushargr(void); static void pushargi(void); - static void finishr(void); static void finishi(void); static void ret(void); - static void retr_c(void); static void reti_c(void); static void retr_uc(void); static void reti_uc(void); static void retr_s(void); static void reti_s(void); @@ -449,8 +473,13 @@ static void subr_f(void); static void subi_f(void); static void rsbr_f(void); static void rsbi_f(void); static void mulr_f(void); static void muli_f(void); static void divr_f(void); static void divi_f(void); -static void negr_f(void); static void absr_f(void); -static void sqrtr_f(void); +static void negr_f(void); static void negi_f(void); +static void absr_f(void); static void absi_f(void); +static void sqrtr_f(void); static void sqrti_f(void); +static void fmar_f(void); static void fmai_f(void); +static void fmsr_f(void); static void fmsi_f(void); +static void fnmar_f(void); static void fnmai_f(void); +static void fnmsr_f(void); static void fnmsi_f(void); static void ltr_f(void); static void lti_f(void); static void ler_f(void); static void lei_f(void); static void eqr_f(void); static void eqi_f(void); @@ -472,10 +501,15 @@ static void truncr_f_l(void); static void truncr_f(void); static void extr_f(void); static void extr_d_f(void); static void movr_f(void); static void movi_f(void); +static void movr_w_f(void); static void movr_f_w(void); +static void movi_f_w(void); static void movi_w_f(void); static void ldr_f(void); static void ldi_f(void); static void ldxr_f(void); static void ldxi_f(void); +static void unldr_x(void); static void unldi_x(void); static void str_f(void); static void sti_f(void); static void stxr_f(void); static void stxi_f(void); +static void unstr_x(void); static void unsti_x(void); +static void unldr_f(void); static void unldi_f(void); static void bltr_f(void); static void blti_f(void); static void bler_f(void); static void blei_f(void); static void beqr_f(void); static void beqi_f(void); @@ -500,8 +534,13 @@ static void subr_d(void); static void subi_d(void); static void rsbr_d(void); static void rsbi_d(void); static void mulr_d(void); static void muli_d(void); static void divr_d(void); static void divi_d(void); -static void negr_d(void); static void absr_d(void); -static void sqrtr_d(void); +static void negr_d(void); static void negi_d(void); +static void absr_d(void); static void absi_d(void); +static void sqrtr_d(void); static void sqrti_d(void); +static void fmar_d(void); static void fmai_d(void); +static void fmsr_d(void); static void fmsi_d(void); +static void fnmar_d(void); static void fnmai_d(void); +static void fnmsr_d(void); static void fnmsi_d(void); static void ltr_d(void); static void lti_d(void); static void ler_d(void); static void lei_d(void); static void eqr_d(void); static void eqi_d(void); @@ -523,6 +562,13 @@ static void truncr_d_l(void); static void truncr_d(void); static void extr_d(void); static void extr_f_d(void); static void movr_d(void); static void movi_d(void); +#if __WORDSIZE == 32 +static void movr_ww_d(void); static void movr_d_ww(void); +static void movi_d_ww(void); static void movi_ww_d(void); +#else +static void movr_w_d(void); static void movr_d_w(void); +static void movi_d_w(void); static void movi_w_d(void); +#endif static void ldr_d(void); static void ldi_d(void); static void ldxr_d(void); static void ldxi_d(void); static void str_d(void); static void sti_d(void); @@ -647,7 +693,6 @@ static instr_t instr_vector[] = { entry(getarg_ui), entry(getarg_l), #endif entry(getarg), - entry(putargr_c), entry(putargi_c), entry(putargr_uc), entry(putargi_uc), entry(putargr_s), entry(putargi_s), @@ -666,6 +711,8 @@ static instr_t instr_vector[] = { entry(subcr), entry(subci), entry(rsbr), entry(rsbi), entry(mulr), entry(muli), + entry(hmulr), entry(hmuli), + entry(hmulr_u), entry(hmuli_u), entry(qmulr), entry(qmuli), entry(qmulr_u), entry(qmuli_u), entry(divr), entry(divi), @@ -678,11 +725,22 @@ static instr_t instr_vector[] = { entry(orr), entry(ori), entry(xorr), entry(xori), entry(lshr), entry(lshi), + entry(qlshr), entry(qlshi), + entry(qlshr_u), entry(qlshi_u), entry(rshr), entry(rshi), + entry(qrshr), entry(qrshi), entry(rshr_u), entry(rshi_u), - entry(negr), entry(comr), - entry(clor), entry(clzr), - entry(ctor), entry(ctzr), + entry(qrshr_u), entry(qrshi_u), + entry(lrotr), entry(lroti), + entry(rrotr), entry(rroti), + entry(negr), entry(negi), + entry(comr), entry(comi), + entry(clor), entry(cloi), + entry(clzr), entry(clzi), + entry(ctor), entry(ctoi), + entry(ctzr), entry(ctzi), + entry(rbitr), entry(rbiti), + entry(popcntr), entry(popcnti), entry(ltr), entry(lti), entry(ltr_u), entry(lti_u), entry(ler), entry(lei), @@ -695,22 +753,33 @@ static instr_t instr_vector[] = { entry(ner), entry(nei), entry(casr), entry(casi), entry(movr), entry(movi), - entry(extr_c), entry(extr_uc), - entry(extr_s), entry(extr_us), + entry(extr), entry(exti), + entry(extr_u), entry(exti_u), + entry(depr), entry(depi), + entry(extr_c), entry(exti_c), + entry(extr_uc), entry(exti_uc), + entry(extr_s), entry(exti_s), + entry(extr_us), entry(exti_us), #if __WORDSIZE == 64 - entry(extr_i), entry(extr_ui), + entry(extr_i), entry(exti_i), + entry(extr_ui), entry(exti_ui), #endif - entry(htonr_us), entry(ntohr_us), - entry(htonr_ui), entry(ntohr_ui), + entry(htonr_us), entry(htoni_us), + entry(ntohr_us), entry(ntohi_us), + entry(htonr_ui), entry(htoni_ui), + entry(ntohr_ui), entry(ntohi_ui), #if __WORDSIZE == 64 - entry(htonr_ul), entry(ntohr_ul), + entry(htonr_ul), entry(htoni_ul), + entry(ntohr_ul), entry(ntohi_ul), #endif - entry(htonr), entry(ntohr), - entry(bswapr_us), entry(bswapr_ui), + entry(htonr), entry(htoni), + entry(ntohr), entry(ntohi), + entry(bswapr_us), entry(bswapi_us), + entry(bswapr_ui), entry(bswapi_ui), #if __WORDSIZE == 64 - entry(bswapr_ul), + entry(bswapr_ul), entry(bswapi_ul), #endif - entry(bswapr), + entry(bswapr), entry(bswapi), entry(movnr), entry(movzr), entry(ldr_c), entry(ldi_c), entry(ldr_uc), entry(ldi_uc), @@ -732,6 +801,8 @@ static instr_t instr_vector[] = { entry(ldxr_l), entry(ldxi_l), #endif entry(ldxr), entry(ldxi), + entry(unldr), entry(unldi), + entry(unldr_u), entry(unldi_u), entry(str_c), entry(sti_c), entry(str_s), entry(sti_s), entry(str_i), entry(sti_i), @@ -746,6 +817,7 @@ static instr_t instr_vector[] = { entry(stxr_l), entry(stxi_l), #endif entry(stxr), entry(stxi), + entry(unstr), entry(unsti), entry(bltr), entry(blti), entry(bltr_u), entry(blti_u), entry(bler), entry(blei), @@ -806,8 +878,13 @@ static instr_t instr_vector[] = { entry(rsbr_f), entry(rsbi_f), entry(mulr_f), entry(muli_f), entry(divr_f), entry(divi_f), - entry(negr_f), entry(absr_f), - entry(sqrtr_f), + entry(negr_f), entry(negi_f), + entry(absr_f), entry(absi_f), + entry(sqrtr_f), entry(sqrti_f), + entry(fmar_f), entry(fmai_f), + entry(fmsr_f), entry(fmsi_f), + entry(fnmar_f), entry(fnmai_f), + entry(fnmsr_f), entry(fnmsi_f), entry(ltr_f), entry(lti_f), entry(ler_f), entry(lei_f), entry(eqr_f), entry(eqi_f), @@ -829,10 +906,14 @@ static instr_t instr_vector[] = { entry(truncr_f), entry(extr_f), entry(extr_d_f), entry(movr_f), entry(movi_f), + entry(movr_w_f), entry(movr_f_w), + entry(movi_f_w), entry(movi_w_f), entry(ldr_f), entry(ldi_f), entry(ldxr_f), entry(ldxi_f), + entry(unldr_x), entry(unldi_x), entry(str_f), entry(sti_f), entry(stxr_f), entry(stxi_f), + entry(unstr_x), entry(unsti_x), entry(bltr_f), entry(blti_f), entry(bler_f), entry(blei_f), entry(beqr_f), entry(beqi_f), @@ -857,8 +938,13 @@ static instr_t instr_vector[] = { entry(rsbr_d), entry(rsbi_d), entry(mulr_d), entry(muli_d), entry(divr_d), entry(divi_d), - entry(negr_d), entry(absr_d), - entry(sqrtr_d), + entry(negr_d), entry(negi_d), + entry(absr_d), entry(absi_d), + entry(sqrtr_d), entry(sqrti_d), + entry(fmar_d), entry(fmai_d), + entry(fmsr_d), entry(fmsi_d), + entry(fnmar_d), entry(fnmai_d), + entry(fnmsr_d), entry(fnmsi_d), entry(ltr_d), entry(lti_d), entry(ler_d), entry(lei_d), entry(eqr_d), entry(eqi_d), @@ -880,6 +966,13 @@ static instr_t instr_vector[] = { entry(truncr_d), entry(extr_d), entry(extr_f_d), entry(movr_d), entry(movi_d), +#if __WORDSIZE == 32 + entry(movr_ww_d), entry(movr_d_ww), + entry(movi_d_ww), entry(movi_ww_d), +#else + entry(movr_w_d), entry(movr_d_w), + entry(movi_d_w), entry(movi_w_d), +#endif entry(ldr_d), entry(ldi_d), entry(ldxr_d), entry(ldxi_d), entry(str_d), entry(sti_d), @@ -1088,6 +1181,41 @@ name(void) \ jit_word_t im = get_imm(); \ jit_##name(r0, r1, im); \ } +#define entry_ir_im_im(name) \ +static void \ +name(void) \ +{ \ + jit_gpr_t r0 = get_ireg(); \ + jit_word_t i0 = get_imm(), i1 = get_imm(); \ + jit_##name(r0, i0, i1); \ +} +#define entry_ir_fr_im(name) \ +static void \ +name(void) \ +{ \ + jit_gpr_t r0 = get_ireg(); \ + jit_fpr_t r1 = get_freg(); \ + jit_word_t im = get_imm(); \ + jit_##name(r0, r1, im); \ +} +#define entry_im_fr_im(name) \ +static void \ +name(void) \ +{ \ + jit_word_t i0 = get_imm(); \ + jit_fpr_t r0 = get_freg(); \ + jit_word_t i1 = get_imm(); \ + jit_##name(i0, r0, i1); \ +} +#define entry_im_ir_im(name) \ +static void \ +name(void) \ +{ \ + jit_word_t i0 = get_imm(); \ + jit_gpr_t r0 = get_ireg(); \ + jit_word_t i1 = get_imm(); \ + jit_##name(i0, r0, i1); \ +} #define entry_ir_ir_ir_ir(name) \ static void \ name(void) \ @@ -1113,7 +1241,20 @@ name(void) \ jit_gpr_t r1 = get_ireg(), r2 = get_ireg(); \ jit_##name(r0, im, r1, r2); \ } - +#define entry_ir_ir_im_im(name) \ +static void \ +name(void) { \ + jit_gpr_t r0 = get_ireg(), r1 = get_ireg(); \ + jit_word_t i0 = get_imm(), i1 = get_imm(); \ + jit_##name(r0, r1, i0, i1); \ +} +#define entry_ir_im_im_im(name) \ +static void \ +name(void) { \ + jit_gpr_t r0 = get_ireg(); \ + jit_word_t i0 = get_imm(), i1 = get_imm(), i2 = get_imm(); \ + jit_##name(r0, i0, i1, i2); \ +} #define entry_ir_ir(name) \ static void \ name(void) \ @@ -1225,6 +1366,14 @@ name(void) \ jit_fpr_t r0 = get_freg(), r1 = get_freg(), r2 = get_freg(); \ jit_##name(r0, r1, r2); \ } +#define entry_fr_fr_fr_fr(name) \ +static void \ +name(void) \ +{ \ + jit_fpr_t r0 = get_freg(), r1 = get_freg(), \ + r2 = get_freg(), r3 = get_freg(); \ + jit_##name(r0, r1, r2, r3); \ +} #define entry_fr_fr_fm(name) \ static void \ name(void) \ @@ -1233,6 +1382,15 @@ name(void) \ jit_float64_t im = get_float(skip_ws); \ jit_##name(r0, r1, make_float(im)); \ } +#define entry_fr_fr_fr_fm(name) \ +static void \ +name(void) \ +{ \ + jit_fpr_t r0 = get_freg(), r1 = get_freg(), \ + r2 = get_freg(); \ + jit_float64_t im = get_float(skip_ws); \ + jit_##name(r0, r1, r2, make_float(im)); \ +} #define entry_fr_fr_dm(name) \ static void \ name(void) \ @@ -1241,6 +1399,15 @@ name(void) \ jit_float64_t im = get_float(skip_ws); \ jit_##name(r0, r1, im); \ } +#define entry_fr_fr_fr_dm(name) \ +static void \ +name(void) \ +{ \ + jit_fpr_t r0 = get_freg(), r1 = get_freg(), \ + r2 = get_freg(); \ + jit_float64_t im = get_float(skip_ws); \ + jit_##name(r0, r1, r2, im); \ +} #define entry_fr_fr(name) \ static void \ name(void) \ @@ -1290,6 +1457,38 @@ name(void) \ jit_gpr_t r1 = get_ireg(); \ jit_##name(r0, r1); \ } +#define entry_fr_im(name) \ +static void \ +name(void) \ +{ \ + jit_fpr_t r0 = get_freg(); \ + jit_word_t i0 = get_imm(); \ + jit_##name(r0, i0); \ +} +#define entry_ir_fm(name) \ +static void \ +name(void) \ +{ \ + jit_gpr_t r0 = get_ireg(); \ + jit_float64_t im = get_float(skip_ws); \ + jit_##name(r0, make_float(im)); \ +} +#define entry_ir_dm(name) \ +static void \ +name(void) \ +{ \ + jit_gpr_t r0 = get_ireg(); \ + jit_float64_t im = get_float(skip_ws); \ + jit_##name(r0,im); \ +} +#define entry_ir_ir_dm(name) \ +static void \ +name(void) \ +{ \ + jit_gpr_t r0 = get_ireg(), r1 = get_ireg(); \ + jit_float64_t im = get_float(skip_ws); \ + jit_##name(r0, r1, im); \ +} #define entry_fr_fm(name) \ static void \ name(void) \ @@ -1331,6 +1530,15 @@ name(void) \ jit_word_t im = get_imm(); \ jit_##name(r0, r1, im); \ } +#define entry_fr_im_im(name) \ +static void \ +name(void) \ +{ \ + jit_fpr_t r0 = get_freg(); \ + jit_word_t i0 = get_imm(); \ + jit_word_t i1 = get_imm(); \ + jit_##name(r0, i0, i1); \ +} #define entry_pm_fr(name) \ static void \ name(void) \ @@ -1519,6 +1727,8 @@ entry_ir_ir_ir(subxr) entry_ir_ir_im(subxi) entry_ir_ir_ir(subcr) entry_ir_ir_im(subci) entry_ir_ir_ir(rsbr) entry_ir_ir_im(rsbi) entry_ir_ir_ir(mulr) entry_ir_ir_im(muli) +entry_ir_ir_ir(hmulr) entry_ir_ir_im(hmuli) +entry_ir_ir_ir(hmulr_u) entry_ir_ir_im(hmuli_u) entry_ir_ir_ir_ir(qmulr) entry_ir_ir_ir_im(qmuli) entry_ir_ir_ir_ir(qmulr_u) entry_ir_ir_ir_im(qmuli_u) entry_ir_ir_ir(divr) entry_ir_ir_im(divi) @@ -1531,11 +1741,22 @@ entry_ir_ir_ir(andr) entry_ir_ir_im(andi) entry_ir_ir_ir(orr) entry_ir_ir_im(ori) entry_ir_ir_ir(xorr) entry_ir_ir_im(xori) entry_ir_ir_ir(lshr) entry_ir_ir_im(lshi) +entry_ir_ir_ir_ir(qlshr) entry_ir_ir_ir_im(qlshi) +entry_ir_ir_ir_ir(qlshr_u) entry_ir_ir_ir_im(qlshi_u) entry_ir_ir_ir(rshr) entry_ir_ir_im(rshi) +entry_ir_ir_ir_ir(qrshr) entry_ir_ir_ir_im(qrshi) entry_ir_ir_ir(rshr_u) entry_ir_ir_im(rshi_u) -entry_ir_ir(negr) entry_ir_ir(comr) -entry_ir_ir(clor) entry_ir_ir(clzr) -entry_ir_ir(ctor) entry_ir_ir(ctzr) +entry_ir_ir_ir_ir(qrshr_u) entry_ir_ir_ir_im(qrshi_u) +entry_ir_ir_ir(lrotr) entry_ir_ir_im(lroti) +entry_ir_ir_ir(rrotr) entry_ir_ir_im(rroti) +entry_ir_ir(negr) entry_ir_im(negi) +entry_ir_ir(comr) entry_ir_im(comi) +entry_ir_ir(clor) entry_ir_im(cloi) +entry_ir_ir(clzr) entry_ir_im(clzi) +entry_ir_ir(ctor) entry_ir_im(ctoi) +entry_ir_ir(ctzr) entry_ir_im(ctzi) +entry_ir_ir(rbitr) entry_ir_im(rbiti) +entry_ir_ir(popcntr) entry_ir_im(popcnti) entry_ir_ir_ir(ltr) entry_ir_ir_im(lti) entry_ir_ir_ir(ltr_u) entry_ir_ir_im(lti_u) entry_ir_ir_ir(ler) entry_ir_ir_im(lei) @@ -1595,22 +1816,34 @@ movi(void) } jit_movi(r0, (jit_word_t)value); } -entry_ir_ir(extr_c) entry_ir_ir(extr_uc) -entry_ir_ir(extr_s) entry_ir_ir(extr_us) + +entry_ir_ir_im_im(extr) entry_ir_im_im_im(exti) +entry_ir_ir_im_im(extr_u) entry_ir_im_im_im(exti_u) +entry_ir_ir_im_im(depr) entry_ir_im_im_im(depi) +entry_ir_ir(extr_c) entry_ir_im(exti_c) +entry_ir_ir(extr_uc) entry_ir_im(exti_uc) +entry_ir_ir(extr_s) entry_ir_im(exti_s) +entry_ir_ir(extr_us) entry_ir_im(exti_us) #if __WORDSIZE == 64 -entry_ir_ir(extr_i) entry_ir_ir(extr_ui) +entry_ir_ir(extr_i) entry_ir_im(exti_i) +entry_ir_ir(extr_ui) entry_ir_im(exti_ui) #endif -entry_ir_ir(htonr_us) entry_ir_ir(ntohr_us) -entry_ir_ir(htonr_ui) entry_ir_ir(ntohr_ui) +entry_ir_ir(htonr_us) entry_ir_im(htoni_us) +entry_ir_ir(ntohr_us) entry_ir_im(ntohi_us) +entry_ir_ir(htonr_ui) entry_ir_im(htoni_ui) +entry_ir_ir(ntohr_ui) entry_ir_im(ntohi_ui) #if __WORDSIZE == 64 -entry_ir_ir(htonr_ul) entry_ir_ir(ntohr_ul) +entry_ir_ir(htonr_ul) entry_ir_im(htoni_ul) +entry_ir_ir(ntohr_ul) entry_ir_im(ntohi_ul) #endif -entry_ir_ir(htonr) entry_ir_ir(ntohr) -entry_ir_ir(bswapr_us) entry_ir_ir(bswapr_ui) +entry_ir_ir(htonr) entry_ir_im(htoni) +entry_ir_ir(ntohr) entry_ir_im(ntohi) +entry_ir_ir(bswapr_us) entry_ir_im(bswapi_us) +entry_ir_ir(bswapr_ui) entry_ir_im(bswapi_ui) #if __WORDSIZE == 64 -entry_ir_ir(bswapr_ul) +entry_ir_ir(bswapr_ul) entry_ir_im(bswapi_ul) #endif -entry_ir_ir(bswapr) +entry_ir_ir(bswapr) entry_ir_im(bswapi) entry_ir_ir_ir(movnr) entry_ir_ir_ir(movzr) entry_ir_ir(ldr_c) entry_ir_pm(ldi_c) entry_ir_ir(ldr_uc) entry_ir_pm(ldi_uc) @@ -1632,6 +1865,8 @@ entry_ir_ir_ir(ldxr_ui) entry_ir_ir_im(ldxi_ui) entry_ir_ir_ir(ldxr_l) entry_ir_ir_im(ldxi_l) #endif entry_ir_ir_ir(ldxr) entry_ir_ir_im(ldxi) +entry_ir_ir_im(unldr) entry_ir_im_im(unldi) +entry_ir_ir_im(unldr_u) entry_ir_im_im(unldi_u) entry_ir_ir(str_c) entry_pm_ir(sti_c) entry_ir_ir(str_s) entry_pm_ir(sti_s) entry_ir_ir(str_i) entry_pm_ir(sti_i) @@ -1646,6 +1881,7 @@ entry_ir_ir_ir(stxr_i) entry_im_ir_ir(stxi_i) entry_ir_ir_ir(stxr_l) entry_im_ir_ir(stxi_l) #endif entry_ir_ir_ir(stxr) entry_im_ir_ir(stxi) +entry_ir_ir_im(unstr) entry_im_ir_im(unsti) entry_lb_ir_ir(bltr) entry_lb_ir_im(blti) entry_lb_ir_ir(bltr_u) entry_lb_ir_im(blti_u) entry_lb_ir_ir(bler) entry_lb_ir_im(blei) @@ -1706,8 +1942,13 @@ entry_fr_fr_fr(subr_f) entry_fr_fr_fm(subi_f) entry_fr_fr_fr(rsbr_f) entry_fr_fr_fm(rsbi_f) entry_fr_fr_fr(mulr_f) entry_fr_fr_fm(muli_f) entry_fr_fr_fr(divr_f) entry_fr_fr_fm(divi_f) -entry_fr_fr(negr_f) entry_fr_fr(absr_f) -entry_fr_fr(sqrtr_f) +entry_fr_fr(negr_f) entry_fr_fm(negi_f) +entry_fr_fr(absr_f) entry_fr_fm(absi_f) +entry_fr_fr(sqrtr_f) entry_fr_fm(sqrti_f) +entry_fr_fr_fr_fr(fmar_f) entry_fr_fr_fr_fm(fmai_f) +entry_fr_fr_fr_fr(fmsr_f) entry_fr_fr_fr_fm(fmsi_f) +entry_fr_fr_fr_fr(fnmar_f) entry_fr_fr_fr_fm(fnmai_f) +entry_fr_fr_fr_fr(fnmsr_f) entry_fr_fr_fr_fm(fnmsi_f) entry_ir_fr_fr(ltr_f) entry_ir_fr_fm(lti_f) entry_ir_fr_fr(ler_f) entry_ir_fr_fm(lei_f) entry_ir_fr_fr(eqr_f) entry_ir_fr_fm(eqi_f) @@ -1729,10 +1970,14 @@ entry_ir_fr(truncr_f_l) entry_ir_fr(truncr_f) entry_fr_ir(extr_f) entry_fr_fr(extr_d_f) entry_fr_fr(movr_f) entry_fr_fm(movi_f) +entry_fr_ir(movr_w_f) entry_ir_fr(movr_f_w) +entry_ir_fm(movi_f_w) entry_fr_im(movi_w_f) entry_fr_ir(ldr_f) entry_fr_pm(ldi_f) entry_fr_ir_ir(ldxr_f) entry_fr_ir_im(ldxi_f) +entry_fr_ir_im(unldr_x) entry_fr_im_im(unldi_x) entry_ir_fr(str_f) entry_pm_fr(sti_f) entry_ir_ir_fr(stxr_f) entry_im_ir_fr(stxi_f) +entry_ir_fr_im(unstr_x) entry_im_fr_im(unsti_x) entry_lb_fr_fr(bltr_f) entry_lb_fr_fm(blti_f) entry_lb_fr_fr(bler_f) entry_lb_fr_fm(blei_f) entry_lb_fr_fr(beqr_f) entry_lb_fr_fm(beqi_f) @@ -1757,8 +2002,13 @@ entry_fr_fr_fr(subr_d) entry_fr_fr_dm(subi_d) entry_fr_fr_fr(rsbr_d) entry_fr_fr_dm(rsbi_d) entry_fr_fr_fr(mulr_d) entry_fr_fr_dm(muli_d) entry_fr_fr_fr(divr_d) entry_fr_fr_dm(divi_d) -entry_fr_fr(negr_d) entry_fr_fr(absr_d) -entry_fr_fr(sqrtr_d) +entry_fr_fr(negr_d) entry_fr_fm(negi_d) +entry_fr_fr(absr_d) entry_fr_fm(absi_d) +entry_fr_fr(sqrtr_d) entry_fr_fm(sqrti_d) +entry_fr_fr_fr_fr(fmar_d) entry_fr_fr_fr_dm(fmai_d) +entry_fr_fr_fr_fr(fmsr_d) entry_fr_fr_fr_dm(fmsi_d) +entry_fr_fr_fr_fr(fnmar_d) entry_fr_fr_fr_dm(fnmai_d) +entry_fr_fr_fr_fr(fnmsr_d) entry_fr_fr_fr_dm(fnmsi_d) entry_ir_fr_fr(ltr_d) entry_ir_fr_dm(lti_d) entry_ir_fr_fr(ler_d) entry_ir_fr_dm(lei_d) entry_ir_fr_fr(eqr_d) entry_ir_fr_dm(eqi_d) @@ -1780,6 +2030,13 @@ entry_ir_fr(truncr_d_l) entry_ir_fr(truncr_d) entry_fr_ir(extr_d) entry_fr_fr(extr_f_d) entry_fr_fr(movr_d) entry_fr_dm(movi_d) +#if __WORDSIZE == 32 +entry_fr_ir_ir(movr_ww_d) entry_ir_ir_fr(movr_d_ww) +entry_ir_ir_dm(movi_d_ww) entry_fr_im_im(movi_ww_d) +#else +entry_fr_ir(movr_w_d) entry_ir_fr(movr_d_w) +entry_ir_dm(movi_d_w) entry_fr_im(movi_w_d) +#endif entry_fr_ir(ldr_d) entry_fr_pm(ldi_d) entry_fr_ir_ir(ldxr_d) entry_fr_ir_im(ldxi_d) entry_ir_fr(str_d) entry_pm_fr(sti_d) @@ -1868,6 +2125,8 @@ vaend(void) #undef entry_ir_ir #undef entry_ir_ir_im #undef entry_ir_ir_ir +#undef entry_ir_ir_im_im +#undef entry_ir_im_im_im #undef entry_ima #undef entry_ir #undef entry_im @@ -2435,6 +2694,68 @@ dot(void) error("unknown command .%s", parser.string); } +#if _WIN32 +/* Workaround bug in a few patterns in MSYS64 library; + * below is liberty implementation slightly modified. */ +jit_uword_t +liberty_strtoul(const char *nptr, char **endptr, register int base) +{ + register const char *s = nptr; + register jit_uword_t acc; + register int c; + register jit_uword_t cutoff; + register int neg = 0, any, cutlim; + + /* + * See strtol for comments as to the logic used. + */ + do { + c = *s++; + } while (c == ' ' || c == '\t'); + if (c == '-') { + neg = 1; + c = *s++; + } else if (c == '+') + c = *s++; + if ((base == 0 || base == 16) && + c == '0' && (*s == 'x' || *s == 'X')) { + c = s[1]; + s += 2; + base = 16; + } + if (base == 0) + base = c == '0' ? 8 : 10; + cutoff = (jit_uword_t)~0LL / (jit_uword_t)base; + cutlim = (jit_uword_t)~0LL % (jit_uword_t)base; + for (acc = 0, any = 0;; c = *s++) { + if (c >= '0' && c <= '9') + c -= '0'; + else if ((c >= 'a' && c <= 'z') || + (c >= 'A' && c <= 'Z')) + c -= (c >= 'A' && c <= 'Z') ? 'A' - 10 : 'a' - 10; + else + break; + if (c >= base) + break; + if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) + any = -1; + else { + any = 1; + acc *= base; + acc += c; + } + } + if (any < 0) { + acc = ~0LL; + /*errno = ERANGE;*/ + } else if (neg) + acc = -acc; + if (endptr != 0) + *endptr = (char *) (any ? s - 1 : nptr); + return (acc); +} +#endif + static token_t number(int ch) { @@ -2529,7 +2850,7 @@ done: buffer[offset] = '\0'; if (integer) { #if _WIN32 -# define STRTOUL strtoull +# define STRTOUL liberty_strtoul #else # define STRTOUL strtoul #endif diff --git a/deps/lightning/check/popcnt.ok b/deps/lightning/check/popcnt.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/popcnt.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/popcnt.tst b/deps/lightning/check/popcnt.tst new file mode 100644 index 00000000..423cd225 --- /dev/null +++ b/deps/lightning/check/popcnt.tst @@ -0,0 +1,123 @@ +.data 4096 +pop_tab: +.c 0 1 1 2 1 2 2 3 1 2 2 3 2 3 3 4 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 3 4 4 5 4 5 5 6 4 5 5 6 5 6 6 7 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 3 4 4 5 4 5 5 6 4 5 5 6 5 6 6 7 2 3 3 4 3 4 4 5 3 4 4 5 4 5 5 6 3 4 4 5 4 5 5 6 4 5 5 6 5 6 6 7 3 4 4 5 4 5 5 6 4 5 5 6 5 6 6 7 4 5 5 6 5 6 6 7 5 6 6 7 6 7 7 8 +ok: +.c "ok\n" +fmt: +#if __WORDSIZE == 32 +.c "0x%08lx = %d\n" +#else +.c "0x%016lx = %d\n" +#endif + +#define BIT2(OP, ARG, RES, R0, R1) \ + movi %R1 ARG \ + OP##r %R0 %R1 \ + beqi OP##R0##R1##ARG %R0 RES \ + calli @abort \ +OP##R0##R1##ARG: + +#define BIT1(OP, ARG, RES, V0, V1, V2, R0, R1, R2) \ + BIT2(OP, ARG, RES, V0, V0) \ + BIT2(OP, ARG, RES, V0, V1) \ + BIT2(OP, ARG, RES, V0, V2) \ + BIT2(OP, ARG, RES, V0, R0) \ + BIT2(OP, ARG, RES, V0, R1) \ + BIT2(OP, ARG, RES, V0, R2) + +#define BIT(OP, ARG, RES, V0, V1, V2, R0, R1, R2) \ + BIT1(OP, ARG, RES, V1, V2, R0, R1, R2, V0) \ + BIT1(OP, ARG, RES, V2, R0, R1, R2, V0, V1) \ + BIT1(OP, ARG, RES, R0, R1, R2, V0, V1, V2) \ + BIT1(OP, ARG, RES, R1, R2, V0, V1, V2, R0) \ + BIT1(OP, ARG, RES, R2, V0, V1, V2, R0, R1) + +#define POPCNT(ARG, RES) \ + BIT(popcnt, ARG, RES, v0, v1, v2, r0, r1, r2) + +.code + jmpi main +name popcnt +popcnt: + prolog + arg $in + getarg %r1 $in + extr_uc %r2 %r1 + movi %v0 pop_tab + ldxr_uc %r0 %v0 %r2 + movi %v1 8 +popcnt_loop: + rshr %r2 %r1 %v1 + extr_uc %r2 %r2 + ldxr_uc %r2 %v0 %r2 + addr %r0 %r0 %r2 + addi %v1 %v1 8 + blti popcnt_loop %v1 __WORDSIZE + retr %r0 + epilog + +#if 0 + name main +main: + prolog + arg $argc + arg $argv + getarg %r0 $argc + bnei default %r0 2 + getarg %v0 $argv + ldxi %r0 %v0 $(__WORDSIZE >> 3) + prepare + pushargr %r0 + pushargi 0 + pushargi 0 + finishi @strtoul + retval %v0 + jmpi main_do +default: +#if __WORDSIZE == 32 + movi %v0 0x8a13c851 +#else + movi %v0 0x984a137ffec85219 +#endif +main_do: + prepare + pushargr %v0 + finishi popcnt + retval %r0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + popcntr %r0 %v0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + ret + epilog +#else + + name main +main: + prolog +#if __WORDSIZE == 32 + POPCNT(0x8a13c851, 12) + POPCNT(0x12345678, 13) + POPCNT(0x02468ace, 12) +#else + POPCNT(0x984a137ffec85219, 32) + POPCNT(0x123456789abcdef0, 32) + POPCNT(0x02468ace013579bd, 28) +#endif + prepare + pushargi ok + finishi @printf + reti 0 + epilog +#endif diff --git a/deps/lightning/check/qalu_shift.ok b/deps/lightning/check/qalu_shift.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/qalu_shift.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/qalu_shift.tst b/deps/lightning/check/qalu_shift.tst new file mode 100644 index 00000000..fc030e49 --- /dev/null +++ b/deps/lightning/check/qalu_shift.tst @@ -0,0 +1,748 @@ +#define GENTABLE 0 +#define EXPANDFULL 0 + +#if GENTABLE +.data 128 +fmt: +# if __WORDSIZE == 32 +.c "%s(%2d, 0x%08x, %2d, 0x%08x, 0x%08x)" +# else +.c "%s(%2d, 0x%016lx, %2d, 0x%016lx, 0x%016lx)" +# endif +opt_start: +.c "\tOPTIONAL(" +opt_end: +.c ")\n" +use_start: +.c "\t" +use_end: +.c "\n" +QLSH: +.c " QLSH" +QLSHU: +.c "QLSHU" +QRSH: +.c " QRSH" +QRSHU: +.c "QRSHU" +#else +#include "qalu.inc" +#endif + +#define QLSH(N, VAL, SH, LO, HI) QALU(N, , qlsh, VAL, SH, LO, HI) +#define QLSHU(N, VAL, SH, LO, HI) QALU(N, _u, qlsh, VAL, SH, LO, HI) +#define QRSH(N, VAL, SH, LO, HI) QALU(N, , qrsh, VAL, SH, LO, HI) +#define QRSHU(N, VAL, SH, LO, HI) QALU(N, _u, qrsh, VAL, SH, LO, HI) + +#if EXPANDFULL +# define OPTIONAL(OPT) OPT +#else +# define OPTIONAL(OPT) /**/ +#endif + +.code +#if GENTABLE + jmpi main +func_qlsh: + prolog + arg $value + arg $shift + getarg %v0 $value + getarg %v1 $shift + allocai $((__WORDSIZE >> 3) * 2) $buf + beqi func_qlsh_zero %v1 0 + beqi func_qlsh_overflow %v1 __WORDSIZE + rsbi %r0 %v1 __WORDSIZE + rshr %r1 %v0 %r0 + lshr %r0 %v0 %v1 + jmpi func_qlsh_done +func_qlsh_overflow: + movr %r1 %v0 + movi %r0 0 + jmpi func_qlsh_done +func_qlsh_zero: + movr %r0 %v0 + rshi %r1 %v0 $(__WORDSIZE - 1) +func_qlsh_done: + stxi $buf %fp %r0 + stxi $($buf + (__WORDSIZE >> 3)) %fp %r1 + beqi func_qlsh_not_optional %v1 0 + beqi func_qlsh_not_optional %v1 1 + beqi func_qlsh_not_optional %v1 $(__WORDSIZE / 2 - 1) + beqi func_qlsh_not_optional %v1 $(__WORDSIZE / 2) + beqi func_qlsh_not_optional %v1 $(__WORDSIZE / 2 + 1) + beqi func_qlsh_not_optional %v1 $(__WORDSIZE - 1) + beqi func_qlsh_not_optional %v1 $(__WORDSIZE) + jmpi func_qlsh_optional +func_qlsh_not_optional: + prepare + pushargi use_start + finishi @printf + movi %v2 0 + jmpi func_qlsh_printf +func_qlsh_optional: + prepare + pushargi opt_start + finishi @printf + movi %v2 1 +func_qlsh_printf: + ldxi %r0 %fp $buf + ldxi %r1 %fp $($buf + (__WORDSIZE >> 3)) + prepare + pushargi fmt + ellipsis + pushargi QLSH + pushargr %v1 + pushargr %v0 + pushargr %v1 + pushargr %r0 + pushargr %r1 + finishi @printf + beqi func_qlsh_not_optional_end %v2 0 + prepare + pushargi opt_end + finishi @printf + jmpi func_qlsh_ret +func_qlsh_not_optional_end: + prepare + pushargi use_end + finishi @printf +func_qlsh_ret: + ret + epilog + +func_qlsh_u: + prolog + arg $value + arg $shift + getarg %v0 $value + getarg %v1 $shift + allocai $((__WORDSIZE >> 3) * 2) $buf + beqi func_qlsh_u_zero %v1 0 + beqi func_qlsh_u_overflow %v1 __WORDSIZE + rsbi %r0 %v1 __WORDSIZE + rshr_u %r1 %v0 %r0 + lshr %r0 %v0 %v1 + jmpi func_qlsh_u_done +func_qlsh_u_overflow: + movr %r1 %v0 + movi %r0 0 + jmpi func_qlsh_u_done +func_qlsh_u_zero: + movr %r0 %v0 + movi %r1 0 +func_qlsh_u_done: + stxi $buf %fp %r0 + stxi $($buf + (__WORDSIZE >> 3)) %fp %r1 + beqi func_qlsh_u_not_optional %v1 0 + beqi func_qlsh_u_not_optional %v1 1 + beqi func_qlsh_u_not_optional %v1 $(__WORDSIZE / 2 - 1) + beqi func_qlsh_u_not_optional %v1 $(__WORDSIZE / 2) + beqi func_qlsh_u_not_optional %v1 $(__WORDSIZE / 2 + 1) + beqi func_qlsh_u_not_optional %v1 $(__WORDSIZE - 1) + beqi func_qlsh_u_not_optional %v1 $(__WORDSIZE) + jmpi func_qlsh_u_optional +func_qlsh_u_not_optional: + prepare + pushargi use_start + finishi @printf + movi %v2 0 + jmpi func_qlsh_u_printf +func_qlsh_u_optional: + prepare + pushargi opt_start + finishi @printf + movi %v2 1 +func_qlsh_u_printf: + ldxi %r0 %fp $buf + ldxi %r1 %fp $($buf + (__WORDSIZE >> 3)) + prepare + pushargi fmt + ellipsis + pushargi QLSHU + pushargr %v1 + pushargr %v0 + pushargr %v1 + pushargr %r0 + pushargr %r1 + finishi @printf + beqi func_qlsh_u_not_optional_end %v2 0 + prepare + pushargi opt_end + finishi @printf + jmpi func_qlsh_u_ret +func_qlsh_u_not_optional_end: + prepare + pushargi use_end + finishi @printf +func_qlsh_u_ret: + ret + epilog + +func_qrsh: + prolog + arg $value + arg $shift + getarg %v0 $value + getarg %v1 $shift + allocai $((__WORDSIZE >> 3) * 2) $buf + beqi func_qrsh_zero %v1 0 + beqi func_qrsh_overflow %v1 __WORDSIZE + rsbi %r0 %v1 __WORDSIZE + lshr %r1 %v0 %r0 + rshr %r0 %v0 %v1 + jmpi func_qrsh_done +func_qrsh_overflow: + movr %r1 %v0 + rshi %r0 %v0 $(__WORDSIZE - 1) + jmpi func_qrsh_done +func_qrsh_zero: + movr %r0 %v0 + rshi %r1 %v0 $(__WORDSIZE - 1) +func_qrsh_done: + stxi $buf %fp %r0 + stxi $($buf + (__WORDSIZE >> 3)) %fp %r1 + beqi func_qrsh_not_optional %v1 0 + beqi func_qrsh_not_optional %v1 1 + beqi func_qrsh_not_optional %v1 $(__WORDSIZE / 2 - 1) + beqi func_qrsh_not_optional %v1 $(__WORDSIZE / 2) + beqi func_qrsh_not_optional %v1 $(__WORDSIZE / 2 + 1) + beqi func_qrsh_not_optional %v1 $(__WORDSIZE - 1) + beqi func_qrsh_not_optional %v1 $(__WORDSIZE) + jmpi func_qrsh_optional +func_qrsh_not_optional: + prepare + pushargi use_start + finishi @printf + movi %v2 0 + jmpi func_qrsh_printf +func_qrsh_optional: + prepare + pushargi opt_start + finishi @printf + movi %v2 1 +func_qrsh_printf: + ldxi %r0 %fp $buf + ldxi %r1 %fp $($buf + (__WORDSIZE >> 3)) + prepare + pushargi fmt + ellipsis + pushargi QRSH + pushargr %v1 + pushargr %v0 + pushargr %v1 + pushargr %r0 + pushargr %r1 + finishi @printf + beqi func_qrsh_not_optional_end %v2 0 + prepare + pushargi opt_end + finishi @printf + jmpi func_qrsh_ret +func_qrsh_not_optional_end: + prepare + pushargi use_end + finishi @printf +func_qrsh_ret: + ret + epilog + +func_qrsh_u: + prolog + arg $value + arg $shift + getarg %v0 $value + getarg %v1 $shift + allocai $((__WORDSIZE >> 3) * 2) $buf + beqi func_qrsh_u_zero %v1 0 + beqi func_qrsh_u_overflow %v1 __WORDSIZE + rsbi %r0 %v1 __WORDSIZE + lshr %r1 %v0 %r0 + rshr_u %r0 %v0 %v1 + jmpi func_qrsh_u_done +func_qrsh_u_overflow: + movr %r1 %v0 + movi %r0 0 + jmpi func_qrsh_u_done +func_qrsh_u_zero: + movr %r0 %v0 + movi %r1 0 +func_qrsh_u_done: + stxi $buf %fp %r0 + stxi $($buf + (__WORDSIZE >> 3)) %fp %r1 + beqi func_qrsh_u_not_optional %v1 0 + beqi func_qrsh_u_not_optional %v1 1 + beqi func_qrsh_u_not_optional %v1 $(__WORDSIZE / 2 - 1) + beqi func_qrsh_u_not_optional %v1 $(__WORDSIZE / 2) + beqi func_qrsh_u_not_optional %v1 $(__WORDSIZE / 2 + 1) + beqi func_qrsh_u_not_optional %v1 $(__WORDSIZE - 1) + beqi func_qrsh_u_not_optional %v1 $(__WORDSIZE) + jmpi func_qrsh_u_optional +func_qrsh_u_not_optional: + prepare + pushargi use_start + finishi @printf + movi %v2 0 + jmpi func_qrsh_u_printf +func_qrsh_u_optional: + prepare + pushargi opt_start + finishi @printf + movi %v2 1 +func_qrsh_u_printf: + ldxi %r0 %fp $buf + ldxi %r1 %fp $($buf + (__WORDSIZE >> 3)) + prepare + pushargi fmt + ellipsis + pushargi QRSHU + pushargr %v1 + pushargr %v0 + pushargr %v1 + pushargr %r0 + pushargr %r1 + finishi @printf + beqi func_qrsh_u_not_optional_end %v2 0 + prepare + pushargi opt_end + finishi @printf + jmpi func_qrsh_u_ret +func_qrsh_u_not_optional_end: + prepare + pushargi use_end + finishi @printf +func_qrsh_u_ret: + epilog +#endif + + name main +main: + prolog +#if GENTABLE +# if __WORDSIZE == 32 + movi %v0 0x89abcdef +# else + movi %v0 0x89abcdef01234567 +# endif + movi %v1 0 +loop: + prepare + pushargr %v0 + pushargr %v1 + finishi func_qlsh + prepare + pushargr %v0 + pushargr %v1 + finishi func_qlsh_u + prepare + pushargr %v0 + pushargr %v1 + finishi func_qrsh + prepare + pushargr %v0 + pushargr %v1 + finishi func_qrsh_u + addi %v1 %v1 1 + blei loop %v1 __WORDSIZE +#else +# if __WORDSIZE == 32 + QLSH( 0, 0x89abcdef, 0, 0x89abcdef, 0xffffffff) + QLSHU( 0, 0x89abcdef, 0, 0x89abcdef, 0x00000000) + QRSH( 0, 0x89abcdef, 0, 0x89abcdef, 0xffffffff) + QRSHU( 0, 0x89abcdef, 0, 0x89abcdef, 0x00000000) + QLSH( 1, 0x89abcdef, 1, 0x13579bde, 0xffffffff) + QLSHU( 1, 0x89abcdef, 1, 0x13579bde, 0x00000001) + QRSH( 1, 0x89abcdef, 1, 0xc4d5e6f7, 0x80000000) + QRSHU( 1, 0x89abcdef, 1, 0x44d5e6f7, 0x80000000) + OPTIONAL( QLSH( 2, 0x89abcdef, 2, 0x26af37bc, 0xfffffffe)) + OPTIONAL(QLSHU( 2, 0x89abcdef, 2, 0x26af37bc, 0x00000002)) + OPTIONAL( QRSH( 2, 0x89abcdef, 2, 0xe26af37b, 0xc0000000)) + OPTIONAL(QRSHU( 2, 0x89abcdef, 2, 0x226af37b, 0xc0000000)) + OPTIONAL( QLSH( 3, 0x89abcdef, 3, 0x4d5e6f78, 0xfffffffc)) + OPTIONAL(QLSHU( 3, 0x89abcdef, 3, 0x4d5e6f78, 0x00000004)) + OPTIONAL( QRSH( 3, 0x89abcdef, 3, 0xf13579bd, 0xe0000000)) + OPTIONAL(QRSHU( 3, 0x89abcdef, 3, 0x113579bd, 0xe0000000)) + OPTIONAL( QLSH( 4, 0x89abcdef, 4, 0x9abcdef0, 0xfffffff8)) + OPTIONAL(QLSHU( 4, 0x89abcdef, 4, 0x9abcdef0, 0x00000008)) + OPTIONAL( QRSH( 4, 0x89abcdef, 4, 0xf89abcde, 0xf0000000)) + OPTIONAL(QRSHU( 4, 0x89abcdef, 4, 0x089abcde, 0xf0000000)) + OPTIONAL( QLSH( 5, 0x89abcdef, 5, 0x3579bde0, 0xfffffff1)) + OPTIONAL(QLSHU( 5, 0x89abcdef, 5, 0x3579bde0, 0x00000011)) + OPTIONAL( QRSH( 5, 0x89abcdef, 5, 0xfc4d5e6f, 0x78000000)) + OPTIONAL(QRSHU( 5, 0x89abcdef, 5, 0x044d5e6f, 0x78000000)) + OPTIONAL( QLSH( 6, 0x89abcdef, 6, 0x6af37bc0, 0xffffffe2)) + OPTIONAL(QLSHU( 6, 0x89abcdef, 6, 0x6af37bc0, 0x00000022)) + OPTIONAL( QRSH( 6, 0x89abcdef, 6, 0xfe26af37, 0xbc000000)) + OPTIONAL(QRSHU( 6, 0x89abcdef, 6, 0x0226af37, 0xbc000000)) + OPTIONAL( QLSH( 7, 0x89abcdef, 7, 0xd5e6f780, 0xffffffc4)) + OPTIONAL(QLSHU( 7, 0x89abcdef, 7, 0xd5e6f780, 0x00000044)) + OPTIONAL( QRSH( 7, 0x89abcdef, 7, 0xff13579b, 0xde000000)) + OPTIONAL(QRSHU( 7, 0x89abcdef, 7, 0x0113579b, 0xde000000)) + OPTIONAL( QLSH( 8, 0x89abcdef, 8, 0xabcdef00, 0xffffff89)) + OPTIONAL(QLSHU( 8, 0x89abcdef, 8, 0xabcdef00, 0x00000089)) + OPTIONAL( QRSH( 8, 0x89abcdef, 8, 0xff89abcd, 0xef000000)) + OPTIONAL(QRSHU( 8, 0x89abcdef, 8, 0x0089abcd, 0xef000000)) + OPTIONAL( QLSH( 9, 0x89abcdef, 9, 0x579bde00, 0xffffff13)) + OPTIONAL(QLSHU( 9, 0x89abcdef, 9, 0x579bde00, 0x00000113)) + OPTIONAL( QRSH( 9, 0x89abcdef, 9, 0xffc4d5e6, 0xf7800000)) + OPTIONAL(QRSHU( 9, 0x89abcdef, 9, 0x0044d5e6, 0xf7800000)) + OPTIONAL( QLSH(10, 0x89abcdef, 10, 0xaf37bc00, 0xfffffe26)) + OPTIONAL(QLSHU(10, 0x89abcdef, 10, 0xaf37bc00, 0x00000226)) + OPTIONAL( QRSH(10, 0x89abcdef, 10, 0xffe26af3, 0x7bc00000)) + OPTIONAL(QRSHU(10, 0x89abcdef, 10, 0x00226af3, 0x7bc00000)) + OPTIONAL( QLSH(11, 0x89abcdef, 11, 0x5e6f7800, 0xfffffc4d)) + OPTIONAL(QLSHU(11, 0x89abcdef, 11, 0x5e6f7800, 0x0000044d)) + OPTIONAL( QRSH(11, 0x89abcdef, 11, 0xfff13579, 0xbde00000)) + OPTIONAL(QRSHU(11, 0x89abcdef, 11, 0x00113579, 0xbde00000)) + OPTIONAL( QLSH(12, 0x89abcdef, 12, 0xbcdef000, 0xfffff89a)) + OPTIONAL(QLSHU(12, 0x89abcdef, 12, 0xbcdef000, 0x0000089a)) + OPTIONAL( QRSH(12, 0x89abcdef, 12, 0xfff89abc, 0xdef00000)) + OPTIONAL(QRSHU(12, 0x89abcdef, 12, 0x00089abc, 0xdef00000)) + OPTIONAL( QLSH(13, 0x89abcdef, 13, 0x79bde000, 0xfffff135)) + OPTIONAL(QLSHU(13, 0x89abcdef, 13, 0x79bde000, 0x00001135)) + OPTIONAL( QRSH(13, 0x89abcdef, 13, 0xfffc4d5e, 0x6f780000)) + OPTIONAL(QRSHU(13, 0x89abcdef, 13, 0x00044d5e, 0x6f780000)) + OPTIONAL( QLSH(14, 0x89abcdef, 14, 0xf37bc000, 0xffffe26a)) + OPTIONAL(QLSHU(14, 0x89abcdef, 14, 0xf37bc000, 0x0000226a)) + OPTIONAL( QRSH(14, 0x89abcdef, 14, 0xfffe26af, 0x37bc0000)) + OPTIONAL(QRSHU(14, 0x89abcdef, 14, 0x000226af, 0x37bc0000)) + QLSH(15, 0x89abcdef, 15, 0xe6f78000, 0xffffc4d5) + QLSHU(15, 0x89abcdef, 15, 0xe6f78000, 0x000044d5) + QRSH(15, 0x89abcdef, 15, 0xffff1357, 0x9bde0000) + QRSHU(15, 0x89abcdef, 15, 0x00011357, 0x9bde0000) + QLSH(16, 0x89abcdef, 16, 0xcdef0000, 0xffff89ab) + QLSHU(16, 0x89abcdef, 16, 0xcdef0000, 0x000089ab) + QRSH(16, 0x89abcdef, 16, 0xffff89ab, 0xcdef0000) + QRSHU(16, 0x89abcdef, 16, 0x000089ab, 0xcdef0000) + QLSH(17, 0x89abcdef, 17, 0x9bde0000, 0xffff1357) + QLSHU(17, 0x89abcdef, 17, 0x9bde0000, 0x00011357) + QRSH(17, 0x89abcdef, 17, 0xffffc4d5, 0xe6f78000) + QRSHU(17, 0x89abcdef, 17, 0x000044d5, 0xe6f78000) + OPTIONAL( QLSH(18, 0x89abcdef, 18, 0x37bc0000, 0xfffe26af)) + OPTIONAL(QLSHU(18, 0x89abcdef, 18, 0x37bc0000, 0x000226af)) + OPTIONAL( QRSH(18, 0x89abcdef, 18, 0xffffe26a, 0xf37bc000)) + OPTIONAL(QRSHU(18, 0x89abcdef, 18, 0x0000226a, 0xf37bc000)) + OPTIONAL( QLSH(19, 0x89abcdef, 19, 0x6f780000, 0xfffc4d5e)) + OPTIONAL(QLSHU(19, 0x89abcdef, 19, 0x6f780000, 0x00044d5e)) + OPTIONAL( QRSH(19, 0x89abcdef, 19, 0xfffff135, 0x79bde000)) + OPTIONAL(QRSHU(19, 0x89abcdef, 19, 0x00001135, 0x79bde000)) + OPTIONAL( QLSH(20, 0x89abcdef, 20, 0xdef00000, 0xfff89abc)) + OPTIONAL(QLSHU(20, 0x89abcdef, 20, 0xdef00000, 0x00089abc)) + OPTIONAL( QRSH(20, 0x89abcdef, 20, 0xfffff89a, 0xbcdef000)) + OPTIONAL(QRSHU(20, 0x89abcdef, 20, 0x0000089a, 0xbcdef000)) + OPTIONAL( QLSH(21, 0x89abcdef, 21, 0xbde00000, 0xfff13579)) + OPTIONAL(QLSHU(21, 0x89abcdef, 21, 0xbde00000, 0x00113579)) + OPTIONAL( QRSH(21, 0x89abcdef, 21, 0xfffffc4d, 0x5e6f7800)) + OPTIONAL(QRSHU(21, 0x89abcdef, 21, 0x0000044d, 0x5e6f7800)) + OPTIONAL( QLSH(22, 0x89abcdef, 22, 0x7bc00000, 0xffe26af3)) + OPTIONAL(QLSHU(22, 0x89abcdef, 22, 0x7bc00000, 0x00226af3)) + OPTIONAL( QRSH(22, 0x89abcdef, 22, 0xfffffe26, 0xaf37bc00)) + OPTIONAL(QRSHU(22, 0x89abcdef, 22, 0x00000226, 0xaf37bc00)) + OPTIONAL( QLSH(23, 0x89abcdef, 23, 0xf7800000, 0xffc4d5e6)) + OPTIONAL(QLSHU(23, 0x89abcdef, 23, 0xf7800000, 0x0044d5e6)) + OPTIONAL( QRSH(23, 0x89abcdef, 23, 0xffffff13, 0x579bde00)) + OPTIONAL(QRSHU(23, 0x89abcdef, 23, 0x00000113, 0x579bde00)) + OPTIONAL( QLSH(24, 0x89abcdef, 24, 0xef000000, 0xff89abcd)) + OPTIONAL(QLSHU(24, 0x89abcdef, 24, 0xef000000, 0x0089abcd)) + OPTIONAL( QRSH(24, 0x89abcdef, 24, 0xffffff89, 0xabcdef00)) + OPTIONAL(QRSHU(24, 0x89abcdef, 24, 0x00000089, 0xabcdef00)) + OPTIONAL( QLSH(25, 0x89abcdef, 25, 0xde000000, 0xff13579b)) + OPTIONAL(QLSHU(25, 0x89abcdef, 25, 0xde000000, 0x0113579b)) + OPTIONAL( QRSH(25, 0x89abcdef, 25, 0xffffffc4, 0xd5e6f780)) + OPTIONAL(QRSHU(25, 0x89abcdef, 25, 0x00000044, 0xd5e6f780)) + OPTIONAL( QLSH(26, 0x89abcdef, 26, 0xbc000000, 0xfe26af37)) + OPTIONAL(QLSHU(26, 0x89abcdef, 26, 0xbc000000, 0x0226af37)) + OPTIONAL( QRSH(26, 0x89abcdef, 26, 0xffffffe2, 0x6af37bc0)) + OPTIONAL(QRSHU(26, 0x89abcdef, 26, 0x00000022, 0x6af37bc0)) + OPTIONAL( QLSH(27, 0x89abcdef, 27, 0x78000000, 0xfc4d5e6f)) + OPTIONAL(QLSHU(27, 0x89abcdef, 27, 0x78000000, 0x044d5e6f)) + OPTIONAL( QRSH(27, 0x89abcdef, 27, 0xfffffff1, 0x3579bde0)) + OPTIONAL(QRSHU(27, 0x89abcdef, 27, 0x00000011, 0x3579bde0)) + OPTIONAL( QLSH(28, 0x89abcdef, 28, 0xf0000000, 0xf89abcde)) + OPTIONAL(QLSHU(28, 0x89abcdef, 28, 0xf0000000, 0x089abcde)) + OPTIONAL( QRSH(28, 0x89abcdef, 28, 0xfffffff8, 0x9abcdef0)) + OPTIONAL(QRSHU(28, 0x89abcdef, 28, 0x00000008, 0x9abcdef0)) + OPTIONAL( QLSH(29, 0x89abcdef, 29, 0xe0000000, 0xf13579bd)) + OPTIONAL(QLSHU(29, 0x89abcdef, 29, 0xe0000000, 0x113579bd)) + OPTIONAL( QRSH(29, 0x89abcdef, 29, 0xfffffffc, 0x4d5e6f78)) + OPTIONAL(QRSHU(29, 0x89abcdef, 29, 0x00000004, 0x4d5e6f78)) + OPTIONAL( QLSH(30, 0x89abcdef, 30, 0xc0000000, 0xe26af37b)) + OPTIONAL(QLSHU(30, 0x89abcdef, 30, 0xc0000000, 0x226af37b)) + OPTIONAL( QRSH(30, 0x89abcdef, 30, 0xfffffffe, 0x26af37bc)) + OPTIONAL(QRSHU(30, 0x89abcdef, 30, 0x00000002, 0x26af37bc)) + QLSH(31, 0x89abcdef, 31, 0x80000000, 0xc4d5e6f7) + QLSHU(31, 0x89abcdef, 31, 0x80000000, 0x44d5e6f7) + QRSH(31, 0x89abcdef, 31, 0xffffffff, 0x13579bde) + QRSHU(31, 0x89abcdef, 31, 0x00000001, 0x13579bde) + QLSH(32, 0x89abcdef, 32, 0x00000000, 0x89abcdef) + QLSHU(32, 0x89abcdef, 32, 0x00000000, 0x89abcdef) + QRSH(32, 0x89abcdef, 32, 0xffffffff, 0x89abcdef) + QRSHU(32, 0x89abcdef, 32, 0x00000000, 0x89abcdef) +# else + QLSH( 0, 0x89abcdef01234567, 0, 0x89abcdef01234567, 0xffffffffffffffff) + QLSHU( 0, 0x89abcdef01234567, 0, 0x89abcdef01234567, 0x0000000000000000) + QRSH( 0, 0x89abcdef01234567, 0, 0x89abcdef01234567, 0xffffffffffffffff) + QRSHU( 0, 0x89abcdef01234567, 0, 0x89abcdef01234567, 0x0000000000000000) + QLSH( 1, 0x89abcdef01234567, 1, 0x13579bde02468ace, 0xffffffffffffffff) + QLSHU( 1, 0x89abcdef01234567, 1, 0x13579bde02468ace, 0x0000000000000001) + QRSH( 1, 0x89abcdef01234567, 1, 0xc4d5e6f78091a2b3, 0x8000000000000000) + QRSHU( 1, 0x89abcdef01234567, 1, 0x44d5e6f78091a2b3, 0x8000000000000000) + OPTIONAL( QLSH( 2, 0x89abcdef01234567, 2, 0x26af37bc048d159c, 0xfffffffffffffffe)) + OPTIONAL(QLSHU( 2, 0x89abcdef01234567, 2, 0x26af37bc048d159c, 0x0000000000000002)) + OPTIONAL( QRSH( 2, 0x89abcdef01234567, 2, 0xe26af37bc048d159, 0xc000000000000000)) + OPTIONAL(QRSHU( 2, 0x89abcdef01234567, 2, 0x226af37bc048d159, 0xc000000000000000)) + OPTIONAL( QLSH( 3, 0x89abcdef01234567, 3, 0x4d5e6f78091a2b38, 0xfffffffffffffffc)) + OPTIONAL(QLSHU( 3, 0x89abcdef01234567, 3, 0x4d5e6f78091a2b38, 0x0000000000000004)) + OPTIONAL( QRSH( 3, 0x89abcdef01234567, 3, 0xf13579bde02468ac, 0xe000000000000000)) + OPTIONAL(QRSHU( 3, 0x89abcdef01234567, 3, 0x113579bde02468ac, 0xe000000000000000)) + OPTIONAL( QLSH( 4, 0x89abcdef01234567, 4, 0x9abcdef012345670, 0xfffffffffffffff8)) + OPTIONAL(QLSHU( 4, 0x89abcdef01234567, 4, 0x9abcdef012345670, 0x0000000000000008)) + OPTIONAL( QRSH( 4, 0x89abcdef01234567, 4, 0xf89abcdef0123456, 0x7000000000000000)) + OPTIONAL(QRSHU( 4, 0x89abcdef01234567, 4, 0x089abcdef0123456, 0x7000000000000000)) + OPTIONAL( QLSH( 5, 0x89abcdef01234567, 5, 0x3579bde02468ace0, 0xfffffffffffffff1)) + OPTIONAL(QLSHU( 5, 0x89abcdef01234567, 5, 0x3579bde02468ace0, 0x0000000000000011)) + OPTIONAL( QRSH( 5, 0x89abcdef01234567, 5, 0xfc4d5e6f78091a2b, 0x3800000000000000)) + OPTIONAL(QRSHU( 5, 0x89abcdef01234567, 5, 0x044d5e6f78091a2b, 0x3800000000000000)) + OPTIONAL( QLSH( 6, 0x89abcdef01234567, 6, 0x6af37bc048d159c0, 0xffffffffffffffe2)) + OPTIONAL(QLSHU( 6, 0x89abcdef01234567, 6, 0x6af37bc048d159c0, 0x0000000000000022)) + OPTIONAL( QRSH( 6, 0x89abcdef01234567, 6, 0xfe26af37bc048d15, 0x9c00000000000000)) + OPTIONAL(QRSHU( 6, 0x89abcdef01234567, 6, 0x0226af37bc048d15, 0x9c00000000000000)) + OPTIONAL( QLSH( 7, 0x89abcdef01234567, 7, 0xd5e6f78091a2b380, 0xffffffffffffffc4)) + OPTIONAL(QLSHU( 7, 0x89abcdef01234567, 7, 0xd5e6f78091a2b380, 0x0000000000000044)) + OPTIONAL( QRSH( 7, 0x89abcdef01234567, 7, 0xff13579bde02468a, 0xce00000000000000)) + OPTIONAL(QRSHU( 7, 0x89abcdef01234567, 7, 0x0113579bde02468a, 0xce00000000000000)) + OPTIONAL( QLSH( 8, 0x89abcdef01234567, 8, 0xabcdef0123456700, 0xffffffffffffff89)) + OPTIONAL(QLSHU( 8, 0x89abcdef01234567, 8, 0xabcdef0123456700, 0x0000000000000089)) + OPTIONAL( QRSH( 8, 0x89abcdef01234567, 8, 0xff89abcdef012345, 0x6700000000000000)) + OPTIONAL(QRSHU( 8, 0x89abcdef01234567, 8, 0x0089abcdef012345, 0x6700000000000000)) + OPTIONAL( QLSH( 9, 0x89abcdef01234567, 9, 0x579bde02468ace00, 0xffffffffffffff13)) + OPTIONAL(QLSHU( 9, 0x89abcdef01234567, 9, 0x579bde02468ace00, 0x0000000000000113)) + OPTIONAL( QRSH( 9, 0x89abcdef01234567, 9, 0xffc4d5e6f78091a2, 0xb380000000000000)) + OPTIONAL(QRSHU( 9, 0x89abcdef01234567, 9, 0x0044d5e6f78091a2, 0xb380000000000000)) + OPTIONAL( QLSH(10, 0x89abcdef01234567, 10, 0xaf37bc048d159c00, 0xfffffffffffffe26)) + OPTIONAL(QLSHU(10, 0x89abcdef01234567, 10, 0xaf37bc048d159c00, 0x0000000000000226)) + OPTIONAL( QRSH(10, 0x89abcdef01234567, 10, 0xffe26af37bc048d1, 0x59c0000000000000)) + OPTIONAL(QRSHU(10, 0x89abcdef01234567, 10, 0x00226af37bc048d1, 0x59c0000000000000)) + OPTIONAL( QLSH(11, 0x89abcdef01234567, 11, 0x5e6f78091a2b3800, 0xfffffffffffffc4d)) + OPTIONAL(QLSHU(11, 0x89abcdef01234567, 11, 0x5e6f78091a2b3800, 0x000000000000044d)) + OPTIONAL( QRSH(11, 0x89abcdef01234567, 11, 0xfff13579bde02468, 0xace0000000000000)) + OPTIONAL(QRSHU(11, 0x89abcdef01234567, 11, 0x00113579bde02468, 0xace0000000000000)) + OPTIONAL( QLSH(12, 0x89abcdef01234567, 12, 0xbcdef01234567000, 0xfffffffffffff89a)) + OPTIONAL(QLSHU(12, 0x89abcdef01234567, 12, 0xbcdef01234567000, 0x000000000000089a)) + OPTIONAL( QRSH(12, 0x89abcdef01234567, 12, 0xfff89abcdef01234, 0x5670000000000000)) + OPTIONAL(QRSHU(12, 0x89abcdef01234567, 12, 0x00089abcdef01234, 0x5670000000000000)) + OPTIONAL( QLSH(13, 0x89abcdef01234567, 13, 0x79bde02468ace000, 0xfffffffffffff135)) + OPTIONAL(QLSHU(13, 0x89abcdef01234567, 13, 0x79bde02468ace000, 0x0000000000001135)) + OPTIONAL( QRSH(13, 0x89abcdef01234567, 13, 0xfffc4d5e6f78091a, 0x2b38000000000000)) + OPTIONAL(QRSHU(13, 0x89abcdef01234567, 13, 0x00044d5e6f78091a, 0x2b38000000000000)) + OPTIONAL( QLSH(14, 0x89abcdef01234567, 14, 0xf37bc048d159c000, 0xffffffffffffe26a)) + OPTIONAL(QLSHU(14, 0x89abcdef01234567, 14, 0xf37bc048d159c000, 0x000000000000226a)) + OPTIONAL( QRSH(14, 0x89abcdef01234567, 14, 0xfffe26af37bc048d, 0x159c000000000000)) + OPTIONAL(QRSHU(14, 0x89abcdef01234567, 14, 0x000226af37bc048d, 0x159c000000000000)) + OPTIONAL( QLSH(15, 0x89abcdef01234567, 15, 0xe6f78091a2b38000, 0xffffffffffffc4d5)) + OPTIONAL(QLSHU(15, 0x89abcdef01234567, 15, 0xe6f78091a2b38000, 0x00000000000044d5)) + OPTIONAL( QRSH(15, 0x89abcdef01234567, 15, 0xffff13579bde0246, 0x8ace000000000000)) + OPTIONAL(QRSHU(15, 0x89abcdef01234567, 15, 0x000113579bde0246, 0x8ace000000000000)) + OPTIONAL( QLSH(16, 0x89abcdef01234567, 16, 0xcdef012345670000, 0xffffffffffff89ab)) + OPTIONAL(QLSHU(16, 0x89abcdef01234567, 16, 0xcdef012345670000, 0x00000000000089ab)) + OPTIONAL( QRSH(16, 0x89abcdef01234567, 16, 0xffff89abcdef0123, 0x4567000000000000)) + OPTIONAL(QRSHU(16, 0x89abcdef01234567, 16, 0x000089abcdef0123, 0x4567000000000000)) + OPTIONAL( QLSH(17, 0x89abcdef01234567, 17, 0x9bde02468ace0000, 0xffffffffffff1357)) + OPTIONAL(QLSHU(17, 0x89abcdef01234567, 17, 0x9bde02468ace0000, 0x0000000000011357)) + OPTIONAL( QRSH(17, 0x89abcdef01234567, 17, 0xffffc4d5e6f78091, 0xa2b3800000000000)) + OPTIONAL(QRSHU(17, 0x89abcdef01234567, 17, 0x000044d5e6f78091, 0xa2b3800000000000)) + OPTIONAL( QLSH(18, 0x89abcdef01234567, 18, 0x37bc048d159c0000, 0xfffffffffffe26af)) + OPTIONAL(QLSHU(18, 0x89abcdef01234567, 18, 0x37bc048d159c0000, 0x00000000000226af)) + OPTIONAL( QRSH(18, 0x89abcdef01234567, 18, 0xffffe26af37bc048, 0xd159c00000000000)) + OPTIONAL(QRSHU(18, 0x89abcdef01234567, 18, 0x0000226af37bc048, 0xd159c00000000000)) + OPTIONAL( QLSH(19, 0x89abcdef01234567, 19, 0x6f78091a2b380000, 0xfffffffffffc4d5e)) + OPTIONAL(QLSHU(19, 0x89abcdef01234567, 19, 0x6f78091a2b380000, 0x0000000000044d5e)) + OPTIONAL( QRSH(19, 0x89abcdef01234567, 19, 0xfffff13579bde024, 0x68ace00000000000)) + OPTIONAL(QRSHU(19, 0x89abcdef01234567, 19, 0x0000113579bde024, 0x68ace00000000000)) + OPTIONAL( QLSH(20, 0x89abcdef01234567, 20, 0xdef0123456700000, 0xfffffffffff89abc)) + OPTIONAL(QLSHU(20, 0x89abcdef01234567, 20, 0xdef0123456700000, 0x0000000000089abc)) + OPTIONAL( QRSH(20, 0x89abcdef01234567, 20, 0xfffff89abcdef012, 0x3456700000000000)) + OPTIONAL(QRSHU(20, 0x89abcdef01234567, 20, 0x0000089abcdef012, 0x3456700000000000)) + OPTIONAL( QLSH(21, 0x89abcdef01234567, 21, 0xbde02468ace00000, 0xfffffffffff13579)) + OPTIONAL(QLSHU(21, 0x89abcdef01234567, 21, 0xbde02468ace00000, 0x0000000000113579)) + OPTIONAL( QRSH(21, 0x89abcdef01234567, 21, 0xfffffc4d5e6f7809, 0x1a2b380000000000)) + OPTIONAL(QRSHU(21, 0x89abcdef01234567, 21, 0x0000044d5e6f7809, 0x1a2b380000000000)) + OPTIONAL( QLSH(22, 0x89abcdef01234567, 22, 0x7bc048d159c00000, 0xffffffffffe26af3)) + OPTIONAL(QLSHU(22, 0x89abcdef01234567, 22, 0x7bc048d159c00000, 0x0000000000226af3)) + OPTIONAL( QRSH(22, 0x89abcdef01234567, 22, 0xfffffe26af37bc04, 0x8d159c0000000000)) + OPTIONAL(QRSHU(22, 0x89abcdef01234567, 22, 0x00000226af37bc04, 0x8d159c0000000000)) + OPTIONAL( QLSH(23, 0x89abcdef01234567, 23, 0xf78091a2b3800000, 0xffffffffffc4d5e6)) + OPTIONAL(QLSHU(23, 0x89abcdef01234567, 23, 0xf78091a2b3800000, 0x000000000044d5e6)) + OPTIONAL( QRSH(23, 0x89abcdef01234567, 23, 0xffffff13579bde02, 0x468ace0000000000)) + OPTIONAL(QRSHU(23, 0x89abcdef01234567, 23, 0x00000113579bde02, 0x468ace0000000000)) + OPTIONAL( QLSH(24, 0x89abcdef01234567, 24, 0xef01234567000000, 0xffffffffff89abcd)) + OPTIONAL(QLSHU(24, 0x89abcdef01234567, 24, 0xef01234567000000, 0x000000000089abcd)) + OPTIONAL( QRSH(24, 0x89abcdef01234567, 24, 0xffffff89abcdef01, 0x2345670000000000)) + OPTIONAL(QRSHU(24, 0x89abcdef01234567, 24, 0x00000089abcdef01, 0x2345670000000000)) + OPTIONAL( QLSH(25, 0x89abcdef01234567, 25, 0xde02468ace000000, 0xffffffffff13579b)) + OPTIONAL(QLSHU(25, 0x89abcdef01234567, 25, 0xde02468ace000000, 0x000000000113579b)) + OPTIONAL( QRSH(25, 0x89abcdef01234567, 25, 0xffffffc4d5e6f780, 0x91a2b38000000000)) + OPTIONAL(QRSHU(25, 0x89abcdef01234567, 25, 0x00000044d5e6f780, 0x91a2b38000000000)) + OPTIONAL( QLSH(26, 0x89abcdef01234567, 26, 0xbc048d159c000000, 0xfffffffffe26af37)) + OPTIONAL(QLSHU(26, 0x89abcdef01234567, 26, 0xbc048d159c000000, 0x000000000226af37)) + OPTIONAL( QRSH(26, 0x89abcdef01234567, 26, 0xffffffe26af37bc0, 0x48d159c000000000)) + OPTIONAL(QRSHU(26, 0x89abcdef01234567, 26, 0x000000226af37bc0, 0x48d159c000000000)) + OPTIONAL( QLSH(27, 0x89abcdef01234567, 27, 0x78091a2b38000000, 0xfffffffffc4d5e6f)) + OPTIONAL(QLSHU(27, 0x89abcdef01234567, 27, 0x78091a2b38000000, 0x00000000044d5e6f)) + OPTIONAL( QRSH(27, 0x89abcdef01234567, 27, 0xfffffff13579bde0, 0x2468ace000000000)) + OPTIONAL(QRSHU(27, 0x89abcdef01234567, 27, 0x000000113579bde0, 0x2468ace000000000)) + OPTIONAL( QLSH(28, 0x89abcdef01234567, 28, 0xf012345670000000, 0xfffffffff89abcde)) + OPTIONAL(QLSHU(28, 0x89abcdef01234567, 28, 0xf012345670000000, 0x00000000089abcde)) + OPTIONAL( QRSH(28, 0x89abcdef01234567, 28, 0xfffffff89abcdef0, 0x1234567000000000)) + OPTIONAL(QRSHU(28, 0x89abcdef01234567, 28, 0x000000089abcdef0, 0x1234567000000000)) + OPTIONAL( QLSH(29, 0x89abcdef01234567, 29, 0xe02468ace0000000, 0xfffffffff13579bd)) + OPTIONAL(QLSHU(29, 0x89abcdef01234567, 29, 0xe02468ace0000000, 0x00000000113579bd)) + OPTIONAL( QRSH(29, 0x89abcdef01234567, 29, 0xfffffffc4d5e6f78, 0x091a2b3800000000)) + OPTIONAL(QRSHU(29, 0x89abcdef01234567, 29, 0x000000044d5e6f78, 0x091a2b3800000000)) + OPTIONAL( QLSH(30, 0x89abcdef01234567, 30, 0xc048d159c0000000, 0xffffffffe26af37b)) + OPTIONAL(QLSHU(30, 0x89abcdef01234567, 30, 0xc048d159c0000000, 0x00000000226af37b)) + OPTIONAL( QRSH(30, 0x89abcdef01234567, 30, 0xfffffffe26af37bc, 0x048d159c00000000)) + OPTIONAL(QRSHU(30, 0x89abcdef01234567, 30, 0x0000000226af37bc, 0x048d159c00000000)) + QLSH(31, 0x89abcdef01234567, 31, 0x8091a2b380000000, 0xffffffffc4d5e6f7) + QLSHU(31, 0x89abcdef01234567, 31, 0x8091a2b380000000, 0x0000000044d5e6f7) + QRSH(31, 0x89abcdef01234567, 31, 0xffffffff13579bde, 0x02468ace00000000) + QRSHU(31, 0x89abcdef01234567, 31, 0x0000000113579bde, 0x02468ace00000000) + QLSH(32, 0x89abcdef01234567, 32, 0x0123456700000000, 0xffffffff89abcdef) + QLSHU(32, 0x89abcdef01234567, 32, 0x0123456700000000, 0x0000000089abcdef) + QRSH(32, 0x89abcdef01234567, 32, 0xffffffff89abcdef, 0x0123456700000000) + QRSHU(32, 0x89abcdef01234567, 32, 0x0000000089abcdef, 0x0123456700000000) + QLSH(33, 0x89abcdef01234567, 33, 0x02468ace00000000, 0xffffffff13579bde) + QLSHU(33, 0x89abcdef01234567, 33, 0x02468ace00000000, 0x0000000113579bde) + QRSH(33, 0x89abcdef01234567, 33, 0xffffffffc4d5e6f7, 0x8091a2b380000000) + QRSHU(33, 0x89abcdef01234567, 33, 0x0000000044d5e6f7, 0x8091a2b380000000) + OPTIONAL( QLSH(34, 0x89abcdef01234567, 34, 0x048d159c00000000, 0xfffffffe26af37bc)) + OPTIONAL(QLSHU(34, 0x89abcdef01234567, 34, 0x048d159c00000000, 0x0000000226af37bc)) + OPTIONAL( QRSH(34, 0x89abcdef01234567, 34, 0xffffffffe26af37b, 0xc048d159c0000000)) + OPTIONAL(QRSHU(34, 0x89abcdef01234567, 34, 0x00000000226af37b, 0xc048d159c0000000)) + OPTIONAL( QLSH(35, 0x89abcdef01234567, 35, 0x091a2b3800000000, 0xfffffffc4d5e6f78)) + OPTIONAL(QLSHU(35, 0x89abcdef01234567, 35, 0x091a2b3800000000, 0x000000044d5e6f78)) + OPTIONAL( QRSH(35, 0x89abcdef01234567, 35, 0xfffffffff13579bd, 0xe02468ace0000000)) + OPTIONAL(QRSHU(35, 0x89abcdef01234567, 35, 0x00000000113579bd, 0xe02468ace0000000)) + OPTIONAL( QLSH(36, 0x89abcdef01234567, 36, 0x1234567000000000, 0xfffffff89abcdef0)) + OPTIONAL(QLSHU(36, 0x89abcdef01234567, 36, 0x1234567000000000, 0x000000089abcdef0)) + OPTIONAL( QRSH(36, 0x89abcdef01234567, 36, 0xfffffffff89abcde, 0xf012345670000000)) + OPTIONAL(QRSHU(36, 0x89abcdef01234567, 36, 0x00000000089abcde, 0xf012345670000000)) + OPTIONAL( QLSH(37, 0x89abcdef01234567, 37, 0x2468ace000000000, 0xfffffff13579bde0)) + OPTIONAL(QLSHU(37, 0x89abcdef01234567, 37, 0x2468ace000000000, 0x000000113579bde0)) + OPTIONAL( QRSH(37, 0x89abcdef01234567, 37, 0xfffffffffc4d5e6f, 0x78091a2b38000000)) + OPTIONAL(QRSHU(37, 0x89abcdef01234567, 37, 0x00000000044d5e6f, 0x78091a2b38000000)) + OPTIONAL( QLSH(38, 0x89abcdef01234567, 38, 0x48d159c000000000, 0xffffffe26af37bc0)) + OPTIONAL(QLSHU(38, 0x89abcdef01234567, 38, 0x48d159c000000000, 0x000000226af37bc0)) + OPTIONAL( QRSH(38, 0x89abcdef01234567, 38, 0xfffffffffe26af37, 0xbc048d159c000000)) + OPTIONAL(QRSHU(38, 0x89abcdef01234567, 38, 0x000000000226af37, 0xbc048d159c000000)) + OPTIONAL( QLSH(39, 0x89abcdef01234567, 39, 0x91a2b38000000000, 0xffffffc4d5e6f780)) + OPTIONAL(QLSHU(39, 0x89abcdef01234567, 39, 0x91a2b38000000000, 0x00000044d5e6f780)) + OPTIONAL( QRSH(39, 0x89abcdef01234567, 39, 0xffffffffff13579b, 0xde02468ace000000)) + OPTIONAL(QRSHU(39, 0x89abcdef01234567, 39, 0x000000000113579b, 0xde02468ace000000)) + OPTIONAL( QLSH(40, 0x89abcdef01234567, 40, 0x2345670000000000, 0xffffff89abcdef01)) + OPTIONAL(QLSHU(40, 0x89abcdef01234567, 40, 0x2345670000000000, 0x00000089abcdef01)) + OPTIONAL( QRSH(40, 0x89abcdef01234567, 40, 0xffffffffff89abcd, 0xef01234567000000)) + OPTIONAL(QRSHU(40, 0x89abcdef01234567, 40, 0x000000000089abcd, 0xef01234567000000)) + OPTIONAL( QLSH(41, 0x89abcdef01234567, 41, 0x468ace0000000000, 0xffffff13579bde02)) + OPTIONAL(QLSHU(41, 0x89abcdef01234567, 41, 0x468ace0000000000, 0x00000113579bde02)) + OPTIONAL( QRSH(41, 0x89abcdef01234567, 41, 0xffffffffffc4d5e6, 0xf78091a2b3800000)) + OPTIONAL(QRSHU(41, 0x89abcdef01234567, 41, 0x000000000044d5e6, 0xf78091a2b3800000)) + OPTIONAL( QLSH(42, 0x89abcdef01234567, 42, 0x8d159c0000000000, 0xfffffe26af37bc04)) + OPTIONAL(QLSHU(42, 0x89abcdef01234567, 42, 0x8d159c0000000000, 0x00000226af37bc04)) + OPTIONAL( QRSH(42, 0x89abcdef01234567, 42, 0xffffffffffe26af3, 0x7bc048d159c00000)) + OPTIONAL(QRSHU(42, 0x89abcdef01234567, 42, 0x0000000000226af3, 0x7bc048d159c00000)) + OPTIONAL( QLSH(43, 0x89abcdef01234567, 43, 0x1a2b380000000000, 0xfffffc4d5e6f7809)) + OPTIONAL(QLSHU(43, 0x89abcdef01234567, 43, 0x1a2b380000000000, 0x0000044d5e6f7809)) + OPTIONAL( QRSH(43, 0x89abcdef01234567, 43, 0xfffffffffff13579, 0xbde02468ace00000)) + OPTIONAL(QRSHU(43, 0x89abcdef01234567, 43, 0x0000000000113579, 0xbde02468ace00000)) + OPTIONAL( QLSH(44, 0x89abcdef01234567, 44, 0x3456700000000000, 0xfffff89abcdef012)) + OPTIONAL(QLSHU(44, 0x89abcdef01234567, 44, 0x3456700000000000, 0x0000089abcdef012)) + OPTIONAL( QRSH(44, 0x89abcdef01234567, 44, 0xfffffffffff89abc, 0xdef0123456700000)) + OPTIONAL(QRSHU(44, 0x89abcdef01234567, 44, 0x0000000000089abc, 0xdef0123456700000)) + OPTIONAL( QLSH(45, 0x89abcdef01234567, 45, 0x68ace00000000000, 0xfffff13579bde024)) + OPTIONAL(QLSHU(45, 0x89abcdef01234567, 45, 0x68ace00000000000, 0x0000113579bde024)) + OPTIONAL( QRSH(45, 0x89abcdef01234567, 45, 0xfffffffffffc4d5e, 0x6f78091a2b380000)) + OPTIONAL(QRSHU(45, 0x89abcdef01234567, 45, 0x0000000000044d5e, 0x6f78091a2b380000)) + OPTIONAL( QLSH(46, 0x89abcdef01234567, 46, 0xd159c00000000000, 0xffffe26af37bc048)) + OPTIONAL(QLSHU(46, 0x89abcdef01234567, 46, 0xd159c00000000000, 0x0000226af37bc048)) + OPTIONAL( QRSH(46, 0x89abcdef01234567, 46, 0xfffffffffffe26af, 0x37bc048d159c0000)) + OPTIONAL(QRSHU(46, 0x89abcdef01234567, 46, 0x00000000000226af, 0x37bc048d159c0000)) + OPTIONAL( QLSH(47, 0x89abcdef01234567, 47, 0xa2b3800000000000, 0xffffc4d5e6f78091)) + OPTIONAL(QLSHU(47, 0x89abcdef01234567, 47, 0xa2b3800000000000, 0x000044d5e6f78091)) + OPTIONAL( QRSH(47, 0x89abcdef01234567, 47, 0xffffffffffff1357, 0x9bde02468ace0000)) + OPTIONAL(QRSHU(47, 0x89abcdef01234567, 47, 0x0000000000011357, 0x9bde02468ace0000)) + OPTIONAL( QLSH(48, 0x89abcdef01234567, 48, 0x4567000000000000, 0xffff89abcdef0123)) + OPTIONAL(QLSHU(48, 0x89abcdef01234567, 48, 0x4567000000000000, 0x000089abcdef0123)) + OPTIONAL( QRSH(48, 0x89abcdef01234567, 48, 0xffffffffffff89ab, 0xcdef012345670000)) + OPTIONAL(QRSHU(48, 0x89abcdef01234567, 48, 0x00000000000089ab, 0xcdef012345670000)) + OPTIONAL( QLSH(49, 0x89abcdef01234567, 49, 0x8ace000000000000, 0xffff13579bde0246)) + OPTIONAL(QLSHU(49, 0x89abcdef01234567, 49, 0x8ace000000000000, 0x000113579bde0246)) + OPTIONAL( QRSH(49, 0x89abcdef01234567, 49, 0xffffffffffffc4d5, 0xe6f78091a2b38000)) + OPTIONAL(QRSHU(49, 0x89abcdef01234567, 49, 0x00000000000044d5, 0xe6f78091a2b38000)) + OPTIONAL( QLSH(50, 0x89abcdef01234567, 50, 0x159c000000000000, 0xfffe26af37bc048d)) + OPTIONAL(QLSHU(50, 0x89abcdef01234567, 50, 0x159c000000000000, 0x000226af37bc048d)) + OPTIONAL( QRSH(50, 0x89abcdef01234567, 50, 0xffffffffffffe26a, 0xf37bc048d159c000)) + OPTIONAL(QRSHU(50, 0x89abcdef01234567, 50, 0x000000000000226a, 0xf37bc048d159c000)) + OPTIONAL( QLSH(51, 0x89abcdef01234567, 51, 0x2b38000000000000, 0xfffc4d5e6f78091a)) + OPTIONAL(QLSHU(51, 0x89abcdef01234567, 51, 0x2b38000000000000, 0x00044d5e6f78091a)) + OPTIONAL( QRSH(51, 0x89abcdef01234567, 51, 0xfffffffffffff135, 0x79bde02468ace000)) + OPTIONAL(QRSHU(51, 0x89abcdef01234567, 51, 0x0000000000001135, 0x79bde02468ace000)) + OPTIONAL( QLSH(52, 0x89abcdef01234567, 52, 0x5670000000000000, 0xfff89abcdef01234)) + OPTIONAL(QLSHU(52, 0x89abcdef01234567, 52, 0x5670000000000000, 0x00089abcdef01234)) + OPTIONAL( QRSH(52, 0x89abcdef01234567, 52, 0xfffffffffffff89a, 0xbcdef01234567000)) + OPTIONAL(QRSHU(52, 0x89abcdef01234567, 52, 0x000000000000089a, 0xbcdef01234567000)) + OPTIONAL( QLSH(53, 0x89abcdef01234567, 53, 0xace0000000000000, 0xfff13579bde02468)) + OPTIONAL(QLSHU(53, 0x89abcdef01234567, 53, 0xace0000000000000, 0x00113579bde02468)) + OPTIONAL( QRSH(53, 0x89abcdef01234567, 53, 0xfffffffffffffc4d, 0x5e6f78091a2b3800)) + OPTIONAL(QRSHU(53, 0x89abcdef01234567, 53, 0x000000000000044d, 0x5e6f78091a2b3800)) + OPTIONAL( QLSH(54, 0x89abcdef01234567, 54, 0x59c0000000000000, 0xffe26af37bc048d1)) + OPTIONAL(QLSHU(54, 0x89abcdef01234567, 54, 0x59c0000000000000, 0x00226af37bc048d1)) + OPTIONAL( QRSH(54, 0x89abcdef01234567, 54, 0xfffffffffffffe26, 0xaf37bc048d159c00)) + OPTIONAL(QRSHU(54, 0x89abcdef01234567, 54, 0x0000000000000226, 0xaf37bc048d159c00)) + OPTIONAL( QLSH(55, 0x89abcdef01234567, 55, 0xb380000000000000, 0xffc4d5e6f78091a2)) + OPTIONAL(QLSHU(55, 0x89abcdef01234567, 55, 0xb380000000000000, 0x0044d5e6f78091a2)) + OPTIONAL( QRSH(55, 0x89abcdef01234567, 55, 0xffffffffffffff13, 0x579bde02468ace00)) + OPTIONAL(QRSHU(55, 0x89abcdef01234567, 55, 0x0000000000000113, 0x579bde02468ace00)) + OPTIONAL( QLSH(56, 0x89abcdef01234567, 56, 0x6700000000000000, 0xff89abcdef012345)) + OPTIONAL(QLSHU(56, 0x89abcdef01234567, 56, 0x6700000000000000, 0x0089abcdef012345)) + OPTIONAL( QRSH(56, 0x89abcdef01234567, 56, 0xffffffffffffff89, 0xabcdef0123456700)) + OPTIONAL(QRSHU(56, 0x89abcdef01234567, 56, 0x0000000000000089, 0xabcdef0123456700)) + OPTIONAL( QLSH(57, 0x89abcdef01234567, 57, 0xce00000000000000, 0xff13579bde02468a)) + OPTIONAL(QLSHU(57, 0x89abcdef01234567, 57, 0xce00000000000000, 0x0113579bde02468a)) + OPTIONAL( QRSH(57, 0x89abcdef01234567, 57, 0xffffffffffffffc4, 0xd5e6f78091a2b380)) + OPTIONAL(QRSHU(57, 0x89abcdef01234567, 57, 0x0000000000000044, 0xd5e6f78091a2b380)) + OPTIONAL( QLSH(58, 0x89abcdef01234567, 58, 0x9c00000000000000, 0xfe26af37bc048d15)) + OPTIONAL(QLSHU(58, 0x89abcdef01234567, 58, 0x9c00000000000000, 0x0226af37bc048d15)) + OPTIONAL( QRSH(58, 0x89abcdef01234567, 58, 0xffffffffffffffe2, 0x6af37bc048d159c0)) + OPTIONAL(QRSHU(58, 0x89abcdef01234567, 58, 0x0000000000000022, 0x6af37bc048d159c0)) + OPTIONAL( QLSH(59, 0x89abcdef01234567, 59, 0x3800000000000000, 0xfc4d5e6f78091a2b)) + OPTIONAL(QLSHU(59, 0x89abcdef01234567, 59, 0x3800000000000000, 0x044d5e6f78091a2b)) + OPTIONAL( QRSH(59, 0x89abcdef01234567, 59, 0xfffffffffffffff1, 0x3579bde02468ace0)) + OPTIONAL(QRSHU(59, 0x89abcdef01234567, 59, 0x0000000000000011, 0x3579bde02468ace0)) + OPTIONAL( QLSH(60, 0x89abcdef01234567, 60, 0x7000000000000000, 0xf89abcdef0123456)) + OPTIONAL(QLSHU(60, 0x89abcdef01234567, 60, 0x7000000000000000, 0x089abcdef0123456)) + OPTIONAL( QRSH(60, 0x89abcdef01234567, 60, 0xfffffffffffffff8, 0x9abcdef012345670)) + OPTIONAL(QRSHU(60, 0x89abcdef01234567, 60, 0x0000000000000008, 0x9abcdef012345670)) + OPTIONAL( QLSH(61, 0x89abcdef01234567, 61, 0xe000000000000000, 0xf13579bde02468ac)) + OPTIONAL(QLSHU(61, 0x89abcdef01234567, 61, 0xe000000000000000, 0x113579bde02468ac)) + OPTIONAL( QRSH(61, 0x89abcdef01234567, 61, 0xfffffffffffffffc, 0x4d5e6f78091a2b38)) + OPTIONAL(QRSHU(61, 0x89abcdef01234567, 61, 0x0000000000000004, 0x4d5e6f78091a2b38)) + OPTIONAL( QLSH(62, 0x89abcdef01234567, 62, 0xc000000000000000, 0xe26af37bc048d159)) + OPTIONAL(QLSHU(62, 0x89abcdef01234567, 62, 0xc000000000000000, 0x226af37bc048d159)) + OPTIONAL( QRSH(62, 0x89abcdef01234567, 62, 0xfffffffffffffffe, 0x26af37bc048d159c)) + OPTIONAL(QRSHU(62, 0x89abcdef01234567, 62, 0x0000000000000002, 0x26af37bc048d159c)) + QLSH(63, 0x89abcdef01234567, 63, 0x8000000000000000, 0xc4d5e6f78091a2b3) + QLSHU(63, 0x89abcdef01234567, 63, 0x8000000000000000, 0x44d5e6f78091a2b3) + QRSH(63, 0x89abcdef01234567, 63, 0xffffffffffffffff, 0x13579bde02468ace) + QRSHU(63, 0x89abcdef01234567, 63, 0x0000000000000001, 0x13579bde02468ace) + QLSH(64, 0x89abcdef01234567, 64, 0x0000000000000000, 0x89abcdef01234567) + QLSHU(64, 0x89abcdef01234567, 64, 0x0000000000000000, 0x89abcdef01234567) + QRSH(64, 0x89abcdef01234567, 64, 0xffffffffffffffff, 0x89abcdef01234567) + QRSHU(64, 0x89abcdef01234567, 64, 0x0000000000000000, 0x89abcdef01234567) + #endif +#endif + prepare + pushargi ok + finishi @printf + ret + epilog diff --git a/deps/lightning/check/rbit.ok b/deps/lightning/check/rbit.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/rbit.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/rbit.tst b/deps/lightning/check/rbit.tst new file mode 100644 index 00000000..e6e6bbb3 --- /dev/null +++ b/deps/lightning/check/rbit.tst @@ -0,0 +1,232 @@ +.data 4096 +swap_tab: +.c 0 128 64 192 32 160 96 224 16 144 80 208 48 176 112 240 8 136 72 200 40 168 104 232 24 152 88 216 56 184 120 248 4 132 68 196 36 164 100 228 20 148 84 212 52 180 116 244 12 140 76 204 44 172 108 236 28 156 92 220 60 188 124 252 2 130 66 194 34 162 98 226 18 146 82 210 50 178 114 242 10 138 74 202 42 170 106 234 26 154 90 218 58 186 122 250 6 134 70 198 38 166 102 230 22 150 86 214 54 182 118 246 14 142 78 206 46 174 110 238 30 158 94 222 62 190 126 254 1 129 65 193 33 161 97 225 17 145 81 209 49 177 113 241 9 137 73 201 41 169 105 233 25 153 89 217 57 185 121 249 5 133 69 197 37 165 101 229 21 149 85 213 53 181 117 245 13 141 77 205 45 173 109 237 29 157 93 221 61 189 125 253 3 131 67 195 35 163 99 227 19 147 83 211 51 179 115 243 11 139 75 203 43 171 107 235 27 155 91 219 59 187 123 251 7 135 71 199 39 167 103 231 23 151 87 215 55 183 119 247 15 143 79 207 47 175 111 239 31 159 95 223 63 191 127 255 +ok: +.c "ok\n" +fmt: +#if __WORDSIZE == 32 +.c "0x%08lx = 0x%08lx\n" +#else +.c "0x%016lx = 0x%016lx\n" +#endif + +#define BIT2(OP, ARG, RES, R0, R1) \ + movi %R1 ARG \ + OP##r %R0 %R1 \ + beqi OP##R0##R1##ARG %R0 RES \ + calli @abort \ +OP##R0##R1##ARG: + +#define BIT1(OP, ARG, RES, V0, V1, V2, R0, R1, R2) \ + BIT2(OP, ARG, RES, V0, V0) \ + BIT2(OP, ARG, RES, V0, V1) \ + BIT2(OP, ARG, RES, V0, V2) \ + BIT2(OP, ARG, RES, V0, R0) \ + BIT2(OP, ARG, RES, V0, R1) \ + BIT2(OP, ARG, RES, V0, R2) + +#define BIT(OP, ARG, RES, V0, V1, V2, R0, R1, R2) \ + BIT1(OP, ARG, RES, V1, V2, R0, R1, R2, V0) \ + BIT1(OP, ARG, RES, V2, R0, R1, R2, V0, V1) \ + BIT1(OP, ARG, RES, R0, R1, R2, V0, V1, V2) \ + BIT1(OP, ARG, RES, R1, R2, V0, V1, V2, R0) \ + BIT1(OP, ARG, RES, R2, V0, V1, V2, R0, R1) + +#define RBIT(ARG, RES) \ + BIT(rbit, ARG, RES, v0, v1, v2, r0, r1, r2) + +.code + jmpi main + name rbit_table +rbit_table: + prolog + arg $in + getarg %r1 $in + extr_uc %r2 %r1 + movi %v0 swap_tab + ldxr_uc %r0 %v0 %r2 + movi %v1 8 +rbit_table_loop: + rshr %r2 %r1 %v1 + extr_uc %r2 %r2 + lshi %r0 %r0 8 + ldxr_uc %r2 %v0 %r2 + orr %r0 %r0 %r2 + addi %v1 %v1 8 + blti rbit_table_loop %v1 __WORDSIZE + retr %r0 + epilog + + name rbit_unrolled +rbit_unrolled: + prolog + arg $in + getarg %r0 $in +#if __WORDSIZE == 32 + movi %r1 0x55555555 +#else + movi %r1 0x5555555555555555 +#endif + rshi_u %r2 %r0 1 // r2 = r0 >> 1 + andr %r2 %r2 %r1 // r2 &= r1 + andr %v0 %r0 %r1 // v0 = r0 & r1 + lshi %v0 %v0 1 // v0 <<= 1 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#if __WORDSIZE == 32 + movi %r1 0x33333333 +#else + movi %r1 0x3333333333333333 +#endif + rshi_u %r2 %r0 2 // r2 = r0 >> 2 + andr %r2 %r2 %r1 // r2 &= r1 + andr %v0 %r0 %r1 // v0 = r0 & r1 + lshi %v0 %v0 2 // v0 <<= 2 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#if __WORDSIZE == 32 + movi %r1 0x0f0f0f0f +#else + movi %r1 0x0f0f0f0f0f0f0f0f +#endif + rshi_u %r2 %r0 4 // r2 = r0 >> 4 + andr %r2 %r2 %r1 // r2 &= r1 + andr %v0 %r0 %r1 // v0 = r0 & r1 + lshi %v0 %v0 4 // v0 <<= 4 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#if __WORDSIZE == 32 + movi %r1 0x00ff00ff +#else + movi %r1 0x00ff00ff00ff00ff +#endif + rshi_u %r2 %r0 8 // r2 = r0 >> 8 + andr %r2 %r2 %r1 // r2 &= r1 + andr %v0 %r0 %r1 // v0 = r0 & r1 + lshi %v0 %v0 8 // v0 <<= 8 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#if __WORDSIZE == 32 + rshi_u %r2 %r0 16 // r2 = r0 >> 16 + lshi %v0 %r0 16 // v0 = r0 << 16 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#else + movi %r1 0x0000ffff0000ffff + rshi_u %r2 %r0 16 // r2 = r0 >> 16 + andr %r2 %r2 %r1 // r2 &= r1 + andr %v0 %r0 %r1 // v0 = r0 & r1 + lshi %v0 %v0 16 // v0 <<= 16 + orr %r0 %r2 %v0 // r0 = r2 | v0 + rshi_u %r2 %r0 32 // r2 = r0 >> 32 + lshi %v0 %r0 32 // v0 = r0 << 32 + orr %r0 %r2 %v0 // r0 = r2 | v0 +#endif + retr %r0 + epilog + + name rbit_loop +rbit_loop: + prolog + arg $in + getarg %r0 $in + movi %r1 __WORDSIZE + movi %r2 $(~0) +rbit_loop_loop: // while (%r1 >>= 1) > 0 + rshi %r1 %r1 1 // %r1 >>= 1 + blei rbit_loop_done %r1 0 // no loop if %r1 <= 0 + lshr %v0 %r2 %r1 // %v0 = %r2 << %r1 + xorr %r2 %r2 %v0 // %r2 ^= %v0 + rshr %v0 %r0 %r1 // %v0 = %r0 >> %r1 + andr %v0 %v0 %r2 // %r2 = %v0 & %r2 + lshr %v1 %r0 %r1 // %v1 = %r0 << %r1 + comr %r0 %r2 // %r0 = ~%r2 + andr %v1 %r0 %v1 // %v1 &= %r0 + orr %r0 %v0 %v1 // %r0 = %v0 | %v1 + jmpi rbit_loop_loop +rbit_loop_done: + retr %r0 + epilog + +#if 0 + name main +main: + prolog + arg $argc + arg $argv + getarg %r0 $argc + bnei default %r0 2 + getarg %v0 $argv + ldxi %r0 %v0 $(__WORDSIZE >> 3) + prepare + pushargr %r0 + pushargi 0 + pushargi 0 + finishi @strtoul + retval %v0 + jmpi main_do +default: +#if __WORDSIZE == 32 + movi %v0 0x8a13c851 +#else + movi %v0 0x984a137ffec85219 +#endif +main_do: + prepare + pushargr %v0 + finishi rbit_table + retval %r0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + prepare + pushargr %v0 + finishi rbit_unrolled + retval %r0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + prepare + pushargr %v0 + finishi rbit_loop + retval %r0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + rbitr %r0 %v0 + prepare + pushargi fmt + ellipsis + pushargr %v0 + pushargr %r0 + finishi @printf + + ret + epilog +#else + + name main +main: + prolog +#if __WORDSIZE == 32 + RBIT(0x8a13c851, 0x8a13c851) + RBIT(0x12345678, 0x1e6a2c48) + RBIT(0x02468ace, 0x73516240) +#else + RBIT(0x984a137ffec85219, 0x984a137ffec85219) + RBIT(0x123456789abcdef0, 0x0f7b3d591e6a2c48) + RBIT(0x02468ace013579bd, 0xbd9eac8073516240) +#endif + prepare + pushargi ok + finishi @printf + reti 0 + epilog +#endif diff --git a/deps/lightning/check/unldst.ok b/deps/lightning/check/unldst.ok new file mode 100644 index 00000000..9766475a --- /dev/null +++ b/deps/lightning/check/unldst.ok @@ -0,0 +1 @@ +ok diff --git a/deps/lightning/check/unldst.tst b/deps/lightning/check/unldst.tst new file mode 100644 index 00000000..7bc297a2 --- /dev/null +++ b/deps/lightning/check/unldst.tst @@ -0,0 +1,2468 @@ +#define GENTABLE 0 +#define USEFUNC 0 + +#if __WORDSIZE == 32 +#define GVAL 0xfedcba98 +#else +#define GVAL 0xfedcba9876543210 +#endif +#define FVAL 2.5 +#define DVAL 7.5 + +#if USEFUNC +# define LOAD(NAME, TYPE, R0, BASE, SIZE, RESULT) \ + prepare \ + pushargi BASE \ + pushargi SIZE \ + finishi NAME##TYPE \ + retval %R0 \ + beqi NAME##TYPE##R0##BASE##SIZE %R0 RESULT \ + calli @abort \ +NAME##TYPE##R0##BASE##SIZE: +#else +# define LOAD(NAME, TYPE, R0, BASE, SIZE, RESULT) \ + movi %R0 BASE \ + NAME##r##TYPE %R0 %R0 SIZE \ + beqi NAME##r##TYPE##R0##BASE##SIZE %R0 RESULT \ + calli @abort \ +NAME##r##TYPE##R0##BASE##SIZE: \ + NAME##i##TYPE %R0 BASE SIZE \ + beqi NAME##i##TYPE##R0##BASE##SIZE %R0 RESULT \ + calli @abort \ +NAME##i##TYPE##R0##BASE##SIZE: +#endif +#define LOAD1(NAME, TYPE, R0, R1, R2, V0, V1, V2, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, R0, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, R1, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, R2, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, V0, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, V1, BASE, SIZE, RESULT) \ + LOAD(NAME, TYPE, V2, BASE, SIZE, RESULT) +#define UNLD(BASE, SIZE, RESULT) \ + LOAD1(unld, , r0, r1, r2, v0, v1, v2, BASE, SIZE, RESULT) +#define UNLDU(BASE, SIZE, RESULT) \ + LOAD1(unld, _u, r0, r1, r2, v0, v1, v2, BASE, SIZE, RESULT) + +#if USEFUNC +# define STORE(R0, R1, R2, BASE, SIZE, RES0, RES1) \ + movi %R0 str0 \ + movi %R1 0 \ + str %R0 %R1 \ + stxi $(__WORDSIZE >> 3) %R0 %R1 \ + movi %R0 GVAL \ + prepare \ + pushargi BASE \ + pushargr %R0 \ + pushargi SIZE \ + finishi unst \ + movi %R0 str0 \ + ldr %R1 %R0 \ + ldxi %R2 %R0 $(__WORDSIZE >> 3) \ + bnei unst##R0##R1##R2##BASE##SIZE##fail %R1 RES0 \ + beqi unst##R0##R1##R2##BASE##SIZE %R2 RES1 \ +unst##R0##R1##R2##BASE##SIZE##fail: \ + calli @abort \ +unst##R0##R1##R2##BASE##SIZE: +#else +# define STORE(R0, R1, R2, BASE, SIZE, RES0, RES1) \ + movi %R0 str0 \ + movi %R1 0 \ + str %R0 %R1 \ + stxi $(__WORDSIZE >> 3) %R0 %R1 \ + movi %R0 GVAL \ + movi %R1 BASE \ + unstr %R1 %R0 SIZE \ + movi %R0 str0 \ + ldr %R1 %R0 \ + ldxi %R2 %R0 $(__WORDSIZE >> 3) \ + bnei unst##r##R0##R1##R2##BASE##SIZE##fail %R1 RES0 \ + beqi unst##r##R0##R1##R2##BASE##SIZE %R2 RES1 \ +unst##r##R0##R1##R2##BASE##SIZE##fail: \ + calli @abort \ +unst##r##R0##R1##R2##BASE##SIZE: \ + movi %R0 str0 \ + movi %R1 0 \ + str %R0 %R1 \ + stxi $(__WORDSIZE >> 3) %R0 %R1 \ + movi %R0 GVAL \ + unsti BASE %R0 SIZE \ + movi %R0 str0 \ + ldr %R1 %R0 \ + ldxi %R2 %R0 $(__WORDSIZE >> 3) \ + bnei unst##i##R0##R1##R2##BASE##SIZE##fail %R1 RES0 \ + beqi unst##i##R0##R1##R2##BASE##SIZE %R2 RES1 \ +unst##i##R0##R1##R2##BASE##SIZE##fail: \ + calli @abort \ +unst##i##R0##R1##R2##BASE##SIZE: +#endif +#define STORE1(R0, R1, R2, V0, V1, V2, BASE, SIZE, RES0, RES1) \ + STORE(R0, R1, R2, BASE, SIZE, RES0, RES1) \ + STORE(R1, R2, V0, BASE, SIZE, RES0, RES1) \ + STORE(R2, V0, V1, BASE, SIZE, RES0, RES1) \ + STORE(V0, V1, V2, BASE, SIZE, RES0, RES1) \ + STORE(V1, V2, R0, BASE, SIZE, RES0, RES1) \ + STORE(V2, R0, R1, BASE, SIZE, RES0, RES1) +#define UNST(BASE, SIZE, RES0, RES1) \ + STORE1(r0, r1, r2, v0, v1, v2, BASE, SIZE, RES0, RES1) + +#if USEFUNC +# define F_LDST(F0, BASE, VAL) \ + movi %r2 str0 \ + movi %r1 0 \ + str %r2 %r1 \ + stxi $(__WORDSIZE >> 3) %r2 %r1 \ + movi_f %F0 VAL \ + sti_f cvt %F0 \ + ldi_i %r0 cvt \ + prepare \ + pushargi BASE \ + pushargr %r0 \ + finishi st4 \ + prepare \ + pushargi BASE \ + finishi ld4 \ + retval %r0 \ + sti_i cvt %r0 \ + movi_f %F0 -VAL \ + ldi_f %F0 cvt \ + beqi_f f##F0##BASE %F0 VAL \ + calli @abort \ +f##F0##BASE: +#else +# define F_LDST(F0, BASE, VAL) \ + movi %v0 BASE \ + movi_f %F0 VAL \ + unstr_x %v0 %F0 4 \ + movi_f %F0 0 \ + unldr_x %F0 %v0 4 \ + beqi_f fr##F0##BASE %F0 VAL \ + calli @abort \ +fr##F0##BASE: \ + movi_f %F0 VAL \ + unsti_x BASE %F0 4 \ + movi_f %F0 0 \ + unldi_x %F0 BASE 4 \ + beqi_f fi##F0##BASE %F0 VAL \ + calli @abort \ +fi##F0##BASE: +#endif +#define FLDST1(F0, F1, F2, F3, F4, F5, BASE, VAL) \ + F_LDST(F0, BASE, VAL) \ + F_LDST(F1, BASE, VAL) \ + F_LDST(F2, BASE, VAL) \ + F_LDST(F3, BASE, VAL) \ + F_LDST(F4, BASE, VAL) \ + F_LDST(F5, BASE, VAL) +#define FLDST(BASE, VAL) \ + FLDST1(f0, f1, f2, f3, f4, f5, BASE, VAL) + +#if USEFUNC +# if __WORDSIZE == 32 +# if __BYTE_ORDER == __LITTLE_ENDIAN +# define D_LDST(F0, BASE, VAL) \ + movi %r2 BASE \ + movi %r1 0 \ + str %r2 %r1 \ + stxi 4 %r2 %r1 \ + movi_d %F0 VAL \ + sti_d cvt %F0 \ + movi %r0 cvt \ + ldr %r0 %r0 \ + prepare \ + pushargi BASE \ + pushargr %r0 \ + finishi st4 \ + prepare \ + pushargi BASE \ + finishi ld4 \ + retval %v2 \ + movi %r0 cvt \ + addi %r0 %r0 4 \ + ldr %r0 %r0 \ + movi %v0 BASE \ + addi %v0 %v0 4 \ + prepare \ + pushargr %v0 \ + pushargr %r0 \ + finishi st4 \ + prepare \ + pushargr %v0 \ + finishi ld4 \ + retval %r0 \ + movi %r1 cvt \ + str %r1 %v2 \ + stxi 4 %r1 %r0 \ + ldi_d %F0 cvt \ + beqi_d d##F0##BASE %F0 VAL \ + calli @abort \ +d##F0##BASE: +# else +# define D_LDST(F0, BASE, VAL) \ + movi %r2 BASE \ + movi %r1 0 \ + str %r2 %r1 \ + stxi 4 %r2 %r1 \ + movi_d %F0 VAL \ + sti_d cvt %F0 \ + movi %r0 cvt \ + addi %r0 %r0 4 \ + ldr %r0 %r0 \ + prepare \ + pushargi BASE \ + pushargr %r0 \ + finishi st4 \ + prepare \ + pushargi BASE \ + finishi ld4 \ + retval %v2 \ + movi %r0 cvt \ + ldr %r0 %r0 \ + movi %v0 BASE \ + addi %v0 %v0 4 \ + prepare \ + pushargr %v0 \ + pushargr %r0 \ + finishi st4 \ + prepare \ + pushargr %v0 \ + finishi ld4 \ + retval %r0 \ + movi %r1 cvt \ + str %r1 %r0 \ + stxi 4 %r1 %v2 \ + ldi_d %F0 cvt \ + beqi_d d##F0##BASE %F0 VAL \ + calli @abort \ +d##F0##BASE: +# endif +# else +# define D_LDST(F0, BASE, VAL) \ + movi %r2 str0 \ + movi %r1 0 \ + stxi 8 %r2 %r1 \ + movi_d %F0 DVAL \ + sti_d cvt %F0 \ + ldi %r0 cvt \ + prepare \ + pushargi BASE \ + pushargr %r0 \ + finishi st8 \ + prepare \ + pushargi BASE \ + finishi ld8 \ + retval %r0 \ + sti cvt %r0 \ + ldi_d %F0 cvt \ + beqi_d d##F0##BASE %F0 VAL \ + calli @abort \ +d##F0##BASE: +# endif +#else +# define D_LDST(F0, BASE, VAL) \ + movi %v0 BASE \ + movi_d %F0 VAL \ + unstr_x %v0 %F0 8 \ + movi_d %F0 0 \ + unldr_x %F0 %v0 8 \ + beqi_d dr##F0##BASE %F0 VAL \ + calli @abort \ +dr##F0##BASE: \ + movi_d %F0 VAL \ + unsti_x BASE %F0 8 \ + movi_d %F0 0 \ + unldi_x %F0 BASE 8 \ + beqi_d di##F0##BASE %F0 VAL \ + calli @abort \ +di##F0##BASE: +#endif + +#define DLDST1(F0, F1, F2, F3, F4, F5, BASE, VAL) \ + D_LDST(F0, BASE, VAL) \ + D_LDST(F1, BASE, VAL) \ + D_LDST(F2, BASE, VAL) \ + D_LDST(F3, BASE, VAL) \ + D_LDST(F4, BASE, VAL) \ + D_LDST(F5, BASE, VAL) +#define DLDST(BASE, VAL) \ + DLDST1(f0, f1, f2, f3, f4, f5, BASE, VAL) + +.data 4096 +ok: +.c "ok" +sUNLD: +.c " UNLD" +sUNLDU: +.c "UNLDU" +fmt_ldf: +.c "\tFLDST(str%d, %.1f)\n" +fmt_ldd: +.c "\tDLDST(str%d, %.1f)\n" +.align 8 +cvt: +.size 8 +str0: +.c 0x00 +str1: +.c 0x00 +str2: +.c 0x00 +str3: +.c 0x00 +str4: +.c 0x00 +str5: +.c 0x00 +str6: +.c 0x00 +str7: +.c 0x00 +str8: +.c 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 +#if __WORDSIZE == 32 +buf0: +.c 0x80 +buf1: +.c 0x81 +buf2: +.c 0x82 +buf3: +.c 0x83 0x84 0x85 0x86 0x87 +fmt: +.c "0x%08x\n" +fmt_ld: +.c "\t%s(buf%d, %d, 0x%08x)\n" +fmt_st: +.c "\t UNST(str%d, %d, 0x%08x, 0x%08x)\n" +#else +buf0: +.c 0x80 +buf1: +.c 0x81 +buf2: +.c 0x82 +buf3: +.c 0x83 +buf4: +.c 0x84 +buf5: +.c 0x85 +buf6: +.c 0x86 +buf7: +.c 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f +fmt: +.c "0x%016lx\n" +fmt_ld: +.c "\t%s(buf%d, %d, 0x%016lx)\n" +fmt_st: +.c "\t UNST(str%d, %d, 0x%016lx, 0x%016lx)\n" +#endif + +.code + jmpi main + +ld2: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -2 + bner ld2_un2 %r1 %r2 + ldr_s %r0 %r1 + jmpi ld2_al +ld2_un2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_c %r2 %r1 1 + lshi %r2 %r2 8 +#else + ldr_c %r0 %r1 + lshi %r0 %r0 8 + ldxi_uc %r2 %r1 1 +#endif + orr %r0 %r0 %r2 +ld2_al: + retr %r0 + epilog + +ld2u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -2 + bner ld2u_un2 %r1 %r2 + ldr_us %r0 %r1 + jmpi ld2u_al +ld2u_un2: + ldr_uc %r0 %r1 + ldxi_uc %r2 %r1 1 +#if __BYTE_ORDER == __LITTLE_ENDIAN + lshi %r2 %r2 8 +#else + lshi %r0 %r0 8 +#endif + orr %r0 %r0 %r2 +ld2u_al: + retr %r0 + epilog + +ld3: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -2 + bner ld3_un2 %r1 %r2 +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_c %r2 %r1 2 + lshi %r2 %r2 16 +#else + ldr_s %r0 %r1 + lshi %r0 %r0 8 + ldxi_uc %r2 %r1 2 +#endif + jmpi ld3_or +ld3_un2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_s %r2 %r1 1 + lshi %r2 %r2 8 +#else + ldr_c %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 1 +#endif +ld3_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld3u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -2 + bner ld3u_un2 %r1 %r2 +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_uc %r2 %r1 2 + lshi %r2 %r2 16 +#else + ldr_us %r0 %r1 + lshi %r0 %r0 8 + ldxi_uc %r2 %r1 2 +#endif + jmpi ld3u_or +ld3u_un2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 +#else + ldr_uc %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 1 +#endif +ld3u_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld4: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld4_un4 %r1 %r2 + ldr_i %r0 %r1 + jmpi ld4_al +ld4_un4: + andi %r2 %r1 -2 + bner ld4_un2 %r1 %r2 +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_s %r2 %r1 2 + lshi %r2 %r2 16 +#else + ldr_s %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 2 +#endif + jmpi ld4_or + // assume address is mapped in a multiple of 4 as it will read + // one out of bounds byte to reduce number of used instructions +ld4_un2: + andi %r2 %r1 3 + bnei ld4_un3 %r2 3 +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_i %r2 %r1 1 + lshi %r2 %r2 8 +# if __WORDSIZE == 64 + extr_i %r2 %r2 +# endif +#else + ldr_c %r0 %r1 + lshi %r0 %r0 24 +# if __WORDSIZE == 32 + ldxi %r2 %r1 1 +# else + ldxi_ui %r2 %r1 1 +# endif + rshi_u %r2 %r2 8 +#endif + jmpi ld4_or +ld4_un3: +#if __BYTE_ORDER == __LITTLE_ENDIAN +# if __WORDSIZE == 32 + ldxi %r0 %r1 -1 +# else + ldxi_ui %r0 %r1 -1 +# endif + rshi_u %r0 %r0 8 + ldxi_c %r2 %r1 3 + lshi %r2 %r2 24 +#else + ldxi_i %r0 %r1 -1 + lshi %r0 %r0 8 +# if __WORDSIZE == 64 + extr_i %r0 %r0 +# endif + ldxi_uc %r2 %r1 3 +#endif +ld4_or: + orr %r0 %r0 %r2 +ld4_al: + retr %r0 + epilog + +#if __WORDSIZE == 64 +ld4u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld4u_un4 %r1 %r2 + ldr_ui %r0 %r1 + jmpi ld4u_al +ld4u_un4: + andi %r2 %r1 -2 + bner ld4u_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_us %r2 %r1 2 + lshi %r2 %r2 16 +# else + ldr_us %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 2 +# endif + jmpi ld4u_or + // assume address is mapped in a multiple of 4 as it will read + // one out of bounds byte to reduce number of used instructions +ld4u_un2: + andi %r2 %r1 3 + bnei ld4u_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + extr_ui %r2 %r2 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 24 + ldxi_ui %r2 %r1 1 + rshi_u %r2 %r2 8 +# endif + jmpi ld4u_or +ld4u_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldxi_ui %r0 %r1 -1 + rshi %r0 %r0 8 + ldxi_uc %r2 %r1 3 + lshi %r2 %r2 24 +# else + ldxi_ui %r0 %r1 -1 + lshi %r0 %r0 8 + extr_ui %r0 %r0 + ldxi_uc %r2 %r1 3 +# endif +ld4u_or: + orr %r0 %r0 %r2 +ld4u_al: + retr %r0 + epilog + +ld5: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld5_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_c %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_i %r0 %r1 + lshi %r0 %r0 8 + ldxi_uc %r2 %r1 4 +# endif + jmpi ld5_or +ld5_un4: + andi %r2 %r1 -2 + bner ld5_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_us %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_s %r0 %r1 + lshi %r0 %r0 24 + ldxi_us %r2 %r1 2 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 4 +# endif + jmpi ld5_or +ld5_un2: + andi %r2 %r1 3 + bnei ld5_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_i %r2 %r1 1 + lshi %r2 %r2 8 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 32 + ldxi_ui %r2 %r1 1 +# endif + jmpi ld5_or +ld5_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_s %r2 %r1 3 + lshi %r2 %r2 24 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 32 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 +# endif +ld5_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld5u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld5u_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_uc %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_ui %r0 %r1 + lshi %r0 %r0 8 + ldxi_uc %r2 %r1 4 +# endif + jmpi ld5u_or +ld5u_un4: + andi %r2 %r1 -2 + bner ld5u_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_us %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_us %r0 %r1 + lshi %r0 %r0 24 + ldxi_us %r2 %r1 2 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 4 +# endif + jmpi ld5u_or +ld5u_un2: + andi %r2 %r1 3 + bnei ld5u_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 32 + ldxi_ui %r2 %r1 1 +# endif + jmpi ld5u_or +ld5u_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 + lshi %r2 %r2 24 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 32 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 +# endif +ld5u_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld6: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld6_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_s %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_i %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 4 +# endif + jmpi ld6_or +ld6_un4: + andi %r2 %r1 -2 + bner ld6_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_i %r2 %r1 2 + lshi %r2 %r2 16 +# else + ldr_s %r0 %r1 + lshi %r0 %r0 32 + ldxi_ui %r2 %r1 2 +# endif + jmpi ld6_or +ld6_un2: + andi %r2 %r1 3 + bnei ld6_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 5 + lshi %r2 %r2 40 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 40 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 +# endif + jmpi ld6_or +ld6_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 5 + lshi %r2 %r2 40 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 40 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 +# endif +ld6_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld6u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld6u_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_us %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_ui %r0 %r1 + lshi %r0 %r0 16 + ldxi_us %r2 %r1 4 +# endif + jmpi ld6u_or +ld6u_un4: + andi %r2 %r1 -2 + bner ld6u_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 16 +# else + ldr_us %r0 %r1 + lshi %r0 %r0 32 + ldxi_ui %r2 %r1 2 +# endif + jmpi ld6u_or +ld6u_un2: + andi %r2 %r1 3 + bnei ld6u_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 + lshi %r2 %r2 40 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 40 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 +# endif + jmpi ld6u_or +ld6u_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 + lshi %r2 %r2 40 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 40 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 3 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 5 +# endif +ld6u_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld7: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld7_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_i %r2 %r1 4 + lshi %r2 %r2 40 + rshi %r2 %r2 8 +# else + ldr_i %r0 %r1 + lshi %r0 %r0 24 + ldxi_ui %r2 %r1 4 + rshi %r2 %r2 8 +# endif + jmpi ld7_or +ld7_un4: + andi %r2 %r1 -2 + bner ld7_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 6 + lshi %r2 %r2 48 +# else + ldr_s %r0 %r1 + lshi %r0 %r0 40 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 6 +# endif + jmpi ld7_or +ld7_un2: + andi %r2 %r1 3 + bnei ld7_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_s %r2 %r1 5 + lshi %r2 %r2 40 +#else + ldr_c %r0 %r1 + lshi %r0 %r0 48 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 5 +# endif + jmpi ld7_or +ld7_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_i %r2 %r1 3 + lshi %r2 %r2 24 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 48 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 32 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 3 +# endif +ld7_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld7u: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -4 + bner ld7u_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_ui %r2 %r1 4 + lshi %r2 %r2 40 + rshi_u %r2 %r2 8 +# else + ldr_ui %r0 %r1 + lshi %r0 %r0 24 + ldxi_ui %r2 %r1 4 + rshi_u %r2 %r2 8 +# endif + jmpi ld7u_or +ld7u_un4: + andi %r2 %r1 -2 + bner ld7u_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 6 + lshi %r2 %r2 48 +# else + ldr_us %r0 %r1 + lshi %r0 %r0 40 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 6 +# endif + jmpi ld7u_or +ld7u_un2: + andi %r2 %r1 3 + bnei ld7u_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 5 + lshi %r2 %r2 40 +#else + ldr_uc %r0 %r1 + lshi %r0 %r0 48 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 5 +# endif + jmpi ld7u_or +ld7u_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 3 + lshi %r2 %r2 24 +# else + ldr_uc %r0 %r1 + lshi %r0 %r0 48 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 32 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 3 +# endif +ld7u_or: + orr %r0 %r0 %r2 + retr %r0 + epilog + +ld8: + prolog + arg $addr + getarg %r1 $addr + andi %r2 %r1 -8 + bner ld8_un8 %r1 %r2 + ldr_l %r0 %r1 + jmpi ld8_al +ld8_un8: + andi %r2 %r1 -4 + bner ld8_un4 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui %r0 %r1 + ldxi_i %r2 %r1 4 + lshi %r2 %r2 32 +# else + ldr_i %r0 %r1 + ldxi_ui %r2 %r1 4 + lshi %r0 %r0 32 +# endif + jmpi ld8_or +ld8_un4: + andi %r2 %r1 -2 + bner ld8_un2 %r1 %r2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_s %r2 %r1 6 + lshi %r2 %r2 48 +# else + ldr_s %r0 %r1 + lshi %r0 %r0 48 + ldxi_ui %r2 %r1 2 + lshi %r2 %r2 16 + orr %r0 %r0 %r2 + ldxi_us %r2 %r1 6 +# endif + jmpi ld8_or +ld8_un2: + andi %r2 %r1 7 + bnei ld8_un7 %r2 7 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_l %r2 %r1 1 + lshi %r2 %r2 8 +# else + ldr_c %r0 %r1 + ldxi_l %r2 %r1 1 + rshi_u %r2 %r2 8 + lshi %r0 %r0 56 +# endif + jmpi ld8_or +ld8_un7: + bnei ld8_un6 %r2 6 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us %r0 %r1 + ldxi_l %r2 %r1 2 + lshi %r2 %r2 16 +# else + ldr_s %r0 %r1 + lshi %r0 %r0 48 + ldxi_l %r2 %r1 2 + rshi_u %r2 %r2 16 +# endif + jmpi ld8_or +ld8_un6: + bnei ld8_un5 %r2 5 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldxi_ui %r0 %r1 -1 + rshi_u %r0 %r0 8 + ldxi_ui %r2 %r1 3 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 7 + lshi %r2 %r2 56 +# else + ldxi_i %r0 %r1 -1 + lshi %r0 %r0 40 + ldxi_ui %r2 %r1 3 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 7 +# endif + jmpi ld8_or +ld8_un5: + bnei ld8_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_i %r2 %r1 5 + lshi %r2 %r2 40 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 56 + ldxi_ui %r2 %r1 1 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 5 + rshi_u %r2 %r2 8 +# endif + jmpi ld8_or +ld8_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc %r0 %r1 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 3 + lshi %r2 %r2 24 + orr %r0 %r0 %r2 + ldxi_c %r2 %r1 7 + lshi %r2 %r2 56 +# else + ldr_c %r0 %r1 + lshi %r0 %r0 56 + ldxi_us %r2 %r1 1 + lshi %r2 %r2 40 + orr %r0 %r0 %r2 + ldxi_ui %r2 %r1 3 + lshi %r2 %r2 8 + orr %r0 %r0 %r2 + ldxi_uc %r2 %r1 7 +# endif +ld8_or: + orr %r0 %r0 %r2 +ld8_al: + retr %r0 + epilog +#endif + +st2: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 -2 + bner st2_un2 %r2 %r1 + str_s %r1 %r0 + jmpi st2_al +st2_un2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi_u %r0 %r0 8 + stxi_c 1 %r1 %r0 +#else + stxi_c 1 %r1 %r0 + rshi_u %r0 %r0 8 + str_c %r1 %r0 +#endif +st2_al: + ret + epilog + +st3: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 -2 + bner st3_un2 %r2 %r1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_c 2 %r1 %r0 +# else + stxi_c 2 %r1 %r0 + rshi %r0 %r0 8 + str_s %r1 %r0 +# endif + jmpi st3_al +st3_un2: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 +# else + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif +st3_al: + ret + epilog + +st4: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 -4 + bner st4_un4 %r2 %r1 + str_i %r1 %r0 + jmpi st4_al +st4_un4: + andi %r2 %r1 -2 + bner st4_un2 %r2 %r1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_s 2 %r1 %r0 +# else + stxi_s 2 %r1 %r0 + rshi %r0 %r0 16 + str_s %r1 %r0 +# endif + jmpi st4_al +st4_un2: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + stxi_c 3 %r1 %r0 +# else + stxi_c 3 %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif +st4_al: + ret + epilog + +#if __WORDSIZE == 64 +st5: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 3 + bnei st5_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_i 1 %r1 %r0 +# else + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + str_c %r1 %r0 +# endif + jmpi st5_al +st5_un3: + bnei st5_un2 %r2 2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_s 2 %r1 %r0 + rshi %r0 %r0 16 + stxi_c 4 %r1 %r0 +# else + stxi_c 4 %r1 %r0 + rshi %r0 %r0 8 + stxi_s 2 %r1 %r0 + rshi %r0 %r0 16 + str_s %r1 %r0 +# endif + jmpi st5_al +st5_un2: + bnei st5_un1 %r2 1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 3 %r1 %r0 +# else + stxi_s 3 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif + jmpi st5_al +st5_un1: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i %r1 %r0 + rshi %r0 %r0 32 + stxi_c 4 %r1 %r0 +# else + stxi_c 4 %r1 %r0 + rshi %r0 %r0 8 + str_i %r1 %r0 +# endif +st5_al: + ret + epilog + +st6: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 3 + bnei st6_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + stxi_c 5 %r1 %r0 +# else + stxi_c 5 %r1 %r0 + rshi %r0 %r0 8 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + str_c %r1 %r0 +# endif + jmpi st6_al +st6_un3: + bnei st6_un2 %r2 2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_s 2 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 4 %r1 %r0 +# else + stxi_s 4 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 2 %r1 %r0 + rshi %r0 %r0 16 + str_s %r1 %r0 +# endif + jmpi st6_al +st6_un2: + bnei st6_un1 %r2 1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 3 %r1 %r0 + rshi %r0 %r0 16 + stxi_c 5 %r1 %r0 +# else + stxi_c 5 %r1 %r0 + rshi %r0 %r0 8 + stxi_s 3 %r1 %r0 + rshi %r0 %r0 16 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif + jmpi st6_al +st6_un1: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i %r1 %r0 + rshi %r0 %r0 32 + stxi_s 4 %r1 %r0 +# else + stxi_s 4 %r1 %r0 + rshi %r0 %r0 16 + str_i %r1 %r0 +# endif +st6_al: + ret + epilog + +st7: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 3 + bnei st7_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + stxi_s 5 %r1 %r0 +# else + stxi_s 5 %r1 %r0 + rshi %r0 %r0 16 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + str_c %r1 %r0 +# endif + jmpi st7_al +st7_un3: + bnei st7_un2 %r2 2 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_i 2 %r1 %r0 + rshi %r0 %r0 32 + stxi_c 6 %r1 %r0 +# else + stxi_c 6 %r1 %r0 + rshi %r0 %r0 8 + stxi_i 2 %r1 %r0 + rshi %r0 %r0 32 + str_s %r1 %r0 +# endif + jmpi st7_al +st7_un2: + bnei st7_un1 %r2 1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + stxi_i 3 %r1 %r0 +# else + stxi_i 3 %r1 %r0 + rshi %r0 %r0 32 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif + jmpi st7_al +st7_un1: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i %r1 %r0 + rshi %r0 %r0 32 + stxi_s 4 %r1 %r0 + rshi %r0 %r0 16 + stxi_c 6 %r1 %r0 +# else + stxi_c 6 %r1 %r0 + rshi %r0 %r0 8 + stxi_s 4 %r1 %r0 + rshi %r0 %r0 16 + str_i %r1 %r0 +# endif +st7_al: + ret + epilog + +st8: + prolog + arg $addr + arg $value + getarg %r1 $addr + getarg %r0 $value + andi %r2 %r1 -8 + bner st8_un8 %r2 %r1 + str_l %r1 %r0 + jmpi st8_al +st8_un8: + andi %r2 %r1 -4 + bner st8_un4 %r2 %r1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i %r1 %r0 + rshi %r0 %r0 32 + stxi_i 4 %r1 %r0 +# else + stxi_i 4 %r1 %r0 + rshi %r0 %r0 32 + str_i %r1 %r0 +# endif + jmpi st8_al +st8_un4: + andi %r2 %r1 -2 + bner st8_un2 %r2 %r1 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s %r1 %r0 + rshi %r0 %r0 16 + stxi_i 2 %r1 %r0 + rshi %r0 %r0 32 + stxi_s 6 %r1 %r0 +# else + stxi_s 6 %r1 %r0 + rshi %r0 %r0 16 + stxi_i 2 %r1 %r0 + rshi %r0 %r0 32 + str_s %r1 %r0 +# endif + jmpi st8_al +st8_un2: + andi %r2 %r1 3 + bnei st8_un3 %r2 3 +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + stxi_s 5 %r1 %r0 + rshi %r0 %r0 16 + stxi_c 7 %r1 %r0 +# else + stxi_c 7 %r1 %r0 + rshi %r0 %r0 8 + stxi_s 5 %r1 %r0 + rshi %r0 %r0 16 + stxi_i 1 %r1 %r0 + rshi %r0 %r0 32 + str_c %r1 %r0 +# endif + jmpi st8_al +st8_un3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c %r1 %r0 + rshi %r0 %r0 8 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + stxi_i 3 %r1 %r0 + rshi %r0 %r0 32 + stxi_c 7 %r1 %r0 +# else + stxi_c 7 %r1 %r0 + rshi %r0 %r0 8 + stxi_i 3 %r1 %r0 + rshi %r0 %r0 32 + stxi_s 1 %r1 %r0 + rshi %r0 %r0 16 + str_c %r1 %r0 +# endif +st8_al: + ret + epilog +#endif + +unld: + prolog + arg $base + arg $size + getarg %v0 $base + getarg %v1 $size + bnei unld2 %v1 1 + ldr_c %r0 %v0 + jmpi unld_done +unld2: + bnei unld3 %v1 2 + prepare + pushargr %v0 + finishi ld2 + retval %r0 + jmpi unld_done +unld3: + bnei unld4 %v1 3 + prepare + pushargr %v0 + finishi ld3 + retval %r0 + jmpi unld_done +unld4: +#if __WORDSIZE == 64 + bnei unld5 %v1 4 +#else + bnei unld_fail %v1 4 +#endif + prepare + pushargr %v0 + finishi ld4 + retval %r0 + jmpi unld_done +#if __WORDSIZE == 64 +unld5: + bnei unld6 %v1 5 + prepare + pushargr %v0 + finishi ld5 + retval %r0 + jmpi unld_done +unld6: + bnei unld7 %v1 6 + prepare + pushargr %v0 + finishi ld6 + retval %r0 + jmpi unld_done +unld7: + bnei unld8 %v1 7 + prepare + pushargr %v0 + finishi ld7 + retval %r0 + jmpi unld_done +unld8: + bnei unld_fail %v1 8 + prepare + pushargr %v0 + finishi ld8 + retval %r0 +#endif +unld_done: + retr %r0 +unld_fail: + calli @abort + epilog + +unld_u: + prolog + arg $base + arg $size + getarg %v0 $base + getarg %v1 $size + bnei unld_u2 %v1 1 + ldr_uc %r0 %v0 + jmpi unld_done +unld_u2: + bnei unld_u3 %v1 2 + prepare + pushargr %v0 + finishi ld2u + retval %r0 + jmpi unld_u_done +unld_u3: + bnei unld_u4 %v1 3 + prepare + pushargr %v0 + finishi ld3u + retval %r0 + jmpi unld_u_done +unld_u4: +#if __WORDSIZE == 64 + bnei unld_u5 %v1 4 +#else + bnei unld_fail %v1 4 +#endif + prepare + pushargr %v0 +#if __WORDSIZE == 32 + finishi ld4 +#else + finishi ld4u +#endif + retval %r0 + jmpi unld_u_done +#if __WORDSIZE == 64 +unld_u5: + bnei unld_u6 %v1 5 + prepare + pushargr %v0 + finishi ld5u + retval %r0 + jmpi unld_u_done +unld_u6: + bnei unld_u7 %v1 6 + prepare + pushargr %v0 + finishi ld6u + retval %r0 + jmpi unld_u_done +unld_u7: + bnei unld_u8 %v1 7 + prepare + pushargr %v0 + finishi ld7u + retval %r0 + jmpi unld_u_done +unld_u8: + bnei unld_u_fail %v1 8 + prepare + pushargr %v0 + finishi ld8 + retval %r0 +#endif +unld_u_done: + retr %r0 +unld_u_fail: + calli @abort + epilog + +unst: + prolog + arg $base + arg $data + arg $size + getarg %v0 $base + getarg %v2 $data + getarg %v1 $size + bnei unst2 %v1 1 + str_c %v0 %v2 + jmpi unst_done +unst2: + bnei unst3 %v1 2 + prepare + pushargr %v0 + pushargr %v2 + finishi st2 + jmpi unst_done +unst3: + bnei unst4 %v1 3 + prepare + pushargr %v0 + pushargr %v2 + finishi st3 + jmpi unst_done +unst4: +#if __WORDSIZE == 64 + bnei unst5 %v1 4 +#else + bnei unst_fail %v1 4 +#endif + prepare + pushargr %v0 + pushargr %v2 + finishi st4 +#if __WORDSIZE == 64 + jmpi unst_done +unst5: + bnei unst6 %v1 5 + prepare + pushargr %v0 + pushargr %v2 + finishi st5 + jmpi unst_done +unst6: + bnei unst7 %v1 6 + prepare + pushargr %v0 + pushargr %v2 + finishi st6 + jmpi unst_done +unst7: + bnei unst8 %v1 7 + prepare + pushargr %v0 + pushargr %v2 + finishi st7 + jmpi unst_done +unst8: + bnei unst_fail %v1 8 + prepare + pushargr %v0 + pushargr %v2 + finishi st8 +#endif +unst_done: + ret +unst_fail: + calli @abort + epilog + +main: + prolog +#if GENTABLE + movi %v0 buf0 +out_loop_ld: + movi %v1 GVAL + movi %v2 1 +loop_ld: + prepare + pushargr %v0 + pushargr %v2 + finishi unld + retval %r0 + subi %r2 %v0 buf0 + prepare + pushargi fmt_ld + ellipsis + pushargi sUNLD + pushargr %r2 + pushargr %v2 + pushargr %r0 + finishi @printf + addi %v2 %v2 1 + blei loop_ld %v2 $(__WORDSIZE >> 3) + addi %v0 %v0 1 + subi %r2 %v0 buf0 + blti out_loop_ld %r2 $(__WORDSIZE >> 3) + + movi %v0 buf0 +out_loop_ldu: + movi %v2 1 +loop_ldu: + prepare + pushargr %v0 + pushargr %v2 + finishi unld_u + retval %r0 + subi %r2 %v0 buf0 + prepare + pushargi fmt_ld + ellipsis + pushargi sUNLDU + pushargr %r2 + pushargr %v2 + pushargr %r0 + finishi @printf + addi %v2 %v2 1 + blei loop_ldu %v2 $(__WORDSIZE >> 3) + addi %v0 %v0 1 + subi %r2 %v0 buf0 + blti out_loop_ldu %r2 $(__WORDSIZE >> 3) + + movi %v0 str0 +out_loop_st: + movi %v2 1 +loop_st: + movi %r0 str0 + movi %r1 0 + str %r0 %r1 + stxi $(__WORDSIZE >> 3) %r0 %r1 + prepare + pushargr %v0 + pushargr %v1 + pushargr %v2 + finishi unst + movi %r2 str0 + ldr %r0 %r2 + ldxi %r1 %r2 $(__WORDSIZE >> 3) + subi %r2 %v0 str0 + prepare + pushargi fmt_st + ellipsis + pushargr %r2 + pushargr %v2 + pushargr %r0 + pushargr %r1 + finishi @printf + addi %v2 %v2 1 + blei loop_st %v2 $(__WORDSIZE >> 3) + addi %v0 %v0 1 + subi %r2 %v0 str0 + blti out_loop_st %r2 $(__WORDSIZE >> 3) + + /* Do complex operations to also ensure sample fallbacks are correct */ + movi %v0 str0 + movi %v1 0 +loop_f: + movi %r2 str0 + movi %r1 0 + str %r2 %r1 + stxi $(__WORDSIZE >> 3) %r2 %r1 + movi_f %f0 FVAL + sti_f cvt %f0 + ldi_i %r0 cvt + prepare + pushargr %v0 + pushargr %r0 + finishi st4 + prepare + pushargr %v0 + finishi ld4 + retval %r0 + sti_i cvt %r0 + ldi_f %f0 cvt + extr_f_d %f0 %f0 + prepare + pushargi fmt_ldf + ellipsis + pushargr %v1 + pushargr_d %f0 + finishi @printf + addi %v0 %v0 1 + addi %v1 %v1 1 + blei loop_f %v1 4 + + movi %v0 str0 + movi %v1 0 +loop_d: + movi %r2 str0 + movi %r1 0 + str %r2 %r1 + stxi $(__WORDSIZE >> 3) %r2 %r1 + movi_d %f0 DVAL + sti_d cvt %f0 +# if __WORDSIZE == 32 + movi %r0 cvt +# if __BYTE_ORDER == __BIG_ENDIAN + addi %r0 %r0 4 +# endif + ldr %r0 %r0 + prepare + pushargr %v0 + pushargr %r0 + finishi st4 + prepare + pushargr %v0 + finishi ld4 + retval %v2 + movi %r0 cvt +# if __BYTE_ORDER == __LITTLE_ENDIAN + addi %r0 %r0 4 +# endif + ldr %r0 %r0 + prepare + pushargr %v0 + pushargr %r0 + finishi st4 + prepare + pushargr %v0 + finishi ld4 + retval %r0 + movi %r1 cvt +# if __BYTE_ORDER == __LITTLE_ENDIAN + str %r1 %v1 + stxi 4 %r1 %r0 +# else + str %r1 %r0 + stxi 4 %r1 %v1 +# endif +# else + ldi %r0 cvt + prepare + pushargr %v0 + pushargr %r0 + finishi st8 + prepare + pushargr %v0 + finishi ld8 + retval %r0 + sti cvt %r0 +# endif + ldi_d %f0 cvt + prepare + pushargi fmt_ldd + ellipsis + pushargr %v1 + pushargr_d %f0 + finishi @printf + addi %v0 %v0 1 + addi %v1 %v1 1 + blei loop_d %v1 8 +#else + +# if __WORDSIZE == 32 +# if __BYTE_ORDER == __LITTLE_ENDIAN + UNLD(buf0, 1, 0xffffff80) + UNLD(buf0, 2, 0xffff8180) + UNLD(buf0, 3, 0xff828180) + UNLD(buf0, 4, 0x83828180) + UNLD(buf1, 1, 0xffffff81) + UNLD(buf1, 2, 0xffff8281) + UNLD(buf1, 3, 0xff838281) + UNLD(buf1, 4, 0x84838281) + UNLD(buf2, 1, 0xffffff82) + UNLD(buf2, 2, 0xffff8382) + UNLD(buf2, 3, 0xff848382) + UNLD(buf2, 4, 0x85848382) + UNLD(buf3, 1, 0xffffff83) + UNLD(buf3, 2, 0xffff8483) + UNLD(buf3, 3, 0xff858483) + UNLD(buf3, 4, 0x86858483) + UNLDU(buf0, 1, 0x00000080) + UNLDU(buf0, 2, 0x00008180) + UNLDU(buf0, 3, 0x00828180) + UNLDU(buf0, 4, 0x83828180) + UNLDU(buf1, 1, 0x00000081) + UNLDU(buf1, 2, 0x00008281) + UNLDU(buf1, 3, 0x00838281) + UNLDU(buf1, 4, 0x84838281) + UNLDU(buf2, 1, 0x00000082) + UNLDU(buf2, 2, 0x00008382) + UNLDU(buf2, 3, 0x00848382) + UNLDU(buf2, 4, 0x85848382) + UNLDU(buf3, 1, 0x00000083) + UNLDU(buf3, 2, 0x00008483) + UNLDU(buf3, 3, 0x00858483) + UNLDU(buf3, 4, 0x86858483) + UNST(str0, 1, 0x00000098, 0x00000000) + UNST(str0, 2, 0x0000ba98, 0x00000000) + UNST(str0, 3, 0x00dcba98, 0x00000000) + UNST(str0, 4, 0xfedcba98, 0x00000000) + UNST(str1, 1, 0x00009800, 0x00000000) + UNST(str1, 2, 0x00ba9800, 0x00000000) + UNST(str1, 3, 0xdcba9800, 0x00000000) + UNST(str1, 4, 0xdcba9800, 0x000000fe) + UNST(str2, 1, 0x00980000, 0x00000000) + UNST(str2, 2, 0xba980000, 0x00000000) + UNST(str2, 3, 0xba980000, 0x000000dc) + UNST(str2, 4, 0xba980000, 0x0000fedc) + UNST(str3, 1, 0x98000000, 0x00000000) + UNST(str3, 2, 0x98000000, 0x000000ba) + UNST(str3, 3, 0x98000000, 0x0000dcba) + UNST(str3, 4, 0x98000000, 0x00fedcba) +# else + UNLD(buf0, 1, 0xffffff80) + UNLD(buf0, 2, 0xffff8081) + UNLD(buf0, 3, 0xff808182) + UNLD(buf0, 4, 0x80818283) + UNLD(buf1, 1, 0xffffff81) + UNLD(buf1, 2, 0xffff8182) + UNLD(buf1, 3, 0xff818283) + UNLD(buf1, 4, 0x81828384) + UNLD(buf2, 1, 0xffffff82) + UNLD(buf2, 2, 0xffff8283) + UNLD(buf2, 3, 0xff828384) + UNLD(buf2, 4, 0x82838485) + UNLD(buf3, 1, 0xffffff83) + UNLD(buf3, 2, 0xffff8384) + UNLD(buf3, 3, 0xff838485) + UNLD(buf3, 4, 0x83848586) + UNLDU(buf0, 1, 0x00000080) + UNLDU(buf0, 2, 0x00008081) + UNLDU(buf0, 3, 0x00808182) + UNLDU(buf0, 4, 0x80818283) + UNLDU(buf1, 1, 0x00000081) + UNLDU(buf1, 2, 0x00008182) + UNLDU(buf1, 3, 0x00818283) + UNLDU(buf1, 4, 0x81828384) + UNLDU(buf2, 1, 0x00000082) + UNLDU(buf2, 2, 0x00008283) + UNLDU(buf2, 3, 0x00828384) + UNLDU(buf2, 4, 0x82838485) + UNLDU(buf3, 1, 0x00000083) + UNLDU(buf3, 2, 0x00008384) + UNLDU(buf3, 3, 0x00838485) + UNLDU(buf3, 4, 0x83848586) + UNST(str0, 1, 0x98000000, 0x00000000) + UNST(str0, 2, 0xba980000, 0x00000000) + UNST(str0, 3, 0xdcba9800, 0x00000000) + UNST(str0, 4, 0xfedcba98, 0x00000000) + UNST(str1, 1, 0x00980000, 0x00000000) + UNST(str1, 2, 0x00ba9800, 0x00000000) + UNST(str1, 3, 0x00dcba98, 0x00000000) + UNST(str1, 4, 0x00fedcba, 0x98000000) + UNST(str2, 1, 0x00009800, 0x00000000) + UNST(str2, 2, 0x0000ba98, 0x00000000) + UNST(str2, 3, 0x0000dcba, 0x98000000) + UNST(str2, 4, 0x0000fedc, 0xba980000) + UNST(str3, 1, 0x00000098, 0x00000000) + UNST(str3, 2, 0x000000ba, 0x98000000) + UNST(str3, 3, 0x000000dc, 0xba980000) + UNST(str3, 4, 0x000000fe, 0xdcba9800) +# endif + +# else +# if __BYTE_ORDER == __LITTLE_ENDIAN + UNLD(buf0, 1, 0xffffffffffffff80) + UNLD(buf0, 2, 0xffffffffffff8180) + UNLD(buf0, 3, 0xffffffffff828180) + UNLD(buf0, 4, 0xffffffff83828180) + UNLD(buf0, 5, 0xffffff8483828180) + UNLD(buf0, 6, 0xffff858483828180) + UNLD(buf0, 7, 0xff86858483828180) + UNLD(buf0, 8, 0x8786858483828180) + UNLD(buf1, 1, 0xffffffffffffff81) + UNLD(buf1, 2, 0xffffffffffff8281) + UNLD(buf1, 3, 0xffffffffff838281) + UNLD(buf1, 4, 0xffffffff84838281) + UNLD(buf1, 5, 0xffffff8584838281) + UNLD(buf1, 6, 0xffff868584838281) + UNLD(buf1, 7, 0xff87868584838281) + UNLD(buf1, 8, 0x8887868584838281) + UNLD(buf2, 1, 0xffffffffffffff82) + UNLD(buf2, 2, 0xffffffffffff8382) + UNLD(buf2, 3, 0xffffffffff848382) + UNLD(buf2, 4, 0xffffffff85848382) + UNLD(buf2, 5, 0xffffff8685848382) + UNLD(buf2, 6, 0xffff878685848382) + UNLD(buf2, 7, 0xff88878685848382) + UNLD(buf2, 8, 0x8988878685848382) + UNLD(buf3, 1, 0xffffffffffffff83) + UNLD(buf3, 2, 0xffffffffffff8483) + UNLD(buf3, 3, 0xffffffffff858483) + UNLD(buf3, 4, 0xffffffff86858483) + UNLD(buf3, 5, 0xffffff8786858483) + UNLD(buf3, 6, 0xffff888786858483) + UNLD(buf3, 7, 0xff89888786858483) + UNLD(buf3, 8, 0x8a89888786858483) + UNLD(buf4, 1, 0xffffffffffffff84) + UNLD(buf4, 2, 0xffffffffffff8584) + UNLD(buf4, 3, 0xffffffffff868584) + UNLD(buf4, 4, 0xffffffff87868584) + UNLD(buf4, 5, 0xffffff8887868584) + UNLD(buf4, 6, 0xffff898887868584) + UNLD(buf4, 7, 0xff8a898887868584) + UNLD(buf4, 8, 0x8b8a898887868584) + UNLD(buf5, 1, 0xffffffffffffff85) + UNLD(buf5, 2, 0xffffffffffff8685) + UNLD(buf5, 3, 0xffffffffff878685) + UNLD(buf5, 4, 0xffffffff88878685) + UNLD(buf5, 5, 0xffffff8988878685) + UNLD(buf5, 6, 0xffff8a8988878685) + UNLD(buf5, 7, 0xff8b8a8988878685) + UNLD(buf5, 8, 0x8c8b8a8988878685) + UNLD(buf6, 1, 0xffffffffffffff86) + UNLD(buf6, 2, 0xffffffffffff8786) + UNLD(buf6, 3, 0xffffffffff888786) + UNLD(buf6, 4, 0xffffffff89888786) + UNLD(buf6, 5, 0xffffff8a89888786) + UNLD(buf6, 6, 0xffff8b8a89888786) + UNLD(buf6, 7, 0xff8c8b8a89888786) + UNLD(buf6, 8, 0x8d8c8b8a89888786) + UNLD(buf7, 1, 0xffffffffffffff87) + UNLD(buf7, 2, 0xffffffffffff8887) + UNLD(buf7, 3, 0xffffffffff898887) + UNLD(buf7, 4, 0xffffffff8a898887) + UNLD(buf7, 5, 0xffffff8b8a898887) + UNLD(buf7, 6, 0xffff8c8b8a898887) + UNLD(buf7, 7, 0xff8d8c8b8a898887) + UNLD(buf7, 8, 0x8e8d8c8b8a898887) + UNLDU(buf0, 1, 0x0000000000000080) + UNLDU(buf0, 2, 0x0000000000008180) + UNLDU(buf0, 3, 0x0000000000828180) + UNLDU(buf0, 4, 0x0000000083828180) + UNLDU(buf0, 5, 0x0000008483828180) + UNLDU(buf0, 6, 0x0000858483828180) + UNLDU(buf0, 7, 0x0086858483828180) + UNLDU(buf0, 8, 0x8786858483828180) + UNLDU(buf1, 1, 0x0000000000000081) + UNLDU(buf1, 2, 0x0000000000008281) + UNLDU(buf1, 3, 0x0000000000838281) + UNLDU(buf1, 4, 0x0000000084838281) + UNLDU(buf1, 5, 0x0000008584838281) + UNLDU(buf1, 6, 0x0000868584838281) + UNLDU(buf1, 7, 0x0087868584838281) + UNLDU(buf1, 8, 0x8887868584838281) + UNLDU(buf2, 1, 0x0000000000000082) + UNLDU(buf2, 2, 0x0000000000008382) + UNLDU(buf2, 3, 0x0000000000848382) + UNLDU(buf2, 4, 0x0000000085848382) + UNLDU(buf2, 5, 0x0000008685848382) + UNLDU(buf2, 6, 0x0000878685848382) + UNLDU(buf2, 7, 0x0088878685848382) + UNLDU(buf2, 8, 0x8988878685848382) + UNLDU(buf3, 1, 0x0000000000000083) + UNLDU(buf3, 2, 0x0000000000008483) + UNLDU(buf3, 3, 0x0000000000858483) + UNLDU(buf3, 4, 0x0000000086858483) + UNLDU(buf3, 5, 0x0000008786858483) + UNLDU(buf3, 6, 0x0000888786858483) + UNLDU(buf3, 7, 0x0089888786858483) + UNLDU(buf3, 8, 0x8a89888786858483) + UNLDU(buf4, 1, 0x0000000000000084) + UNLDU(buf4, 2, 0x0000000000008584) + UNLDU(buf4, 3, 0x0000000000868584) + UNLDU(buf4, 4, 0x0000000087868584) + UNLDU(buf4, 5, 0x0000008887868584) + UNLDU(buf4, 6, 0x0000898887868584) + UNLDU(buf4, 7, 0x008a898887868584) + UNLDU(buf4, 8, 0x8b8a898887868584) + UNLDU(buf5, 1, 0x0000000000000085) + UNLDU(buf5, 2, 0x0000000000008685) + UNLDU(buf5, 3, 0x0000000000878685) + UNLDU(buf5, 4, 0x0000000088878685) + UNLDU(buf5, 5, 0x0000008988878685) + UNLDU(buf5, 6, 0x00008a8988878685) + UNLDU(buf5, 7, 0x008b8a8988878685) + UNLDU(buf5, 8, 0x8c8b8a8988878685) + UNLDU(buf6, 1, 0x0000000000000086) + UNLDU(buf6, 2, 0x0000000000008786) + UNLDU(buf6, 3, 0x0000000000888786) + UNLDU(buf6, 4, 0x0000000089888786) + UNLDU(buf6, 5, 0x0000008a89888786) + UNLDU(buf6, 6, 0x00008b8a89888786) + UNLDU(buf6, 7, 0x008c8b8a89888786) + UNLDU(buf6, 8, 0x8d8c8b8a89888786) + UNLDU(buf7, 1, 0x0000000000000087) + UNLDU(buf7, 2, 0x0000000000008887) + UNLDU(buf7, 3, 0x0000000000898887) + UNLDU(buf7, 4, 0x000000008a898887) + UNLDU(buf7, 5, 0x0000008b8a898887) + UNLDU(buf7, 6, 0x00008c8b8a898887) + UNLDU(buf7, 7, 0x008d8c8b8a898887) + UNLDU(buf7, 8, 0x8e8d8c8b8a898887) + UNST(str0, 1, 0x0000000000000010, 0x0000000000000000) + UNST(str0, 2, 0x0000000000003210, 0x0000000000000000) + UNST(str0, 3, 0x0000000000543210, 0x0000000000000000) + UNST(str0, 4, 0x0000000076543210, 0x0000000000000000) + UNST(str0, 5, 0x0000009876543210, 0x0000000000000000) + UNST(str0, 6, 0x0000ba9876543210, 0x0000000000000000) + UNST(str0, 7, 0x00dcba9876543210, 0x0000000000000000) + UNST(str0, 8, 0xfedcba9876543210, 0x0000000000000000) + UNST(str1, 1, 0x0000000000001000, 0x0000000000000000) + UNST(str1, 2, 0x0000000000321000, 0x0000000000000000) + UNST(str1, 3, 0x0000000054321000, 0x0000000000000000) + UNST(str1, 4, 0x0000007654321000, 0x0000000000000000) + UNST(str1, 5, 0x0000987654321000, 0x0000000000000000) + UNST(str1, 6, 0x00ba987654321000, 0x0000000000000000) + UNST(str1, 7, 0xdcba987654321000, 0x0000000000000000) + UNST(str1, 8, 0xdcba987654321000, 0x00000000000000fe) + UNST(str2, 1, 0x0000000000100000, 0x0000000000000000) + UNST(str2, 2, 0x0000000032100000, 0x0000000000000000) + UNST(str2, 3, 0x0000005432100000, 0x0000000000000000) + UNST(str2, 4, 0x0000765432100000, 0x0000000000000000) + UNST(str2, 5, 0x0098765432100000, 0x0000000000000000) + UNST(str2, 6, 0xba98765432100000, 0x0000000000000000) + UNST(str2, 7, 0xba98765432100000, 0x00000000000000dc) + UNST(str2, 8, 0xba98765432100000, 0x000000000000fedc) + UNST(str3, 1, 0x0000000010000000, 0x0000000000000000) + UNST(str3, 2, 0x0000003210000000, 0x0000000000000000) + UNST(str3, 3, 0x0000543210000000, 0x0000000000000000) + UNST(str3, 4, 0x0076543210000000, 0x0000000000000000) + UNST(str3, 5, 0x9876543210000000, 0x0000000000000000) + UNST(str3, 6, 0x9876543210000000, 0x00000000000000ba) + UNST(str3, 7, 0x9876543210000000, 0x000000000000dcba) + UNST(str3, 8, 0x9876543210000000, 0x0000000000fedcba) + UNST(str4, 1, 0x0000001000000000, 0x0000000000000000) + UNST(str4, 2, 0x0000321000000000, 0x0000000000000000) + UNST(str4, 3, 0x0054321000000000, 0x0000000000000000) + UNST(str4, 4, 0x7654321000000000, 0x0000000000000000) + UNST(str4, 5, 0x7654321000000000, 0x0000000000000098) + UNST(str4, 6, 0x7654321000000000, 0x000000000000ba98) + UNST(str4, 7, 0x7654321000000000, 0x0000000000dcba98) + UNST(str4, 8, 0x7654321000000000, 0x00000000fedcba98) + UNST(str5, 1, 0x0000100000000000, 0x0000000000000000) + UNST(str5, 2, 0x0032100000000000, 0x0000000000000000) + UNST(str5, 3, 0x5432100000000000, 0x0000000000000000) + UNST(str5, 4, 0x5432100000000000, 0x0000000000000076) + UNST(str5, 5, 0x5432100000000000, 0x0000000000009876) + UNST(str5, 6, 0x5432100000000000, 0x0000000000ba9876) + UNST(str5, 7, 0x5432100000000000, 0x00000000dcba9876) + UNST(str5, 8, 0x5432100000000000, 0x000000fedcba9876) + UNST(str6, 1, 0x0010000000000000, 0x0000000000000000) + UNST(str6, 2, 0x3210000000000000, 0x0000000000000000) + UNST(str6, 3, 0x3210000000000000, 0x0000000000000054) + UNST(str6, 4, 0x3210000000000000, 0x0000000000007654) + UNST(str6, 5, 0x3210000000000000, 0x0000000000987654) + UNST(str6, 6, 0x3210000000000000, 0x00000000ba987654) + UNST(str6, 7, 0x3210000000000000, 0x000000dcba987654) + UNST(str6, 8, 0x3210000000000000, 0x0000fedcba987654) + UNST(str7, 1, 0x1000000000000000, 0x0000000000000000) + UNST(str7, 2, 0x1000000000000000, 0x0000000000000032) + UNST(str7, 3, 0x1000000000000000, 0x0000000000005432) + UNST(str7, 4, 0x1000000000000000, 0x0000000000765432) + UNST(str7, 5, 0x1000000000000000, 0x0000000098765432) + UNST(str7, 6, 0x1000000000000000, 0x000000ba98765432) + UNST(str7, 7, 0x1000000000000000, 0x0000dcba98765432) + UNST(str7, 8, 0x1000000000000000, 0x00fedcba98765432) +# else + UNLD(buf0, 1, 0xffffffffffffff80) + UNLD(buf0, 2, 0xffffffffffff8081) + UNLD(buf0, 3, 0xffffffffff808182) + UNLD(buf0, 4, 0xffffffff80818283) + UNLD(buf0, 5, 0xffffff8081828384) + UNLD(buf0, 6, 0xffff808182838485) + UNLD(buf0, 7, 0xff80818283848586) + UNLD(buf0, 8, 0x8081828384858687) + UNLD(buf1, 1, 0xffffffffffffff81) + UNLD(buf1, 2, 0xffffffffffff8182) + UNLD(buf1, 3, 0xffffffffff818283) + UNLD(buf1, 4, 0xffffffff81828384) + UNLD(buf1, 5, 0xffffff8182838485) + UNLD(buf1, 6, 0xffff818283848586) + UNLD(buf1, 7, 0xff81828384858687) + UNLD(buf1, 8, 0x8182838485868788) + UNLD(buf2, 1, 0xffffffffffffff82) + UNLD(buf2, 2, 0xffffffffffff8283) + UNLD(buf2, 3, 0xffffffffff828384) + UNLD(buf2, 4, 0xffffffff82838485) + UNLD(buf2, 5, 0xffffff8283848586) + UNLD(buf2, 6, 0xffff828384858687) + UNLD(buf2, 7, 0xff82838485868788) + UNLD(buf2, 8, 0x8283848586878889) + UNLD(buf3, 1, 0xffffffffffffff83) + UNLD(buf3, 2, 0xffffffffffff8384) + UNLD(buf3, 3, 0xffffffffff838485) + UNLD(buf3, 4, 0xffffffff83848586) + UNLD(buf3, 5, 0xffffff8384858687) + UNLD(buf3, 6, 0xffff838485868788) + UNLD(buf3, 7, 0xff83848586878889) + UNLD(buf3, 8, 0x838485868788898a) + UNLD(buf4, 1, 0xffffffffffffff84) + UNLD(buf4, 2, 0xffffffffffff8485) + UNLD(buf4, 3, 0xffffffffff848586) + UNLD(buf4, 4, 0xffffffff84858687) + UNLD(buf4, 5, 0xffffff8485868788) + UNLD(buf4, 6, 0xffff848586878889) + UNLD(buf4, 7, 0xff8485868788898a) + UNLD(buf4, 8, 0x8485868788898a8b) + UNLD(buf5, 1, 0xffffffffffffff85) + UNLD(buf5, 2, 0xffffffffffff8586) + UNLD(buf5, 3, 0xffffffffff858687) + UNLD(buf5, 4, 0xffffffff85868788) + UNLD(buf5, 5, 0xffffff8586878889) + UNLD(buf5, 6, 0xffff85868788898a) + UNLD(buf5, 7, 0xff85868788898a8b) + UNLD(buf5, 8, 0x85868788898a8b8c) + UNLD(buf6, 1, 0xffffffffffffff86) + UNLD(buf6, 2, 0xffffffffffff8687) + UNLD(buf6, 3, 0xffffffffff868788) + UNLD(buf6, 4, 0xffffffff86878889) + UNLD(buf6, 5, 0xffffff868788898a) + UNLD(buf6, 6, 0xffff868788898a8b) + UNLD(buf6, 7, 0xff868788898a8b8c) + UNLD(buf6, 8, 0x868788898a8b8c8d) + UNLD(buf7, 1, 0xffffffffffffff87) + UNLD(buf7, 2, 0xffffffffffff8788) + UNLD(buf7, 3, 0xffffffffff878889) + UNLD(buf7, 4, 0xffffffff8788898a) + UNLD(buf7, 5, 0xffffff8788898a8b) + UNLD(buf7, 6, 0xffff8788898a8b8c) + UNLD(buf7, 7, 0xff8788898a8b8c8d) + UNLD(buf7, 8, 0x8788898a8b8c8d8e) + UNLDU(buf0, 1, 0x0000000000000080) + UNLDU(buf0, 2, 0x0000000000008081) + UNLDU(buf0, 3, 0x0000000000808182) + UNLDU(buf0, 4, 0x0000000080818283) + UNLDU(buf0, 5, 0x0000008081828384) + UNLDU(buf0, 6, 0x0000808182838485) + UNLDU(buf0, 7, 0x0080818283848586) + UNLDU(buf0, 8, 0x8081828384858687) + UNLDU(buf1, 1, 0x0000000000000081) + UNLDU(buf1, 2, 0x0000000000008182) + UNLDU(buf1, 3, 0x0000000000818283) + UNLDU(buf1, 4, 0x0000000081828384) + UNLDU(buf1, 5, 0x0000008182838485) + UNLDU(buf1, 6, 0x0000818283848586) + UNLDU(buf1, 7, 0x0081828384858687) + UNLDU(buf1, 8, 0x8182838485868788) + UNLDU(buf2, 1, 0x0000000000000082) + UNLDU(buf2, 2, 0x0000000000008283) + UNLDU(buf2, 3, 0x0000000000828384) + UNLDU(buf2, 4, 0x0000000082838485) + UNLDU(buf2, 5, 0x0000008283848586) + UNLDU(buf2, 6, 0x0000828384858687) + UNLDU(buf2, 7, 0x0082838485868788) + UNLDU(buf2, 8, 0x8283848586878889) + UNLDU(buf3, 1, 0x0000000000000083) + UNLDU(buf3, 2, 0x0000000000008384) + UNLDU(buf3, 3, 0x0000000000838485) + UNLDU(buf3, 4, 0x0000000083848586) + UNLDU(buf3, 5, 0x0000008384858687) + UNLDU(buf3, 6, 0x0000838485868788) + UNLDU(buf3, 7, 0x0083848586878889) + UNLDU(buf3, 8, 0x838485868788898a) + UNLDU(buf4, 1, 0x0000000000000084) + UNLDU(buf4, 2, 0x0000000000008485) + UNLDU(buf4, 3, 0x0000000000848586) + UNLDU(buf4, 4, 0x0000000084858687) + UNLDU(buf4, 5, 0x0000008485868788) + UNLDU(buf4, 6, 0x0000848586878889) + UNLDU(buf4, 7, 0x008485868788898a) + UNLDU(buf4, 8, 0x8485868788898a8b) + UNLDU(buf5, 1, 0x0000000000000085) + UNLDU(buf5, 2, 0x0000000000008586) + UNLDU(buf5, 3, 0x0000000000858687) + UNLDU(buf5, 4, 0x0000000085868788) + UNLDU(buf5, 5, 0x0000008586878889) + UNLDU(buf5, 6, 0x000085868788898a) + UNLDU(buf5, 7, 0x0085868788898a8b) + UNLDU(buf5, 8, 0x85868788898a8b8c) + UNLDU(buf6, 1, 0x0000000000000086) + UNLDU(buf6, 2, 0x0000000000008687) + UNLDU(buf6, 3, 0x0000000000868788) + UNLDU(buf6, 4, 0x0000000086878889) + UNLDU(buf6, 5, 0x000000868788898a) + UNLDU(buf6, 6, 0x0000868788898a8b) + UNLDU(buf6, 7, 0x00868788898a8b8c) + UNLDU(buf6, 8, 0x868788898a8b8c8d) + UNLDU(buf7, 1, 0x0000000000000087) + UNLDU(buf7, 2, 0x0000000000008788) + UNLDU(buf7, 3, 0x0000000000878889) + UNLDU(buf7, 4, 0x000000008788898a) + UNLDU(buf7, 5, 0x0000008788898a8b) + UNLDU(buf7, 6, 0x00008788898a8b8c) + UNLDU(buf7, 7, 0x008788898a8b8c8d) + UNLDU(buf7, 8, 0x8788898a8b8c8d8e) + UNST(str0, 1, 0x1000000000000000, 0x0000000000000000) + UNST(str0, 2, 0x3210000000000000, 0x0000000000000000) + UNST(str0, 3, 0x5432100000000000, 0x0000000000000000) + UNST(str0, 4, 0x7654321000000000, 0x0000000000000000) + UNST(str0, 5, 0x9876543210000000, 0x0000000000000000) + UNST(str0, 6, 0xba98765432100000, 0x0000000000000000) + UNST(str0, 7, 0xdcba987654321000, 0x0000000000000000) + UNST(str0, 8, 0xfedcba9876543210, 0x0000000000000000) + UNST(str1, 1, 0x0010000000000000, 0x0000000000000000) + UNST(str1, 2, 0x0032100000000000, 0x0000000000000000) + UNST(str1, 3, 0x0054321000000000, 0x0000000000000000) + UNST(str1, 4, 0x0076543210000000, 0x0000000000000000) + UNST(str1, 5, 0x0098765432100000, 0x0000000000000000) + UNST(str1, 6, 0x00ba987654321000, 0x0000000000000000) + UNST(str1, 7, 0x00dcba9876543210, 0x0000000000000000) + UNST(str1, 8, 0x00fedcba98765432, 0x1000000000000000) + UNST(str2, 1, 0x0000100000000000, 0x0000000000000000) + UNST(str2, 2, 0x0000321000000000, 0x0000000000000000) + UNST(str2, 3, 0x0000543210000000, 0x0000000000000000) + UNST(str2, 4, 0x0000765432100000, 0x0000000000000000) + UNST(str2, 5, 0x0000987654321000, 0x0000000000000000) + UNST(str2, 6, 0x0000ba9876543210, 0x0000000000000000) + UNST(str2, 7, 0x0000dcba98765432, 0x1000000000000000) + UNST(str2, 8, 0x0000fedcba987654, 0x3210000000000000) + UNST(str3, 1, 0x0000001000000000, 0x0000000000000000) + UNST(str3, 2, 0x0000003210000000, 0x0000000000000000) + UNST(str3, 3, 0x0000005432100000, 0x0000000000000000) + UNST(str3, 4, 0x0000007654321000, 0x0000000000000000) + UNST(str3, 5, 0x0000009876543210, 0x0000000000000000) + UNST(str3, 6, 0x000000ba98765432, 0x1000000000000000) + UNST(str3, 7, 0x000000dcba987654, 0x3210000000000000) + UNST(str3, 8, 0x000000fedcba9876, 0x5432100000000000) + UNST(str4, 1, 0x0000000010000000, 0x0000000000000000) + UNST(str4, 2, 0x0000000032100000, 0x0000000000000000) + UNST(str4, 3, 0x0000000054321000, 0x0000000000000000) + UNST(str4, 4, 0x0000000076543210, 0x0000000000000000) + UNST(str4, 5, 0x0000000098765432, 0x1000000000000000) + UNST(str4, 6, 0x00000000ba987654, 0x3210000000000000) + UNST(str4, 7, 0x00000000dcba9876, 0x5432100000000000) + UNST(str4, 8, 0x00000000fedcba98, 0x7654321000000000) + UNST(str5, 1, 0x0000000000100000, 0x0000000000000000) + UNST(str5, 2, 0x0000000000321000, 0x0000000000000000) + UNST(str5, 3, 0x0000000000543210, 0x0000000000000000) + UNST(str5, 4, 0x0000000000765432, 0x1000000000000000) + UNST(str5, 5, 0x0000000000987654, 0x3210000000000000) + UNST(str5, 6, 0x0000000000ba9876, 0x5432100000000000) + UNST(str5, 7, 0x0000000000dcba98, 0x7654321000000000) + UNST(str5, 8, 0x0000000000fedcba, 0x9876543210000000) + UNST(str6, 1, 0x0000000000001000, 0x0000000000000000) + UNST(str6, 2, 0x0000000000003210, 0x0000000000000000) + UNST(str6, 3, 0x0000000000005432, 0x1000000000000000) + UNST(str6, 4, 0x0000000000007654, 0x3210000000000000) + UNST(str6, 5, 0x0000000000009876, 0x5432100000000000) + UNST(str6, 6, 0x000000000000ba98, 0x7654321000000000) + UNST(str6, 7, 0x000000000000dcba, 0x9876543210000000) + UNST(str6, 8, 0x000000000000fedc, 0xba98765432100000) + UNST(str7, 1, 0x0000000000000010, 0x0000000000000000) + UNST(str7, 2, 0x0000000000000032, 0x1000000000000000) + UNST(str7, 3, 0x0000000000000054, 0x3210000000000000) + UNST(str7, 4, 0x0000000000000076, 0x5432100000000000) + UNST(str7, 5, 0x0000000000000098, 0x7654321000000000) + UNST(str7, 6, 0x00000000000000ba, 0x9876543210000000) + UNST(str7, 7, 0x00000000000000dc, 0xba98765432100000) + UNST(str7, 8, 0x00000000000000fe, 0xdcba987654321000) +# endif + +# endif + FLDST(str0, 2.5) + FLDST(str1, 2.5) + FLDST(str2, 2.5) + FLDST(str3, 2.5) + FLDST(str4, 2.5) + DLDST(str0, 7.5) + DLDST(str1, 7.5) + DLDST(str2, 7.5) + DLDST(str3, 7.5) + DLDST(str4, 7.5) + DLDST(str5, 7.5) + DLDST(str6, 7.5) + DLDST(str7, 7.5) + DLDST(str8, 7.5) + + prepare + pushargi ok + finishi @puts +#endif + ret + epilog diff --git a/deps/lightning/configure.ac b/deps/lightning/configure.ac index 3fb09e79..76457b45 100644 --- a/deps/lightning/configure.ac +++ b/deps/lightning/configure.ac @@ -15,7 +15,7 @@ dnl License for more details. dnl AC_PREREQ([2.71]) -AC_INIT([GNU lightning],[2.2.1],[pcpa@gnu.org],[lightning]) +AC_INIT([GNU lightning],[2.2.2],[pcpa@gnu.org],[lightning]) AC_CONFIG_AUX_DIR([build-aux]) AC_CANONICAL_TARGET AC_CONFIG_SRCDIR([Makefile.am]) diff --git a/deps/lightning/doc/body.texi b/deps/lightning/doc/body.texi index 1bd3f675..f71b77cb 100644 --- a/deps/lightning/doc/body.texi +++ b/deps/lightning/doc/body.texi @@ -247,6 +247,8 @@ rsbr _f _d O1 = O3 - O1 rsbi _f _d O1 = O3 - O1 mulr _f _d O1 = O2 * O3 muli _f _d O1 = O2 * O3 +hmulr _u O1 = ((O2 * O3) >> WORDSIZE) +hmuli _u O1 = ((O2 * O3) >> WORDSIZE) divr _u _f _d O1 = O2 / O3 divi _u _f _d O1 = O2 / O3 remr _u O1 = O2 % O3 @@ -261,10 +263,18 @@ lshr O1 = O2 << O3 lshi O1 = O2 << O3 rshr _u O1 = O2 >> O3@footnote{The sign bit is propagated unless using the @code{_u} modifier.} rshi _u O1 = O2 >> O3@footnote{The sign bit is propagated unless using the @code{_u} modifier.} +lrotr O1 = (O2 << O3) | (O3 >> (WORDSIZE - O3)) +lroti O1 = (O2 << O3) | (O3 >> (WORDSIZE - O3)) +rrotr O1 = (O2 >> O3) | (O3 << (WORDSIZE - O3)) +rroti O1 = (O2 >> O3) | (O3 << (WORDSIZE - O3)) movzr O1 = O3 ? O1 : O2 movnr O1 = O3 ? O2 : O1 @end example +Note that @code{lrotr}, @code{lroti}, @code{rrotr} and @code{rroti} +are described as the fallback operation. These are bit shift/rotation +operation. + @item Four operand binary ALU operations These accept two result registers, and two operands; the last one can be an immediate. The first two arguments cannot be the same register. @@ -279,22 +289,84 @@ minus one. @code{O2}. It can be used as quick way to check if a division is exact, in which case the remainder is zero. +@code{qlsh} shifts from 0 to @emph{wordsize}, doing a normal left +shift for the first result register and setting the second result +resister to the overflow bits. @code{qlsh} can be used as a quick +way to multiply by powers of two. + +@code{qrsh} shifts from 0 to @emph{wordsize}, doing a normal right +shift for the first result register and setting the second result +register to the overflow bits. @code{qrsh} can be used as a quick +way to divide by powers of two. + +Note that @code{qlsh} and @code{qrsh} are basically implemented as +two shifts. It is undefined behavior to pass a value not in the range +0 to @emph{wordsize}. Most cpus will usually @code{and} the shift +amount with @emph{wordsize} - 1, or possible use the @emph{remainder}. +@lightning{} only generates code to specially handle 0 and @emph{wordsize} +shifts. Since in a code generator for a @emph{safe language} should +usually check the shift amount, these instructions usually should be +used as a fast path to check for division without remainder or +multiplication that does not overflow. + @example qmulr _u O1 O2 = O3 * O4 qmuli _u O1 O2 = O3 * O4 qdivr _u O1 O2 = O3 / O4 qdivi _u O1 O2 = O3 / O4 +qlshr _u O1 = O3 << O4, O2 = O3 >> (WORDSIZE - O4) +qlshi _u O1 = O3 << O4, O2 = O3 >> (WORDSIZE - O4) +qrshr _u O1 = O3 >> O4, O2 = O3 << (WORDSIZE - O4) +qrshi _u O1 = O3 >> O4, O2 = O3 << (WORDSIZE - O4) @end example +These four operand ALU operations are only defined for float operands. + +@example +fmar _f _d O1 = O2 * O3 + O4 +fmai _f _d O1 = O2 * O3 + O4 +fmsr _f _d O1 = O2 * O3 - O4 +fmsi _f _d O1 = O2 * O3 - O4 +fnmar _f _d O1 = -O2 * O3 - O4 +fnmai _f _d O1 = -O2 * O3 - O4 +fnmsr _f _d O1 = -O2 * O3 + O4 +fnmsi _f _d O1 = -O2 * O3 + O4 +@end example + +These are a family of fused multiply-add instructions. +Note that @lightning{} does not handle rounding modes nor math exceptions. +Also note that not all backends provide a instruction for the equivalent +@lightning{} instruction presented above. Some are completely implemented +as fallbacks and some are composed of one or more instructions. For common +input this should not cause major issues, but note that when implemented by +the cpu, these are implemented as the multiplication calculated with infinite +precision, and after the addition step rounding is done. Due to this, For +specially crafted input different ports might show different output. When +implemented by the CPU, it is also possible to have exceptions that do +not happen if implemented as a fallback. + @item Unary ALU operations -These accept two operands, both of which must be registers. +These accept two operands, the first must be a register and the +second is a register if the @code{r} modifier is used, otherwise, +the @code{i} modifier is used and the second argument is a constant. + @example negr _f _d O1 = -O2 +negi _f _d O1 = -O2 comr O1 = ~O2 -clor O1 = number of leading one bits -clzr O1 = number of leading zero bits -ctor O1 = number of trailing one bits -ctzr O1 = number of trailing zero bits +comi O1 = ~O2 +clor O1 = number of leading one bits in O2 +cloi O1 = number of leading one bits in O2 +clzr O1 = number of leading zero bits in O2 +clzi O1 = number of leading zero bits in O2 +ctor O1 = number of trailing one bits in O2 +ctoi O1 = number of trailing one bits in O2 +ctzr O1 = number of trailing zero bits in O2 +ctzi O1 = number of trailing zero bits in O2 +rbitr O1 = bits of O2 reversed +rbiti O1 = bits of O2 reversed +popcntr O1 = number of bits set in O2 +popcnti O1 = number of bits set in O2 @end example Note that @code{ctzr} is basically equivalent of a @code{C} call @@ -309,13 +381,16 @@ The @code{clor} and @code{ctor} are just counterparts of the versions that search for zero bits. These unary ALU operations are only defined for float operands. + @example absr _f _d O1 = fabs(O2) +absi _f _d O1 = fabs(O2) sqrtr _f _d O1 = sqrt(O2) +sqrti _f _d O1 = sqrt(O2) @end example -Besides requiring the @code{r} modifier, there are no unary operations -with an immediate operand. +Note that for @code{float} and @code{double} unary operations, @lightning{} +will generate code to actually execute the operation at runtime. @item Compare instructions These accept three operands; again, the last can be an immediate. @@ -365,6 +440,35 @@ movr _f _d O1 = O2 movi _f _d O1 = O2 extr _c _uc _s _us _i _ui _f _d O1 = O2 truncr _f _d O1 = trunc(O2) +extr O1 = sign_extend(O2[O3:O3+04]) +extr_u O1 = O2[O3:O3+04] +depr O1[O3:O3+O4] = O2 +@end example + +@code{extr}, @code{extr_u} and @code{depr} are useful to access @code{C} +compatible bit fields, provided that these are contained in a machine +word. @code{extr} is used to @emph{extract} and signed extend a value +from a bit field. @code{extr_u} is used to @emph{extract} and zero +extend a value from a bit field. @code{depr} is used to @emph{deposit} +a value into a bit field. + +@example +extr(result, source, offset, length) +extr_u(result, source, offset, length) +depr(result, source, offset, length) +@end example + +A common way to declare @code{C} and @lightning{} compatible bit fields is: +@example +union @{ + struct @{ + jit_word_t signed_bits: @code{length}; + jit_uword_t unsigned_bits: @code{length}; + ... + @} s; + jit_word_t signed_value; + jit_uword_t unsigned_value; +@} u; @end example In 64-bit architectures it may be required to use @code{truncr_f_i}, @@ -373,10 +477,10 @@ the equivalent C code. Only the @code{_i} modifier is available in 32-bit architectures. @example -truncr_f_i = O1 = O2 -truncr_f_l = O1 = O2 -truncr_d_i = O1 = O2 -truncr_d_l = O1 = O2 +truncr_f_i O1 = O2 +truncr_f_l O1 = O2 +truncr_d_i O1 = O2 +truncr_d_l O1 = O2 @end example The float conversion operations are @emph{destination first, @@ -384,10 +488,38 @@ source second}, but the order of the types is reversed. This happens for historical reasons. @example -extr_f_d = O1 = O2 -extr_d_f = O1 = O2 +extr_f_d O1 = O2 +extr_d_f O1 = O2 @end example +The float to/from integer transfer operations are also @emph{destination +first, source second}. These were added later, but follow the pattern +of historic patterns. + +@example +movr_w_f O1 = O2 +movi_w_f O1 = O2 +movr_f_w O1 = O2 +movi_f_w O1 = O2 +movr_w_d O1 = O2 +movi_w_d O1 = O2 +movr_d_w O1 = O2 +movi_d_w O1 = O2 +movr_ww_d O1 = [O2:O3] +movi_ww_d O1 = [O2:O3] +movr_d_ww [O1:O2] = O3 +movi_d_ww [O1:O2] = O3 +@end example + +These are used to transfer bits to/from floats to/from integers, and are +useful to access bits of floating point values. + +@code{movr_w_d}, @code{movi_w_d}, @code{movr_d_w} and @code{movi_d_w} are +only available in 64-bit. Conversely, @code{movr_ww_d}, @code{movi_ww_d}, +@code{movr_d_ww} and @code{movi_d_ww} are only available in 32-bit. +For the int pair to/from double transfers, integer arguments must respect +endianess, to match how the cpu handles the verbatim byte values. + @item Network extensions These accept two operands, both of which must be registers; these two instructions actually perform the same task, yet they are @@ -440,6 +572,29 @@ The @code{_l} type is only available in 64-bit architectures, and for convenience, there is a version without a type modifier for integer or pointer operands that uses the appropriate wordsize call. +@item Unaligned memory access +These allow access to integers of size 3, in 32-bit, and extra sizes +5, 6 and 7 in 64-bit. +For floating point values only support for size 4 and 8 is provided. +@example +unldr O1 = *(signed O3 byte integer)* = O2 +unldi O1 = *(signed O3 byte integer)* = O2 +unldr_u O1 = *(unsigned O3 byte integer)* = O2 +unldi_u O1 = *(unsigned O3 byte integer)* = O2 +unldr_x O1 = *(O3 byte float)* = O2 +unldi_x O1 = *(O3 byte float)* = O2 +unstr *(O3 byte integer)O1 = O2 +unsti *(O3 byte integer)O1 = O2 +unstr_x *(O3 byte float)O1 = O2 +unsti_x *(O3 byte float)O1 = O2 +@end example +With the exception of non standard sized integers, these might be +implemented as normal loads and stores, if the processor supports +unaligned memory access, or, mode can be chosen at jit initialization +time, to generate or not generate, code that does trap on unaligned +memory access. Letting the kernel trap means smaller code generation +as it is required to check alignment at runtime@footnote{This requires changing jit_cpu.unaligned to 0 to disable or 1 to enable unaligned code generation. Not all ports have the C jit_cpu.unaligned value.}. + @item Argument management These are: @example diff --git a/deps/lightning/include/lightning.h.in b/deps/lightning/include/lightning.h.in index 7aa654cb..6d512352 100644 --- a/deps/lightning/include/lightning.h.in +++ b/deps/lightning/include/lightning.h.in @@ -365,8 +365,11 @@ typedef enum { jit_code_rshr_u, jit_code_rshi_u, #define jit_negr(u,v) jit_new_node_ww(jit_code_negr,u,v) +#define jit_negi(u,v) jit_new_node_ww(jit_code_negi,u,v) + jit_code_negr, jit_code_negi, #define jit_comr(u,v) jit_new_node_ww(jit_code_comr,u,v) - jit_code_negr, jit_code_comr, +#define jit_comi(u,v) jit_new_node_ww(jit_code_comi,u,v) + jit_code_comr, jit_code_comi, #define jit_ltr(u,v,w) jit_new_node_www(jit_code_ltr,u,v,w) #define jit_lti(u,v,w) jit_new_node_www(jit_code_lti,u,v,w) @@ -412,44 +415,81 @@ typedef enum { #define jit_casi(u, v, w, x) jit_new_node_wwq(jit_code_casi, u, v, w, x) #define jit_extr_c(u,v) jit_new_node_ww(jit_code_extr_c,u,v) +#define jit_exti_c(u,v) jit_new_node_ww(jit_code_exti_c,u,v) + jit_code_extr_c, jit_code_exti_c, + #define jit_extr_uc(u,v) jit_new_node_ww(jit_code_extr_uc,u,v) - jit_code_extr_c, jit_code_extr_uc, +#define jit_exti_uc(u,v) jit_new_node_ww(jit_code_exti_uc,u,v) + jit_code_extr_uc, jit_code_exti_uc, + #define jit_extr_s(u,v) jit_new_node_ww(jit_code_extr_s,u,v) +#define jit_exti_s(u,v) jit_new_node_ww(jit_code_exti_s,u,v) + jit_code_extr_s, jit_code_exti_s, + #define jit_extr_us(u,v) jit_new_node_ww(jit_code_extr_us,u,v) - jit_code_extr_s, jit_code_extr_us, +#define jit_exti_us(u,v) jit_new_node_ww(jit_code_exti_us,u,v) + jit_code_extr_us, jit_code_exti_us, + #if __WORDSIZE == 64 # define jit_extr_i(u,v) jit_new_node_ww(jit_code_extr_i,u,v) +# define jit_exti_i(u,v) jit_new_node_ww(jit_code_exti_i,u,v) # define jit_extr_ui(u,v) jit_new_node_ww(jit_code_extr_ui,u,v) +# define jit_exti_ui(u,v) jit_new_node_ww(jit_code_exti_ui,u,v) #endif - jit_code_extr_i, jit_code_extr_ui, + jit_code_extr_i, jit_code_exti_i, + jit_code_extr_ui, jit_code_exti_ui, #define jit_bswapr_us(u,v) jit_new_node_ww(jit_code_bswapr_us,u,v) - jit_code_bswapr_us, +#define jit_bswapi_us(u,v) jit_new_node_ww(jit_code_bswapi_us,u,v) + jit_code_bswapr_us, jit_code_bswapi_us, + #define jit_bswapr_ui(u,v) jit_new_node_ww(jit_code_bswapr_ui,u,v) - jit_code_bswapr_ui, -#define jit_bswapr_ul(u,v) jit_new_node_ww(jit_code_bswapr_ul,u,v) - jit_code_bswapr_ul, +#define jit_bswapi_ui(u,v) jit_new_node_ww(jit_code_bswapi_ui,u,v) + jit_code_bswapr_ui, jit_code_bswapi_ui, + +#if __WORDSIZE == 64 +# define jit_bswapr_ul(u,v) jit_new_node_ww(jit_code_bswapr_ul,u,v) +# define jit_bswapi_ul(u,v) jit_new_node_ww(jit_code_bswapi_ul,u,v) +#endif + jit_code_bswapr_ul, jit_code_bswapi_ul, + #if __WORDSIZE == 32 -#define jit_bswapr(u,v) jit_new_node_ww(jit_code_bswapr_ui,u,v) +# define jit_bswapr(u,v) jit_bswapr_ui(u,v) +# define jit_bswapi(u,v) jit_bswapi_ui(u,v) #else -#define jit_bswapr(u,v) jit_new_node_ww(jit_code_bswapr_ul,u,v) +# define jit_bswapr(u,v) jit_bswapr_ul(u,v) +# define jit_bswapi(u,v) jit_bswapi_ul(u,v) #endif #define jit_htonr_us(u,v) jit_new_node_ww(jit_code_htonr_us,u,v) -#define jit_ntohr_us(u,v) jit_new_node_ww(jit_code_htonr_us,u,v) - jit_code_htonr_us, +#define jit_ntohr_us(u,v) jit_htonr_us(u,v) +#define jit_htoni_us(u,v) jit_new_node_ww(jit_code_htoni_us,u,v) +#define jit_ntohi_us(u,v) jit_htoni_us(u, v) + jit_code_htonr_us, jit_code_htoni_us, + #define jit_htonr_ui(u,v) jit_new_node_ww(jit_code_htonr_ui,u,v) -#define jit_ntohr_ui(u,v) jit_new_node_ww(jit_code_htonr_ui,u,v) +#define jit_ntohr_ui(u,v) jit_htonr_ui(u,v) +#define jit_htoni_ui(u,v) jit_new_node_ww(jit_code_htoni_ui,u,v) +#define jit_ntohi_ui(u,v) jit_htoni_ui(u, v) + jit_code_htonr_ui, jit_code_htoni_ui, + +#if __WORDSIZE == 64 +# define jit_htonr_ul(u,v) jit_new_node_ww(jit_code_htonr_ul,u,v) +# define jit_ntohr_ul(u,v) jit_htonr_ul(u,v) +# define jit_htoni_ul(u,v) jit_new_node_ww(jit_code_htoni_ul,u,v) +# define jit_ntohi_ul(u,v) jit_htoni_ul(u, v) +#endif + jit_code_htonr_ul, jit_code_htoni_ul, + #if __WORDSIZE == 32 -# define jit_htonr(u,v) jit_new_node_ww(jit_code_htonr_ui,u,v) -# define jit_ntohr(u,v) jit_new_node_ww(jit_code_htonr_ui,u,v) +# define jit_htonr(u,v) jit_htonr_ui(u,v) +# define jit_htoni(u,v) jit_htoni_ui(u,v) #else -#define jit_htonr_ul(u,v) jit_new_node_ww(jit_code_htonr_ul,u,v) -#define jit_ntohr_ul(u,v) jit_new_node_ww(jit_code_htonr_ul,u,v) -# define jit_htonr(u,v) jit_new_node_ww(jit_code_htonr_ul,u,v) -# define jit_ntohr(u,v) jit_new_node_ww(jit_code_htonr_ul,u,v) +# define jit_htonr(u,v) jit_htonr_ul(u,v) +# define jit_htoni(u,v) jit_htoni_ul(u,v) #endif - jit_code_htonr_ui, jit_code_htonr_ul, +#define jit_ntohr(u,v) jit_htonr(u,v) +#define jit_ntohi(u,v) jit_htoni(u,v) #define jit_ldr_c(u,v) jit_new_node_ww(jit_code_ldr_c,u,v) #define jit_ldi_c(u,v) jit_new_node_wp(jit_code_ldi_c,u,v) @@ -748,10 +788,16 @@ typedef enum { #define jit_divr_f(u,v,w) jit_new_node_www(jit_code_divr_f,u,v,w) #define jit_divi_f(u,v,w) jit_new_node_wwf(jit_code_divi_f,u,v,w) jit_code_divr_f, jit_code_divi_f, + #define jit_negr_f(u,v) jit_new_node_ww(jit_code_negr_f,u,v) +#define jit_negi_f(u,v) _jit_negi_f(_jit,u,v) + jit_code_negr_f, jit_code_negi_f, #define jit_absr_f(u,v) jit_new_node_ww(jit_code_absr_f,u,v) +#define jit_absi_f(u,v) _jit_absi_f(_jit,u,v) + jit_code_absr_f, jit_code_absi_f, #define jit_sqrtr_f(u,v) jit_new_node_ww(jit_code_sqrtr_f,u,v) - jit_code_negr_f, jit_code_absr_f, jit_code_sqrtr_f, +#define jit_sqrti_f(u,v) _jit_sqrti_f(_jit,u,v) + jit_code_sqrtr_f, jit_code_sqrti_f, #define jit_ltr_f(u,v,w) jit_new_node_www(jit_code_ltr_f,u,v,w) #define jit_lti_f(u,v,w) jit_new_node_wwf(jit_code_lti_f,u,v,w) @@ -902,9 +948,14 @@ typedef enum { jit_code_divr_d, jit_code_divi_d, #define jit_negr_d(u,v) jit_new_node_ww(jit_code_negr_d,u,v) +#define jit_negi_d(u,v) _jit_negi_d(_jit,u,v) + jit_code_negr_d, jit_code_negi_d, #define jit_absr_d(u,v) jit_new_node_ww(jit_code_absr_d,u,v) +#define jit_absi_d(u,v) _jit_absi_d(_jit,u,v) + jit_code_absr_d, jit_code_absi_d, #define jit_sqrtr_d(u,v) jit_new_node_ww(jit_code_sqrtr_d,u,v) - jit_code_negr_d, jit_code_absr_d, jit_code_sqrtr_d, +#define jit_sqrti_d(u,v) _jit_sqrti_d(_jit,u,v) + jit_code_sqrtr_d, jit_code_sqrti_d, #define jit_ltr_d(u,v,w) jit_new_node_www(jit_code_ltr_d,u,v,w) #define jit_lti_d(u,v,w) jit_new_node_wwd(jit_code_lti_d,u,v,w) @@ -1030,31 +1081,134 @@ typedef enum { #define jit_retval_d(u) _jit_retval_d(_jit,u) jit_code_retval_d, - /* Special internal backend specific codes */ - jit_code_movr_w_f, jit_code_movr_ww_d, /* w* -> f|d */ + /* w* -> f|d */ #define jit_movr_w_f(u, v) jit_new_node_ww(jit_code_movr_w_f, u, v) +#define jit_movi_w_f(u,v) jit_new_node_ww(jit_code_movi_w_f, u, v) + jit_code_movr_w_f, jit_code_movi_w_f, #define jit_movr_ww_d(u, v, w) jit_new_node_www(jit_code_movr_ww_d, u, v, w) - jit_code_movr_w_d, /* w -> d */ +#define jit_movi_ww_d(u,v, w) jit_new_node_www(jit_code_movi_ww_d, u, v, w) + jit_code_movr_ww_d, jit_code_movi_ww_d, + + /* w -> d */ #define jit_movr_w_d(u, v) jit_new_node_ww(jit_code_movr_w_d, u, v) +#define jit_movi_w_d(u,v) jit_new_node_ww(jit_code_movi_w_d, u, v) + jit_code_movr_w_d, jit_code_movi_w_d, - jit_code_movr_f_w, jit_code_movi_f_w, /* f|d -> w* */ + /* f|d -> w* */ #define jit_movr_f_w(u, v) jit_new_node_ww(jit_code_movr_f_w, u, v) #define jit_movi_f_w(u, v) jit_new_node_wf(jit_code_movi_f_w, u, v) - jit_code_movr_d_ww, jit_code_movi_d_ww, + jit_code_movr_f_w, jit_code_movi_f_w, #define jit_movr_d_ww(u, v, w) jit_new_node_www(jit_code_movr_d_ww, u, v, w) #define jit_movi_d_ww(u, v, w) jit_new_node_wwd(jit_code_movi_d_ww, u, v, w) + jit_code_movr_d_ww, jit_code_movi_d_ww, - jit_code_movr_d_w, jit_code_movi_d_w, /* d -> w */ + /* d -> w */ #define jit_movr_d_w(u, v) jit_new_node_ww(jit_code_movr_d_w, u, v) #define jit_movi_d_w(u, v) jit_new_node_wd(jit_code_movi_d_w, u, v) + jit_code_movr_d_w, jit_code_movi_d_w, #define jit_clor(u,v) jit_new_node_ww(jit_code_clor,u,v) +#define jit_cloi(u,v) jit_new_node_ww(jit_code_cloi,u,v) + jit_code_clor, jit_code_cloi, + #define jit_clzr(u,v) jit_new_node_ww(jit_code_clzr,u,v) - jit_code_clor, jit_code_clzr, +#define jit_clzi(u,v) jit_new_node_ww(jit_code_clzi,u,v) + jit_code_clzr, jit_code_clzi, #define jit_ctor(u,v) jit_new_node_ww(jit_code_ctor,u,v) +#define jit_ctoi(u,v) jit_new_node_ww(jit_code_ctoi,u,v) + jit_code_ctor, jit_code_ctoi, #define jit_ctzr(u,v) jit_new_node_ww(jit_code_ctzr,u,v) - jit_code_ctor, jit_code_ctzr, +#define jit_ctzi(u,v) jit_new_node_ww(jit_code_ctzi,u,v) + jit_code_ctzr, jit_code_ctzi, + +#define jit_rbitr(u,v) jit_new_node_ww(jit_code_rbitr,u,v) +#define jit_rbiti(u,v) jit_new_node_ww(jit_code_rbiti,u,v) + jit_code_rbitr, jit_code_rbiti, + +#define jit_popcntr(u,v) jit_new_node_ww(jit_code_popcntr,u,v) +#define jit_popcnti(u,v) jit_new_node_ww(jit_code_popcnti,u,v) + jit_code_popcntr, jit_code_popcnti, + +#define jit_lrotr(u,v,w) jit_new_node_www(jit_code_lrotr,u,v,w) +#define jit_lroti(u,v,w) jit_new_node_www(jit_code_lroti,u,v,w) + jit_code_lrotr, jit_code_lroti, +#define jit_rrotr(u,v,w) jit_new_node_www(jit_code_rrotr,u,v,w) +#define jit_rroti(u,v,w) jit_new_node_www(jit_code_rroti,u,v,w) + jit_code_rrotr, jit_code_rroti, + +#define jit_extr(u,v,w,x) jit_new_node_wwq(jit_code_extr, u, v, w, x) +#define jit_exti(u,v,w,x) jit_new_node_wwq(jit_code_exti, u, v, w, x) + jit_code_extr, jit_code_exti, +#define jit_extr_u(u,v,w,x) jit_new_node_wwq(jit_code_extr_u, u, v, w, x) +#define jit_exti_u(u,v,w,x) jit_new_node_wwq(jit_code_exti_u, u, v, w, x) + jit_code_extr_u, jit_code_exti_u, +#define jit_depr(u,v,w,x) jit_new_node_wwq(jit_code_depr, u, v, w, x) +#define jit_depi(u,v,w,x) jit_new_node_wwq(jit_code_depi, u, v, w, x) + jit_code_depr, jit_code_depi, + +#define jit_qlshr(l,h,v,w) jit_new_node_qww(jit_code_qlshr,l,h,v,w) +#define jit_qlshi(l,h,v,w) jit_new_node_qww(jit_code_qlshi,l,h,v,w) + jit_code_qlshr, jit_code_qlshi, +#define jit_qlshr_u(l,h,v,w) jit_new_node_qww(jit_code_qlshr_u,l,h,v,w) +#define jit_qlshi_u(l,h,v,w) jit_new_node_qww(jit_code_qlshi_u,l,h,v,w) + jit_code_qlshr_u, jit_code_qlshi_u, +#define jit_qrshr(l,h,v,w) jit_new_node_qww(jit_code_qrshr,l,h,v,w) +#define jit_qrshi(l,h,v,w) jit_new_node_qww(jit_code_qrshi,l,h,v,w) + jit_code_qrshr, jit_code_qrshi, +#define jit_qrshr_u(l,h,v,w) jit_new_node_qww(jit_code_qrshr_u,l,h,v,w) +#define jit_qrshi_u(l,h,v,w) jit_new_node_qww(jit_code_qrshi_u,l,h,v,w) + jit_code_qrshr_u, jit_code_qrshi_u, + +#define jit_unldr(u,v,w) jit_new_node_www(jit_code_unldr, u, v, w) +#define jit_unldi(u,v,w) jit_new_node_www(jit_code_unldi, u, v, w) + jit_code_unldr, jit_code_unldi, +#define jit_unldr_u(u,v,w) jit_new_node_www(jit_code_unldr_u, u, v, w) +#define jit_unldi_u(u,v,w) jit_new_node_www(jit_code_unldi_u, u, v, w) + jit_code_unldr_u, jit_code_unldi_u, +#define jit_unstr(u,v,w) jit_new_node_www(jit_code_unstr, u, v, w) +#define jit_unsti(u,v,w) jit_new_node_www(jit_code_unsti, u, v, w) + jit_code_unstr, jit_code_unsti, + +#define jit_unldr_x(u,v,w) jit_new_node_www(jit_code_unldr_x, u, v, w) +#define jit_unldi_x(u,v,w) jit_new_node_www(jit_code_unldi_x, u, v, w) + jit_code_unldr_x, jit_code_unldi_x, +#define jit_unstr_x(u,v,w) jit_new_node_www(jit_code_unstr_x, u, v, w) +#define jit_unsti_x(u,v,w) jit_new_node_www(jit_code_unsti_x, u, v, w) + jit_code_unstr_x, jit_code_unsti_x, + +#define jit_fmar_f(u,v,w,x) jit_new_node_wqw(jit_code_fmar_f, u, v, w, x) +#define jit_fmai_f(u,v,w,x) _jit_fmai_f(_jit, u, v, w, x) + jit_code_fmar_f, jit_code_fmai_f, +#define jit_fmsr_f(u,v,w,x) jit_new_node_wqw(jit_code_fmsr_f, u, v, w, x) +#define jit_fmsi_f(u,v,w,x) _jit_fmsi_f(_jit, u, v, w, x) + jit_code_fmsr_f, jit_code_fmsi_f, +#define jit_fmar_d(u,v,w,x) jit_new_node_wqw(jit_code_fmar_d, u, v, w, x) +#define jit_fmai_d(u,v,w,x) _jit_fmai_d(_jit, u, v, w, x) + jit_code_fmar_d, jit_code_fmai_d, +#define jit_fmsr_d(u,v,w,x) jit_new_node_wqw(jit_code_fmsr_d, u, v, w, x) +#define jit_fmsi_d(u,v,w,x) _jit_fmsi_d(_jit, u, v, w, x) + jit_code_fmsr_d, jit_code_fmsi_d, + +#define jit_fnmar_f(u,v,w,x) jit_new_node_wqw(jit_code_fnmar_f, u, v, w, x) +#define jit_fnmai_f(u,v,w,x) _jit_fnmai_f(_jit, u, v, w, x) + jit_code_fnmar_f, jit_code_fnmai_f, +#define jit_fnmsr_f(u,v,w,x) jit_new_node_wqw(jit_code_fnmsr_f, u, v, w, x) +#define jit_fnmsi_f(u,v,w,x) _jit_fnmsi_f(_jit, u, v, w, x) + jit_code_fnmsr_f, jit_code_fnmsi_f, +#define jit_fnmar_d(u,v,w,x) jit_new_node_wqw(jit_code_fnmar_d, u, v, w, x) +#define jit_fnmai_d(u,v,w,x) _jit_fnmai_d(_jit, u, v, w, x) + jit_code_fnmar_d, jit_code_fnmai_d, +#define jit_fnmsr_d(u,v,w,x) jit_new_node_wqw(jit_code_fnmsr_d, u, v, w, x) +#define jit_fnmsi_d(u,v,w,x) _jit_fnmsi_d(_jit, u, v, w, x) + jit_code_fnmsr_d, jit_code_fnmsi_d, + +#define jit_hmulr(u,v,w) jit_new_node_www(jit_code_hmulr,u,v,w) +#define jit_hmuli(u,v,w) jit_new_node_www(jit_code_hmuli,u,v,w) + jit_code_hmulr, jit_code_hmuli, +#define jit_hmulr_u(u,v,w) jit_new_node_www(jit_code_hmulr_u,u,v,w) +#define jit_hmuli_u(u,v,w) jit_new_node_www(jit_code_hmuli_u,u,v,w) + jit_code_hmulr_u, jit_code_hmuli_u, jit_code_last_code } jit_code_t; @@ -1176,6 +1330,17 @@ extern void _jit_pushargi_f(jit_state_t*, jit_float32_t); extern void _jit_retr_f(jit_state_t*, jit_fpr_t); extern void _jit_reti_f(jit_state_t*, jit_float32_t); extern void _jit_retval_f(jit_state_t*, jit_fpr_t); +extern void _jit_negi_f(jit_state_t*, jit_fpr_t, jit_float32_t); +extern void _jit_absi_f(jit_state_t*, jit_fpr_t, jit_float32_t); +extern void _jit_sqrti_f(jit_state_t*, jit_fpr_t, jit_float32_t); +extern void _jit_fmai_f(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float32_t); +extern void _jit_fmsi_f(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float32_t); +extern void _jit_fnmai_f(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float32_t); +extern void _jit_fnmsi_f(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float32_t); extern jit_node_t *_jit_arg_d(jit_state_t*); extern void _jit_getarg_d(jit_state_t*, jit_fpr_t, jit_node_t*); @@ -1186,6 +1351,17 @@ extern void _jit_pushargi_d(jit_state_t*, jit_float64_t); extern void _jit_retr_d(jit_state_t*, jit_fpr_t); extern void _jit_reti_d(jit_state_t*, jit_float64_t); extern void _jit_retval_d(jit_state_t*, jit_fpr_t); +extern void _jit_negi_d(jit_state_t*, jit_fpr_t, jit_float64_t); +extern void _jit_absi_d(jit_state_t*, jit_fpr_t, jit_float64_t); +extern void _jit_sqrti_d(jit_state_t*, jit_fpr_t, jit_float64_t); +extern void _jit_fmai_d(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float64_t); +extern void _jit_fmsi_d(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float64_t); +extern void _jit_fnmai_d(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float64_t); +extern void _jit_fnmsi_d(jit_state_t*, + jit_fpr_t, jit_fpr_t, jit_fpr_t, jit_float64_t); #define jit_get_reg(s) _jit_get_reg(_jit,s) extern jit_int32_t _jit_get_reg(jit_state_t*, jit_int32_t); @@ -1235,6 +1411,10 @@ extern jit_node_t *_jit_new_node_www(jit_state_t*, jit_code_t, extern jit_node_t *_jit_new_node_qww(jit_state_t*, jit_code_t, jit_int32_t, jit_int32_t, jit_word_t, jit_word_t); +#define jit_new_node_wqw(c,u,l,h,w) _jit_new_node_wqw(_jit,c,u,l,h,w) +extern jit_node_t *_jit_new_node_wqw(jit_state_t*, jit_code_t, + jit_word_t, jit_int32_t, + jit_int32_t, jit_word_t); #define jit_new_node_wwq(c,u,v,l,h) _jit_new_node_wwq(_jit,c,u,v,l,h) extern jit_node_t *_jit_new_node_wwq(jit_state_t*, jit_code_t, jit_word_t, jit_word_t, @@ -1242,9 +1422,17 @@ extern jit_node_t *_jit_new_node_wwq(jit_state_t*, jit_code_t, #define jit_new_node_wwf(c,u,v,w) _jit_new_node_wwf(_jit,c,u,v,w) extern jit_node_t *_jit_new_node_wwf(jit_state_t*, jit_code_t, jit_word_t, jit_word_t, jit_float32_t); +#define jit_new_node_wqf(c,u,l,h,w) _jit_new_node_wqf(_jit,c,u,l,h,w) +extern jit_node_t *_jit_new_node_wqf(jit_state_t*, jit_code_t, + jit_word_t, jit_int32_t, + jit_int32_t, jit_float32_t); #define jit_new_node_wwd(c,u,v,w) _jit_new_node_wwd(_jit,c,u,v,w) extern jit_node_t *_jit_new_node_wwd(jit_state_t*, jit_code_t, jit_word_t, jit_word_t, jit_float64_t); +#define jit_new_node_wqd(c,u,l,h,w) _jit_new_node_wqd(_jit,c,u,l,h,w) +extern jit_node_t *_jit_new_node_wqd(jit_state_t*, jit_code_t, + jit_word_t, jit_int32_t, + jit_int32_t, jit_float64_t); #define jit_new_node_pww(c,u,v,w) _jit_new_node_pww(_jit,c,u,v,w) extern jit_node_t *_jit_new_node_pww(jit_state_t*, jit_code_t, jit_pointer_t, jit_word_t, jit_word_t); @@ -1274,5 +1462,4 @@ extern void jit_set_memory_functions(jit_alloc_func_ptr, extern void jit_get_memory_functions(jit_alloc_func_ptr*, jit_realloc_func_ptr*, jit_free_func_ptr*); - #endif /* _lightning_h */ diff --git a/deps/lightning/include/lightning/jit_arm.h b/deps/lightning/include/lightning/jit_arm.h index 0ed95351..558f5535 100644 --- a/deps/lightning/include/lightning/jit_arm.h +++ b/deps/lightning/include/lightning/jit_arm.h @@ -126,6 +126,63 @@ typedef struct { * of that function if generating jit for a relative jump. */ jit_uint32_t exchange : 1; + /* By default assume cannot load unaligned data. + * A3.2.1 + * Unaligned data access + * An ARMv7 implementation must support unaligned data accesses by + * some load and store instructions, as Table A3-1 shows. Software + * can set the SCTLR.A bit to control whether a misaligned access by + * one of these instructions causes an Alignment fault Data Abort + * exception. + * Table A3-1 Alignment requirements of load/store instructions + * Result if check fails when + * Instructions Alignment check SCTLR.A is 0 SCTLR.A is 1 + * LDRB, LDREXB, + * LDRBT, LDRSB, + * LDRSBT, STRB, + * STREXB, STRBT, + * SWPB, TBB None - - + * LDRH, LDRHT, + * LDRSH, LDRSHT, + * STRH, STRHT, + * TBH Halfword Unaligned access Alignment fault + * LDREXH, STREXH Halfword Alignment fault Alignment fault + * LDR, LDRT, + * STR, STRT Word Unaligned access Alignment fault + * LDREX, STREX Word Alignment fault Alignment fault + * LDREXD, STREXD Doubleword Alignment fault Alignment fault + * All forms of + * LDM and STM, + * LDRD, RFE, SRS, + * STRD, SWP Word Alignment fault Alignment fault + * LDC, LDC2, + * STC, STC2 Word Alignment fault Alignment fault + * VLDM, VLDR, + * VPOP, VPUSH, + * VSTM, VSTR Word Alignment fault Alignment fault + * VLD1, VLD2, + * VLD3, VLD4, + * VST1, VST2, + * VST3, VST4, + * all with + * standard + * alignment (a) Element size Unaligned access Alignment fault + * VLD1, VLD2, + * VLD3, VLD4, + * VST1, VST2, + * VST3, VST4, + * all with + * @ + * specified (a) As specified by Alignment fault Alignment fault + * @ + * + * (a) These element and structure load/store instructions are only in + * the Advanced SIMD Extension to the ARMv7 ARM and Thumb instruction + * sets. ARMv7 does not support the pre-ARMv6 alignment model, so + * software cannot use that model with these instructions. + */ + jit_uint32_t unaligned : 1; + jit_uint32_t vfp_unaligned : 1; } jit_cpu_t; /* diff --git a/deps/lightning/include/lightning/jit_hppa.h b/deps/lightning/include/lightning/jit_hppa.h index df361baa..66a3adf1 100644 --- a/deps/lightning/include/lightning/jit_hppa.h +++ b/deps/lightning/include/lightning/jit_hppa.h @@ -131,4 +131,18 @@ typedef enum { _NOREG, } jit_reg_t; +typedef struct { + /* Need this to pass unldst.tst on . This is very strange, because + * even for aligned addresses it is required, but all other load/store + * tests *work* with index immediates. Possibly a qemu (7.0.0) bug, + * and for the moment, by default keep failing. Need to test in + * actual hardware. */ + jit_uint32_t imm_idx : 1; +} jit_cpu_t; + +/* + * Initialization + */ +extern jit_cpu_t jit_cpu; + #endif /* _jit_hppa */ diff --git a/deps/lightning/include/lightning/jit_ia64.h b/deps/lightning/include/lightning/jit_ia64.h index e45818aa..519f3f89 100644 --- a/deps/lightning/include/lightning/jit_ia64.h +++ b/deps/lightning/include/lightning/jit_ia64.h @@ -119,6 +119,8 @@ typedef enum { typedef struct { jit_uint32_t clz : 1; + /* generate special instructions for unaligned load/store? */ + jit_uint32_t unaligned : 1; } jit_cpu_t; /* diff --git a/deps/lightning/include/lightning/jit_loongarch.h b/deps/lightning/include/lightning/jit_loongarch.h index 89b1a862..72e9f1fd 100644 --- a/deps/lightning/include/lightning/jit_loongarch.h +++ b/deps/lightning/include/lightning/jit_loongarch.h @@ -74,4 +74,15 @@ typedef enum { _NOREG, } jit_reg_t; +typedef struct { + /* generate special instructions for unaligned load/store? */ + /* It is not guaranteed unaligned memory access is supported. */ + jit_uint32_t unaligned : 1; +} jit_cpu_t; + +/* + * Initialization + */ +extern jit_cpu_t jit_cpu; + #endif /* _jit_loongarch_h */ diff --git a/deps/lightning/include/lightning/jit_mips.h b/deps/lightning/include/lightning/jit_mips.h index 52aebccb..9791c294 100644 --- a/deps/lightning/include/lightning/jit_mips.h +++ b/deps/lightning/include/lightning/jit_mips.h @@ -118,6 +118,16 @@ typedef enum { typedef struct { jit_uint32_t release : 4; + /* set if lwc1, ldc1, swc1, sdc1, mtc1, mfc1, dmtc1, and dmfc1 + * can be put in delay slot */ + jit_uint32_t cop1_delay : 1; + /* set if sll can be put in delay slot */ + jit_uint32_t sll_delay : 1; + /* set if lwl and lwr can be put in delay slot */ + jit_uint32_t lwl_lwr_delay : 1; + /* generate special instructions for un{ld,st}*; ignored for mips 6 + * that does not have unaligned load/store instructions. */ + jit_uint32_t unaligned : 1; } jit_cpu_t; /* diff --git a/deps/lightning/include/lightning/jit_private.h b/deps/lightning/include/lightning/jit_private.h index 444a2953..5052a362 100644 --- a/deps/lightning/include/lightning/jit_private.h +++ b/deps/lightning/include/lightning/jit_private.h @@ -250,6 +250,30 @@ extern jit_node_t *_jit_data(jit_state_t*, const void*, } while (0) #define jit_inc_synth_dp(name, u, v) \ jit_code_inc_synth_dp(jit_code_##name, u, v) +#define jit_inc_synth_wf(name, u, v) \ + jit_code_inc_synth_wf(jit_code_##name, u, v) +#define jit_code_inc_synth_wf(code, u, v) \ + do { \ + (void)jit_new_node_wf(code, u, v); \ + jit_synth_inc(); \ + } while (0) +#define jit_inc_synth_wqf(name, u, v, w, x) \ + do { \ + (void)jit_new_node_wqf(jit_code_##name, u, v, w, x); \ + jit_synth_inc(); \ + } while (0) +#define jit_inc_synth_wd(name, u, v) \ + jit_code_inc_synth_wd(jit_code_##name, u, v) +#define jit_inc_synth_wqd(name, u, v, w, x) \ + do { \ + (void)jit_new_node_wqd(jit_code_##name, u, v, w, x); \ + jit_synth_inc(); \ + } while (0) +#define jit_code_inc_synth_wd(code, u, v) \ + do { \ + (void)jit_new_node_wd(code, u, v); \ + jit_synth_inc(); \ + } while (0) #define jit_dec_synth() jit_synth_dec() #define jit_link_alist(node) \ @@ -326,10 +350,11 @@ extern jit_node_t *_jit_data(jit_state_t*, const void*, #define jit_cc_a0_cnd 0x00000100 /* arg1 is a conditinally set register */ #define jit_cc_a1_reg 0x00000200 /* arg1 is a register */ #define jit_cc_a1_chg 0x00000400 /* arg1 is modified */ -#define jit_cc_a1_int 0x00001000 /* arg1 is immediate word */ -#define jit_cc_a1_flt 0x00002000 /* arg1 is immediate float */ -#define jit_cc_a1_dbl 0x00004000 /* arg1 is immediate double */ -#define jit_cc_a1_arg 0x00008000 /* arg1 is an argument node */ +#define jit_cc_a1_int 0x00000800 /* arg1 is immediate word */ +#define jit_cc_a1_flt 0x00001000 /* arg1 is immediate float */ +#define jit_cc_a1_dbl 0x00002000 /* arg1 is immediate double */ +#define jit_cc_a1_arg 0x00004000 /* arg1 is an argument node */ +#define jit_cc_a1_rlh 0x00008000 /* arg1 is a register pair */ #define jit_cc_a2_reg 0x00010000 /* arg2 is a register */ #define jit_cc_a2_chg 0x00020000 /* arg2 is modified */ #define jit_cc_a2_int 0x00100000 /* arg2 is immediate word */ @@ -530,7 +555,10 @@ struct jit_function { jit_int32_t *regoff; jit_regset_t regset; jit_int32_t stack; -#if defined(__i386__) || defined(__x86_64__) +#if defined(__i386__) || defined(__x86_64__) || \ + defined(__powerpc__) || defined(__sparc__) || \ + defined(__s390__) || defined(__s390x__) || \ + defined(__hppa__) || defined(__alpha__) jit_int32_t cvt_offset; /* allocai'd offset for x87<->xmm or * fpr<->gpr transfer using the stack */ #endif @@ -606,6 +634,12 @@ struct jit_compiler { #endif jit_uint32_t no_data : 1; jit_uint32_t no_note : 1; + /* FIXME undocumented, might be moved to a jit_cpu field or a better + * configuration api. + * These are switches to a different unld* or unst*. + * Defaults are the algorithms that generate shorter code*/ + jit_uint32_t unld_algorithm : 1; + jit_uint32_t unst_algorithm : 1; jit_int32_t framesize; /* space for callee save registers, * frame pointer and return address */ jit_int32_t reglen; /* number of registers */ @@ -739,7 +773,7 @@ struct jit_state { jit_uint8_t *ptr; jit_word_t length; /* PROTECTED bytes starting at PTR are mprotect'd. */ - jit_word_t protected; + jit_word_t protect; } code; struct { jit_uint8_t *ptr; diff --git a/deps/lightning/include/lightning/jit_riscv.h b/deps/lightning/include/lightning/jit_riscv.h index bf59c5b9..652e42ec 100644 --- a/deps/lightning/include/lightning/jit_riscv.h +++ b/deps/lightning/include/lightning/jit_riscv.h @@ -144,4 +144,24 @@ typedef enum { #define JIT_NOREG _NOREG } jit_reg_t; +typedef struct { + /* generate special instructions for unaligned load/store? */ + /* + * For best performance, the effective address for all loads and stores + * should be naturally aligned for each data type (i.e., on a four-byte + * boundary for 32-bit accesses, and a two-byte boundary for 16-bit + * accesses). The base ISA supports misaligned accesses, but these might + * run extremely slowly depending on the implementation. Furthermore, + * naturally aligned loads and stores are guaranteed to execute atomically, + * whereas misaligned loads and stores might not, and hence require + * additional synchronization to ensure atomicity + */ + jit_uint32_t unaligned : 1; +} jit_cpu_t; + +/* + * Initialization + */ +extern jit_cpu_t jit_cpu; + #endif /* _jit_riscv_h */ diff --git a/deps/lightning/include/lightning/jit_x86.h b/deps/lightning/include/lightning/jit_x86.h index 4c480131..9491afc3 100644 --- a/deps/lightning/include/lightning/jit_x86.h +++ b/deps/lightning/include/lightning/jit_x86.h @@ -193,6 +193,10 @@ typedef struct { jit_uint32_t abm : 1; /* adcx and adox instructions available? */ jit_uint32_t adx : 1; + /* pdep and pext instructions available? */ + jit_uint32_t bmi2 : 1; + /* fma 4 arguments instruction available? */ + jit_uint32_t fma4 : 1; } jit_cpu_t; /* diff --git a/deps/lightning/lib/Makefile.am b/deps/lightning/lib/Makefile.am index 44ac4f2e..04b5f924 100644 --- a/deps/lightning/lib/Makefile.am +++ b/deps/lightning/lib/Makefile.am @@ -17,7 +17,7 @@ AM_CFLAGS = -I$(top_builddir)/include -I$(top_srcdir)/include \ -D_GNU_SOURCE $(LIGHTNING_CFLAGS) liblightning_LTLIBRARIES = liblightning.la -liblightning_la_LDFLAGS = -version-info 2:0:0 +liblightning_la_LDFLAGS = -version-info 2:1:0 AM_CPPFLAGS = if get_jit_size diff --git a/deps/lightning/lib/jit_aarch64-cpu.c b/deps/lightning/lib/jit_aarch64-cpu.c index d5e64ad3..76a988bd 100644 --- a/deps/lightning/lib/jit_aarch64-cpu.c +++ b/deps/lightning/lib/jit_aarch64-cpu.c @@ -213,8 +213,12 @@ typedef union { # define s26_p(d) ((d) >= -33554432 && (d) <= 33554431) # define ii(i) *_jit->pc.ui++ = i # define ldr(r0,r1) ldr_l(r0,r1) +# define ldi(r0,i0) ldi_l(r0,i0) # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) +# define str(r0,r1) str_l(r0,r1) +# define sti(i0,r0) sti_l(i0,r0) +# define stxr(r0,r1,r2) stxr_l(r0,r1,r2) # define stxi(i0,r0,r1) stxi_l(i0,r0,r1) # define FP_REGNO 0x1d # define LR_REGNO 0x1e @@ -278,9 +282,11 @@ typedef union { # define A64_NEG 0x4b0003e0 # define A64_SUBS 0x6b000000 # define A64_CMP 0x6b00001f +# define A64_BFM 0x33400000 # define A64_SBFM 0x93400000 +# define A64_SBFX 0x13400000 # define A64_UBFM 0x53400000 -# define A64_UBFX 0x53000000 +# define A64_UBFX 0x53400000 # define A64_B 0x14000000 # define A64_BL 0x94000000 # define A64_BR 0xd61f0000 @@ -297,6 +303,8 @@ typedef union { # define A64_LSL 0x1ac02000 # define A64_LSR 0x1ac02400 # define A64_ASR 0x1ac02800 +# define A64_RORV 0x1ac02c00 +# define A64_EXTR 0x13800000 # define A64_MUL 0x1b007c00 # define A64_SMULL 0x9b207c00 # define A64_SMULH 0x9b407c00 @@ -358,9 +366,11 @@ typedef union { # define A64_MOVN 0x12800000 # define A64_MOVZ 0x52800000 # define A64_MOVK 0x72800000 +# define BFM(Rd,Rn,ImmR,ImmS) oxxrs(A64_BFM|XS,Rd,Rn,ImmR,ImmS) # define SBFM(Rd,Rn,ImmR,ImmS) oxxrs(A64_SBFM|XS,Rd,Rn,ImmR,ImmS) # define UBFM(Rd,Rn,ImmR,ImmS) oxxrs(A64_UBFM|XS,Rd,Rn,ImmR,ImmS) -# define UBFX(Rd,Rn,ImmR,ImmS) oxxrs(A64_UBFX,Rd,Rn,ImmR,ImmS) +# define SBFX(Rd,Rn,ImmR,ImmS) oxxrs(A64_SBFX|XS,Rd,Rn,ImmR,ImmS) +# define UBFX(Rd,Rn,ImmR,ImmS) oxxrs(A64_UBFX|XS,Rd,Rn,ImmR,ImmS) # define CMP(Rn,Rm) oxx_(A64_CMP|XS,Rn,Rm) # define CMPI(Rn,Imm12) oxxi(A64_SUBSI|XS,XZR_REGNO,Rn,Imm12) # define CMPI_12(Rn,Imm12) oxxi(A64_SUBSI|XS|LSL_12,XZR_REGNO,Rn,Imm12) @@ -416,6 +426,9 @@ typedef union { # define ASRI(r0,r1,i0) SBFM(r0,r1,i0,63) # define LSR(Rd,Rn,Rm) oxxx(A64_LSR|XS,Rd,Rn,Rm) # define LSRI(r0,r1,i0) UBFM(r0,r1,i0,63) +# define RORV(Rd,Rn,Rm) oxxx(A64_RORV|XS,Rd,Rn,Rm) +# define EXTR(Rd,Rn,Rm,Im) oxxx6(A64_EXTR|XS|DS,Rm,Im,Rn,Rd) +# define ROR(Rd,Rn,Rm,Im) EXTR(Rd,Rn,Rm,Im) # define AND(Rd,Rn,Rm) oxxx(A64_AND|XS,Rd,Rn,Rm) /* actually should use oxxrs but logical_immediate returns proper encoding */ # define ANDI(Rd,Rn,Imm12) oxxi(A64_ANDI|XS,Rd,Rn,Imm12) @@ -428,8 +441,8 @@ typedef union { # define SXTB(Rd,Rn) SBFM(Rd,Rn,0,7) # define SXTH(Rd,Rn) SBFM(Rd,Rn,0,15) # define SXTW(Rd,Rn) SBFM(Rd,Rn,0,31) -# define UXTB(Rd,Rn) UBFX(Rd,Rn,0,7) -# define UXTH(Rd,Rn) UBFX(Rd,Rn,0,15) +# define UXTB(Rd,Rn) oxxrs(A64_UBFX & ~DS,Rd,Rn,0,7) +# define UXTH(Rd,Rn) oxxrs(A64_UBFX & ~DS,Rd,Rn,0,15) # define UXTW(Rd,Rm) ox_x(A64_UXTW,Rd,Rm) # define REV(Rd,Rn) o_xx(A64_REV,Rd,Rn) # define LDRSB(Rt,Rn,Rm) oxxx(A64_LDRSB,Rt,Rn,Rm) @@ -514,6 +527,9 @@ static void _oxxxc(jit_state_t*,jit_int32_t,jit_int32_t, # define oxxx7(Op,Rt,Rt2,Rn,Simm7) _oxxx7(_jit,Op,Rt,Rt2,Rn,Simm7) static void _oxxx7(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define oxxx6(Op,Rm,Imm6,Rn,Rd) _oxxx6(_jit,Op,Rm,Imm6,Rn,Rd) +static void _oxxx6(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define nop(i0) _nop(_jit,i0) static void _nop(jit_state_t*,jit_int32_t); # define addr(r0,r1,r2) ADD(r0,r1,r2) @@ -539,6 +555,12 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define mulr(r0,r1,r2) MUL(r0,r1,r2) # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0,r1,r2) SMULH(r0,r1,r2) +# define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0) +static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr_u(r0,r1,r2) UMULH(r0,r1,r2) +# define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0) +static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3) static void _qmulr(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); @@ -584,6 +606,31 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define rshr_u(r0,r1,r2) LSR(r0,r1,r2) # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3) +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2) +static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define lroti(r0,r1,i0) rroti(r0,r1,64-i0) +# define rrotr(r0,r1,r2) RORV(r0,r1,r2) +# define rroti(r0,r1,i0) ROR(r0,r1,r1,i0) # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2) static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2) @@ -598,6 +645,7 @@ static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +# define rbitr(r0, r1) RBIT(r0, r1) # define andr(r0,r1,r2) AND(r0,r1,r2) # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0) static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -657,6 +705,10 @@ static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define ldxr_l(r0,r1,r2) LDR(r0,r1,r2) # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0) static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr(r0, r1, i0) generic_unldr(r0, r1, i0) +# define unldi(r0, i0, i1) generic_unldi(r0, i0, i1) +# define unldr_u(r0, r1, i0) generic_unldr_u(r0, r1, i0) +# define unldi_u(r0, i0, i1) generic_unldi_u(r0, i0, i1) # define str_c(r0,r1) STRBI(r1,r0,0) # define sti_c(i0,r0) _sti_c(_jit,i0,r0) static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); @@ -681,11 +733,19 @@ static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); # define stxr_l(r0,r1,r2) STR(r2,r1,r0) # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1) static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +# define unstr(r0, r1, i0) generic_unstr(r0, r1, i0) +# define unsti(i0, r0, i1) generic_unsti(i0, r0, i1) # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1) static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ul(r0,r1) REV(r0,r1) +#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0,r1) SXTB(r0,r1) # define extr_uc(r0,r1) UXTB(r0,r1) # define extr_s(r0,r1) SXTH(r0,r1) @@ -1031,6 +1091,24 @@ _oxxx7(jit_state_t *_jit, jit_int32_t Op, ii(i.w); } +static void +_oxxx6(jit_state_t *_jit, jit_int32_t Op, + jit_int32_t Rm, jit_int32_t Imm6, jit_int32_t Rn, jit_int32_t Rd) +{ + instr_t i; + assert(!(Rm & ~0x1f)); + assert(!(Rn & ~0x1f)); + assert(!(Rd & ~0x1f)); + assert(Imm6 >= 0 && Imm6 <= 63); + assert(!(Op & ~0xffe0fc00)); + i.w = Op; + i.Rm.b = Rm; + i.imm6.b = Imm6; + i.Rn.b = Rn; + i.Rd.b = Rd; + ii(i.w); +} + static void _nop(jit_state_t *_jit, jit_int32_t i0) { @@ -1156,6 +1234,26 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + static void _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) @@ -1379,6 +1477,224 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + if (sign) + rshr(r1, t2, t0); + else + rshr_u(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + } + else { + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + /* zero? */ + movzr(r1, t0, t3); + /* Branchless but 4 bytes longer than branching fallback */ + if (sign) + movi(t0, 0); + /* overflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + if (sign) + rshr(r0, t2, t3); + else + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* underflow */ + if (sign) + rshi(r0, t2, __WORDSIZE - 1); + else + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + jit_unget_reg(s1); + } + else { + /* zero? */ + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + movzr(r1, t0, t3); + /* underflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + +static void +_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, 64); + rrotr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + rsbi(rn(reg), r2, 64); + rrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + static void _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { @@ -1393,6 +1709,53 @@ _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) CSEL(r0, r0, r1, CC_EQ); } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if ( i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + SBFX(r0, r1, i0, (i0 + i1) - 1); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + UBFX(r0, r1, i0, (i0 + i1) - 1); + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + BFM(r0, r1, -i0 & 63, i1 - 1); + } +} + static void _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_aarch64-fpu.c b/deps/lightning/lib/jit_aarch64-fpu.c index 3d17e324..51f40ce3 100644 --- a/deps/lightning/lib/jit_aarch64-fpu.c +++ b/deps/lightning/lib/jit_aarch64-fpu.c @@ -18,6 +18,8 @@ */ #if PROTO +# define A64_CNT 0x0e205800 +# define A64_ADDV 0x0e31b800 # define A64_SCVTF 0x1e220000 # define A64_FMOVWV 0x1e260000 # define A64_FMOVVW 0x1e270000 @@ -29,12 +31,18 @@ # define A64_FABS 0x1e20c000 # define A64_FNEG 0x1e214000 # define A64_FSQRT 0x1e21c000 +# define A64_FMADD 0x1f000000 +# define A64_FMSUB 0x1f008000 +# define A64_FNMADD 0x1f200000 +# define A64_FNMSUB 0x1f208000 # define A64_FCVTS 0x1e224000 # define A64_FCVTD 0x1e22c000 # define A64_FMUL 0x1e200800 # define A64_FDIV 0x1e201800 # define A64_FADD 0x1e202800 # define A64_FSUB 0x1e203800 +# define CNT(Rd,Rn) vqo_vv(0,A64_CNT,Rn,Rd) +# define ADDV(Rd,Rn) vqo_vv(0,A64_ADDV,Rn,Rd) # define FCMPES(Rn,Rm) os_vv(A64_FCMPE,0,Rn,Rm) # define FCMPED(Rn,Rm) os_vv(A64_FCMPE,1,Rn,Rm) # define FMOVS(Rd,Rn) osvv_(A64_FMOV,0,Rd,Rn) @@ -57,8 +65,21 @@ # define FNEGD(Rd,Rn) osvv_(A64_FNEG,1,Rd,Rn) # define FSQRTS(Rd,Rn) osvv_(A64_FSQRT,0,Rd,Rn) # define FSQRTD(Rd,Rn) osvv_(A64_FSQRT,1,Rd,Rn) +/* Vd = Va + Vn*Vm */ +# define FMADDS(Rd,Rn,Rm,Ra) osvvvv(A64_FMADD,0,Rd,Rn,Rm,Ra) +# define FMADDD(Rd,Rn,Rm,Ra) osvvvv(A64_FMADD,1,Rd,Rn,Rm,Ra) +/* Vd = Va + (-Vn)*Vm */ +# define FMSUBS(Rd,Rn,Rm,Ra) osvvvv(A64_FMSUB,0,Rd,Rn,Rm,Ra) +# define FMSUBD(Rd,Rn,Rm,Ra) osvvvv(A64_FMSUB,1,Rd,Rn,Rm,Ra) +/* Vd = (-Va) + (-Vn)*Vm */ +# define FNMADDS(Rd,Rn,Rm,Ra) osvvvv(A64_FNMADD,0,Rd,Rn,Rm,Ra) +# define FNMADDD(Rd,Rn,Rm,Ra) osvvvv(A64_FNMADD,1,Rd,Rn,Rm,Ra) +/* Vd = (-Va) + Vn*Vm */ +# define FNMSUBS(Rd,Rn,Rm,Ra) osvvvv(A64_FNMSUB,0,Rd,Rn,Rm,Ra) +# define FNMSUBD(Rd,Rn,Rm,Ra) osvvvv(A64_FNMSUB,1,Rd,Rn,Rm,Ra) # define FADDS(Rd,Rn,Rm) osvvv(A64_FADD,0,Rd,Rn,Rm) # define FADDD(Rd,Rn,Rm) osvvv(A64_FADD,1,Rd,Rn,Rm) +# define FADDV(Rd,Rn,Rm) osvvv(A64_FADD,0,Rd,Rn,Rm) # define FSUBS(Rd,Rn,Rm) osvvv(A64_FSUB,0,Rd,Rn,Rm) # define FSUBD(Rd,Rn,Rm) osvvv(A64_FSUB,1,Rd,Rn,Rm) # define FMULS(Rd,Rn,Rm) osvvv(A64_FMUL,0,Rd,Rn,Rm) @@ -68,12 +89,20 @@ # define osvvv(Op,Sz,Rd,Rn,Rm) _osvvv(_jit,Op,Sz,Rd,Rn,Rm) static void _osvvv(jit_state_t*,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); +# define osvvvv(Op,Sz,Rd,Rn,Rm,Ra) _osvvvv(_jit,Op,Sz,Rd,Rn,Rm,Ra) +static void _osvvvv(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define osvv_(Op,Sz,Rd,Rn) _osvv_(_jit,Op,Sz,Rd,Rn) static void _osvv_(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); # define os_vv(Op,Sz,Rn,Rm) _os_vv(_jit,Op,Sz,Rn,Rm) static void _os_vv(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); +# define vqo_vv(Q,Op,Rn,Rd) _vqo_vv(_jit,Q,Op,Rn,Rd) +static void _vqo_vv(jit_state_t*,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t); +# define popcntr(r0,r1) _popcntr(_jit,r0,r1); +static void _popcntr(jit_state_t*,jit_int32_t,jit_int32_t); # define truncr_f_i(r0,r1) _truncr_f_i(_jit,r0,r1) static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t); # define truncr_f_l(r0,r1) FCVTSZ_XS(r0,r1) @@ -98,6 +127,10 @@ static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t); # define absr_f(r0,r1) FABSS(r0,r1) # define negr_f(r0,r1) FNEGS(r0,r1) # define sqrtr_f(r0,r1) FSQRTS(r0,r1) +# define fmar_f(r0,r1,r2,r3) FMADDS(r0,r1,r2,r3) +# define fmsr_f(r0,r1,r2,r3) FNMSUBS(r0,r1,r2,r3) +# define fnmar_f(r0,r1,r2,r3) FNMADDS(r0,r1,r2,r3) +# define fnmsr_f(r0,r1,r2,r3) FMSUBS(r0,r1,r2,r3) # define extr_f(r0,r1) SCVTFS(r0,r1) # define ldr_f(r0,r1) _ldr_f(_jit,r0,r1) static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t); @@ -107,6 +140,8 @@ static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t); static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0) static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr_x(r0, r1, i0) generic_unldr_x(r0, r1, i0) +# define unldi_x(r0, i0, i1) generic_unldi_x(r0, i0, i1) # define str_f(r0,r1) _str_f(_jit,r0,r1) static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t); # define sti_f(i0,r0) _sti_f(_jit,i0,r0) @@ -115,10 +150,16 @@ static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1) static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +# define unstr_x(r0, r1, i0) generic_unstr_x(r0, r1, i0) +# define unsti_x(i0, r0, i1) generic_unsti_x(i0, r0, i1) # define movr_f(r0,r1) _movr_f(_jit,r0,r1) static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_f(r0,i0) _movi_f(_jit,r0,i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t); +# define movr_w_f(r0,r1) FMOVSW(r0, r1) +# define movr_f_w(r0,r1) FMOVWS(r0, r1) +# define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define extr_d_f(r0,r1) FCVT_SD(r0,r1) # define fccr(cc,r0,r1,r2) _fccr(_jit,cc,r0,r1,r2) static void _fccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); @@ -157,10 +198,10 @@ static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t); # define ordi_f(r0,r1,i0) fcci(CC_VC,r0,r1,i0) # define unordr_f(r0,r1,r2) fccr(CC_VS,r0,r1,r2) # define unordi_f(r0,r1,i0) fcci(CC_VS,r0,r1,i0) -#define fbccr(cc,i0,r0,r1) _fbccr(_jit,cc,i0,r0,r1) +# define fbccr(cc,i0,r0,r1) _fbccr(_jit,cc,i0,r0,r1) static jit_word_t _fbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t); -#define fbcci(cc,i0,r0,i1) _fbcci(_jit,cc,i0,r0,i1) +# define fbcci(cc,i0,r0,i1) _fbcci(_jit,cc,i0,r0,i1) static jit_word_t _fbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t); # define bltr_f(i0,r0,r1) fbccr(BCC_MI,i0,r0,r1) @@ -213,6 +254,10 @@ static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t); # define absr_d(r0,r1) FABSD(r0,r1) # define negr_d(r0,r1) FNEGD(r0,r1) # define sqrtr_d(r0,r1) FSQRTD(r0,r1) +# define fmar_d(r0,r1,r2,r3) FMADDD(r0,r1,r2,r3) +# define fmsr_d(r0,r1,r2,r3) FNMSUBD(r0,r1,r2,r3) +# define fnmar_d(r0,r1,r2,r3) FNMADDD(r0,r1,r2,r3) +# define fnmsr_d(r0,r1,r2,r3) FMSUBD(r0,r1,r2,r3) # define extr_d(r0,r1) SCVTFD(r0,r1) # define ldr_d(r0,r1) _ldr_d(_jit,r0,r1) static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t); @@ -234,6 +279,10 @@ static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_d(r0,i0) _movi_d(_jit,r0,i0) static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t); +# define movr_w_d(r0, r1) FMOVDX(r0, r1) +# define movr_d_w(r0, r1) FMOVXD(r0, r1) +#define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # define extr_f_d(r0,r1) FCVT_DS(r0,r1) # define dccr(cc,r0,r1,r2) _dccr(_jit,cc,r0,r1,r2) static void _dccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); @@ -272,10 +321,10 @@ static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t); # define ordi_d(r0,r1,i0) dcci(CC_VC,r0,r1,i0) # define unordr_d(r0,r1,r2) dccr(CC_VS,r0,r1,r2) # define unordi_d(r0,r1,i0) dcci(CC_VS,r0,r1,i0) -#define dbccr(cc,i0,r0,r1) _dbccr(_jit,cc,i0,r0,r1) +# define dbccr(cc,i0,r0,r1) _dbccr(_jit,cc,i0,r0,r1) static jit_word_t _dbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t); -#define dbcci(cc,i0,r0,i1) _dbcci(_jit,cc,i0,r0,i1) +# define dbcci(cc,i0,r0,i1) _dbcci(_jit,cc,i0,r0,i1) static jit_word_t _dbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t); # define bltr_d(i0,r0,r1) dbccr(BCC_MI,i0,r0,r1) @@ -333,6 +382,26 @@ _osvvv(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz, ii(i.w); } +static void +_osvvvv(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz, + jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm, jit_int32_t Ra) +{ + instr_t i; + assert(!(Rd & ~0x1f)); + assert(!(Rn & ~0x1f)); + assert(!(Rm & ~0x1f)); + assert(!(Ra & ~0x1f)); + assert(!(Sz & ~0x3)); + assert(!(Op & ~0xff208000)); + i.w = Op; + i.size.b = Sz; + i.Rd.b = Rd; + i.Rn.b = Rn; + i.Rm.b = Rm; + i.Ra.b = Ra; + ii(i.w); +} + static void _osvv_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz, jit_int32_t Rd, jit_int32_t Rn) @@ -365,6 +434,22 @@ _os_vv(jit_state_t *_jit, jit_int32_t Op, ii(i.w); } +static void +_vqo_vv(jit_state_t *_jit, jit_int32_t Q, + jit_int32_t Op, jit_int32_t Rn, jit_int32_t Rd) +{ + instr_t i; + assert(!(Rn & ~0x1f)); + assert(!(Rd & ~0x1f)); + assert(!(Q & ~0x1)); + assert(!(Op & ~0xbffffc00)); + i.w = Op; + i.Q.b = Q; + i.Rn.b = Rn; + i.Rd.b = Rd; + ii(i.w); +} + #define fopi(name) \ static void \ _##name##i_f(jit_state_t *_jit, \ @@ -412,6 +497,18 @@ _b##name##i_d(jit_state_t *_jit, \ return (word); \ } +static void +_popcntr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + FMOVDX(rn(reg), r1); + CNT(rn(reg), rn(reg)); + ADDV(rn(reg), rn(reg)); + FMOVXD(r0, rn(reg)); + jit_unget_reg(reg); +} + static void _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -539,6 +636,16 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) } } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + static void _fccr(jit_state_t *_jit, jit_int32_t cc, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -755,6 +862,16 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) } } +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); +} + static void _dccr(jit_state_t *_jit, jit_int32_t cc, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) diff --git a/deps/lightning/lib/jit_aarch64-sz.c b/deps/lightning/lib/jit_aarch64-sz.c index 3d1ea99a..435bbe95 100644 --- a/deps/lightning/lib/jit_aarch64-sz.c +++ b/deps/lightning/lib/jit_aarch64-sz.c @@ -4,7 +4,7 @@ #define JIT_INSTR_MAX 96 0, /* data */ 0, /* live */ - 12, /* align */ + 4, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -77,11 +77,11 @@ 12, /* remr_u */ 20, /* remi_u */ 4, /* andr */ - 20, /* andi */ + 4, /* andi */ 4, /* orr */ - 20, /* ori */ + 4, /* ori */ 4, /* xorr */ - 20, /* xori */ + 4, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -89,7 +89,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 8, /* ltr */ 8, /* lti */ 8, /* ltr_u */ @@ -117,17 +119,29 @@ 28, /* casr */ 36, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 4, /* exti_us */ 4, /* extr_i */ + 12, /* exti_i */ 4, /* extr_ui */ + 4, /* exti_ui */ 8, /* bswapr_us */ + 4, /* bswapi_us */ 8, /* bswapr_ui */ + 8, /* bswapi_ui */ 4, /* bswapr_ul */ + 16, /* bswapi_ul */ 8, /* htonr_us */ + 4, /* htoni_us */ 8, /* htonr_ui */ + 8, /* htoni_ui */ 4, /* htonr_ul */ + 16, /* htoni_ul */ 4, /* ldr_c */ 16, /* ldi_c */ 4, /* ldr_uc */ @@ -270,8 +284,11 @@ 4, /* divr_f */ 12, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 8, /* ltr_f */ 16, /* lti_f */ 8, /* ler_f */ @@ -361,8 +378,11 @@ 4, /* divr_d */ 12, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 8, /* ltr_d */ 16, /* lti_d */ 8, /* ler_d */ @@ -438,21 +458,80 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 4, /* movr_w_f */ + 8, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 4, /* movr_w_d */ + 8, /* movi_w_d */ + 4, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 12, /* cto */ - 8, /* ctz */ - + 4, /* movr_d_w */ + 4, /* movi_d_w */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 12, /* ctor */ + 4, /* ctoi */ + 8, /* ctzr */ + 4, /* ctzi */ + 4, /* rbitr */ + 16, /* rbiti */ + 16, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 4, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 52, /* qlshr_u */ + 8, /* qlshi_u */ + 52, /* qrshr */ + 8, /* qrshi */ + 52, /* qrshr_u */ + 8, /* qrshi_u */ + 24, /* unldr */ + 44, /* unldi */ + 24, /* unldr_u */ + 44, /* unldi_u */ + 20, /* unstr */ + 56, /* unsti */ + 8, /* unldr_x */ + 20, /* unldi_x */ + 8, /* unstr_x */ + 20, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 16, /* hmuli */ + 4, /* hmulr_u */ + 16, /* hmuli_u */ # else /* PACKED_STACK */ + #define JIT_INSTR_MAX 120 0, /* data */ 0, /* live */ @@ -493,9 +572,9 @@ 0, /* putargi_ui */ 0, /* putargr_l */ 0, /* putargi_l */ - 4, /* va_start */ - 8, /* va_arg */ - 12, /* va_arg_d */ + 44, /* va_start */ + 48, /* va_arg */ + 56, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ 20, /* addi */ @@ -529,11 +608,11 @@ 12, /* remr_u */ 20, /* remi_u */ 4, /* andr */ - 20, /* andi */ + 4, /* andi */ 4, /* orr */ - 20, /* ori */ + 4, /* ori */ 4, /* xorr */ - 20, /* xori */ + 4, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -541,7 +620,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 8, /* ltr */ 8, /* lti */ 8, /* ltr_u */ @@ -567,19 +648,31 @@ 8, /* movnr */ 8, /* movzr */ 28, /* casr */ - 36, /* casi */ + 40, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 4, /* exti_us */ 4, /* extr_i */ + 12, /* exti_i */ 4, /* extr_ui */ + 4, /* exti_ui */ 8, /* bswapr_us */ + 4, /* bswapi_us */ 8, /* bswapr_ui */ + 8, /* bswapi_ui */ 4, /* bswapr_ul */ + 16, /* bswapi_ul */ 8, /* htonr_us */ + 4, /* htoni_us */ 8, /* htonr_ui */ + 8, /* htoni_ui */ 4, /* htonr_ul */ + 16, /* htoni_ul */ 4, /* ldr_c */ 16, /* ldi_c */ 4, /* ldr_uc */ @@ -722,8 +815,11 @@ 4, /* divr_f */ 12, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 8, /* ltr_f */ 16, /* lti_f */ 8, /* ler_f */ @@ -813,8 +909,11 @@ 4, /* divr_d */ 12, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 8, /* ltr_d */ 16, /* lti_d */ 8, /* ler_d */ @@ -890,18 +989,77 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 4, /* movr_w_f */ + 8, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 4, /* movr_w_d */ + 8, /* movi_w_d */ + 4, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 12, /* cto */ - 8, /* ctz */ + 4, /* movr_d_w */ + 4, /* movi_d_w */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 12, /* ctor */ + 4, /* ctoi */ + 8, /* ctzr */ + 4, /* ctzi */ + 4, /* rbitr */ + 16, /* rbiti */ + 16, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 4, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 52, /* qlshr_u */ + 8, /* qlshi_u */ + 52, /* qrshr */ + 8, /* qrshi */ + 52, /* qrshr_u */ + 8, /* qrshi_u */ + 24, /* unldr */ + 44, /* unldi */ + 24, /* unldr_u */ + 44, /* unldi_u */ + 20, /* unstr */ + 56, /* unsti */ + 8, /* unldr_x */ + 20, /* unldi_x */ + 8, /* unstr_x */ + 20, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 16, /* hmuli */ + 4, /* hmulr_u */ + 16, /* hmuli_u */ # endif #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_aarch64.c b/deps/lightning/lib/jit_aarch64.c index 243e677c..bc788009 100644 --- a/deps/lightning/lib/jit_aarch64.c +++ b/deps/lightning/lib/jit_aarch64.c @@ -1297,6 +1297,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1420,6 +1426,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1438,16 +1448,30 @@ _emit_code(jit_state_t *_jit) case_rrw(rem, _u); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); + case_rr(popcnt,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1486,6 +1510,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _ui); case_rrr(ldx, _l); case_rrw(ldx, _l); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1502,12 +1538,30 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _i); case_rrr(stx, _l); case_wrr(stx, _l); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); case_rr(hton, _ul); case_rr(bswap, _us); case_rr(bswap, _ui); case_rr(bswap, _ul); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1614,15 +1668,31 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert_data(node); @@ -1697,6 +1767,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1870,6 +1944,30 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + movi_f_w(rn(node->u.w), node->v.f); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_d_w: + movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + movi_d_w(rn(node->u.w), node->v.d); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1937,6 +2035,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_alpha-cpu.c b/deps/lightning/lib/jit_alpha-cpu.c index 91d15c8c..b977214a 100644 --- a/deps/lightning/lib/jit_alpha-cpu.c +++ b/deps/lightning/lib/jit_alpha-cpu.c @@ -52,6 +52,14 @@ # define _s32_p(v) ((v) >= -0x80000000 && (v) <= 0x7fffffff) # define _u32_p(v) ((v) >= 0 && (v) <= 0xffffffff) # define ii(i) *_jit->pc.ui++ = i +# define ldr(r0,r1) ldr_l(r0,r1) +# define ldi(r0,i0) ldi_l(r0,i0) +# define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) +# define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) +# define str(r0,r1) str_l(r0,r1) +# define sti(i0,r0) sti_l(i0,r0) +# define stxr(r0,r1,r2) stxr_l(r0,r1,r2) +# define stxi(i0,r0,r1) stxi_l(i0,r0,r1) # define stack_framesize 224 # define _S0_REGNO 0x09 # define _S1_REGNO 0x0a @@ -326,6 +334,7 @@ static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctor(r0, r1) _ctor(_jit, r0, r1) static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) CTTZ(r1, r0) +# define popcntr(r0, r1) CTPOP(r1, r0) # define addr(r0,r1,r2) ADDQ(r1,r2,r0) # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0) static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -353,6 +362,10 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t, jit_word_t); # define mulr(r0,r1,r2) MULQ(r1,r2,r0) # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2) +# define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0) +# define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2) +# define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0) # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3) static void _qmulr(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); @@ -408,6 +421,26 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define rshr_u(r0,r1,r2) SRL(r1,r2,r0) # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3) +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); # define andr(r0,r1,r2) AND(r1,r2,r0) # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0) static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -559,7 +592,6 @@ static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t); static void _ldr_ui(jit_state_t*,jit_int32_t,jit_int32_t); # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0) static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t); -# define ldr(r0,r1) ldr_l(r0,r1) # define ldr_l(r0,r1) LDQ(r0,r1,0) # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0) static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t); @@ -587,12 +619,18 @@ static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0) static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); -# define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) # define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2) static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); -# define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0) static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_c(r0,r1) STB(r1,r0,0) # define sti_c(i0,r0) _sti_c(_jit,i0,r0) static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); @@ -602,7 +640,6 @@ static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t); # define str_i(r0,r1) STL(r1,r0,0) # define sti_i(i0,r0) _sti_i(_jit,i0,r0) static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t); -# define str(r0,r1) str_l(r0,r1) # define str_l(r0,r1) STQ(r1,r0,0) # define sti_l(i0,r0) _sti_l(_jit,i0,r0) static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t); @@ -623,18 +660,23 @@ static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi(i0,r0,r1) stxi_l(i0,r0,r1) # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1) static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); -# define extr_c(r0,r1) _extr_c(_jit,r0,r1) -static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t); -# define extr_uc(r0,r1) _extr_uc(_jit,r0,r1) -static void _extr_uc(jit_state_t*,jit_int32_t,jit_int32_t); -# define extr_s(r0,r1) _extr_s(_jit,r0,r1) -static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t); -# define extr_us(r0,r1) _extr_us(_jit,r0,r1) -static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t); +# define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); +# define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_c(r0,r1) SEXTB(r1, r0) +# define extr_uc(r0,r1) EXTBLi(r1, 0, r0) +# define extr_s(r0,r1) SEXTW(r1, r0) +# define extr_us(r0,r1) EXTWLi(r1, 0, r0) # define extr_i(r0,r1) _extr_i(_jit,r0,r1) static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t); -# define extr_ui(r0,r1) _extr_ui(_jit,r0,r1) -static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t); +# define extr_ui(r0,r1) EXTLLi(r1, 0, r0) # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1) static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) @@ -1044,14 +1086,14 @@ _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t reg; /* The only invalid condition is r0 == r1 */ jit_int32_t t2, t3, s2, s3; - if (r2 == r0 || r2 == r1) { + if ((r0 != JIT_NOREG && r2 == r0) || r2 == r1) { s2 = jit_get_reg(jit_class_gpr); t2 = rn(s2); movr(t2, r2); } else t2 = r2; - if (r3 == r0 || r3 == r1) { + if ((r0 != JIT_NOREG && r3 == r0) || r3 == r1) { s3 = jit_get_reg(jit_class_gpr); t3 = rn(s3); movr(t3, r3); @@ -1091,16 +1133,20 @@ _qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) { jit_int32_t reg; - if (r0 == r2 || r0 == r3) { - reg = jit_get_reg(jit_class_gpr); - mulr(rn(reg), r2, r3); + if (r0 != JIT_NOREG) { + if (r0 == r2 || r0 == r3) { + reg = jit_get_reg(jit_class_gpr); + mulr(rn(reg), r2, r3); + } + else + mulr(r0, r2, r3); } - else - mulr(r0, r2, r3); UMULH(r2, r3, r1); - if (r0 == r2 || r0 == r3) { - movr(r0, rn(reg)); - jit_unget_reg(reg); + if (r0 != JIT_NOREG) { + if (r0 == r2 || r0 == r3) { + movr(r0, rn(reg)); + jit_unget_reg(reg); + } } } @@ -1110,16 +1156,20 @@ _qmuli_u(jit_state_t *_jit, jit_int32_t r0, { jit_int32_t reg; if (_u8_p(i0)) { - if (r0 == r2) { - reg = jit_get_reg(jit_class_gpr); - muli(rn(reg), r2, i0); + if (r0 != JIT_NOREG) { + if (r0 == r2) { + reg = jit_get_reg(jit_class_gpr); + muli(rn(reg), r2, i0); + } + else + muli(r0, r2, i0); } - else - muli(r0, r2, i0); UMULHi(r2, i0, r1); - if (r0 == r2) { - movr(r0, rn(reg)); - jit_unget_reg(reg); + if (r0 != JIT_NOREG) { + if (r0 == r2) { + movr(r0, rn(reg)); + jit_unget_reg(reg); + } } } else { @@ -1309,17 +1359,240 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) SRLi(r1, i0, r0); } +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + if (sign) + rshr(r1, t2, t0); + else + rshr_u(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + } + else { + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + /* zero? */ + movzr(r1, t0, t3); + /* Branchless but 4 bytes longer than branching fallback */ + if (sign) + movi(t0, 0); + /* overflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + if (sign) + rshr(r0, t2, t3); + else + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* underflow */ + if (sign) + rshi(r0, t2, __WORDSIZE - 1); + else + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + jit_unget_reg(s1); + } + else { + /* zero? */ + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + movzr(r1, t0, t3); + /* underflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + static void _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { - jit_int32_t reg; + union { + jit_uword_t uw; + jit_uint8_t uc[8]; + } u; + jit_int32_t reg, zapnot; if (_u8_p(i0)) ANDi(r1, i0, r0); else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), i0); - andr(r0, r1, rn(reg)); - jit_unget_reg(reg); + u.uw = i0; + for (reg = zapnot = 0; reg < 8; ++reg) { +# if __BYTE_ORDER == __LITTLE_ENDIAN +# define OFFS(i) (i) +# else +# define OFFS(i) (7 - (i)) +# endif + if (u.uc[OFFS(reg)] == 0xff) + zapnot |= 1 << reg; + else if (u.uc[OFFS(reg)] != 0) + break; +# undef OFFS + } + if (reg == 8) + ZAPNOTi(r1, zapnot, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + andr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } } } @@ -2307,6 +2580,161 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2, t1, r3; + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 == 1) + ldr_c(r0, r1); + else { + t0 = jit_get_reg(jit_class_gpr); r2 = rn(t0); + t1 = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + r3 = rn(t1); + movr(r3, r1); + } + else + r3 = r1; + LDQ_U(r0, r3, 0); + LDQ_U(r2, r3, 7); + if (r0 == r1) { +#if __BYTE_ORDER == __LITTLE_ENDIAN + LDA(r3, r3, 0); +#else + LDA(r3, r3, 7); +#endif + } + else { + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + LDA(r3, r1, 0); +#else + LDA(r3, r1, 7); +#endif + } + EXTQL(r0, r3, r0); + EXTQH(r2, r3, r2); + OR(r2, r0, r0); + jit_unget_reg(t1); + jit_unget_reg(t0); + switch (i0) { + case 2: + extr_s(r0, r0); + break; + case 3: + lshi(r0, r0, __WORDSIZE - 24); + rshi(r0, r0, __WORDSIZE - 24); + break; + case 4: + extr_i(r0, r0); + break; + case 5: + lshi(r0, r0, __WORDSIZE - 40); + rshi(r0, r0, __WORDSIZE - 40); + break; + case 6: + lshi(r0, r0, __WORDSIZE - 48); + rshi(r0, r0, __WORDSIZE - 48); + break; + case 7: + lshi(r0, r0, __WORDSIZE - 56); + rshi(r0, r0, __WORDSIZE - 56); + break; + default: + break; + } + } +} + +/* Slightly shorter than fallback, and branchless */ +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + unldr(r0, rn(reg), i1); + jit_unget_reg(reg); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2, t1, r3; + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 == 1) + ldr_uc(r0, r1); + else { + t0 = jit_get_reg(jit_class_gpr); r2 = rn(t0); + t1 = jit_get_reg(jit_class_gpr); + if (r0 == r1) { + r3 = rn(t1); + movr(r3, r1); + } + else + r3 = r1; + LDQ_U(r0, r3, 0); + LDQ_U(r2, r3, 7); + if (r0 == r1) { +#if __BYTE_ORDER == __LITTLE_ENDIAN + LDA(r3, r3, 0); +#else + LDA(r3, r3, 7); +#endif + } + else { + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + LDA(r3, r1, 0); +#else + LDA(r3, r1, 7); +#endif + } + EXTQL(r0, r3, r0); + EXTQH(r2, r3, r2); + OR(r2, r0, r0); + jit_unget_reg(t1); + jit_unget_reg(t0); + switch (i0) { + case 2: + extr_us(r0, r0); + break; + case 3: + lshi(r0, r0, __WORDSIZE - 24); + rshi_u(r0, r0, __WORDSIZE - 24); + break; + case 4: + extr_ui(r0, r0); + break; + case 5: + lshi(r0, r0, __WORDSIZE - 40); + rshi_u(r0, r0, __WORDSIZE - 40); + break; + case 6: + lshi(r0, r0, __WORDSIZE - 48); + rshi_u(r0, r0, __WORDSIZE - 48); + break; + case 7: + lshi(r0, r0, __WORDSIZE - 56); + rshi_u(r0, r0, __WORDSIZE - 56); + break; + default: + break; + } + } +} + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + unldr_u(r0, rn(reg), i1); + jit_unget_reg(reg); +} + static void _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -2460,45 +2888,168 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } static void -_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { - lshi(r0, r1, 56); - rshi(r0, r0, 56); + jit_word_t t0, t1, t2, t3, t4, r2, r3, r4, r5, r6; + assert(i0 > 0 && i0 <= sizeof(jit_word_t)); + if (i0 == 1) + str_c(r0, r1); + else if (i0 == 4 || i0 == 8) { + t0 = jit_get_reg(jit_class_gpr); r2 = rn(t0); + t1 = jit_get_reg(jit_class_gpr); r3 = rn(t1); + t2 = jit_get_reg(jit_class_gpr); r4 = rn(t2); + t3 = jit_get_reg(jit_class_gpr); r5 = rn(t3); + t4 = jit_get_reg(jit_class_gpr); r6 = rn(t4); +#if __BYTE_ORDER == __LITTLE_ENDIAN + LDA(r4, r0, 0); /* r4<2:0> = (X mod 8) = 5 */ +#else + LDA(r4, r0, i0 - 1); /* r4<2:0> = ((X+7) mod 8) = 5 */ +#endif + LDQ_U(r2, r0, i0 - 1); /* Ignores va<2:0>, r2 = yyyH GFED + or (if i0 == 4) + r2 = yyyy yyyD */ + LDQ_U(r3, r0, 0); /* Ignores va<2:0>, r3 = CBAx xxxx */ + if (i0 == 8) { + INSQH(r1, r4, r5); /* r5 = 000H GFED */ + INSQL(r1, r4, r6); /* r6 = CBA0 0000 */ + MSKQH(r2, r4, r2); /* r2 = yyy0 0000 */ + MSKQL(r3, r4, r3); /* r3 = 000x xxxx */ + } + else { + INSLH(r1, r4, r5); /* r5 = 0000 000D */ + INSLL(r1, r4, r6); /* r6 = CBA0 0000 */ + MSKLH(r2, r4, r2); /* r2 = yyy0 0000 */ + MSKLL(r3, r4, r3); /* r3 = 000x xxxx */ + } + OR(r2, r5, r2); /* r2 = yyyH GFED (or yyyy yyyD) */ + OR(r3, r6, r3); /* r1 = CBAx xxxx */ + STQ_U(r2, r0, i0 - 1); /* Must store high then low for */ + STQ_U(r3, r0, 0); /* degenerate case of aligned QW */ + jit_unget_reg(t4); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); + } + else + fallback_unstr(r0, r1, i0); } static void -_extr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) { - lshi(r0, r1, 56); - rshi_u(r0, r0, 56); + jit_int32_t reg; + if (i1 == 4 || i1 == 8) { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + unstr(rn(reg), r0, i1); + jit_unget_reg(reg); + } + else + fallback_unsti(i0, r0, i1); } static void -_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) { - lshi(r0, r1, 48); - rshi(r0, r0, 48); + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } } static void -_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) { - lshi(r0, r1, 48); - rshi_u(r0, r0, 48); + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if ((i0 & 7) == 0) { + if (i1 == 8) { + EXTBLi(r1, i0 >> 3, r0); + goto done; + } + if (i1 == 16) { + EXTWLi(r1, i0 >> 3, r0); + goto done; + } + if (i1 == 32) { + EXTLLi(r1, i0 >> 3, r0); + goto done; + } + } + if (i0) + rshi_u(r0, r1, i0); + andi(r0, r0, (1L << i1) - 1); + } +done:; } static void -_extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) { - lshi(r0, r1, 32); - rshi(r0, r0, 32); + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + t0 = jit_get_reg(jit_class_gpr); + if ((i0 & 7) == 0) { + if (i1 == 8) { + MSKBLi(r0, i0 >> 3, rn(t0)); + INSBLi(r1, i0 >> 3, r0); + goto done; + } + if (i1 == 16) { + MSKWLi(r0, i0 >> 3, rn(t0)); + INSWLi(r1, i0 >> 3, r0); + goto done; + } + if (i1 == 32) { + MSKLLi(r0, i0 >> 3, rn(t0)); + INSLLi(r1, i0 >> 3, r0); + goto done; + } + } + mask = (1L << i1) - 1; + andi(rn(t0), r1, mask); + if (i0) { + lshi(rn(t0), rn(t0), i0); + mask <<= i0; + } + andi(r0, r0, ~mask); + done: + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } } static void -_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { lshi(r0, r1, 32); - rshi_u(r0, r0, 32); + rshi(r0, r0, 32); } static void diff --git a/deps/lightning/lib/jit_alpha-fpu.c b/deps/lightning/lib/jit_alpha-fpu.c index 83736b77..9e4d0dc1 100644 --- a/deps/lightning/lib/jit_alpha-fpu.c +++ b/deps/lightning/lib/jit_alpha-fpu.c @@ -303,16 +303,44 @@ static void _Opr(jit_state_t*,int,int,int,unsigned int,int); static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_f(r0,i0) _movi_f(_jit,r0,i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); +# define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define movi_d(r0,i0) _movi_d(_jit,r0,i0) static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); +# define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # define absr_f(r0,r1) FABS(r1,r0) # define absr_d(r0,r1) FABS(r1,r0) # define negr_f(r0,r1) FNEGS(r1,r0) # define negr_d(r0,r1) FNEGT(r1,r0) # define sqrtr_f(r0,r1) _sqrtr_f(_jit,r0,r1) static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t); +# define fmar_f(r0,r1,r2,r3) _fmar_f(_jit,r0,r1,r2,r3) +static void _fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fmsr_f(r0,r1,r2,r3) _fmsr_f(_jit,r0,r1,r2,r3) +static void _fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmar_f(r0,r1,r2,r3) _fnmar_f(_jit,r0,r1,r2,r3) +static void _fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmsr_f(r0,r1,r2,r3) _fnmsr_f(_jit,r0,r1,r2,r3) +static void _fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define sqrtr_d(r0,r1) _sqrtr_d(_jit,r0,r1) static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t); +# define fmar_d(r0,r1,r2,r3) _fmar_d(_jit,r0,r1,r2,r3) +static void _fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fmsr_d(r0,r1,r2,r3) _fmsr_d(_jit,r0,r1,r2,r3) +static void _fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmar_d(r0,r1,r2,r3) _fnmar_d(_jit,r0,r1,r2,r3) +static void _fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmsr_d(r0,r1,r2,r3) _fnmsr_d(_jit,r0,r1,r2,r3) +static void _fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define extr_f_d(r0,r1) movr_d(r0,r1) # define extr_d_f(r0,r1) movr_f(r0,r1) # define truncr_f_i(r0,r1) truncr_d_i(r0,r1) @@ -648,6 +676,17 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) ldi_f(r0, (jit_word_t)i0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi_i(-8, _FP_REGNO, rn(reg)); + jit_unget_reg(reg); + ldxi_f(r0, _FP_REGNO, -8); +} + static void _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) { @@ -669,6 +708,17 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) ldi_d(r0, (jit_word_t)i0); } +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi(-8, _FP_REGNO, rn(reg)); + jit_unget_reg(reg); + ldxi_d(r0, _FP_REGNO, -8); +} + static void _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -688,6 +738,65 @@ _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) TRAPB(); } + +static void +_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + mulr_f(r0, r1, r2); + addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_f(rn(t0), r1, r2); + addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + mulr_f(r0, r1, r2); + subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_f(rn(t0), r1, r2); + subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -695,6 +804,64 @@ _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) TRAPB(); } +static void +_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + mulr_d(r0, r1, r2); + addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_d(rn(t0), r1, r2); + addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + mulr_d(r0, r1, r2); + subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_d(rn(t0), r1, r2); + subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_alpha-sz.c b/deps/lightning/lib/jit_alpha-sz.c index 14949b25..fd39c0dd 100644 --- a/deps/lightning/lib/jit_alpha-sz.c +++ b/deps/lightning/lib/jit_alpha-sz.c @@ -1,8 +1,8 @@ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 88 +#define JIT_INSTR_MAX 140 0, /* data */ 0, /* live */ - 12, /* align */ + 4, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -87,7 +87,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 4, /* ltr */ 4, /* lti */ 4, /* ltr_u */ @@ -114,44 +116,56 @@ 4, /* movzr */ 32, /* casr */ 60, /* casi */ - 8, /* extr_c */ - 8, /* extr_uc */ - 8, /* extr_s */ - 8, /* extr_us */ + 4, /* extr_c */ + 4, /* exti_c */ + 4, /* extr_uc */ + 4, /* exti_uc */ + 4, /* extr_s */ + 4, /* exti_s */ + 4, /* extr_us */ + 16, /* exti_us */ 8, /* extr_i */ - 8, /* extr_ui */ + 28, /* exti_i */ + 4, /* extr_ui */ + 16, /* exti_ui */ 16, /* bswapr_us */ + 4, /* bswapi_us */ 36, /* bswapr_ui */ + 16, /* bswapi_ui */ 36, /* bswapr_ul */ + 32, /* bswapi_ul */ 16, /* htonr_us */ + 16, /* htoni_us */ 36, /* htonr_ui */ + 16, /* htoni_ui */ 36, /* htonr_ul */ - 12, /* ldr_c */ - 40, /* ldi_c */ + 32, /* htoni_ul */ + 8, /* ldr_c */ + 36, /* ldi_c */ 4, /* ldr_uc */ 32, /* ldi_uc */ - 12, /* ldr_s */ - 40, /* ldi_s */ + 8, /* ldr_s */ + 36, /* ldi_s */ 4, /* ldr_us */ 32, /* ldi_us */ 4, /* ldr_i */ 32, /* ldi_i */ - 12, /* ldr_ui */ - 40, /* ldi_ui */ + 8, /* ldr_ui */ + 36, /* ldi_ui */ 4, /* ldr_l */ 32, /* ldi_l */ - 16, /* ldxr_c */ - 44, /* ldxi_c */ + 12, /* ldxr_c */ + 40, /* ldxi_c */ 8, /* ldxr_uc */ 36, /* ldxi_uc */ - 16, /* ldxr_s */ - 44, /* ldxi_s */ + 12, /* ldxr_s */ + 40, /* ldxi_s */ 8, /* ldxr_us */ 36, /* ldxi_us */ 8, /* ldxr_i */ 36, /* ldxi_i */ - 16, /* ldxr_ui */ - 44, /* ldxi_ui */ + 12, /* ldxr_ui */ + 40, /* ldxi_ui */ 8, /* ldxr_l */ 36, /* ldxi_l */ 4, /* str_c */ @@ -189,7 +203,7 @@ 8, /* bgtr_u */ 12, /* bgti_u */ 8, /* bner */ - 36, /* bnei */ + 40, /* bnei */ 8, /* bmsr */ 8, /* bmsi */ 8, /* bmcr */ @@ -211,7 +225,7 @@ 16, /* bxsubr_u */ 16, /* bxsubi_u */ 4, /* jmpr */ - 4, /* jmpi */ + 36, /* jmpi */ 8, /* callr */ 36, /* calli */ 0, /* prepare */ @@ -268,8 +282,11 @@ 8, /* divr_f */ 40, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 8, /* sqrtr_f */ + 0, /* sqrti_f */ 32, /* ltr_f */ 64, /* lti_f */ 32, /* ler_f */ @@ -359,8 +376,11 @@ 8, /* divr_d */ 40, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 8, /* sqrtr_d */ + 0, /* sqrti_d */ 32, /* ltr_d */ 64, /* lti_d */ 32, /* ler_d */ @@ -436,17 +456,76 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 8, /* movr_w_f */ + 24, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 8, /* movr_w_d */ + 20, /* movi_w_d */ + 8, /* movr_f_w */ + 16, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 8, /* cto */ - 4, /* ctz */ + 8, /* movr_d_w */ + 12, /* movi_d_w */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 8, /* ctor */ + 4, /* ctoi */ + 4, /* ctzr */ + 4, /* ctzi */ + 84, /* rbitr */ + 32, /* rbiti */ + 4, /* popcntr */ + 4, /* popcnti */ + 20, /* lrotr */ + 12, /* lroti */ + 20, /* rrotr */ + 12, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 36, /* extr_u */ + 4, /* exti_u */ + 72, /* depr */ + 24, /* depi */ + 44, /* qlshr */ + 8, /* qlshi */ + 40, /* qlshr_u */ + 8, /* qlshi_u */ + 40, /* qrshr */ + 8, /* qrshi */ + 40, /* qrshr_u */ + 8, /* qrshi_u */ + 36, /* unldr */ + 60, /* unldi */ + 36, /* unldr_u */ + 60, /* unldi_u */ + 120, /* unstr */ + 140, /* unsti */ + 40, /* unldr_x */ + 68, /* unldi_x */ + 52, /* unstr_x */ + 80, /* unsti_x */ + 16, /* fmar_f */ + 0, /* fmai_f */ + 16, /* fmsr_f */ + 0, /* fmsi_f */ + 16, /* fmar_d */ + 0, /* fmai_d */ + 16, /* fmsr_d */ + 0, /* fmsi_d */ + 20, /* fnmar_f */ + 0, /* fnmai_f */ + 20, /* fnmsr_f */ + 0, /* fnmsi_f */ + 20, /* fnmar_d */ + 0, /* fnmai_d */ + 20, /* fnmsr_d */ + 0, /* fnmsi_d */ + 36, /* hmulr */ + 60, /* hmuli */ + 4, /* hmulr_u */ + 28, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_alpha.c b/deps/lightning/lib/jit_alpha.c index 25566f41..69bf397f 100644 --- a/deps/lightning/lib/jit_alpha.c +++ b/deps/lightning/lib/jit_alpha.c @@ -64,6 +64,7 @@ static void _patch(jit_state_t*,jit_word_t,jit_node_t*); #define PROTO 1 # include "jit_alpha-cpu.c" # include "jit_alpha-fpu.c" +# include "jit_fallback.c" #undef PROTO /* @@ -172,7 +173,7 @@ _jit_prolog(jit_state_t *_jit) _jitc->function->self.size = stack_framesize; _jitc->function->self.argi = _jitc->function->self.alen = 0; /* float conversion */ - _jitc->function->self.aoff = -8; + _jitc->function->self.aoff = _jitc->function->cvt_offset = -8; _jitc->function->self.call = jit_call_default; jit_alloc((jit_pointer_t *)&_jitc->function->regoff, _jitc->reglen * sizeof(jit_int32_t)); @@ -910,6 +911,12 @@ _emit_code(jit_state_t *_jit) name##i##type(rn(node->u.w), rn(node->v.w), \ (jit_float##size##_t *)node->w.n->u.w); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrrr(name, type) \ case jit_code_##name##r##type: \ name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ @@ -1012,6 +1019,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1030,10 +1041,26 @@ _emit_code(jit_state_t *_jit) case_rrw(rem, _u); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); +#define lrotr(r0,r1,r2) fallback_lrotr(r0,r1,r2) +#define lroti(r0,r1,i0) fallback_lroti(r0,r1,i0) +#define rrotr(r0,r1,r2) fallback_rrotr(r0,r1,r2) +#define rroti(r0,r1,i0) fallback_rroti(r0,r1,i0) + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1072,6 +1099,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _ui); case_rrr(ldx, _l); case_rrw(ldx, _l); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1088,12 +1127,30 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _i); case_rrr(stx, _l); case_wrr(stx, _l); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); case_rr(hton, _ul); case_rr(bswap, _us); case_rr(bswap, _ui); case_rr(bswap, _ul); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1134,6 +1191,9 @@ _emit_code(jit_state_t *_jit) case_rr(clz,); case_rr(cto,); case_rr(ctz,); +#define rbitr(r0, r1) fallback_rbit(r0, r1) + case_rr(rbit,); + case_rr(popcnt,); case_rrr(lt,); case_rrw(lt,); case_rrr(lt, _u); @@ -1206,15 +1266,39 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); +#define unldr_x(r0, r1, i0) fallback_unldr_x(r0, r1, i0) + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_x(r0, i0, i1) fallback_unldi_x(r0, i0, i1) + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); + /* Cost of loading, masking, oring, etc to use STQ_U is + * too high. Could be branchless for doubles, but would + * generate larger code, and speed for unaligned double + * store is not so important; just support it. */ +#define unstr_x(r0, r1, i0) fallback_unstr_x(r0, r1, i0) + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti_x(i0, r0, i1) fallback_unsti_x(i0, r0, i1) + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert(node->flag & jit_flag_data); @@ -1289,6 +1373,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1448,6 +1536,32 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; + case jit_code_movr_d_w: + movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1504,6 +1618,75 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); @@ -1555,6 +1738,7 @@ _emit_code(jit_state_t *_jit) #define CODE 1 # include "jit_alpha-cpu.c" # include "jit_alpha-fpu.c" +# include "jit_fallback.c" #undef CODE void diff --git a/deps/lightning/lib/jit_arm-cpu.c b/deps/lightning/lib/jit_arm-cpu.c index a0852a2c..149db9ab 100644 --- a/deps/lightning/lib/jit_arm-cpu.c +++ b/deps/lightning/lib/jit_arm-cpu.c @@ -18,9 +18,16 @@ */ #if PROTO -# define stxi(i0,r0,r1) stxi_i(i0,r0,r1) -# define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0) +# define jit_unaligned_p() (jit_cpu.unaligned) +# define jit_vfp_unaligned_p() (jit_cpu.vfp_unaligned) # define ldr(r0,r1) ldr_i(r0,r1) +# define ldi(r0,i0) ldi_i(r0,i0) +# define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2) +# define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0) +# define str(r0,r1) str_i(r0,r1) +# define sti(i0,r0) sti_i(i0,r0) +# define stxr(r0,r1,r2) stxr_i(r0,r1,r2) +# define stxi(i0,r0,r1) stxi_i(i0,r0,r1) # define _s20P(d) ((d) >= -(int)0x80000 && d <= 0x7ffff) # define _s24P(d) ((d) >= -(int)0x800000 && d <= 0x7fffff) # define _u3(v) ((v) & 0x7) @@ -192,6 +199,12 @@ extern unsigned __aeabi_uidivmod(unsigned, unsigned); # define THUMB2_CLZ 0xfab0f080 # define THUMB2_RBIT 0xfa90f0a0 # define ARM_RBIT 0x06f00030 +# define THUMB2_SBFX 0xf3400000 +# define ARM_SBFX 0x07a00050 +# define THUMB2_UBFX 0xf3c00000 +# define ARM_UBFX 0x07e00050 +# define THUMB2_BFI 0xf3600000 +# define ARM_BFI 0x07c00010 /* << ARMv6t2 */ # define ARM_CLZ 0x01600010 /* >> ARMv7 */ @@ -224,6 +237,9 @@ extern unsigned __aeabi_uidivmod(unsigned, unsigned); # define THUMB_ASRI 0x1000 # define THUMB2_ASRI 0xea4f0020 # define ARM_ROR 0x00000060 +# define THUMB_ROR 0x41c0 +# define THUMB2_ROR 0xfa60f000 +# define THUMB2_RORI 0xea4f0030 # define ARM_CMP 0x01500000 # define THUMB_CMP 0x4280 # define THUMB_CMPX 0x4500 @@ -456,6 +472,19 @@ static void _tdmb(jit_state_t *_jit, int im); # define NOT(rd,rm) CC_NOT(ARM_CC_AL,rd,rm) # define T1_NOT(rd,rm) T1_MVN(rd,rm) # define T2_NOT(rd,rm) T2_MVN(rd,rm) +# define torrlw(o,rd,rn,lsb,wm1) _torrlw(_jit,o,rd,rn,lsb,wm1) +static void _torrlw(jit_state_t*,int,int,int,int,int); +# define corrlw(cc,o,rd,rn,lsb,wm1) _corrlw(_jit,cc,o,rd,rn,lsb,wm1) +static void _corrlw(jit_state_t*,int,int,int,int,int,int); +# define T2_SBFX(rd,rn,lsb,wm1) torrlw(THUMB2_SBFX,rd,rn,lsb,wm1) +# define CC_SBFX(cc,o,rd,rn,lsb,wm1) corrlw(cc,o,rd,rn,lsb,wm1) +# define SBFX(rd,rn,lsb,wm1) CC_SBFX(ARM_CC_AL,ARM_SBFX,rd,rn,lsb,wm1) +# define T2_UBFX(rd,rn,lsb,wm1) torrlw(THUMB2_UBFX,rd,rn,lsb,wm1) +# define CC_UBFX(cc,rd,rn,lsb,wm1) corrlw(cc,o,rd,rn,lsb,wm1) +# define UBFX(rd,rn,lsb,wm1) CC_SBFX(ARM_CC_AL,ARM_UBFX,rd,rn,lsb,wm1) +# define T2_BFI(rd,rn,lsb,wm1) torrlw(THUMB2_BFI,rd,rn,lsb,wm1) +# define CC_BFI(cc,rd,rn,lsb,wm1) corrlw(cc,o,rd,rn,lsb,wm1) +# define BFI(rd,rn,lsb,wm1) CC_SBFX(ARM_CC_AL,ARM_BFI,rd,rn,lsb,wm1) # define T2_CLZ(rd,rm) torrr(THUMB2_CLZ,rm,rd,rm) # define CC_CLZ(cc,rd,rm) corrrr(cc,ARM_CLZ,_R15_REGNO,rd,_R15_REGNO,rm) # define CLZ(rd,rm) CC_CLZ(ARM_CC_AL,rd,rm) @@ -637,6 +666,13 @@ static void _tdmb(jit_state_t *_jit, int im); # define ASRI(rd,rn,im) CC_ASRI(ARM_CC_AL,rd,rn,im) # define T1_ASRI(rd,rm,im) is(THUMB_ASRI|(_u5(im)<<6)|(_u3(rm)<<3)|_u3(rd)) # define T2_ASRI(rd,rm,im) tshift(THUMB2_ASRI,rd,rm,im) +# define CC_ROR(cc,rd,rn,rm) CC_SHIFT(cc,ARM_ROR|ARM_R,rd,rm,rn,0) +# define ROR(rd,rn,rm) CC_ROR(ARM_CC_AL,rd,rn,rm) +# define T1_ROR(rdn,rm) is(THUMB_ROR|(_u3(rm)<<3)|_u3(rdn)) +# define T2_ROR(rd,rn,rm) torrr(THUMB2_ROR,rn,rd,rm) +# define CC_RORI(cc,rd,rn,im) CC_SHIFT(cc,ARM_ROR,rd,0,rn,im) +# define RORI(rd,rn,im) CC_RORI(ARM_CC_AL,rd,rn,im) +# define T2_RORI(rd,rm,im) tshift(THUMB2_RORI,rd,rm,im) # define CC_CMP(cc,rn,rm) corrr(cc,ARM_CMP,rn,0,rm) # define CMP(rn,rm) CC_CMP(ARM_CC_AL,rn,rm) # define T1_CMP(rn,rm) is(THUMB_CMP|(_u3(rm)<<3)|_u3(rn)) @@ -914,6 +950,10 @@ static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +# define rbitr(r0, r1) _rbitr(_jit, r0, r1) +static void _rbitr(jit_state_t*, jit_int32_t, jit_int32_t); +# define popcntr(r0, r1) _popcntr(_jit, r0, r1) +static void _popcntr(jit_state_t*, jit_int32_t, jit_int32_t); # define addr(r0,r1,r2) _addr(_jit,r0,r1,r2) static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0) @@ -944,6 +984,16 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0,r1,r2) ihmulr(r0,r1,r2,1) +# define hmulr_u(r0,r1,r2) ihmulr(r0,r1,r2,0) +# define ihmulr(r0,r1,r2,cc) _ihmulr(_jit,r0,r1,r2,cc) +static void _ihmulr(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t,jit_bool_t); +# define hmuli(r0,r1,i0) ihmuli(r0,r1,i0,1) +# define hmuli_u(r0,r1,i0) ihmuli(r0,r1,i0,0) +# define ihmuli(r0,r1,i0,cc) _ihmuli(_jit,r0,r1,i0,cc) +static void _ihmuli(jit_state_t*,jit_int32_t,jit_int32_t, + jit_word_t,jit_bool_t); # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc) @@ -1006,6 +1056,13 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2) +static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define lroti(r0,r1,i0) rroti(r0,r1,32-i0) +# define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2) +static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0) +static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define ccr(ct,cf,r0,r1,r2) _ccr(_jit,ct,cf,r0,r1,r2) static void _ccr(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t); # define cci(ct,cf,r0,r1,i0) _cci(_jit,ct,cf,r0,r1,i0) @@ -1134,6 +1191,14 @@ static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t); static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0) static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_c(r0,r1) _str_c(_jit,r0,r1) static void _str_c(jit_state_t*,jit_int32_t,jit_int32_t); # define sti_c(i0,r0) _sti_c(_jit,i0,r0) @@ -1158,10 +1223,20 @@ static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t); static void _stxr_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); # define stxi_i(r0,r1,i0) _stxi_i(_jit,r0,r1,i0) static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1) static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t); +# define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0,r1) _extr_c(_jit,r0,r1) static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t); # define extr_uc(r0,r1) _extr_uc(_jit,r0,r1) @@ -1186,6 +1261,8 @@ static void _vastart(jit_state_t*, jit_int32_t); static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t); # define patch_at(kind,jump,label) _patch_at(_jit,kind,jump,label) static void _patch_at(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t); + +# define NEED_FALLBACK_CASX 1 #endif #if CODE @@ -1587,6 +1664,27 @@ _tdmb(jit_state_t *_jit, int im) iss(thumb.s[0], thumb.s[1]); } +static void +_torrlw(jit_state_t *_jit, int o, int rd, int rn, int lsb, int wm1) +{ + jit_thumb_t thumb; + assert(!(o & 0x000f0fdf)); + assert(!(lsb & 0xffffffe0)); + assert(!(wm1 & 0xffffffe0)); + thumb.i = o|(_u4(rn)<<16)|((lsb&28)<<10)|(_u4(rd)<<8)|((lsb&3)<<6)|_u5(wm1); + iss(thumb.s[0], thumb.s[1]); +} + +static void +_corrlw(jit_state_t *_jit, int cc, int o, int rd, int rn, int lsb, int wm1) +{ + assert(!(cc & 0x0fffffff)); + assert(!(o & 0xf000f00f)); + assert(!(lsb & 0xffffffe0)); + assert(!(wm1 & 0xffffffe0)); + ii(cc|o|(_u5(wm1)<<16)|(_u4(rd)<<12)|(_u5(lsb)<<7)|_u4(rn)); +} + static void _nop(jit_state_t *_jit, jit_int32_t i0) { @@ -1813,6 +1911,29 @@ _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) fallback_ctz(r0, r1); } +static void +_rbitr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (jit_armv7_p()) { /* armv6t2 actually */ + if (jit_thumb_p()) + T2_RBIT(r0, r1); + else + RBIT(r0, r1); + } + else + fallback_rbit(r0, r1); +} + +static void +_popcntr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + /* FIXME Untested. Apdated from aarch64 pattern. */ + if (jit_cpu.vfp >= 4) + vfp_popcntr(r0, r1); + else + fallback_popcnt(r0, r1); +} + static void _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { @@ -2210,6 +2331,29 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_ihmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_int32_t r2, jit_bool_t sign) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + iqmulr(rn(reg), r0, r1, r2, sign); + jit_unget_reg(reg); +} + +static void +_ihmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, + jit_word_t i0, jit_bool_t sign) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t1), i0); + iqmulr(rn(t0), r0, r1, rn(t1), sign); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) @@ -2692,6 +2836,47 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) LSRI(r0, r1, i0); } +static void +_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, 64); + rrotr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + rsbi(rn(reg), r2, 64); + rrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (jit_thumb_p()) { + if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1) + T1_ROR(r0, r2); + else + T2_ROR(r0, r1, r2); + } + else + ROR(r0, r1, r2); +} + +static void +_rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 >= 0 && i0 <= 31); + if (i0 == 0) + movr(r0, r1); + else if (jit_thumb_p()) + T2_RORI(r0, r1, i0); + else + RORI(r0, r1, i0); +} + static void _ccr(jit_state_t *_jit, int ct, int cf, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -3602,6 +3787,44 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr(r0, r1, i0); + else + generic_unldr(r0, r1, i0); +} + +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi(r0, i0, i1); + else + generic_unldi(r0, i0, i1); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_u(r0, r1, i0); + else + generic_unldr_u(r0, r1, i0); +} + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi_u(r0, i0, i1); + else + generic_unldi_u(r0, i0, i1); +} + static void _str_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -3821,6 +4044,24 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr(r0, r1, i0); + else + generic_unstr(r0, r1, i0); +} + +static void +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti(i0, r0, i1); + else + generic_unsti(i0, r0, i1); +} + static void _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -3867,6 +4108,57 @@ _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1,jit_word_t i0, jit_word_t i1) +{ + if (jit_armv7_p()) { /* armv6t2 actually */ +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (jit_thumb_p()) + T2_SBFX(r0, r1, i0, i1 - 1); + else + SBFX(r0, r1, i0, i1 - 1); + } + else + fallback_ext(r0, r1, i0, i1); +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1,jit_word_t i0, jit_word_t i1) +{ + if (jit_armv7_p()) { /* armv6t2 actually */ +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (jit_thumb_p()) + T2_UBFX(r0, r1, i0, i1 - 1); + else + UBFX(r0, r1, i0, i1 - 1); + } + else + fallback_ext_u(r0, r1, i0, i1); +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1,jit_word_t i0, jit_word_t i1) +{ + if (jit_armv7_p()) { /* armv6t2 actually */ +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (jit_thumb_p()) + T2_BFI(r0, r1, i0, i0 + i1 - 1); + else + BFI(r0, r1, i0, i0 + i1 - 1); + } + else + fallback_dep(r0, r1, i0, i1); +} + static void _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_arm-swf.c b/deps/lightning/lib/jit_arm-swf.c index 2aa6a12e..46e4308c 100644 --- a/deps/lightning/lib/jit_arm-swf.c +++ b/deps/lightning/lib/jit_arm-swf.c @@ -128,12 +128,24 @@ static void _swf_truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t); static void _swf_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_movr_f(r0,r1) _swf_movr_f(_jit,r0,r1) static void _swf_movr_f(jit_state_t*,jit_int32_t,jit_int32_t); -# define swf_movr_d(r0,r1) _swf_movr_d(_jit,r0,r1) -static void _swf_movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_movi_f(r0,i0) _swf_movi_f(_jit,r0,i0) static void _swf_movi_f(jit_state_t*,jit_int32_t,jit_float32_t); +# define swf_movr_w_f(r0, r1) _swf_movr_w_f(_jit, r0, r1) +static void _swf_movr_w_f(jit_state_t*,jit_int32_t,jit_int32_t); +# define swf_movr_f_w(r0, r1) _swf_movr_f_w(_jit, r0, r1) +static void _swf_movr_f_w(jit_state_t*,jit_int32_t,jit_int32_t); +#define swf_movi_w_f(r0, i0) _swf_movi_w_f(_jit, r0, i0) +static void _swf_movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); +# define swf_movr_d(r0,r1) _swf_movr_d(_jit,r0,r1) +static void _swf_movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_movi_d(r0,i0) _swf_movi_d(_jit,r0,i0) static void _swf_movi_d(jit_state_t*,jit_int32_t,jit_float64_t); +# define swf_movr_ww_d(r0, r1, r2) _swf_movr_ww_d(_jit, r0, r1, r2) +static void _swf_movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define swf_movr_d_ww(r0, r1, r2) _swf_movr_d_ww(_jit, r0, r1, r2) +static void _swf_movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define swf_movi_ww_d(r0, i0, i1) _swf_movi_ww_d(_jit, r0, i0, i1) +static void _swf_movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define swf_absr_f(r0,r1) _swf_absr_f(_jit,r0,r1) static void _swf_absr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_absr_d(r0,r1) _swf_absr_d(_jit,r0,r1) @@ -144,6 +156,30 @@ static void _swf_negr_f(jit_state_t*,jit_int32_t,jit_int32_t); static void _swf_negr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_sqrtr_f(r0,r1) swf_ff(sqrtf,r0,r1) # define swf_sqrtr_d(r0,r1) swf_dd(sqrt,r0,r1) +# define swf_fmar_f(r0,r1,r2,r3) _swf_fmar_f(_jit,r0,r1,r2,r3) +static void _swf_fmar_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fmsr_f(r0,r1,r2,r3) _swf_fmsr_f(_jit,r0,r1,r2,r3) +static void _swf_fmsr_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fmar_d(r0,r1,r2,r3) _swf_fmar_d(_jit,r0,r1,r2,r3) +static void _swf_fmar_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fmsr_d(r0,r1,r2,r3) _swf_fmsr_d(_jit,r0,r1,r2,r3) +static void _swf_fmsr_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fnmar_f(r0,r1,r2,r3) _swf_fnmar_f(_jit,r0,r1,r2,r3) +static void _swf_fnmar_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fnmsr_f(r0,r1,r2,r3) _swf_fnmsr_f(_jit,r0,r1,r2,r3) +static void _swf_fnmsr_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fnmar_d(r0,r1,r2,r3) _swf_fnmar_d(_jit,r0,r1,r2,r3) +static void _swf_fnmar_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define swf_fnmsr_d(r0,r1,r2,r3) _swf_fnmsr_d(_jit,r0,r1,r2,r3) +static void _swf_fnmsr_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); # define swf_addr_f(r0,r1,r2) swf_fff(__addsf3,r0,r1,r2) # define swf_addi_f(r0,r1,i0) swf_fff_(__addsf3,r0,r1,i0) # define swf_addr_d(r0,r1,r2) swf_ddd(__adddf3,r0,r1,r2) @@ -306,12 +342,20 @@ static void _swf_ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); static void _swf_ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define swf_ldxi_d(r0,r1,i0) _swf_ldxi_d(_jit,r0,r1,i0) static void _swf_ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define swf_unldr_x(r0, r1, i0) _swf_unldr_x(_jit, r0, r1, i0) +static void _swf_unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define swf_unldi_x(r0, i0, i1) _swf_unldi_x(_jit, r0, i0, i1) +static void _swf_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define swf_str_f(r0,r1) _swf_str_f(_jit,r0,r1) static void _swf_str_f(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_str_d(r0,r1) _swf_str_d(_jit,r0,r1) static void _swf_str_d(jit_state_t*,jit_int32_t,jit_int32_t); # define swf_sti_f(r0,i0) _swf_sti_f(_jit,r0,i0) static void _swf_sti_f(jit_state_t*,jit_word_t,jit_int32_t); +#define swf_unstr_x(r0, r1, i0) _swf_unstr_x(_jit, r0, r1, i0) +static void _swf_unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define swf_unsti_x(i0, r0, i1) _swf_unsti_x(_jit, i0, r0, i1) +static void _swf_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define swf_sti_d(r0,i0) _swf_sti_d(_jit,r0,i0) static void _swf_sti_d(jit_state_t*,jit_word_t,jit_int32_t); # define swf_stxr_f(r0,r1,r2) _swf_stxr_f(_jit,r0,r1,r2) @@ -1882,70 +1926,12 @@ _swf_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { jit_int32_t reg; if (r0 != r1) { - if (jit_fpr_p(r0) || jit_fpr_p(r1)) - CHECK_SWF_OFFSET(); - if (jit_fpr_p(r1)) { - reg = jit_get_reg(jit_class_gpr); - swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8); - if (jit_fpr_p(r0)) - swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); - else - movr(r0, rn(reg)); - jit_unget_reg(reg); - } - else if (jit_fpr_p(r0)) - swf_strin(r1, _FP_REGNO, swf_off(r0) + 8); - else - movr(r0, r1); - } -} - -static void -_swf_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) -{ - jit_int32_t reg; - if (r0 != r1) { - if (jit_fpr_p(r0) || jit_fpr_p(r1)) - CHECK_SWF_OFFSET(); - if (jit_fpr_p(r1)) { - if (!jit_thumb_p() && jit_armv5e_p() && - (reg = jit_get_reg_pair()) != JIT_NOREG) { - LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8); - if (jit_fpr_p(r0)) - STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8); - else { - movr(r0, rn(reg)); - movr(r0 + 1, rn(reg) + 1); - } - jit_unget_reg_pair(reg); - } - else { - reg = jit_get_reg(jit_class_gpr); - swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8); - if (jit_fpr_p(r0)) - swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); - else - movr(r0, rn(reg)); - swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4); - if (jit_fpr_p(r0)) - swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4); - else - movr(r0 + 1, rn(reg)); - jit_unget_reg(reg); - } - } - else if (jit_fpr_p(r0)) { - if (!jit_thumb_p() && jit_armv5e_p() && !(r1 & 1)) - STRDIN(r1, _FP_REGNO, swf_off(r0) + 8); - else { - swf_strin(r1, _FP_REGNO, swf_off(r0) + 8); - swf_strin(r1 + 1, _FP_REGNO, swf_off(r0) + 4); - } - } - else { - movr(r0, r1); - movr(r0 + 1, r1 + 1); - } + assert(jit_fpr_p(r0) && jit_fpr_p(r1)); + CHECK_SWF_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); + jit_unget_reg(reg); } } @@ -1957,53 +1943,129 @@ _swf_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) jit_float32_t f; } data; jit_int32_t reg; - if (jit_fpr_p(r0)) - CHECK_SWF_OFFSET(); + assert(jit_fpr_p(r0)); + CHECK_SWF_OFFSET(); data.f = i0; - if (jit_fpr_p(r0)) { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), data.i); - swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); - jit_unget_reg(reg); - } - else - movi(r0, data.i); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), data.i); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); + jit_unget_reg(reg); } static void -_swf_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) +_swf_movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + assert(jit_fpr_p(r0)); + CHECK_SWF_OFFSET(); + swf_strin(r1, _FP_REGNO, swf_off(r0) + 8); +} + +static void +_swf_movr_f_w(jit_state_t *_jit ,jit_int32_t r0, jit_int32_t r1) +{ + assert(jit_fpr_p(r1)); + CHECK_SWF_OFFSET(); + swf_ldrin(r0, _FP_REGNO, swf_off(r1) + 8); +} + +static void +_swf_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; - union { - jit_int32_t i[2]; - jit_float64_t d; - } data; - if (jit_fpr_p(r0)) + CHECK_SWF_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + swf_movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_swf_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t reg; + if (r0 != r1) { + assert(jit_fpr_p(r0) && jit_fpr_p(r1)); CHECK_SWF_OFFSET(); - data.d = i0; - if (jit_fpr_p(r0)) { if (!jit_thumb_p() && jit_armv5e_p() && (reg = jit_get_reg_pair()) != JIT_NOREG) { - movi(rn(reg), data.i[0]); - movi(rn(reg) + 1, data.i[1]); + LDRDIN(rn(reg), _FP_REGNO, swf_off(r1) + 8); STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8); jit_unget_reg_pair(reg); } else { reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), data.i[0]); + swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8); swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); - movi(rn(reg), data.i[1]); + swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 4); swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4); jit_unget_reg(reg); } } +} + +static void +_swf_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) +{ + jit_int32_t reg; + union { + jit_int32_t i[2]; + jit_float64_t d; + } data; + assert(jit_fpr_p(r0)); + CHECK_SWF_OFFSET(); + data.d = i0; + if (!jit_thumb_p() && jit_armv5e_p() && + (reg = jit_get_reg_pair()) != JIT_NOREG) { + movi(rn(reg), data.i[0]); + movi(rn(reg) + 1, data.i[1]); + STRDIN(rn(reg), _FP_REGNO, swf_off(r0) + 8); + jit_unget_reg_pair(reg); + } else { - movi(r0, data.i[0]); - movi(r0 + 1, data.i[1]); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), data.i[0]); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); + movi(rn(reg), data.i[1]); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4); + jit_unget_reg(reg); } } +static void +_swf_movr_ww_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + assert(jit_fpr_p(r0)); + CHECK_SWF_OFFSET(); + swf_strin(r1, _FP_REGNO, swf_off(r0) + 8); + swf_strin(r2, _FP_REGNO, swf_off(r0) + 4); +} + +static void +_swf_movr_d_ww(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + assert(jit_fpr_p(r2)); + CHECK_SWF_OFFSET(); + swf_ldrin(r0, _FP_REGNO, swf_off(r2) + 8); + swf_ldrin(r1, _FP_REGNO, swf_off(r2) + 4); +} + +static void +_swf_movi_ww_d(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t reg; + assert(jit_fpr_p(r0)); + CHECK_SWF_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 8); + movi(rn(reg), i1); + swf_strin(rn(reg), _FP_REGNO, swf_off(r0) + 4); + jit_unget_reg(reg); +} + static void _swf_absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -2156,6 +2218,122 @@ _swf_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } } +static void +_swf_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + swf_mulr_f(r0, r1, r2); + swf_addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + swf_mulr_f(rn(t0), r1, r2); + swf_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_swf_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + swf_mulr_f(r0, r1, r2); + swf_subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + swf_mulr_f(rn(t0), r1, r2); + swf_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_swf_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + swf_negr_f(rn(t0), r1); + swf_mulr_f(rn(t0), rn(t0), r2); + swf_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_swf_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + swf_negr_f(rn(t0), r1); + swf_mulr_f(rn(t0), rn(t0), r2); + swf_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_swf_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + swf_mulr_d(r0, r1, r2); + swf_addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + swf_mulr_d(rn(t0), r1, r2); + swf_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_swf_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + swf_mulr_d(r0, r1, r2); + swf_subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + swf_mulr_d(rn(t0), r1, r2); + swf_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_swf_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + swf_negr_d(rn(t0), r1); + swf_mulr_d(rn(t0), rn(t0), r2); + swf_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_swf_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + swf_negr_d(rn(t0), r1); + swf_mulr_d(rn(t0), rn(t0), r2); + swf_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _swf_ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { @@ -2401,6 +2579,80 @@ _swf_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) ldxi_i(r0, r1, i0); } +static void +_swf_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i0 == 4 || i0 == 8); + if (jit_unaligned_p()) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + unldr(r2, r1, 4); + swf_movr_w_f(r0, r2); + } + else { + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + unldr(r2, r1, 4); + addi(r3, r1, 4); + unldr(r3, r3, 4); +#else + unldr(r3, r1, 4); + addi(r2, r1, 4); + unldr(r2, r2, 4); +#endif + swf_movr_ww_d(r0, r2, r3); + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + swf_ldr_f(r0, r1); + else + swf_ldr_d(r0, r1); + } +} + +static void +_swf_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i1 == 4 || i1 == 8); + if (jit_unaligned_p()) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + unldi(r2, i0, 4); + swf_movr_w_f(r0, r2); + } + else { + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + unldi(r2, i0, 4); + unldi(r3, i0 + 4, 4); +#else + unldi(r3, i0, 4); + unldi(r2, i0 + 4, 4); +#endif + swf_movr_ww_d(r0, r3, r2); + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + swf_ldi_f(r0, i0); + else + swf_ldi_d(r0, i0); + } +} + static void _swf_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -2532,6 +2784,80 @@ _swf_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) sti_i(i0, r0); } +static void +_swf_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i0 == 4 || i0 == 8); + if (jit_unaligned_p()) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + swf_movr_f_w(r2, r1); + unstr(r0, r2, 4); + } + else { + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); + swf_movr_d_ww(r2, r3, r1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + unstr(r0, r2, 4); + addi(r2, r0, 4); + unstr(r2, r3, 4); +#else + unstr(r0, r3, 4); + addi(r3, r0, 4); + unstr(r3, r2, 4); +#endif + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + swf_str_f(r0, r1); + else + swf_str_d(r0, r1); + } +} + +static void +_swf_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i1 == 4 || i1 == 8); + if (jit_unaligned_p()) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + swf_movr_f_w(r2, r0); + unsti(i0, r2, 4); + } + else { + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); + swf_movr_d_ww(r2, r3, r0); +#if __BYTE_ORDER == __LITTLE_ENDIAN + unsti(i0, r3, 4); + unsti(i0 + 4, r2, 4); +#else + unsti(i0, r2, 4); + unsti(i0 + 4, r3, 4); +#endif + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i1 == 4) + swf_sti_f(i0, r0); + else + swf_sti_d(i0, r0); + } +} + static void _swf_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { diff --git a/deps/lightning/lib/jit_arm-sz.c b/deps/lightning/lib/jit_arm-sz.c index faba5a81..7ec5e9e8 100644 --- a/deps/lightning/lib/jit_arm-sz.c +++ b/deps/lightning/lib/jit_arm-sz.c @@ -1,17 +1,17 @@ #if __WORDSIZE == 32 -#if defined(__ARM_PCS_VFP) -#define JIT_INSTR_MAX 50 +#if !defined(__ARM_PCS_VFP) +#define JIT_INSTR_MAX 144 0, /* data */ 0, /* live */ - 14, /* align */ + 20, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ 2, /* #name */ 0, /* #note */ 0, /* label */ - 34, /* prolog */ + 30, /* prolog */ 0, /* ellipsis */ 0, /* va_push */ 0, /* allocai */ @@ -43,7 +43,7 @@ 0, /* putargi_l */ 4, /* va_start */ 8, /* va_arg */ - 16, /* va_arg_d */ + 28, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ 12, /* addi */ @@ -58,7 +58,7 @@ 4, /* subxr */ 4, /* subxi */ 16, /* rsbi */ - 4, /* mulr */ + 8, /* mulr */ 12, /* muli */ 4, /* qmulr */ 12, /* qmuli */ @@ -89,7 +89,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 14, /* ltr */ 14, /* lti */ 14, /* ltr_u */ @@ -115,19 +117,31 @@ 8, /* movnr */ 8, /* movzr */ 42, /* casr */ - 50, /* casi */ - 4, /* extr_c */ + 46, /* casi */ + 8, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ - 4, /* extr_s */ - 4, /* extr_us */ + 4, /* exti_uc */ + 8, /* extr_s */ + 4, /* exti_s */ + 8, /* extr_us */ + 4, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ - 8, /* bswapr_us */ - 4, /* bswapr_ui */ + 0, /* exti_ui */ + 20, /* bswapr_us */ + 4, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ - 8, /* htonr_us */ - 4, /* htonr_ui */ + 0, /* bswapi_ul */ + 20, /* htonr_us */ + 4, /* htoni_us */ + 16, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 4, /* ldr_c */ 12, /* ldi_c */ 4, /* ldr_uc */ @@ -212,8 +226,8 @@ 8, /* bxsubi */ 8, /* bxsubr_u */ 8, /* bxsubi_u */ - 4, /* jmpr */ - 8, /* jmpi */ + 12, /* jmpr */ + 72, /* jmpi */ 4, /* callr */ 20, /* calli */ 0, /* prepare */ @@ -255,93 +269,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 24, /* epilog */ + 276, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ - 4, /* addr_f */ - 8, /* addi_f */ - 4, /* subr_f */ - 8, /* subi_f */ - 8, /* rsbi_f */ - 4, /* mulr_f */ - 8, /* muli_f */ - 4, /* divr_f */ - 8, /* divi_f */ - 4, /* negr_f */ - 4, /* absr_f */ - 4, /* sqrtr_f */ - 18, /* ltr_f */ + 24, /* addr_f */ + 24, /* addi_f */ + 24, /* subr_f */ + 24, /* subi_f */ + 24, /* rsbi_f */ + 24, /* mulr_f */ + 24, /* muli_f */ + 24, /* divr_f */ + 24, /* divi_f */ + 12, /* negr_f */ + 0, /* negi_f */ + 12, /* absr_f */ + 0, /* absi_f */ + 20, /* sqrtr_f */ + 0, /* sqrti_f */ + 24, /* ltr_f */ 30, /* lti_f */ - 20, /* ler_f */ + 24, /* ler_f */ 32, /* lei_f */ - 18, /* eqr_f */ + 24, /* eqr_f */ 30, /* eqi_f */ - 18, /* ger_f */ + 24, /* ger_f */ 30, /* gei_f */ - 18, /* gtr_f */ + 24, /* gtr_f */ 30, /* gti_f */ - 18, /* ner_f */ - 30, /* nei_f */ - 18, /* unltr_f */ - 30, /* unlti_f */ - 18, /* unler_f */ - 30, /* unlei_f */ - 24, /* uneqr_f */ - 36, /* uneqi_f */ - 18, /* unger_f */ - 30, /* ungei_f */ - 18, /* ungtr_f */ - 30, /* ungti_f */ - 24, /* ltgtr_f */ - 36, /* ltgti_f */ - 18, /* ordr_f */ - 30, /* ordi_f */ - 18, /* unordr_f */ - 30, /* unordi_f */ - 8, /* truncr_f_i */ + 28, /* ner_f */ + 32, /* nei_f */ + 56, /* unltr_f */ + 64, /* unlti_f */ + 56, /* unler_f */ + 64, /* unlei_f */ + 56, /* uneqr_f */ + 64, /* uneqi_f */ + 56, /* unger_f */ + 64, /* ungei_f */ + 56, /* ungtr_f */ + 64, /* ungti_f */ + 60, /* ltgtr_f */ + 68, /* ltgti_f */ + 28, /* ordr_f */ + 32, /* ordi_f */ + 56, /* unordr_f */ + 64, /* unordi_f */ + 20, /* truncr_f_i */ 0, /* truncr_f_l */ - 8, /* extr_f */ - 4, /* extr_d_f */ - 4, /* movr_f */ - 12, /* movi_f */ - 4, /* ldr_f */ - 12, /* ldi_f */ + 28, /* extr_f */ + 22, /* extr_d_f */ + 8, /* movr_f */ + 16, /* movi_f */ + 8, /* ldr_f */ + 16, /* ldi_f */ 8, /* ldxr_f */ 16, /* ldxi_f */ - 4, /* str_f */ - 12, /* sti_f */ + 8, /* str_f */ + 16, /* sti_f */ 8, /* stxr_f */ 16, /* stxi_f */ - 12, /* bltr_f */ - 24, /* blti_f */ - 12, /* bler_f */ - 24, /* blei_f */ - 12, /* beqr_f */ - 24, /* beqi_f */ - 12, /* bger_f */ - 24, /* bgei_f */ - 12, /* bgtr_f */ - 24, /* bgti_f */ - 12, /* bner_f */ - 24, /* bnei_f */ - 16, /* bunltr_f */ - 28, /* bunlti_f */ - 16, /* bunler_f */ - 28, /* bunlei_f */ - 20, /* buneqr_f */ - 32, /* buneqi_f */ - 16, /* bunger_f */ - 28, /* bungei_f */ - 12, /* bungtr_f */ - 24, /* bungti_f */ - 20, /* bltgtr_f */ - 32, /* bltgti_f */ - 12, /* bordr_f */ - 24, /* bordi_f */ - 12, /* bunordr_f */ - 24, /* bunordi_f */ + 28, /* bltr_f */ + 32, /* blti_f */ + 28, /* bler_f */ + 32, /* blei_f */ + 28, /* beqr_f */ + 48, /* beqi_f */ + 28, /* bger_f */ + 32, /* bgei_f */ + 28, /* bgtr_f */ + 32, /* bgti_f */ + 28, /* bner_f */ + 32, /* bnei_f */ + 28, /* bunltr_f */ + 32, /* bunlti_f */ + 28, /* bunler_f */ + 32, /* bunlei_f */ + 60, /* buneqr_f */ + 68, /* buneqi_f */ + 28, /* bunger_f */ + 32, /* bungei_f */ + 28, /* bungtr_f */ + 32, /* bungti_f */ + 60, /* bltgtr_f */ + 68, /* bltgti_f */ + 28, /* bordr_f */ + 32, /* bordi_f */ + 28, /* bunordr_f */ + 32, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -351,122 +368,184 @@ 0, /* getarg_d */ 0, /* putargr_d */ 0, /* putargi_d */ - 4, /* addr_d */ - 20, /* addi_d */ - 4, /* subr_d */ - 20, /* subi_d */ - 20, /* rsbi_d */ - 4, /* mulr_d */ - 20, /* muli_d */ - 4, /* divr_d */ - 20, /* divi_d */ - 4, /* negr_d */ - 4, /* absr_d */ - 4, /* sqrtr_d */ - 18, /* ltr_d */ + 34, /* addr_d */ + 36, /* addi_d */ + 34, /* subr_d */ + 36, /* subi_d */ + 36, /* rsbi_d */ + 34, /* mulr_d */ + 36, /* muli_d */ + 34, /* divr_d */ + 36, /* divi_d */ + 20, /* negr_d */ + 0, /* negi_d */ + 20, /* absr_d */ + 0, /* absi_d */ + 26, /* sqrtr_d */ + 0, /* sqrti_d */ + 28, /* ltr_d */ 34, /* lti_d */ - 20, /* ler_d */ + 28, /* ler_d */ 36, /* lei_d */ - 18, /* eqr_d */ + 28, /* eqr_d */ 34, /* eqi_d */ - 18, /* ger_d */ + 28, /* ger_d */ 34, /* gei_d */ - 18, /* gtr_d */ + 28, /* gtr_d */ 34, /* gti_d */ - 18, /* ner_d */ - 34, /* nei_d */ - 18, /* unltr_d */ - 34, /* unlti_d */ - 18, /* unler_d */ - 34, /* unlei_d */ - 24, /* uneqr_d */ - 40, /* uneqi_d */ - 18, /* unger_d */ - 34, /* ungei_d */ - 18, /* ungtr_d */ - 34, /* ungti_d */ - 24, /* ltgtr_d */ - 40, /* ltgti_d */ - 18, /* ordr_d */ - 34, /* ordi_d */ - 18, /* unordr_d */ - 34, /* unordi_d */ - 8, /* truncr_d_i */ + 32, /* ner_d */ + 36, /* nei_d */ + 66, /* unltr_d */ + 72, /* unlti_d */ + 66, /* unler_d */ + 72, /* unlei_d */ + 66, /* uneqr_d */ + 72, /* uneqi_d */ + 66, /* unger_d */ + 72, /* ungei_d */ + 66, /* ungtr_d */ + 72, /* ungti_d */ + 70, /* ltgtr_d */ + 76, /* ltgti_d */ + 32, /* ordr_d */ + 36, /* ordi_d */ + 66, /* unordr_d */ + 72, /* unordi_d */ + 20, /* truncr_d_i */ 0, /* truncr_d_l */ - 8, /* extr_d */ - 4, /* extr_f_d */ - 4, /* movr_d */ + 36, /* extr_d */ + 22, /* extr_f_d */ + 16, /* movr_d */ 32, /* movi_d */ - 4, /* ldr_d */ - 12, /* ldi_d */ - 8, /* ldxr_d */ - 16, /* ldxi_d */ - 4, /* str_d */ - 12, /* sti_d */ - 8, /* stxr_d */ - 16, /* stxi_d */ - 12, /* bltr_d */ - 28, /* blti_d */ - 12, /* bler_d */ - 28, /* blei_d */ - 12, /* beqr_d */ - 36, /* beqi_d */ - 12, /* bger_d */ - 28, /* bgei_d */ - 12, /* bgtr_d */ - 28, /* bgti_d */ - 12, /* bner_d */ - 28, /* bnei_d */ - 16, /* bunltr_d */ - 32, /* bunlti_d */ - 16, /* bunler_d */ - 32, /* bunlei_d */ - 20, /* buneqr_d */ - 36, /* buneqi_d */ - 16, /* bunger_d */ - 32, /* bungei_d */ - 12, /* bungtr_d */ - 28, /* bungti_d */ - 20, /* bltgtr_d */ - 36, /* bltgti_d */ - 12, /* bordr_d */ - 28, /* bordi_d */ - 12, /* bunordr_d */ - 28, /* bunordi_d */ + 16, /* ldr_d */ + 24, /* ldi_d */ + 20, /* ldxr_d */ + 28, /* ldxi_d */ + 16, /* str_d */ + 24, /* sti_d */ + 20, /* stxr_d */ + 28, /* stxi_d */ + 32, /* bltr_d */ + 36, /* blti_d */ + 32, /* bler_d */ + 36, /* blei_d */ + 32, /* beqr_d */ + 52, /* beqi_d */ + 32, /* bger_d */ + 36, /* bgei_d */ + 32, /* bgtr_d */ + 36, /* bgti_d */ + 32, /* bner_d */ + 36, /* bnei_d */ + 32, /* bunltr_d */ + 36, /* bunlti_d */ + 32, /* bunler_d */ + 36, /* bunlei_d */ + 68, /* buneqr_d */ + 76, /* buneqi_d */ + 32, /* bunger_d */ + 36, /* bungei_d */ + 32, /* bungtr_d */ + 36, /* bungti_d */ + 68, /* bltgtr_d */ + 76, /* bltgti_d */ + 32, /* bordr_d */ + 36, /* bordi_d */ + 32, /* bunordr_d */ + 36, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 4, /* movr_ww_d */ + 4, /* movr_w_f */ + 8, /* movi_w_f */ + 8, /* movr_ww_d */ + 20, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 4, /* movr_d_ww */ + 0, /* movi_w_d */ + 4, /* movr_f_w */ + 8, /* movi_f_w */ + 8, /* movr_d_ww */ 12, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 12, /* cto */ - 8, /* ctz */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 12, /* ctor */ + 4, /* ctoi */ + 8, /* ctzr */ + 4, /* ctzi */ + 4, /* rbitr */ + 8, /* rbiti */ + 40, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 12, /* extr_u */ + 4, /* exti_u */ + 24, /* depr */ + 20, /* depi */ + 50, /* qlshr */ + 8, /* qlshi */ + 50, /* qlshr_u */ + 8, /* qlshi_u */ + 50, /* qrshr */ + 8, /* qrshi */ + 50, /* qrshr_u */ + 8, /* qrshi_u */ + 72, /* unldr */ + 44, /* unldi */ + 72, /* unldr_u */ + 44, /* unldi_u */ + 68, /* unstr */ + 44, /* unsti */ + 144, /* unldr_x */ + 80, /* unldi_x */ + 148, /* unstr_x */ + 96, /* unsti_x */ + 48, /* fmar_f */ + 0, /* fmai_f */ + 48, /* fmsr_f */ + 0, /* fmsi_f */ + 68, /* fmar_d */ + 0, /* fmai_d */ + 68, /* fmsr_d */ + 0, /* fmsi_d */ + 60, /* fnmar_f */ + 0, /* fnmai_f */ + 60, /* fnmsr_f */ + 0, /* fnmsi_f */ + 88, /* fnmar_d */ + 0, /* fnmai_d */ + 88, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 12, /* hmuli */ + 4, /* hmulr_u */ + 8, /* hmuli_u */ #endif /* __ARM_PCS_VFP */ #endif /* __WORDSIZE */ #if __WORDSIZE == 32 -#if !defined(__ARM_PCS_VFP) -#define JIT_INSTR_MAX 50 +#if defined(__ARM_PCS_VFP) +#define JIT_INSTR_MAX 144 0, /* data */ 0, /* live */ - 18, /* align */ + 20, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ 2, /* #name */ 0, /* #note */ 0, /* label */ - 30, /* prolog */ + 26, /* prolog */ 0, /* ellipsis */ 0, /* va_push */ 0, /* allocai */ @@ -498,7 +577,7 @@ 0, /* putargi_l */ 4, /* va_start */ 8, /* va_arg */ - 28, /* va_arg_d */ + 16, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ 12, /* addi */ @@ -513,7 +592,7 @@ 4, /* subxr */ 4, /* subxi */ 16, /* rsbi */ - 8, /* mulr */ + 4, /* mulr */ 12, /* muli */ 4, /* qmulr */ 12, /* qmuli */ @@ -544,7 +623,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 14, /* ltr */ 14, /* lti */ 14, /* ltr_u */ @@ -570,19 +651,31 @@ 8, /* movnr */ 8, /* movzr */ 42, /* casr */ - 46, /* casi */ - 8, /* extr_c */ + 50, /* casi */ + 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ - 8, /* extr_s */ - 8, /* extr_us */ + 4, /* exti_uc */ + 4, /* extr_s */ + 4, /* exti_s */ + 4, /* extr_us */ + 4, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ - 20, /* bswapr_us */ - 16, /* bswapr_ui */ + 0, /* exti_ui */ + 8, /* bswapr_us */ + 4, /* bswapi_us */ + 4, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ - 20, /* htonr_us */ - 16, /* htonr_ui */ + 0, /* bswapi_ul */ + 8, /* htonr_us */ + 4, /* htoni_us */ + 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 4, /* ldr_c */ 12, /* ldi_c */ 4, /* ldr_uc */ @@ -667,8 +760,8 @@ 8, /* bxsubi */ 8, /* bxsubr_u */ 8, /* bxsubi_u */ - 12, /* jmpr */ - 72, /* jmpi */ + 4, /* jmpr */ + 8, /* jmpi */ 4, /* callr */ 20, /* calli */ 0, /* prepare */ @@ -710,93 +803,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 30, /* epilog */ + 16, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ - 24, /* addr_f */ - 24, /* addi_f */ - 24, /* subr_f */ - 24, /* subi_f */ - 24, /* rsbi_f */ - 24, /* mulr_f */ - 24, /* muli_f */ - 24, /* divr_f */ - 24, /* divi_f */ - 12, /* negr_f */ - 12, /* absr_f */ - 20, /* sqrtr_f */ - 24, /* ltr_f */ + 4, /* addr_f */ + 8, /* addi_f */ + 4, /* subr_f */ + 8, /* subi_f */ + 8, /* rsbi_f */ + 4, /* mulr_f */ + 8, /* muli_f */ + 4, /* divr_f */ + 8, /* divi_f */ + 4, /* negr_f */ + 0, /* negi_f */ + 4, /* absr_f */ + 0, /* absi_f */ + 4, /* sqrtr_f */ + 0, /* sqrti_f */ + 18, /* ltr_f */ 30, /* lti_f */ - 24, /* ler_f */ + 20, /* ler_f */ 32, /* lei_f */ - 24, /* eqr_f */ + 18, /* eqr_f */ 30, /* eqi_f */ - 24, /* ger_f */ + 18, /* ger_f */ 30, /* gei_f */ - 24, /* gtr_f */ + 18, /* gtr_f */ 30, /* gti_f */ - 28, /* ner_f */ - 32, /* nei_f */ - 56, /* unltr_f */ - 64, /* unlti_f */ - 56, /* unler_f */ - 64, /* unlei_f */ - 56, /* uneqr_f */ - 64, /* uneqi_f */ - 56, /* unger_f */ - 64, /* ungei_f */ - 56, /* ungtr_f */ - 64, /* ungti_f */ - 60, /* ltgtr_f */ - 68, /* ltgti_f */ - 28, /* ordr_f */ - 32, /* ordi_f */ - 56, /* unordr_f */ - 64, /* unordi_f */ - 20, /* truncr_f_i */ + 18, /* ner_f */ + 30, /* nei_f */ + 18, /* unltr_f */ + 30, /* unlti_f */ + 18, /* unler_f */ + 30, /* unlei_f */ + 24, /* uneqr_f */ + 36, /* uneqi_f */ + 18, /* unger_f */ + 30, /* ungei_f */ + 18, /* ungtr_f */ + 30, /* ungti_f */ + 24, /* ltgtr_f */ + 36, /* ltgti_f */ + 18, /* ordr_f */ + 30, /* ordi_f */ + 18, /* unordr_f */ + 30, /* unordi_f */ + 8, /* truncr_f_i */ 0, /* truncr_f_l */ - 28, /* extr_f */ - 22, /* extr_d_f */ - 8, /* movr_f */ - 16, /* movi_f */ - 8, /* ldr_f */ - 16, /* ldi_f */ + 8, /* extr_f */ + 4, /* extr_d_f */ + 4, /* movr_f */ + 12, /* movi_f */ + 4, /* ldr_f */ + 12, /* ldi_f */ 8, /* ldxr_f */ 16, /* ldxi_f */ - 8, /* str_f */ - 16, /* sti_f */ + 4, /* str_f */ + 12, /* sti_f */ 8, /* stxr_f */ 16, /* stxi_f */ - 28, /* bltr_f */ - 32, /* blti_f */ - 28, /* bler_f */ - 32, /* blei_f */ - 28, /* beqr_f */ - 48, /* beqi_f */ - 28, /* bger_f */ - 32, /* bgei_f */ - 28, /* bgtr_f */ - 32, /* bgti_f */ - 28, /* bner_f */ - 32, /* bnei_f */ - 28, /* bunltr_f */ - 32, /* bunlti_f */ - 28, /* bunler_f */ - 32, /* bunlei_f */ - 60, /* buneqr_f */ - 68, /* buneqi_f */ - 28, /* bunger_f */ - 32, /* bungei_f */ - 28, /* bungtr_f */ - 32, /* bungti_f */ - 60, /* bltgtr_f */ - 68, /* bltgti_f */ - 28, /* bordr_f */ - 32, /* bordi_f */ - 28, /* bunordr_f */ - 32, /* bunordi_f */ + 12, /* bltr_f */ + 24, /* blti_f */ + 12, /* bler_f */ + 24, /* blei_f */ + 12, /* beqr_f */ + 24, /* beqi_f */ + 12, /* bger_f */ + 24, /* bgei_f */ + 12, /* bgtr_f */ + 24, /* bgti_f */ + 12, /* bner_f */ + 24, /* bnei_f */ + 16, /* bunltr_f */ + 28, /* bunlti_f */ + 16, /* bunler_f */ + 28, /* bunlei_f */ + 20, /* buneqr_f */ + 32, /* buneqi_f */ + 16, /* bunger_f */ + 28, /* bungei_f */ + 12, /* bungtr_f */ + 24, /* bungti_f */ + 20, /* bltgtr_f */ + 32, /* bltgti_f */ + 12, /* bordr_f */ + 24, /* bordi_f */ + 12, /* bunordr_f */ + 24, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -806,105 +902,167 @@ 0, /* getarg_d */ 0, /* putargr_d */ 0, /* putargi_d */ - 34, /* addr_d */ - 36, /* addi_d */ - 34, /* subr_d */ - 36, /* subi_d */ - 36, /* rsbi_d */ - 34, /* mulr_d */ - 36, /* muli_d */ - 34, /* divr_d */ - 36, /* divi_d */ - 20, /* negr_d */ - 20, /* absr_d */ - 26, /* sqrtr_d */ - 28, /* ltr_d */ + 4, /* addr_d */ + 20, /* addi_d */ + 4, /* subr_d */ + 20, /* subi_d */ + 20, /* rsbi_d */ + 4, /* mulr_d */ + 20, /* muli_d */ + 4, /* divr_d */ + 20, /* divi_d */ + 4, /* negr_d */ + 0, /* negi_d */ + 4, /* absr_d */ + 0, /* absi_d */ + 4, /* sqrtr_d */ + 0, /* sqrti_d */ + 18, /* ltr_d */ 34, /* lti_d */ - 28, /* ler_d */ + 20, /* ler_d */ 36, /* lei_d */ - 28, /* eqr_d */ + 18, /* eqr_d */ 34, /* eqi_d */ - 28, /* ger_d */ + 18, /* ger_d */ 34, /* gei_d */ - 28, /* gtr_d */ + 18, /* gtr_d */ 34, /* gti_d */ - 32, /* ner_d */ - 36, /* nei_d */ - 66, /* unltr_d */ - 72, /* unlti_d */ - 66, /* unler_d */ - 72, /* unlei_d */ - 66, /* uneqr_d */ - 72, /* uneqi_d */ - 66, /* unger_d */ - 72, /* ungei_d */ - 66, /* ungtr_d */ - 72, /* ungti_d */ - 70, /* ltgtr_d */ - 76, /* ltgti_d */ - 32, /* ordr_d */ - 36, /* ordi_d */ - 66, /* unordr_d */ - 72, /* unordi_d */ - 20, /* truncr_d_i */ + 18, /* ner_d */ + 34, /* nei_d */ + 18, /* unltr_d */ + 34, /* unlti_d */ + 18, /* unler_d */ + 34, /* unlei_d */ + 24, /* uneqr_d */ + 40, /* uneqi_d */ + 18, /* unger_d */ + 34, /* ungei_d */ + 18, /* ungtr_d */ + 34, /* ungti_d */ + 24, /* ltgtr_d */ + 40, /* ltgti_d */ + 18, /* ordr_d */ + 34, /* ordi_d */ + 18, /* unordr_d */ + 34, /* unordi_d */ + 8, /* truncr_d_i */ 0, /* truncr_d_l */ - 36, /* extr_d */ - 22, /* extr_f_d */ - 16, /* movr_d */ + 8, /* extr_d */ + 4, /* extr_f_d */ + 4, /* movr_d */ 32, /* movi_d */ - 16, /* ldr_d */ - 24, /* ldi_d */ - 20, /* ldxr_d */ - 28, /* ldxi_d */ - 16, /* str_d */ - 24, /* sti_d */ - 20, /* stxr_d */ - 28, /* stxi_d */ - 32, /* bltr_d */ - 36, /* blti_d */ - 32, /* bler_d */ - 36, /* blei_d */ - 32, /* beqr_d */ - 52, /* beqi_d */ - 32, /* bger_d */ - 36, /* bgei_d */ - 32, /* bgtr_d */ - 36, /* bgti_d */ - 32, /* bner_d */ - 36, /* bnei_d */ - 32, /* bunltr_d */ - 36, /* bunlti_d */ - 32, /* bunler_d */ - 36, /* bunlei_d */ - 68, /* buneqr_d */ - 76, /* buneqi_d */ - 32, /* bunger_d */ - 36, /* bungei_d */ - 32, /* bungtr_d */ - 36, /* bungti_d */ - 68, /* bltgtr_d */ - 76, /* bltgti_d */ - 32, /* bordr_d */ - 36, /* bordi_d */ - 32, /* bunordr_d */ - 36, /* bunordi_d */ + 4, /* ldr_d */ + 12, /* ldi_d */ + 8, /* ldxr_d */ + 16, /* ldxi_d */ + 4, /* str_d */ + 12, /* sti_d */ + 8, /* stxr_d */ + 16, /* stxi_d */ + 12, /* bltr_d */ + 28, /* blti_d */ + 12, /* bler_d */ + 28, /* blei_d */ + 12, /* beqr_d */ + 36, /* beqi_d */ + 12, /* bger_d */ + 28, /* bgei_d */ + 12, /* bgtr_d */ + 28, /* bgti_d */ + 12, /* bner_d */ + 28, /* bnei_d */ + 16, /* bunltr_d */ + 32, /* bunlti_d */ + 16, /* bunler_d */ + 32, /* bunlei_d */ + 20, /* buneqr_d */ + 36, /* buneqi_d */ + 16, /* bunger_d */ + 32, /* bungei_d */ + 12, /* bungtr_d */ + 28, /* bungti_d */ + 20, /* bltgtr_d */ + 36, /* bltgti_d */ + 12, /* bordr_d */ + 28, /* bordi_d */ + 12, /* bunordr_d */ + 28, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ 4, /* movr_w_f */ - 8, /* movr_ww_d */ + 8, /* movi_w_f */ + 4, /* movr_ww_d */ + 16, /* movi_ww_d */ 0, /* movr_w_d */ - 8, /* movr_f_w */ - 8, /* movi_f_w */ - 16, /* movr_d_ww */ + 0, /* movi_w_d */ + 4, /* movr_f_w */ + 4, /* movi_f_w */ + 4, /* movr_d_ww */ 12, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 12, /* cto */ - 8, /* ctz */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 12, /* ctor */ + 4, /* ctoi */ + 8, /* ctzr */ + 4, /* ctzi */ + 4, /* rbitr */ + 8, /* rbiti */ + 40, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 4, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 50, /* qlshr */ + 8, /* qlshi */ + 50, /* qlshr_u */ + 8, /* qlshi_u */ + 50, /* qrshr */ + 8, /* qrshi */ + 50, /* qrshr_u */ + 8, /* qrshi_u */ + 72, /* unldr */ + 44, /* unldi */ + 72, /* unldr_u */ + 44, /* unldi_u */ + 68, /* unstr */ + 44, /* unsti */ + 140, /* unldr_x */ + 76, /* unldi_x */ + 144, /* unstr_x */ + 92, /* unsti_x */ + 8, /* fmar_f */ + 0, /* fmai_f */ + 8, /* fmsr_f */ + 0, /* fmsi_f */ + 8, /* fmar_d */ + 0, /* fmai_d */ + 8, /* fmsr_d */ + 0, /* fmsi_d */ + 12, /* fnmar_f */ + 0, /* fnmai_f */ + 12, /* fnmsr_f */ + 0, /* fnmsi_f */ + 12, /* fnmar_d */ + 0, /* fnmai_d */ + 12, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 12, /* hmuli */ + 4, /* hmulr_u */ + 8, /* hmuli_u */ #endif /* __ARM_PCS_VFP */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_arm-vfp.c b/deps/lightning/lib/jit_arm-vfp.c index 20f80a21..adf6a3b6 100644 --- a/deps/lightning/lib/jit_arm-vfp.c +++ b/deps/lightning/lib/jit_arm-vfp.c @@ -88,6 +88,10 @@ # define ARM_VCVTR_U32_F32 ARM_VCVT|ARM_VCVT_2I # define ARM_VCVTR_S32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_VCVT_2S|ARM_V_F64 # define ARM_VCVTR_U32_F64 ARM_VCVT|ARM_VCVT_2I|ARM_V_F64 +# define ARM_VFMA 0x0ea00a00 +# define ARM_VFMS 0x0ea00a40 +# define ARM_VFNMA 0x0e900a00 +# define ARM_VFNMS 0x0e900a40 # define ARM_V_D 0x00400000 # define ARM_V_N 0x00000080 # define ARM_V_Q 0x00000040 @@ -131,7 +135,7 @@ # define ARM_VMOV_ADV_16 0x00000020 # define ARM_VMOV_A_D 0x0e100b10 # define ARM_VMOV_D_A 0x0e000b10 - +# define ARM_VCNT 0x03b00500 # define vodi(oi,r0) _vodi(_jit,oi,r0) static void _vodi(jit_state_t*,int,int) maybe_unused; # define voqi(oi,r0) _voqi(_jit,oi,r0) @@ -157,6 +161,8 @@ static void _cc_vors_(jit_state_t*,int,int,int,int); # define vorv_(o,r0,r1) _cc_vorv_(_jit,ARM_CC_NV,o,r0,r1) # define cc_vorv_(cc,o,r0,r1) _cc_vorv_(_jit,cc,o,r0,r1) static void _cc_vorv_(jit_state_t*,int,int,int,int) maybe_unused; +# define vo_vv(o,r0,r1) _cc_vo_vv(_jit,ARM_CC_NV,o,r0,r1) +static void _cc_vo_vv(jit_state_t*,int,int,int,int) maybe_unused; # define vori_(o,r0,r1) _cc_vori_(_jit,ARM_CC_NV,o,r0,r1) # define cc_vori_(cc,o,r0,r1) _cc_vori_(_jit,cc,o,r0,r1) static void _cc_vori_(jit_state_t*,int,int,int,int); @@ -210,6 +216,22 @@ static void _cc_vorsl(jit_state_t*,int,int,int,int,int); # define VSQRT_F32(r0,r1) CC_VSQRT_F32(ARM_CC_AL,r0,r1) # define CC_VSQRT_F64(cc,r0,r1) cc_vo_dd(cc,ARM_VSQRT_F|ARM_V_F64,r0,r1) # define VSQRT_F64(r0,r1) CC_VSQRT_F64(ARM_CC_AL,r0,r1) +# define CC_VFMA_F32(cc,r0,r1,r2) cc_voddd(cc,ARM_VFMA,r0,r1,r2) +# define VFMA_F32(r0,r1,r2) CC_VFMA_F32(ARM_CC_AL,r0,r1,r2) +# define CC_VFMA_F64(cc,r0,r1,r2) cc_voddd(cc,ARM_VFMA|ARM_V_F64,r0,r1,r2) +# define VFMA_F64(r0,r1,r2) CC_VFMA_F64(ARM_CC_AL,r0,r1,r2) +# define CC_VFMS_F32(cc,r0,r1,r2) cc_voddd(cc,ARM_VFMS,r0,r1,r2) +# define VFMS_F32(r0,r1,r2) CC_VFMS_F32(ARM_CC_AL,r0,r1,r2) +# define CC_VFMS_F64(cc,r0,r1,r2) cc_voddd(cc,ARM_VFMS|ARM_V_F64,r0,r1,r2) +# define VFMS_F64(r0,r1,r2) CC_VFMS_F64(ARM_CC_AL,r0,r1,r2) +# define CC_VFNMA_F32(cc,r0,r1,r2) cc_voddd(cc,ARM_VFNMA,r0,r1,r2) +# define VFNMA_F32(r0,r1,r2) CC_VFNMA_F32(ARM_CC_AL,r0,r1,r2) +# define CC_VFNMA_F64(cc,r0,r1,r2) cc_voddd(cc,ARM_VFNMA|ARM_V_F64,r0,r1,r2) +# define VFNMA_F64(r0,r1,r2) CC_VFNMA_F64(ARM_CC_AL,r0,r1,r2) +# define CC_VFNMS_F32(cc,r0,r1,r2) cc_voddd(cc,ARM_VFNMS,r0,r1,r2) +# define VFNMS_F32(r0,r1,r2) CC_VFNMS_F32(ARM_CC_AL,r0,r1,r2) +# define CC_VFNMS_F64(cc,r0,r1,r2) cc_voddd(cc,ARM_VFNMS|ARM_V_F64,r0,r1,r2) +# define VFNMS_F64(r0,r1,r2) CC_VFNMS_F64(ARM_CC_AL,r0,r1,r2) # define CC_VMOV_F32(cc,r0,r1) cc_vo_ss(cc,ARM_VMOV_F,r0,r1) # define VMOV_F32(r0,r1) CC_VMOV_F32(ARM_CC_AL,r0,r1) # define CC_VMOV_F64(cc,r0,r1) cc_vo_dd(cc,ARM_VMOV_F|ARM_V_F64,r0,r1) @@ -320,6 +342,7 @@ static void _cc_vorsl(jit_state_t*,int,int,int,int,int); # define VMOV_V_I16(r0,r1) CC_VMOV_V_I16(ARM_CC_AL,r0,r1) # define CC_VMOV_V_I32(cc,r0,r1) cc_vori_(cc,ARM_VMOV_D_A,r1,r0) # define VMOV_V_I32(r0,r1) CC_VMOV_V_I32(ARM_CC_AL,r0,r1) +# define VCNT(r0,r1) vo_vv(ARM_VCNT,r0,r1) # define VADD_I8(r0,r1,r2) voddd(ARM_VADD_I,r0,r1,r2) # define VADDQ_I8(r0,r1,r2) voqqq(ARM_VADD_I|ARM_V_Q,r0,r1,r2) # define VADD_I16(r0,r1,r2) voddd(ARM_VADD_I|ARM_V_I16,r0,r1,r2) @@ -466,14 +489,25 @@ static void _cc_vorsl(jit_state_t*,int,int,int,int,int); # define VSTRN_F64(r0,r1,i0) CC_VSTRN_F64(ARM_CC_AL,r0,r1,i0) # define CC_VSTR_F64(cc,r0,r1,i0) cc_vldst(cc,ARM_VSTR|ARM_V_F64|ARM_P,r0,r1,i0) # define VSTR_F64(r0,r1,i0) CC_VSTR_F64(ARM_CC_AL,r0,r1,i0) +# define vfp_popcntr(r0,r1) _vfp_popcntr(_jit,r0,r1) +static void _vfp_popcntr(jit_state_t*,jit_int32_t,jit_int32_t); # define vfp_movr_f(r0,r1) _vfp_movr_f(_jit,r0,r1) static void _vfp_movr_f(jit_state_t*,jit_int32_t,jit_int32_t); -# define vfp_movr_d(r0,r1) _vfp_movr_d(_jit,r0,r1) -static void _vfp_movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define vfp_movi_f(r0,i0) _vfp_movi_f(_jit,r0,i0) static void _vfp_movi_f(jit_state_t*,jit_int32_t,jit_float32_t); +# define vfp_movr_w_f(r0, r1) VMOV_S_A(r0, r1) +# define vfp_movr_f_w(r0, r1) VMOV_A_S(r0, r1) +# define vfp_movi_w_f(r0, i0) _vfp_movi_w_f(_jit, r0, i0) +static void _vfp_movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); +# define vfp_movr_d(r0,r1) _vfp_movr_d(_jit,r0,r1) +static void _vfp_movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define vfp_movi_d(r0,i0) _vfp_movi_d(_jit,r0,i0) static void _vfp_movi_d(jit_state_t*,jit_int32_t,jit_float64_t); +# define vfp_movr_ww_d(r0, r1, r2) VMOV_D_AA(r0, r1, r2) +# define vfp_movr_d_ww(r0, r1, r2) VMOV_AA_D(r0, r1, r2) +static void _vfp_movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_movi_ww_d(r0, i0, i1) _vfp_movi_ww_d(_jit, r0, i0, i1) +static void _vfp_movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define vfp_extr_f(r0,r1) _vfp_extr_f(_jit,r0,r1) static void _vfp_extr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define vfp_extr_d(r0,r1) _vfp_extr_d(_jit,r0,r1) @@ -491,7 +525,31 @@ static void _vfp_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); # define vfp_negr_f(r0,r1) VNEG_F32(r0,r1) # define vfp_negr_d(r0,r1) VNEG_F64(r0,r1) # define vfp_sqrtr_f(r0,r1) VSQRT_F32(r0,r1) +# define vfp_fmar_f(r0,r1,r2,r3) _vfp_fmar_f(_jit,r0,r1,r2,r3) +static void _vfp_fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fmsr_f(r0,r1,r2,r3) _vfp_fmsr_f(_jit,r0,r1,r2,r3) +static void _vfp_fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fnmar_f(r0,r1,r2,r3) _vfp_fnmar_f(_jit,r0,r1,r2,r3) +static void _vfp_fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fnmsr_f(r0,r1,r2,r3) _vfp_fnmsr_f(_jit,r0,r1,r2,r3) +static void _vfp_fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define vfp_sqrtr_d(r0,r1) VSQRT_F64(r0,r1) +# define vfp_fmar_d(r0,r1,r2,r3) _vfp_fmar_d(_jit,r0,r1,r2,r3) +static void _vfp_fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fmsr_d(r0,r1,r2,r3) _vfp_fmsr_d(_jit,r0,r1,r2,r3) +static void _vfp_fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fnmar_d(r0,r1,r2,r3) _vfp_fnmar_d(_jit,r0,r1,r2,r3) +static void _vfp_fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define vfp_fnmsr_d(r0,r1,r2,r3) _vfp_fnmsr_d(_jit,r0,r1,r2,r3) +static void _vfp_fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define vfp_addr_f(r0,r1,r2) VADD_F32(r0,r1,r2) # define vfp_addi_f(r0,r1,i0) _vfp_addi_f(_jit,r0,r1,i0) static void _vfp_addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t); @@ -790,6 +848,10 @@ static void _vfp_ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); static void _vfp_ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define vfp_ldxi_d(r0,r1,i0) _vfp_ldxi_d(_jit,r0,r1,i0) static void _vfp_ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define vfp_unldr_x(r0, r1, i0) _vfp_unldr_x(_jit, r0, r1, i0) +static void _vfp_unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define vfp_unldi_x(r0, i0, i1) _vfp_unldi_x(_jit, r0, i0, i1) +static void _vfp_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define vfp_str_f(r0,r1) VSTR_F32(r1,r0,0) # define vfp_str_d(r0,r1) VSTR_F64(r1,r0,0) # define vfp_sti_f(i0,r0) _vfp_sti_f(_jit,i0,r0) @@ -804,6 +866,10 @@ static void _vfp_stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); static void _vfp_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); # define vfp_stxi_d(i0,r0,r1) _vfp_stxi_d(_jit,i0,r0,r1) static void _vfp_stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define vfp_unstr_x(r0, r1, i0) _vfp_unstr_x(_jit, r0, r1, i0) +static void _vfp_unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define vfp_unsti_x(i0, r0, i1) _vfp_unsti_x(_jit, i0, r0, i1) +static void _vfp_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define vfp_vaarg_d(r0, r1) _vfp_vaarg_d(_jit, r0, r1) static void _vfp_vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t); #endif @@ -1061,6 +1127,21 @@ _cc_vorv_(jit_state_t *_jit, int cc, int o, int r0, int r1) ii(thumb.i); } +static void +_cc_vo_vv(jit_state_t *_jit, int cc, int o, int r0, int r1) +{ + jit_thumb_t thumb; + assert(!(cc & 0x0fffffff)); + assert(!(o & 0xf000f00f)); + r0 = vfp_regno(r0); + r1 = vfp_regno(r1); + thumb.i = cc|o|(_u4(r1)<<12)|_u4(r0); + if (jit_thumb_p()) + iss(thumb.s[0], thumb.s[1]); + else + ii(thumb.i); +} + static void _cc_vori_(jit_state_t *_jit, int cc, int o, int r0, int r1) { @@ -1205,41 +1286,23 @@ _cc_vorsl(jit_state_t *_jit, int cc, int o, int r0, int r1, int i0) } static void -_vfp_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_vfp_popcntr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { - if (r0 != r1) { - if (jit_fpr_p(r1)) { - if (jit_fpr_p(r0)) - VMOV_F32(r0, r1); - else - VMOV_A_S(r0, r1); - } - else if (jit_fpr_p(r0)) - VMOV_S_A(r0, r1); - else - movr(r0, r1); - } + jit_int32_t reg; + reg = jit_get_reg(jit_class_fpr); + VMOV_S_A(rn(reg), r1); + VCNT(rn(reg), rn(reg)); + VADD_I8(rn(reg), rn(reg), rn(reg)); + VMOV_A_S(r0, rn(reg)); + jit_unget_reg(reg); } static void -_vfp_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_vfp_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { - if (r0 != r1) { - if (jit_fpr_p(r1)) { - if (jit_fpr_p(r0)) - VMOV_F64(r0, r1); - else - VMOV_AA_D(r0, r0 + 1, r1); - } - else if (jit_fpr_p(r0)) - VMOV_D_AA(r0, r1, r1 + 1); - else { - /* minor consistency check */ - assert(r0 + 1 != r1 && r0 -1 != r1); - movr(r0, r1); - movr(r0 + 1, r1 + 1); - } - } + assert(jit_fpr_p(r0) && jit_fpr_p(r1)); + if (r0 != r1) + VMOV_F32(r0, r1); } static void @@ -1252,22 +1315,50 @@ _vfp_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) jit_int32_t reg; jit_int32_t code; u.f = i0; - if (jit_fpr_p(r0)) { - /* float arguments are packed, for others, - * lightning only address even registers */ - if (!(r0 & 1) && (r0 - 32) >= 0 && - ((code = encode_vfp_double(1, 0, u.i, u.i)) != -1 || - (code = encode_vfp_double(1, 1, ~u.i, ~u.i)) != -1)) - VIMM(code, r0); - else { - reg = jit_get_reg(jit_class_gpr); - movi(rn(reg), u.i); - VMOV_S_A(r0, rn(reg)); - jit_unget_reg(reg); - } + assert(jit_fpr_p(r0)); + /* float arguments are packed, for others, + * lightning only address even registers */ + if (!(r0 & 1) && (r0 - 32) >= 0 && + ((code = encode_vfp_double(1, 0, u.i, u.i)) != -1 || + (code = encode_vfp_double(1, 1, ~u.i, ~u.i)) != -1)) + VIMM(code, r0); + else { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), u.i); + VMOV_S_A(r0, rn(reg)); + jit_unget_reg(reg); } - else - movi(r0, u.i); +} + +static void +_vfp_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + assert(jit_fpr_p(r0) && jit_fpr_p(r1)); + if (r0 != r1) + VMOV_F64(r0, r1); +} + +static void +_vfp_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + vfp_movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_vfp_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + vfp_movr_ww_d(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); } static void @@ -1280,23 +1371,23 @@ _vfp_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) jit_int32_t code; jit_int32_t rg0, rg1; u.d = i0; - if (jit_fpr_p(r0)) { - if ((code = encode_vfp_double(1, 0, u.i[0], u.i[1])) != -1 || - (code = encode_vfp_double(1, 1, ~u.i[0], ~u.i[1])) != -1) - VIMM(code, r0); - else { - rg0 = jit_get_reg(jit_class_gpr); - rg1 = jit_get_reg(jit_class_gpr); - movi(rn(rg0), u.i[0]); - movi(rn(rg1), u.i[1]); - VMOV_D_AA(r0, rn(rg0), rn(rg1)); - jit_unget_reg(rg1); - jit_unget_reg(rg0); - } - } +# if __BYTE_ORDER == __BIG_ENDIAN + code = u.i[0]; + u.i[0] = u.i[1]; + u.i[1] = code; +# endif + assert(jit_fpr_p(r0)); + if ((code = encode_vfp_double(1, 0, u.i[0], u.i[1])) != -1 || + (code = encode_vfp_double(1, 1, ~u.i[0], ~u.i[1])) != -1) + VIMM(code, r0); else { - movi(r0, u.i[0]); - movi(r0 + 1, u.i[1]); + rg0 = jit_get_reg(jit_class_gpr); + rg1 = jit_get_reg(jit_class_gpr); + movi(rn(rg0), u.i[0]); + movi(rn(rg1), u.i[1]); + VMOV_D_AA(r0, rn(rg0), rn(rg1)); + jit_unget_reg(rg1); + jit_unget_reg(rg0); } } @@ -1416,6 +1507,254 @@ _vfp_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) jit_unget_reg(reg); } +static void +_vfp_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_f(r0, r1); + VFMA_F32(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_f(rn(t0), r1); + VFMA_F32(rn(t0), r2, r3); + vfp_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + vfp_mulr_f(r0, r1, r2); + vfp_addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_mulr_f(rn(t0), r1, r2); + vfp_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_vfp_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_f(r0, r1); + VFMS_F32(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_f(rn(t0), r1); + VFMS_F32(rn(t0), r2, r3); + vfp_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + vfp_negr_f(r0, r0); + } + else { + if (r0 != r3) { + vfp_mulr_f(r0, r1, r2); + vfp_subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_mulr_f(rn(t0), r1, r2); + vfp_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_vfp_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_f(r0, r1); + VFNMA_F32(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_f(rn(t0), r1); + VFNMA_F32(rn(t0), r2, r3); + vfp_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_negr_f(rn(t0), r1); + vfp_mulr_f(rn(t0), rn(t0), r2); + vfp_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_vfp_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_f(r0, r1); + VFNMS_F32(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_f(rn(t0), r1); + VFNMS_F32(rn(t0), r2, r3); + vfp_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + vfp_negr_f(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_negr_f(rn(t0), r1); + vfp_mulr_f(rn(t0), rn(t0), r2); + vfp_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_vfp_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_d(r0, r1); + VFMA_F64(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_d(rn(t0), r1); + VFMA_F64(rn(t0), r2, r3); + vfp_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + vfp_mulr_d(r0, r1, r2); + vfp_addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_mulr_d(rn(t0), r1, r2); + vfp_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_vfp_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_d(r0, r1); + VFMS_F64(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_d(rn(t0), r1); + VFMS_F64(rn(t0), r2, r3); + vfp_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + vfp_negr_d(r0, r0); + } + else { + if (r0 != r3) { + vfp_mulr_d(r0, r1, r2); + vfp_subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_mulr_d(rn(t0), r1, r2); + vfp_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_vfp_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_d(r0, r1); + VFNMA_F64(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_d(rn(t0), r1); + VFNMA_F64(rn(t0), r2, r3); + vfp_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_negr_d(rn(t0), r1); + vfp_mulr_d(rn(t0), rn(t0), r2); + vfp_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_vfp_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + /* untested */ + if (0 && jit_cpu.vfp >= 4) { + if (r0 != r2 && r0 != r3) { + vfp_movr_d(r0, r1); + VFNMS_F64(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_movr_d(rn(t0), r1); + VFNMS_F64(rn(t0), r2, r3); + vfp_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + vfp_negr_d(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + vfp_negr_d(rn(t0), r1); + vfp_mulr_d(rn(t0), rn(t0), r2); + vfp_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + # define fopi(name) \ static void \ _vfp_##name##i_f(jit_state_t *_jit, \ @@ -2175,6 +2514,107 @@ _vfp_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_vfp_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i0 == 4 || i0 == 8); + if (jit_vfp_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + if (jit_unaligned_p()) + unldr(r2, r1, 4); + else + ldr(r2, r1); + vfp_movr_w_f(r0, r2); + } + else { + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + if (jit_unaligned_p()) { + unldr(r2, r1, 4); + addi(r3, r1, 4); + unldr(r3, r3, 4); + } + else { + ldr(r2, r1); + ldxi(r3, r1, 4); + } +#else + if (jit_unaligned_p()) { + unldr(r3, r1, 4); + addi(r2, r1, 4); + unldr(r2, r2, 4); + } + else { + ldr(r3, r1); + ldxi(r2, r1, 4); + } +#endif + vfp_movr_ww_d(r0, r2, r3); + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + vfp_ldr_f(r0, r1); + else + vfp_ldr_d(r0, r1); + } +} + +static void +_vfp_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i1 == 4 || i1 == 8); + if (jit_vfp_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + unldi(r2, i0, 4); + vfp_movr_w_f(r0, r2); + } + else { + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + if (jit_unaligned_p()) { + unldi(r2, i0, 4); + unldi(r3, i0 + 4, 4); + } + else { + ldi(r2, i0); + ldi(r3, i0 + 4); + } +#else + if (jit_unaligned_p()) { + unldi(r3, i0, 4); + unldi(r2, i0 + 4, 4); + } + else { + ldi(r3, i0); + ldi(r2, i0 + 4); + } +#endif + vfp_movr_ww_d(r0, r3, r2); + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + vfp_ldi_f(r0, i0); + else + vfp_ldi_d(r0, i0); + } +} + static void _vfp_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -2304,6 +2744,110 @@ _vfp_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_vfp_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i0 == 4 || i0 == 8); + if (jit_vfp_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + vfp_movr_f_w(r2, r1); + if (jit_unaligned_p()) + unstr(r0, r2, 4); + else + str(r0, r2); + } + else { + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); + vfp_movr_d_ww(r2, r3, r1); +#if __BYTE_ORDER == __LITTLE_ENDIAN + if (jit_unaligned_p()) { + unstr(r0, r2, 4); + addi(r2, r0, 4); + unstr(r2, r3, 4); + } + else { + str(r0, r2); + stxi(4, r0, r3); + } +#else + if (jit_unaligned_p()) { + unstr(r0, r3, 4); + addi(r3, r0, 4); + unstr(r3, r2, 4); + } + else { + str(r0, r3); + stxi(4, r0, r2); + } +#endif + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i0 == 4) + vfp_str_f(r0, r1); + else + vfp_str_d(r0, r1); + } +} + +static void +_vfp_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + jit_int32_t t1, r3; + assert(i1 == 4 || i1 == 8); + if (jit_vfp_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + vfp_movr_f_w(r2, r0); + if (jit_unaligned_p()) + unsti(i0, r2, 4); + else + sti(i0, r2); + } + else { + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); + vfp_movr_d_ww(r2, r3, r0); +#if __BYTE_ORDER == __LITTLE_ENDIAN + if (jit_unaligned_p()) { + unsti(i0, r3, 4); + unsti(i0 + 4, r2, 4); + } + else { + sti(i0, r3); + sti(i0 + 4, r2); + } +#else + if (jit_unaligned_p()) { + unsti(i0, r2, 4); + unsti(i0 + 4, r3, 4); + } + else { + sti(i0, r2); + sti(i0 + 4, r3); + } +#endif + jit_unget_reg(t1); + } + jit_unget_reg(t0); + } + else { + if (i1 == 4) + vfp_sti_f(i0, r0); + else + vfp_sti_d(i0, r0); + } +} + static void _vfp_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_arm.c b/deps/lightning/lib/jit_arm.c index 64a70f96..25aa7cbb 100644 --- a/deps/lightning/lib/jit_arm.c +++ b/deps/lightning/lib/jit_arm.c @@ -240,6 +240,11 @@ jit_get_cpu(void) /* do not generate hardware integer division by default */ if (jit_cpu.version == 7) jit_cpu.extend = 0; + + /* By default generate extra instructions for unaligned load/store. */ + jit_cpu.unaligned = 1; + /* Linux should only not handle unaligned vfp load/store */ + jit_cpu.vfp_unaligned = 1; } void @@ -1337,6 +1342,16 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.w), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + if (jit_swf_p()) \ + swf_##name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w));\ + else \ + vfp_##name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w));\ + case jit_code_##name##i##type: \ + break #define case_rrrr(name, type) \ case jit_code_##name##r##type: \ name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ @@ -1558,6 +1573,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1576,16 +1595,38 @@ _emit_code(jit_state_t *_jit) case_rrw(rem, _u); case_rrr(lsh,); case_rrw(lsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); + case_rr(popcnt,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1614,6 +1655,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _us); case_rrr(ldx, _i); case_rrw(ldx, _i); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1626,10 +1679,28 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _s); case_rrr(stx, _i); case_wrr(stx, _i); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); case_rr(bswap, _us); case_rr(bswap, _ui); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1734,15 +1805,43 @@ _emit_code(jit_state_t *_jit) case_vv(abs, _f); case_vv(neg, _f); case_vv(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_vv(ext, _f); case_vv(ld, _f); case_vw(ld, _f); case_vvv(ldx, _f); case_vvw(ldx, _f); + case jit_code_unldr_x: + if (jit_swf_p()) + swf_unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + else + vfp_unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + if (jit_swf_p()) + swf_unldi_x(rn(node->u.w), node->v.w, node->w.w); + else + vfp_unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_vv(st, _f); case_wv(st, _f); case_vvv(stx, _f); case_wvv(stx, _f); + case jit_code_unstr_x: + if (jit_swf_p()) + swf_unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + else + vfp_unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + if (jit_swf_p()) + swf_unsti_x(node->u.w, rn(node->v.w), node->w.w); + else + vfp_unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_vv(mov, _f); case jit_code_movi_f: assert_data(node); @@ -1820,6 +1919,10 @@ _emit_code(jit_state_t *_jit) case_vv(abs, _d); case_vv(neg, _d); case_vv(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_vv(ext, _d); case_vv(ld, _d); case_vw(ld, _d); @@ -2028,41 +2131,46 @@ _emit_code(jit_state_t *_jit) break; case jit_code_movr_w_f: if (jit_swf_p()) - swf_movr_f(rn(node->u.w), rn(node->v.w)); + swf_movr_w_f(rn(node->u.w), rn(node->v.w)); else - vfp_movr_f(rn(node->u.w), rn(node->v.w)); + vfp_movr_w_f(rn(node->u.w), rn(node->v.w)); break; case jit_code_movr_f_w: if (jit_swf_p()) - swf_movr_f(rn(node->u.w), rn(node->v.w)); + swf_movr_f_w(rn(node->u.w), rn(node->v.w)); else - vfp_movr_f(rn(node->u.w), rn(node->v.w)); + vfp_movr_f_w(rn(node->u.w), rn(node->v.w)); break; case jit_code_movi_f_w: assert_data(node); + movi_f_w(rn(node->u.w), node->v.f); + break; + case jit_code_movi_w_f: if (jit_swf_p()) - swf_movi_f(rn(node->u.w), node->v.f); + swf_movi_w_f(rn(node->u.w), node->v.w); else - vfp_movi_f(rn(node->u.w), node->v.f); + vfp_movi_w_f(rn(node->u.w), node->v.w); break; case jit_code_movr_ww_d: if (jit_swf_p()) - swf_movr_d(rn(node->u.w), rn(node->v.w)); + swf_movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); else - vfp_movr_d(rn(node->u.w), rn(node->v.w)); + vfp_movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); break; case jit_code_movr_d_ww: if (jit_swf_p()) - swf_movr_d(rn(node->u.w), rn(node->w.w)); + swf_movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); else - vfp_movr_d(rn(node->u.w), rn(node->w.w)); + vfp_movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); break; case jit_code_movi_d_ww: - assert_data(node); + movi_d_ww(rn(node->u.w), rn(node->v.w), node->w.d); + break; + case jit_code_movi_ww_d: if (jit_swf_p()) - swf_movi_d(rn(node->u.w), node->w.d); + swf_movi_ww_d(rn(node->u.w), node->v.w, node->w.w); else - vfp_movi_d(rn(node->u.w), node->w.d); + vfp_movi_ww_d(rn(node->u.w), node->v.w, node->w.w); break; case jit_code_va_start: vastart(rn(node->u.w)); @@ -2115,6 +2223,63 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); @@ -2124,12 +2289,19 @@ _emit_code(jit_state_t *_jit) /* update register live state */ jit_reglive(node); +#if defined JIT_INSTR_MAX + word = 4096 - JIT_INSTR_MAX; +#else + word = 3968; +#endif + /* longest sequence should be 64 bytes, but preventively + * do not let it go past 256 remaining bytes before a flush */ + if (word > 3968) + word = 3968; if (_jitc->consts.length && - (_jit->pc.uc - _jitc->consts.data >= 3968 || + (_jit->pc.uc - _jitc->consts.data >= word || (jit_uword_t)_jit->pc.uc - - (jit_uword_t)_jitc->consts.patches[0] >= 3968)) { - /* longest sequence should be 64 bytes, but preventively - * do not let it go past 128 remaining bytes before a flush */ + (jit_uword_t)_jitc->consts.patches[0] >= word)) { if (node->next && node->next->code != jit_code_jmpi && node->next->code != jit_code_jmpr && diff --git a/deps/lightning/lib/jit_fallback.c b/deps/lightning/lib/jit_fallback.c index 2f7f214e..83e05104 100644 --- a/deps/lightning/lib/jit_fallback.c +++ b/deps/lightning/lib/jit_fallback.c @@ -1,4 +1,7 @@ #if PROTO +#define USE_BIT_TABLES 1 +#define USE_BITSWAP_UNROLLED 0 +#define USE_BITSWAP_LOOP 0 #define fallback_save(r0) _fallback_save(_jit, r0) static void _fallback_save(jit_state_t*, jit_int32_t); #define fallback_load(r0) _fallback_load(_jit, r0) @@ -12,6 +15,55 @@ static void _fallback_calli(jit_state_t*, jit_word_t, jit_word_t); #define fallback_casx(r0,r1,r2,r3,im) _fallback_casx(_jit,r0,r1,r2,r3,im) static void _fallback_casx(jit_state_t *, jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t, jit_word_t); +#if !defined(__arm__) +# ifndef movr_w_f +# define movr_w_f(r0, r1) fallback_movr_w_f(r0, r1) +# define fallback_movr_w_f(r0,r1) _fallback_movr_w_f(_jit,r0,r1) +static void _fallback_movr_w_f(jit_state_t*, jit_int32_t, jit_int32_t); +# endif +# ifndef movr_f_w +# define movr_f_w(r0, r1) fallback_movr_f_w(r0, r1) +# define fallback_movr_f_w(r0,r1) _fallback_movr_f_w(_jit,r0,r1) +static void _fallback_movr_f_w(jit_state_t*, jit_int32_t, jit_int32_t); +# endif +# if __WORDSIZE == 32 +# ifndef movr_ww_d +# define movr_ww_d(r0, r1, r2) fallback_movr_ww_d(r0, r1, r2) +# define fallback_movr_ww_d(r0,r1,r2) _fallback_movr_ww_d(_jit,r0,r1,r2) +static void _fallback_movr_ww_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t); +# endif +# ifndef movr_d_ww +# define fallback_movr_d_ww(r0,r1,r2) _fallback_movr_d_ww(_jit,r0,r1,r2) +static void _fallback_movr_d_ww(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t); +# define movr_d_ww(r0, r1, r2) fallback_movr_d_ww(r0, r1, r2) +# endif +# else +# ifndef movr_w_d +# define movr_w_d(r0, r1) fallback_movr_w_d(r0, r1); +# define fallback_movr_w_d(r0,r1) _fallback_movr_w_d(_jit,r0,r1) +static void _fallback_movr_w_d(jit_state_t*, jit_int32_t, jit_int32_t); +# endif +# ifndef movr_d_w +# define movr_d_w(r0, r1) fallback_movr_d_w(r0, r1); +# define fallback_movr_d_w(r0,r1) _fallback_movr_d_w(_jit,r0,r1) +static void _fallback_movr_d_w(jit_state_t*, jit_int32_t, jit_int32_t); +# endif +# endif +#endif +#ifndef unldr +# define unldr(r0, r1, i0) fallback_unldr(r0, r1, i0) +#endif +#ifndef unldi +# define unldi(r0, i0, i1) fallback_unldi(r0, i0, i1) +#endif +#ifndef unstr +# define unstr(r0, r1, i0) fallback_unstr(r0, r1, i0) +#endif +#ifndef unsti +# define unsti(i0, r0, i1) fallback_unsti(i0, r0, i1) +#endif #define fallback_clo(r0,r1) _fallback_clo(_jit,r0,r1) static void _fallback_clo(jit_state_t*, jit_int32_t, jit_int32_t); #define fallback_clz(r0,r1) _fallback_clz(_jit,r0,r1) @@ -20,46 +72,235 @@ static void _fallback_clz(jit_state_t*, jit_int32_t, jit_int32_t); static void _fallback_cto(jit_state_t*, jit_int32_t, jit_int32_t); #define fallback_ctz(r0,r1) _fallback_ctz(_jit,r0,r1) static void _fallback_ctz(jit_state_t*, jit_int32_t, jit_int32_t); -# if defined(__ia64__) -# define fallback_patch_jmpi(inst,lbl) \ - do { \ - sync(); \ - patch_at(jit_code_jmpi, inst, lbl); \ - } while (0) +#define fallback_rbit(r0,r1) _fallback_rbit(_jit, r0, r1) +static void _fallback_rbit(jit_state_t*, jit_int32_t, jit_int32_t); +#define fallback_popcnt(r0,r1) _fallback_popcnt(_jit, r0, r1) +static void _fallback_popcnt(jit_state_t*, jit_int32_t, jit_int32_t); +#define fallback_lrotr(r0, r1, r2) _fallback_lrotr(_jit, r0, r1, r2) +static void _fallback_lrotr(jit_state_t*, jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_lroti(r0, r1, i0) _fallback_lroti(_jit, r0, r1, i0) +static void _fallback_lroti(jit_state_t*, jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_rrotr(r0, r1, r2) _fallback_rrotr(_jit, r0, r1, r2) +static void _fallback_rrotr(jit_state_t*, jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_rroti(r0, r1, i0) _fallback_rroti(_jit, r0, r1, i0) +static void _fallback_rroti(jit_state_t*, jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_ext(r0,r1,i0,i1) _fallback_ext(_jit,r0,r1,i0,i1) +static void _fallback_ext(jit_state_t*, + jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define fallback_ext_u(r0,r1,i0,i1) _fallback_ext_u(_jit,r0,r1,i0,i1) +static void _fallback_ext_u(jit_state_t*, + jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define fallback_dep(r0,r1,i0,i1) _fallback_dep(_jit,r0,r1,i0,i1) +static void _fallback_dep(jit_state_t*, + jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define fallback_qlshr(r0,r1,r2,r3) _fallback_qlshr(_jit,r0,r1,r2,r3) +static void _fallback_qlshr(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_qlshi(r0,r1,r2,i0) _fallback_qlshi(_jit,r0,r1,r2,i0) +static void _fallback_qlshi(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_qlshr_u(r0,r1,r2,r3) _fallback_qlshr_u(_jit,r0,r1,r2,r3) +static void _fallback_qlshr_u(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_qlshi_u(r0,r1,r2,i0) _fallback_qlshi_u(_jit,r0,r1,r2,i0) +static void _fallback_qlshi_u(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_qrshr(r0,r1,r2,r3) _fallback_qrshr(_jit,r0,r1,r2,r3) +static void _fallback_qrshr(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_qrshi(r0,r1,r2,i0) _fallback_qrshi(_jit,r0,r1,r2,i0) +static void _fallback_qrshi(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_qrshr_u(r0,r1,r2,r3) _fallback_qrshr_u(_jit,r0,r1,r2,r3) +static void _fallback_qrshr_u(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fallback_qrshi_u(r0,r1,r2,i0) _fallback_qrshi_u(_jit,r0,r1,r2,i0) +static void _fallback_qrshi_u(jit_state_t *_jit, + jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +#define unldr2(r0, r1, sign) _unldr2(_jit, r0, r1, sign) +static void _unldr2(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +#define unldi2(r0, i1, sign) _unldi2(_jit, r0, i1, sign) +static void _unldi2(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +#define unldr3(r0, r1, sign) _unldr3(_jit, r0, r1, sign) +static void _unldr3(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +#define unldi3(r0, i1, sign) _unldi3(_jit, r0, i1, sign) +static void _unldi3(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +#if __WORDSIZE == 32 +# define unldr4(r0, r1) _unldr4(_jit, r0, r1) +static void _unldr4(jit_state_t*,jit_int32_t,jit_int32_t); +# define unldi4(r0, i1) _unldi4(_jit, r0, i1) +static void _unldi4(jit_state_t*,jit_int32_t,jit_word_t); +#else +# define unldr4(r0, r1, sign) _unldr4(_jit, r0, r1, sign) +static void _unldr4(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +# define unldi4(r0, i1, sign) _unldi4(_jit, r0, i1, sign) +static void _unldi4(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +# define unldr5(r0, r1, sign) _unldr5(_jit, r0, r1, sign) +static void _unldr5(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +# define unldi5(r0, i1, sign) _unldi5(_jit, r0, i1, sign) +static void _unldi5(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +# define unldr6(r0, r1, sign) _unldr6(_jit, r0, r1, sign) +static void _unldr6(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +# define unldi6(r0, i1, sign) _unldi6(_jit, r0, i1, sign) +static void _unldi6(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +# define unldr7(r0, r1, sign) _unldr7(_jit, r0, r1, sign) +static void _unldr7(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t); +# define unldi7(r0, i1, sign) _unldi7(_jit, r0, i1, sign) +static void _unldi7(jit_state_t*,jit_int32_t,jit_word_t,jit_bool_t); +# define unldr8(r0, r1) _unldr8(_jit, r0, r1) +static void _unldr8(jit_state_t*,jit_int32_t,jit_int32_t); +# define unldi8(r0, i1) _unldi8(_jit, r0, i1) +static void _unldi8(jit_state_t*,jit_int32_t,jit_word_t); +#endif +#define unstr2(r0, r1) _unstr2(_jit, r0, r1) +static void _unstr2(jit_state_t*,jit_int32_t,jit_int32_t); +#define unsti2(r0, i0) _unsti2(_jit, r0, i0) +static void _unsti2(jit_state_t*,jit_int32_t,jit_word_t); +#define unstr3(r0, r1) _unstr3(_jit, r0, r1) +static void _unstr3(jit_state_t*,jit_int32_t,jit_int32_t); +#define unsti3(r0, i0) _unsti3(_jit, r0, i0) +static void _unsti3(jit_state_t*,jit_int32_t,jit_word_t); +#define unstr4(r0, r1) _unstr4(_jit, r0, r1) +static void _unstr4(jit_state_t*,jit_int32_t,jit_int32_t); +#define unsti4(r0, i0) _unsti4(_jit, r0, i0) +static void _unsti4(jit_state_t*,jit_int32_t,jit_word_t); +#if __WORDSIZE == 64 +# define unstr5(r0, r1) _unstr5(_jit, r0, r1) +static void _unstr5(jit_state_t*,jit_int32_t,jit_int32_t); +# define unsti5(r0, i0) _unsti5(_jit, r0, i0) +static void _unsti5(jit_state_t*,jit_int32_t,jit_word_t); +# define unstr6(r0, r1) _unstr6(_jit, r0, r1) +static void _unstr6(jit_state_t*,jit_int32_t,jit_int32_t); +# define unsti6(r0, i0) _unsti6(_jit, r0, i0) +static void _unsti6(jit_state_t*,jit_int32_t,jit_word_t); +# define unstr7(r0, r1) _unstr7(_jit, r0, r1) +static void _unstr7(jit_state_t*,jit_int32_t,jit_int32_t); +# define unsti7(r0, i0) _unsti7(_jit, r0, i0) +static void _unsti7(jit_state_t*,jit_int32_t,jit_word_t); +# define unstr8(r0, r1) _unstr8(_jit, r0, r1) +static void _unstr8(jit_state_t*,jit_int32_t,jit_int32_t); +# define unsti8(r0, i0) _unsti8(_jit, r0, i0) +static void _unsti8(jit_state_t*,jit_int32_t,jit_word_t); +#endif +#define unldrw(r0, r1, i0) _unldrw(_jit, r0, r1, i0) +static void _unldrw(jit_state_t*,jit_int32_t,jit_int32_t, jit_word_t); +#define unldiw(r0, i0, i1) _unldiw(_jit, r0, i0, i1) +static void _unldiw(jit_state_t*,jit_int32_t,jit_word_t, jit_word_t); +#define unldx(r0, i0) _unldx(_jit, r0, i0) +static void _unldx(jit_state_t*,jit_int32_t,jit_word_t); +#define unldx_u(r0, i0) _unldx_u(_jit, r0, i0) +static void _unldx_u(jit_state_t*,jit_int32_t,jit_word_t); +#define fallback_unldr(r0, r1, i0) _fallback_unldr(_jit, r0, r1, i0) +static void _fallback_unldr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_unldi(r0, i0, i1) _fallback_unldi(_jit, r0, i0, i1) +static void _fallback_unldi(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t); +#define fallback_unldr_u(r0, r1, i0) _fallback_unldr_u(_jit, r0, r1, i0) +static void _fallback_unldr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_unldi_u(r0, i0, i1) _fallback_unldi_u(_jit, r0, i0, i1) +static void _fallback_unldi_u(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t); +#define fallback_unstr(r0, r1, i0) _fallback_unstr(_jit, r0, r1, i0) +static void _fallback_unstr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define fallback_unsti(i0, r0, i1) _fallback_unsti(_jit, i0, r0, i1) +static void _fallback_unsti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#if !defined(__arm__) +# define fallback_unldr_x(r0, r1, i0) _fallback_unldr_x(_jit, r0, r1, i0) +static void _fallback_unldr_x(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define fallback_unldi_x(r0, i0, i1) _fallback_unldi_x(_jit, r0, i0, i1) +static void _fallback_unldi_x(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t); +# define fallback_unstr_x(r0, r1, i0) _fallback_unstr_x(_jit, r0, r1, i0) +static void _fallback_unstr_x(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define fallback_unsti_x(i0, r0, i1) _fallback_unsti_x(_jit, i0, r0, i1) +static void _fallback_unsti_x(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t); +#endif +# if defined(__s390__) || defined(__s390x__) +# define fallback_jit_get_reg(flags) jit_get_reg_but_zero(flags) # else -# define fallback_patch_jmpi(inst,lbl) fallback_patch_at(inst,lbl) +# define fallback_jit_get_reg(flags) jit_get_reg(flags) # endif -# if defined(__arm__) -# define fallback_patch_at(inst,lbl) patch_at(arm_patch_jump,inst,lbl) -# elif defined(__ia64__) -# define fallback_patch_at(inst,lbl) \ - do { \ - sync(); \ - patch_at(jit_code_bnei, inst, lbl); \ - } while (0); +# if defined(__ia64__) +# define fallback_flush() sync() +# elif defined(__mips__) +# define fallback_flush() flush() # else -# define fallback_patch_at(inst,lbl) patch_at(inst,lbl) +# define fallback_flush() /**/ # endif # if defined(__mips__) -# define fallback_jmpi(i0) jmpi(i0,1) +# define fallback_jmpi(i0) jmpi(i0, 1) # elif defined(__arm__) -# define fallback_jmpi(i0) jmpi_p(i0,1) +# define fallback_jmpi(i0) jmpi_p(i0, 1) # elif defined(__s390__) || defined(__s390x__) -# define fallback_jmpi(i0) jmpi(i0,1) +# define fallback_jmpi(i0) jmpi(i0, 1) # else # define fallback_jmpi(i0) jmpi(i0) # endif -# if defined(__mips__) -# define fallback_bnei(i0,r0,i1) bnei(i0,r0,i1) -# elif defined(__s390__) || defined(__s390x__) -# define fallback_bnei(i0,r0,i1) bnei_p(i0,r0,i1) -# else -# define fallback_bnei(i0,r0,i1) bnei(i0,r0,i1) -# endif # if defined(__s390__) || defined(__s390x__) +# define fallback_beqr(i0,r0,i1) beqr_p(i0,r0,i1) +# define fallback_beqi(i0,r0,i1) beqi_p(i0,r0,i1) +# define fallback_bner(i0,r0,r1) bner_p(i0,r0,r1) +# define fallback_bnei(i0,r0,i1) bnei_p(i0,r0,i1) +# define fallback_blei(i0,r0,i1) blei_p(i0,r0,i1) # define fallback_bmsr(i0,r0,r1) bmsr_p(i0,r0,r1) +# define fallback_bmsi(i0,r0,i1) bmsi_p(i0,r0,i1) # else +# define fallback_beqr(i0,r0,r1) beqr(i0,r0,r1) +# define fallback_beqi(i0,r0,i1) beqi(i0,r0,i1) +# define fallback_bner(i0,r0,r1) bner(i0,r0,r1) +# define fallback_bnei(i0,r0,i1) bnei(i0,r0,i1) +# define fallback_blei(i0,r0,i1) blei(i0,r0,i1) # define fallback_bmsr(i0,r0,r1) bmsr(i0,r0,r1) +# define fallback_bmsi(i0,r0,i1) bmsi(i0,r0,i1) +# endif +# if defined(__ia64__) +# define fallback_patch_jmpi(inst, lbl) \ + patch_at(jit_code_jmpi, inst, lbl) +# define fallback_patch_beqr(inst, lbl) \ + patch_at(jit_code_beqr, inst, lbl) +# define fallback_patch_beqi(inst, lbl) \ + patch_at(jit_code_beqi, inst, lbl) +# define fallback_patch_bner(inst, lbl) \ + patch_at(jit_code_bner, inst, lbl) +# define fallback_patch_bnei(inst, lbl) \ + patch_at(jit_code_bnei, inst, lbl) +# define fallback_patch_blei(inst, lbl) \ + patch_at(jit_code_blei, inst, lbl) +# define fallback_patch_bmsr(inst, lbl) \ + patch_at(jit_code_bmsr, inst, lbl) +# define fallback_patch_bmsi(inst, lbl) \ + patch_at(jit_code_bmsi, inst, lbl) +# elif defined(__arm__) +# define fallback_patch_jmpi(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_beqr(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_beqi(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_bner(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_bnei(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_blei(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_bmsr(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) +# define fallback_patch_bmsi(inst, lbl) \ + patch_at(arm_patch_jump,inst, lbl) + # else +# define fallback_patch_jmpi(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_beqr(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_beqi(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_bner(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_bnei(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_blei(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_bmsr(inst, lbl) \ + patch_at(inst, lbl) +# define fallback_patch_bmsi(inst, lbl) \ + patch_at(inst, lbl) # endif #endif @@ -161,6 +402,7 @@ _fallback_calli(jit_state_t *_jit, jit_word_t i0, jit_word_t i1) # endif } +#ifdef NEED_FALLBACK_CASX static void _fallback_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_word_t i0) @@ -170,7 +412,7 @@ _fallback_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, /* XXX only attempts to fallback cas for lightning jit code */ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; if ((iscasi = r1 == _NOREG)) { - r1_reg = jit_get_reg(jit_class_gpr|jit_class_sav); + r1_reg = fallback_jit_get_reg(jit_class_gpr|jit_class_sav); r1 = rn(r1_reg); movi(r1, i0); } @@ -189,14 +431,149 @@ _fallback_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, str_l(r1, r3); # endif /* done: */ + fallback_flush(); done = _jit->pc.w; fallback_calli((jit_word_t)pthread_mutex_unlock, (jit_word_t)&mutex); fallback_load(r0); - fallback_patch_at(jump, done); + fallback_flush(); + fallback_patch_bnei(jump, done); fallback_load_regs(r0); if (iscasi) jit_unget_reg(r1_reg); } +#endif + +#ifdef fallback_movr_w_f +static void +_fallback_movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } + stxi_i(_jitc->function->cvt_offset, rn(JIT_FP), r1); + /* Useful for special debug builds */ +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_ldxi_f(r0, rn(JIT_FP), _jitc->function->cvt_offset); + else + x87_ldxi_f(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# else + ldxi_f(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# endif +} +#endif + +#ifdef fallback_movr_f_w +static void +_fallback_movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_stxi_f(_jitc->function->cvt_offset, rn(JIT_FP), r1); + else + x87_stxi_f(_jitc->function->cvt_offset, rn(JIT_FP), r1); +# else + stxi_f(_jitc->function->cvt_offset, rn(JIT_FP), r1); +# endif + ldxi_i(r0, rn(JIT_FP), _jitc->function->cvt_offset); +} +#endif + +#if __WORDSIZE == 32 +# ifdef fallback_movr_ww_d +static void +_fallback_movr_ww_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } + stxi_i(_jitc->function->cvt_offset, rn(JIT_FP), + __BYTE_ORDER == __LITTLE_ENDIAN ? r1 : r2); + stxi_i(_jitc->function->cvt_offset + 4, rn(JIT_FP), + __BYTE_ORDER == __LITTLE_ENDIAN ? r2 : r1); +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); + else + x87_ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# else + ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# endif +} +# endif + +# ifdef fallback_movr_d_ww +static void +_fallback_movr_d_ww(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r2); + else + x87_stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r2); +# else + stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r2); +# endif + ldxi_i(__BYTE_ORDER == __LITTLE_ENDIAN ? r0 : r1, + rn(JIT_FP), _jitc->function->cvt_offset); + ldxi_i(__BYTE_ORDER == __LITTLE_ENDIAN ? r1 : r0, + rn(JIT_FP), _jitc->function->cvt_offset + 4); +} +# endif + +#else +# ifdef fallback_movr_w_d +static void +_fallback_movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } + stxi_l(_jitc->function->cvt_offset, rn(JIT_FP), r1); +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); + else + x87_ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# else + ldxi_d(r0, rn(JIT_FP), _jitc->function->cvt_offset); +# endif +} +# endif + +# ifdef fallback_movr_d_w +static void +_fallback_movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (!_jitc->function->cvt_offset) { + _jitc->function->cvt_offset = jit_allocai(8); + _jitc->again = 1; + } +# if defined(__i386__) || defined(__x86_64__) + if (jit_cpu.sse2) + sse_stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r1); + else + x87_stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r1); +# else + stxi_d(_jitc->function->cvt_offset, rn(JIT_FP), r1); +# endif + ldxi_l(r0, rn(JIT_FP), _jitc->function->cvt_offset); +} +# endif +#endif static void _fallback_clo(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) @@ -205,63 +582,119 @@ _fallback_clo(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) comr(r0, r1); clz = fallback_bnei(_jit->pc.w, r0, 0); movi(r0, __WORDSIZE); + fallback_flush(); done = fallback_jmpi(_jit->pc.w); - fallback_patch_at(clz, _jit->pc.w); + fallback_flush(); + fallback_patch_bnei(clz, _jit->pc.w); fallback_clz(r0, r0); + fallback_flush(); fallback_patch_jmpi(done, _jit->pc.w); } static void _fallback_clz(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { +# if USE_BIT_TABLES + /* t0 = __WORDSIZE - 8; + * loop: + * t1 = r1 >> t0; + * if (t1) + * goto done; + * t0 -= 8; + * if (t0) + * goto loop; + * t1 = r1; + * done: + * r0 = __WORDSIZE - 8 - t0 + clz_tab[t1] + */ + /* Table below is count of leading zeros of 8 bit values. */ + static const jit_uint8_t clz_tab[256] = { + 8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + }; + jit_int32_t t0, t1; + jit_word_t loop, done; + t0 = fallback_jit_get_reg(jit_class_gpr); + t1 = fallback_jit_get_reg(jit_class_gpr); + movi(rn(t0), __WORDSIZE - 8); + fallback_flush(); + loop = _jit->pc.w; + rshr_u(rn(t1), r1, rn(t0)); + done = fallback_bnei(_jit->pc.w, rn(t1), 0); + subi(rn(t0), rn(t0), 8); + fallback_bnei(loop, rn(t0), 0); + movr(rn(t1), r1); + fallback_flush(); + fallback_patch_bnei(done, _jit->pc.w); + rsbi(r0, rn(t0), __WORDSIZE - 8); + movi(rn(t0), (jit_word_t)clz_tab); + ldxr_uc(rn(t1), rn(t0), rn(t1)); + addr(r0, r0, rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); +# else jit_int32_t r1_reg, r2, r2_reg; jit_word_t clz, l32, l16, l8, l4, l2, l1; l32 = fallback_bnei(_jit->pc.w, r1, 0); movi(r0, __WORDSIZE); clz = fallback_jmpi(_jit->pc.w); - fallback_patch_at(l32, _jit->pc.w); - r2_reg = jit_get_reg(jit_class_gpr); + fallback_flush(); + fallback_patch_bnei(l32, _jit->pc.w); + r2_reg = fallback_jit_get_reg(jit_class_gpr); r2 = rn(r2_reg); - r1_reg = jit_get_reg(jit_class_gpr); + r1_reg = fallback_jit_get_reg(jit_class_gpr); movr(rn(r1_reg), r1); r1 = rn(r1_reg); movi(r0, 0); -# if __WORDSIZE == 64 +# if __WORDSIZE == 64 movi(r2, 0xffffffff00000000UL); l32 = fallback_bmsr(_jit->pc.w, r1, r2); lshi(r1, r1, 32); addi(r0, r0, 32); - fallback_patch_at(l32, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l32, _jit->pc.w); lshi(r2, r2, 16); -# else +# else movi(r2, 0xffff0000UL); -# endif +# endif l16 = fallback_bmsr(_jit->pc.w, r1, r2); lshi(r1, r1, 16); addi(r0, r0, 16); - fallback_patch_at(l16, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l16, _jit->pc.w); lshi(r2, r2, 8); l8 = fallback_bmsr(_jit->pc.w, r1, r2); lshi(r1, r1, 8); addi(r0, r0, 8); - fallback_patch_at(l8, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l8, _jit->pc.w); lshi(r2, r2, 4); l4 = fallback_bmsr(_jit->pc.w, r1, r2); lshi(r1, r1, 4); addi(r0, r0, 4); - fallback_patch_at(l4, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l4, _jit->pc.w); lshi(r2, r2, 2); l2 = fallback_bmsr(_jit->pc.w, r1, r2); lshi(r1, r1, 2); addi(r0, r0, 2); - fallback_patch_at(l2, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l2, _jit->pc.w); lshi(r2, r2, 1); l1 = fallback_bmsr(_jit->pc.w, r1, r2); addi(r0, r0, 1); - fallback_patch_at(l1, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l1, _jit->pc.w); fallback_patch_jmpi(clz, _jit->pc.w); jit_unget_reg(r2_reg); jit_unget_reg(r1_reg); +# endif } static void @@ -272,61 +705,3544 @@ _fallback_cto(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) ctz = fallback_bnei(_jit->pc.w, r0, 0); movi(r0, __WORDSIZE); done = fallback_jmpi(_jit->pc.w); - fallback_patch_at(ctz, _jit->pc.w); + fallback_flush(); + fallback_patch_bnei(ctz, _jit->pc.w); fallback_ctz(r0, r0); + fallback_flush(); fallback_patch_jmpi(done, _jit->pc.w); } static void _fallback_ctz(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { +# if USE_BIT_TABLES + /* Adapted from http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightModLookup + * Table for 64 bits was recomputed choosing 67 as next prime number. + * The cost of the modulo might not compensate and could be better to + * use the alternate version (or rbit and use clz). + */ + jit_int32_t t0; +# if __WORDSIZE == 32 + static const jit_uint8_t mod37[] = { + 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, + 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, + 5, 20, 8, 19, 18 + }; + /* return mod37[(-r1 & r1) % 37]; */ +# else + static const jit_uint8_t mod67[] = { + 64, 0, 1, 39, 2, 15, 40, 23, 3, 12, 16, 59, 41, 19, 24, 54, + 4, 0, 13, 10, 17, 62, 60, 28, 42, 30, 20, 51, 25, 44, 55, 47, + 5, 32, 0, 38, 14, 22, 11, 58, 18, 53, 63, 9, 61, 27, 29, 50, + 43, 46, 31, 37, 21, 57, 52, 8, 26, 49, 45, 36, 56, 7, 48, 35, + 6, 34, 33 + }; + /* return mod67[(-r1 & r1) % 67]; */ +# endif + t0 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1) { + negr(rn(t0), r1); + andr(r0, rn(t0), r1); + } + else { + negr(r0, r1); + andr(r0, r0, r1); + } +# if __WORDSIZE == 32 + remi_u(r0, r0, 37); + movi(rn(t0), (jit_word_t)mod37); +# else + remi_u(r0, r0, 67); + movi(rn(t0), (jit_word_t)mod67); +# endif + ldxr_uc(r0, rn(t0), r0); + jit_unget_reg(t0); +# else jit_int32_t r1_reg, r2, r2_reg; jit_word_t ctz, l32, l16, l8, l4, l2, l1; l32 = fallback_bnei(_jit->pc.w, r1, 0); movi(r0, __WORDSIZE); ctz = fallback_jmpi(_jit->pc.w); - fallback_patch_at(l32, _jit->pc.w); - r2_reg = jit_get_reg(jit_class_gpr); + fallback_flush(); + fallback_patch_bnei(l32, _jit->pc.w); + r2_reg = fallback_jit_get_reg(jit_class_gpr); r2 = rn(r2_reg); - r1_reg = jit_get_reg(jit_class_gpr); + r1_reg = fallback_jit_get_reg(jit_class_gpr); movr(rn(r1_reg), r1); r1 = rn(r1_reg); movi(r0, 0); -# if __WORDSIZE == 64 +# if __WORDSIZE == 64 movi(r2, 0xffffffffUL); l32 = fallback_bmsr(_jit->pc.w, r1, r2); rshi_u(r1, r1, 32); addi(r0, r0, 32); - fallback_patch_at(l32, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l32, _jit->pc.w); rshi(r2, r2, 16); -# else +# else movi(r2, 0xffffUL); -# endif +# endif l16 = fallback_bmsr(_jit->pc.w, r1, r2); rshi_u(r1, r1, 16); addi(r0, r0, 16); - fallback_patch_at(l16, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l16, _jit->pc.w); rshi(r2, r2, 8); l8 = fallback_bmsr(_jit->pc.w, r1, r2); rshi_u(r1, r1, 8); addi(r0, r0, 8); - fallback_patch_at(l8, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l8, _jit->pc.w); rshi(r2, r2, 4); l4 = fallback_bmsr(_jit->pc.w, r1, r2); rshi_u(r1, r1, 4); addi(r0, r0, 4); - fallback_patch_at(l4, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l4, _jit->pc.w); rshi(r2, r2, 2); l2 = fallback_bmsr(_jit->pc.w, r1, r2); rshi_u(r1, r1, 2); addi(r0, r0, 2); - fallback_patch_at(l2, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l2, _jit->pc.w); rshi(r2, r2, 1); l1 = fallback_bmsr(_jit->pc.w, r1, r2); addi(r0, r0, 1); - fallback_patch_at(l1, _jit->pc.w); + fallback_flush(); + fallback_patch_bmsr(l1, _jit->pc.w); fallback_patch_jmpi(ctz, _jit->pc.w); jit_unget_reg(r2_reg); jit_unget_reg(r1_reg); +# endif +} + +static void +_fallback_rbit(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ +# if USE_BIT_TABLES + /* t0 = r1; + * t1 = t0 & 0xff; + * t2 = swap_tab; + * r0 = t2[t1]; + * t3 = 8; + * loop: + * t1 = t0 >> t3; + * t1 &= 0xff; + * r0 <<= 8; + * r0 |= t2[t1]; + * t3 += 8; + * if (t3 < __WORDSIZE) + * goto loop; + */ + jit_word_t loop; + jit_int32_t t0, r1_reg, t1, t2, t3; + static const unsigned char swap_tab[256] = { + 0, 128, 64, 192, 32, 160, 96, 224, + 16, 144, 80, 208, 48, 176, 112, 240, + 8, 136, 72, 200, 40, 168, 104, 232, + 24, 152, 88, 216 ,56, 184, 120, 248, + 4, 132, 68, 196, 36, 164, 100, 228, + 20, 148, 84, 212, 52, 180, 116, 244, + 12, 140, 76, 204, 44, 172, 108, 236, + 28, 156, 92, 220, 60, 188, 124, 252, + 2, 130, 66, 194, 34, 162, 98, 226, + 18, 146, 82, 210, 50, 178, 114, 242, + 10, 138, 74, 202, 42, 170, 106, 234, + 26, 154, 90, 218, 58, 186, 122, 250, + 6, 134, 70, 198, 38, 166, 102, 230, + 22, 150, 86, 214, 54, 182, 118, 246, + 14, 142, 78, 206, 46, 174, 110, 238, + 30, 158, 94, 222, 62, 190, 126, 254, + 1, 129, 65, 193, 33, 161, 97, 225, + 17, 145, 81, 209, 49, 177, 113, 241, + 9, 137, 73, 201, 41, 169, 105, 233, + 25, 153, 89, 217, 57, 185, 121, 249, + 5, 133, 69, 197, 37, 165, 101, 229, + 21, 149, 85, 213, 53, 181, 117, 245, + 13, 141, 77, 205, 45, 173, 109, 237, + 29, 157, 93, 221, 61, 189, 125, 253, + 3, 131, 67, 195, 35, 163, 99, 227, + 19, 147, 83, 211, 51, 179, 115, 243, + 11, 139, 75, 203, 43, 171, 107, 235, + 27, 155, 91, 219, 59, 187, 123, 251, + 7, 135, 71, 199, 39, 167, 103, 231, + 23, 151, 87, 215, 55, 183, 119, 247, + 15, 143, 79, 207, 47, 175, 111, 239, + 31, 159, 95, 223, 63, 191, 127, 255 + }; + if (r0 == r1) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r1_reg = rn(t0); + } + else { + t0 = JIT_NOREG; + r1_reg = r1; + } + t1 = fallback_jit_get_reg(jit_class_gpr); + t2 = fallback_jit_get_reg(jit_class_gpr); + t3 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1) + movr(rn(t0), r1); + extr_uc(rn(t1), r1_reg); + movi(rn(t2), (jit_word_t)swap_tab); + ldxr_uc(r0, rn(t2), rn(t1)); + movi(rn(t3), 8); + fallback_flush(); + loop = _jit->pc.w; + rshr(rn(t1), r1_reg, rn(t3)); + extr_uc(rn(t1), rn(t1)); + lshi(r0, r0, 8); + ldxr_uc(rn(t1), rn(t2), rn(t1)); + orr(r0, r0, rn(t1)); + addi(rn(t3), rn(t3), 8); + blti(loop, rn(t3), __WORDSIZE); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + if (t0 != JIT_NOREG) + jit_unget_reg(t0); +# elif USE_BITSWAP_UNROLLED +/* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */ +/* +unsigned int v; // 32-bit word to reverse bit order + +// swap odd and even bits +v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1); +// swap consecutive pairs +v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2); +// swap nibbles ... +v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4); +// swap bytes +v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8); +// swap 2-byte long pairs +v = ( v >> 16 ) | ( v << 16); + */ + jit_int32_t t0, t1, t2, t3, t4; + movr(r0, r1); + t0 = fallback_jit_get_reg(jit_class_gpr); + t1 = fallback_jit_get_reg(jit_class_gpr); + t2 = fallback_jit_get_reg(jit_class_gpr); + movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L); + rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */ + andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ + andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ + lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ + movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L); + rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */ + andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ + andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ + lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ + movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL); + rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */ + andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ + andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ + lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ + movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL); + rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */ + andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ + andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ + lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ +# if __WORDSIZE == 32 + rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ + lshi(rn(t2), r0, 16); /* t2 = v << 16 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ +# else + movi(rn(t0), 0x0000ffff0000ffffL); + rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ + andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ + andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ + lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ + rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */ + lshi(rn(t2), r0, 32); /* t2 = v << 32 */ + orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ +# endif + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); +# elif USE_BITSWAP_LOOP +/* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */ +/* +unsigned int s = sizeof(v) * CHAR_BIT; // bit size; must be power of 2 +unsigned int mask = ~0; +while ((s >>= 1) > 0) +{ + mask ^= (mask << s); + v = ((v >> s) & mask) | ((v << s) & ~mask); +} +*/ + jit_int32_t s, mask; + jit_word_t loop, done, t0, t1; + movr(v, r1); + s = fallback_jit_get_reg(jit_class_gpr); + movi(rn(s), __WORDSIZE); /* s = sizeof(v) * CHAR_BIT; */ + mask = fallback_jit_get_reg(jit_class_gpr); + movi(rn(mask), ~0L); /* mask = ~0; */ + flush(); + loop = _jit->pc.w; /* while ((s >>= 1) > 0) */ + rshi(rn(s), rn(s), 1); /* (s >>= 1) */ + done = blei(_jit->pc.w, rn(s), 0); /* no loop if s <= 0 */ + t0 = fallback_jit_get_reg(jit_class_gpr); + lshr(rn(t0), rn(mask), rn(s)); /* t0 = (mask << s) */ + xorr(rn(mask), rn(mask), rn(t0)); /* mask ^= t0 */ + rshr(rn(t0), v, rn(s)); /* t0 = v >> s */ + andr(rn(t0), rn(t0), rn(mask)); /* t0 = t0 & mask */ + t1 = fallback_jit_get_reg(jit_class_gpr); + lshr(rn(t1), v, rn(s)); /* t1 = v << s */ + comr(v, rn(mask)); /* v = ~mask */ + andr(rn(t1), v, rn(t1)); /* t1 = t1 & v */ + orr(v, rn(t0), rn(t1)); /* v = t0 | t1 */ + jmpi(loop); + flush(); + patch_at(done, _jit->pc.w); + jit_unget_reg(t1); + jit_unget_reg(t0); + jit_unget_reg(mask); + jit_unget_reg(s); +# endif +} + +static void +_fallback_popcnt(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + /* Same approach as rbitr */ + /* t0 = r1; + * t1 = t0 & 0xff; + * t2 = pop_tab; + * r0 = t2[t1]; + * t3 = 8; + * loop: + * t1 = t0 >> t3; + * t1 &= 0xff; + * r0 <<= 8; + * r0 |= t2[t1]; + * t3 += 8; + * if (t3 < __WORDSIZE) + * goto loop; + */ + jit_word_t loop; + jit_int32_t t0, r1_reg, t1, t2, t3; + static const unsigned char pop_tab[256] = { + 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8 + }; + if (r0 == r1) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r1_reg = rn(t0); + } + else { + t0 = JIT_NOREG; + r1_reg = r1; + } + t1 = fallback_jit_get_reg(jit_class_gpr); + t2 = fallback_jit_get_reg(jit_class_gpr); + t3 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1) + movr(rn(t0), r1); + extr_uc(rn(t1), r1_reg); + movi(rn(t2), (jit_word_t)pop_tab); + ldxr_uc(r0, rn(t2), rn(t1)); + movi(rn(t3), 8); + fallback_flush(); + loop = _jit->pc.w; + rshr(rn(t1), r1_reg, rn(t3)); + extr_uc(rn(t1), rn(t1)); + ldxr_uc(rn(t1), rn(t2), rn(t1)); + addr(r0, r0, rn(t1)); + addi(rn(t3), rn(t3), 8); + blti(loop, rn(t3), __WORDSIZE); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + if (t0 != JIT_NOREG) + jit_unget_reg(t0); +} + +static void +_fallback_lrotr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + /* r0 = (r1 << r2) | (r1 >> (__WORDSIZE - r2)) */ + jit_int32_t t0, t1; + t0 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1 || r0 == r2) { + t1 = fallback_jit_get_reg(jit_class_gpr); + lshr(rn(t0), r1, r2); + rsbi(rn(t1), r2, __WORDSIZE); + rshr_u(rn(t1), r1, rn(t1)); + orr(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + } + else { + lshr(r0, r1, r2); + rsbi(rn(t0), r2, __WORDSIZE); + rshr_u(rn(t0), r1, rn(t0)); + orr(r0, r0, rn(t0)); + } + jit_unget_reg(t0); +} + +static void +_fallback_lroti(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0; + t0 = fallback_jit_get_reg(jit_class_gpr); + lshi(rn(t0), r1, i0); + rshi_u(r0, r1, __WORDSIZE - i0); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); +} + +static void +_fallback_rrotr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + /* r0 = (r1 >> r2) | (r1 << (__WORDSIZE - r2)) */ + jit_int32_t t0, t1; + t0 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1 || r0 == r2) { + t1 = fallback_jit_get_reg(jit_class_gpr); + rshr_u(rn(t0), r1, r2); + rsbi(rn(t1), r2, __WORDSIZE); + lshr(rn(t1), r1, rn(t1)); + orr(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + } + else { + rshr_u(r0, r1, r2); + rsbi(rn(t0), r2, __WORDSIZE); + lshr(rn(t0), r1, rn(t0)); + orr(r0, r0, rn(t0)); + } + jit_unget_reg(t0); +} + +static void +_fallback_rroti(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0; + t0 = fallback_jit_get_reg(jit_class_gpr); + rshi_u(rn(t0), r1, i0); + lshi(r0, r1, __WORDSIZE - i0); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); +} + +static void +_fallback_ext(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } +} + +static void +_fallback_ext_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (i0) + rshi_u(r0, r1, i0); + andi(r0, r0, (1L << i1) - 1); + } +} + +static void +_fallback_dep(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + mask = (1L << i1) - 1; + t0 = fallback_jit_get_reg(jit_class_gpr); + andi(rn(t0), r1, mask); + if (i0) { + lshi(rn(t0), rn(t0), i0); + mask <<= i0; + } + andi(r0, r0, ~mask); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fallback_qlshr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* r1 = __WORDSIZE - r3; + * if (r1 != __WORDSIZE) { + * r0 = r2 << r3; + * if (r3 != 0) + * r1 = r2 >> r1; + * else + * r1 = 0; + * } + * else { + * r1 = r2; + * r0 = 0; + * } + */ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = fallback_jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = fallback_jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = fallback_jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + rshr(r1, t2, t0); + zero = fallback_beqi(_jit->pc.w, t3, 0); + over = fallback_beqi(_jit->pc.w, t3, __WORDSIZE); + done = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_jmpi(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = fallback_jmpi(_jit->pc.w); + /* zero */ + fallback_flush(); + fallback_patch_beqi(zero, _jit->pc.w); + rshi(r1, t2, __WORDSIZE - 1); + fallback_flush(); + fallback_patch_jmpi(done, _jit->pc.w); + fallback_patch_jmpi(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_fallback_qlshi(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + assert((jit_uword_t)i0 <= __WORDSIZE); + if (i0 == 0) { + if (r0 != r2) { + movr(r0, r2); + rshi(r1, r2, __WORDSIZE - 1); + } + else + rshi(r1, r2, __WORDSIZE - 1); + } + else if (i0 != __WORDSIZE) { + rshi(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } + else { + movr(r1, r2); + movi(r0, 0); + } +} + +static void +_fallback_qlshr_u(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* r1 = __WORDSIZE - r3; + * if (r1 != __WORDSIZE) { + * r0 = r2 << r3; + * if (r3 != 0) + * r1 = (unsigned)r2 >> r1; + * else + * r1 = 0; + * } + * else { + * r1 = r2; + * r0 = 0; + * } + */ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = fallback_jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = fallback_jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = fallback_jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + rshr_u(r1, t2, t0); + zero = fallback_beqi(_jit->pc.w, t3, 0); + over = fallback_beqi(_jit->pc.w, t3, __WORDSIZE); + done = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_jmpi(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = fallback_jmpi(_jit->pc.w); + /* zero */ + fallback_flush(); + fallback_patch_beqi(zero, _jit->pc.w); + movi(r1, 0); + fallback_flush(); + fallback_patch_jmpi(done, _jit->pc.w); + fallback_patch_jmpi(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_fallback_qlshi_u(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + assert(i0 <= __WORDSIZE); + if (i0 == 0) { + movr(r0, r2); + movi(r1, 0); + } + else if (i0 != __WORDSIZE) { + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } + else { + movr(r1, r2); + movi(r0, 0); + } +} + +static void +_fallback_qrshr(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* r1 = __WORDSIZE - r3; + * if (r1 != __WORDSIZE) { + * r0 = r2 >> r3; + * if (r3 != 0) + * r1 = r2 << r1; + * else + * r1 = r2 >> (__WORDSIZE - 1); + * } + * else { + * r1 = r2; + * r0 = r2 >> (__WORDSIZE - 1); + * } + */ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = fallback_jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = fallback_jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = fallback_jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + rshr(r0, t2, t3); + lshr(r1, t2, t0); + zero = fallback_beqi(_jit->pc.w, t3, 0); + over = fallback_beqi(_jit->pc.w, t3, __WORDSIZE); + done = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_jmpi(over, _jit->pc.w); + /* underflow */ + rshi(r0, t2, __WORDSIZE - 1); + done_over = fallback_jmpi(_jit->pc.w); + /* zero */ + fallback_flush(); + fallback_patch_beqi(zero, _jit->pc.w); + rshi(r1, t2, __WORDSIZE - 1); + fallback_flush(); + fallback_patch_jmpi(done, _jit->pc.w); + fallback_patch_jmpi(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_fallback_qrshi(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + assert((jit_uword_t)i0 <= __WORDSIZE); + if (i0 == 0) { + if (r0 != r2) { + movr(r0, r2); + rshi(r1, r2, __WORDSIZE - 1); + } + else + rshi(r1, r2, __WORDSIZE - 1); + } + else if (i0 != __WORDSIZE) { + lshi(r1, r2, __WORDSIZE - i0); + rshi(r0, r2, i0); + } + else { + movr(r1, r2); + rshi(r0, r2, __WORDSIZE - 1); + } +} + +static void +_fallback_qrshr_u(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* r1 = __WORDSIZE - r3; + * if (r1 != __WORDSIZE) { + * r0 = (unsigned)r2 >> r3; + * if (r3 != 0) + * r1 = r2 << r1; + * else + * r1 = 0; + * } + * else { + * r1 = r2; + * r0 = 0; + * } + */ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = fallback_jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = fallback_jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = fallback_jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + zero = fallback_beqi(_jit->pc.w, t3, 0); + over = fallback_beqi(_jit->pc.w, t3, __WORDSIZE); + done = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_jmpi(over, _jit->pc.w); + /* underflow */ + movi(r0, 0); + done_over = fallback_jmpi(_jit->pc.w); + /* zero */ + fallback_flush(); + fallback_patch_beqi(zero, _jit->pc.w); + movi(r1, 0); + fallback_flush(); + fallback_patch_jmpi(done, _jit->pc.w); + fallback_patch_jmpi(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_fallback_qrshi_u(jit_state_t *_jit, jit_int32_t r0, + jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + assert((jit_uword_t)i0 <= __WORDSIZE); + if (i0 == 0) { + movr(r0, r2); + movi(r1, 0); + } + else if (i0 != __WORDSIZE) { + lshi(r1, r2, __WORDSIZE - i0); + rshi_u(r0, r2, i0); + } + else { + movr(r1, r2); + movi(r0, 0); + } +} + +static void +_unldr2(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + jit_word_t un2, al; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); + if (sign) + ldr_s(r0, r1); + else + ldr_us(r0, r1); + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + if (sign) + ldxi_c(r2, r1, 1); + else + ldxi_uc(r2, r1, 1); + lshi(r2, r2, 8); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 8); + ldxi_uc(r2, r1, 1); +# endif + orr(r0, r0, r2); + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unldi2(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + if ((i1 & -2) == i1) { + if (sign) + ldi_s(r0, i1); + else + ldi_us(r0, i1); + } + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + if (sign) + ldi_c(r2, i1 + 1); + else + ldi_uc(r2, i1 + 1); + lshi(r2, r2, 8); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 8); + ldi_uc(r2, i1 + 1); +# endif + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +static void +_unldr3(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + jit_word_t un2, or; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + if (sign) + ldxi_c(r2, r1, 2); + else + ldxi_uc(r2, r1, 2); + lshi(r2, r2, 16); +# else + if (sign) + ldr_s(r0, r1); + else + ldr_us(r0, r1); + lshi(r0, r0, 8); + ldxi_uc(r2, r1, 2); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + if (sign) + ldxi_s(r2, r1, 1); + else + ldxi_us(r2, r1, 1); + lshi(r2, r2, 8); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 16); + ldxi_us(r2, r1, 1); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldi3(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + if (sign) + ldi_c(r2, i1 + 2); + else + ldi_uc(r2, i1 + 2); + lshi(r2, r2, 16); +# else + if (sign) + ldi_s(r0, i1); + else + ldi_us(r0, i1); + lshi(r0, r0, 8); + ldi_uc(r2, i1 + 2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + if (sign) + ldi_s(r2, i1 + 1); + else + ldi_us(r2, i1 + 1); + lshi(r2, r2, 8); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 16); + ldi_us(r2, i1 + 1); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); } + +static void +_unldr4(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 +# if __WORDSIZE == 64 + , jit_bool_t sign +# endif + ) +{ + jit_int32_t t0, r2; + jit_word_t un4, un2, un3, al, or, or3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r1, r2); +# if __WORDSIZE == 64 + if (sign) +# endif + ldr_i(r0, r1); +# if __WORDSIZE == 64 + else + ldr_ui(r0, r1); +# endif + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); +# if __WORDSIZE == 64 + if (sign) + ldxi_s(r2, r1, 2); + else +# endif + ldxi_us(r2, r1, 2); + lshi(r2, r2, 16); +# else +# if __WORDSIZE == 64 + if (sign) + ldr_s(r0, r1); + else +# endif + ldr_us(r0, r1); + lshi(r0, r0, 16); + ldxi_us(r2, r1, 2); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_i(r2, r1, 1); + lshi(r2, r2, 8); +# if __WORDSIZE == 64 + if (sign) + extr_i(r2, r2); + else + extr_ui(r2, r2); +# endif +# else +# if __WORDSIZE == 64 + if (sign) + ldr_c(r0, r1); + else +# endif + ldr_uc(r0, r1); + lshi(r0, r0, 24); +# if __WORDSIZE == 32 + ldxi(r2, r1, 1); +# else + ldxi_ui(r2, r1, 1); +# endif + rshi_u(r2, r2, 8); +# endif + or3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN +# if __WORDSIZE == 32 + ldxi(r0, r1, -1); +# else + ldxi_ui(r0, r1, -1); +# endif + rshi_u(r0, r0, 8); +# if __WORDSIZE == 64 + if (sign) + ldxi_c(r2, r1, 3); + else +# endif + ldxi_uc(r2, r1, 3); + lshi(r2, r2, 24); +# else + ldxi_i(r0, r1, -1); + lshi(r0, r0, 8); +# if __WORDSIZE == 64 + if (sign) + extr_i(r0, r0); + else + extr_ui(r0, r0); +# endif + ldxi_uc(r2, r1, 3); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + fallback_patch_jmpi(or3, _jit->pc.w); + orr(r0, r0, r2); + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unldi4(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1 +# if __WORDSIZE == 64 + , jit_bool_t sign +# endif + ) +{ + jit_int32_t t0, r2; + if ((i1 & -4) == i1) { +# if __WORDSIZE == 64 + if (sign) +# endif + ldi_i(r0, i1); +# if __WORDSIZE == 64 + else + ldi_ui(r0, i1); +# endif + } + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); +# if __WORDSIZE == 64 + if (sign) + ldi_s(r2, i1 + 2); + else +# endif + ldi_us(r2, i1 + 2); + lshi(r2, r2, 16); +# else +# if __WORDSIZE == 64 + if (sign) + ldi_s(r0, i1); + else +# endif + ldi_us(r0, i1); + lshi(r0, r0, 16); + ldi_us(r2, i1 + 2); +# endif + } + else if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_i(r2, i1 + 1); + lshi(r2, r2, 8); +# if __WORDSIZE == 64 + if (sign) + extr_i(r2, r2); + else + extr_ui(r2, r2); +# endif +# else +# if __WORDSIZE == 64 + if (sign) + ldi_c(r0, i1); + else +# endif + ldi_uc(r0, i1); + lshi(r0, r0, 24); +# if __WORDSIZE == 32 + ldi(r2, i1 + 1); +# else + ldi_ui(r2, i1 + 1); +# endif + rshi_u(r2, r2, 8); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN +# if __WORDSIZE == 32 + ldi(r0, i1 - 1); +# else + ldi_ui(r0, i1 - 1); +# endif + rshi_u(r0, r0, 8); +# if __WORDSIZE == 64 + if (sign) + ldi_c(r2, i1 + 3); + else +# endif + ldi_uc(r2, i1 + 3); + lshi(r2, r2, 24); +# else + ldi_i(r0, i1 - 1); + lshi(r0, r0, 8); +# if __WORDSIZE == 64 + if (sign) + extr_i(r0, r0); + else + extr_ui(r0, r0); +# endif + ldi_uc(r2, i1 + 3); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +# if __WORDSIZE == 64 +static void +_unldr5(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + jit_word_t un4, un2, un3, or, or4, or3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r1); + if (sign) + ldxi_c(r2, r1, 4); + else + ldxi_uc(r2, r1, 4); + lshi(r2, r2, 32); +# else + if (sign) + ldr_i(r0, r1); + else + ldr_ui(r0, r1); + lshi(r0, r0, 8); + ldxi_uc(r2, r1, 4); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + ldxi_us(r2, r1, 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + if (sign) + ldxi_c(r2, r1, 4); + else + ldxi_uc(r2, r1, 4); + lshi(r2, r2, 32); +# else + if (sign) + ldr_s(r0, r1); + else + ldr_us(r0, r1); + lshi(r0, r0, 24); + ldxi_us(r2, r1, 2); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 4); +# endif + or4 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + if (sign) + ldxi_i(r2, r1, 1); + else + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 8); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 32); + ldxi_ui(r2, r1, 1); +# endif + or3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldxi_s(r2, r1, 3); + else + ldxi_us(r2, r1, 3); + lshi(r2, r2, 24); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 32); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldxi_us(r2, r1, 3); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + fallback_patch_jmpi(or4, _jit->pc.w); + fallback_patch_jmpi(or3, _jit->pc.w); + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldi5(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -4) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i1); + if (sign) + ldi_c(r2, i1 + 4); + else + ldi_uc(r2, i1 + 4); + lshi(r2, r2, 32); +# else + if (sign) + ldi_i(r0, i1); + else + ldi_ui(r0, i1); + lshi(r0, r0, 8); + ldi_uc(r2, i1 + 4); +# endif + } + else if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + ldi_us(r2, i1 + 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + if (sign) + ldi_c(r2, i1 + 4); + else + ldi_uc(r2, i1 + 4); + lshi(r2, r2, 32); +# else + if (sign) + ldi_s(r0, i1); + else + ldi_us(r0, i1); + lshi(r0, r0, 24); + ldi_us(r2, i1 + 2); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 4); +# endif + } + else if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + if (sign) + ldi_i(r2, i1 + 1); + else + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 8); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 32); + ldi_ui(r2, i1 + 1); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldi_s(r2, i1 + 3); + else + ldi_us(r2, i1 + 3); + lshi(r2, r2, 24); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 32); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldi_us(r2, i1 + 3); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldr6(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + jit_word_t un4, un2, un3, or, or2, or3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r1); + if (sign) + ldxi_s(r2, r1, 4); + else + ldxi_us(r2, r1, 4); + lshi(r2, r2, 32); +# else + if (sign) + ldr_i(r0, r1); + else + ldr_ui(r0, r1); + lshi(r0, r0, 16); + ldxi_us(r2, r1, 4); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + if (sign) + ldxi_i(r2, r1, 2); + else + ldxi_ui(r2, r1, 2); + lshi(r2, r2, 16); +# else + if (sign) + ldr_s(r0, r1); + else + ldr_us(r0, r1); + lshi(r0, r0, 32); + ldxi_ui(r2, r1, 2); +# endif + or2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldxi_c(r2, r1, 5); + else + ldxi_uc(r2, r1, 5); + lshi(r2, r2, 40); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 40); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 5); +# endif + or3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_us(r2, r1, 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + if (sign) + ldxi_c(r2, r1, 5); + else + ldxi_uc(r2, r1, 5); + lshi(r2, r2, 40); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 40); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldxi_us(r2, r1, 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 5); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + fallback_patch_jmpi(or2, _jit->pc.w); + fallback_patch_jmpi(or3, _jit->pc.w); + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldi6(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -4) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i1); + if (sign) + ldi_s(r2, i1 + 4); + else + ldi_us(r2, i1 + 4); + lshi(r2, r2, 32); +# else + if (sign) + ldi_i(r0, i1); + else + ldi_ui(r0, i1); + lshi(r0, r0, 16); + ldi_us(r2, i1 + 4); +# endif + } + else if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + if (sign) + ldi_i(r2, i1 + 2); + else + ldi_ui(r2, i1 + 2); + lshi(r2, r2, 16); +# else + if (sign) + ldi_s(r0, i1); + else + ldi_us(r0, i1); + lshi(r0, r0, 32); + ldi_ui(r2, i1 + 2); +# endif + } + else if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldi_c(r2, i1 + 5); + else + ldi_uc(r2, i1 + 5); + lshi(r2, r2, 40); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 40); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 5); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_us(r2, i1 + 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + if (sign) + ldi_c(r2, i1 + 5); + else + ldi_uc(r2, i1 + 5); + lshi(r2, r2, 40); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 40); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldi_us(r2, i1 + 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 5); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldr7(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + jit_word_t un4, un2, un3, or, or2, or3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r1); + ldxi_us(r2, r1, 4); + lshi(r2, r2, 32); + orr(r0, r0, r2); + if (sign) + ldxi_c(r2, r1, 6); + else + ldxi_uc(r2, r1, 6); + lshi(r2, r2, 48); +# else + if (sign) + ldr_i(r0, r1); + else + ldr_ui(r0, r1); + lshi(r0, r0, 24); + ldxi_us(r2, r1, 4); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 6); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + ldxi_ui(r2, r1, 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + if (sign) + ldxi_c(r2, r1, 6); + else + ldxi_uc(r2, r1, 6); + lshi(r2, r2, 48); +# else + if (sign) + ldr_s(r0, r1); + else + ldr_us(r0, r1); + lshi(r0, r0, 40); + ldxi_ui(r2, r1, 2); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 6); +# endif + or2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldxi_s(r2, r1, 5); + else + ldxi_us(r2, r1, 5); + lshi(r2, r2, 40); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 48); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldxi_us(r2, r1, 5); +# endif + or3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldxi_i(r2, r1, 3); + else + ldxi_ui(r2, r1, 3); + lshi(r2, r2, 24); +# else + if (sign) + ldr_c(r0, r1); + else + ldr_uc(r0, r1); + lshi(r0, r0, 48); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 32); + orr(r0, r0, r2); + ldxi_ui(r2, r1, 3); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + fallback_patch_jmpi(or2, _jit->pc.w); + fallback_patch_jmpi(or3, _jit->pc.w); + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldi7(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1, jit_bool_t sign) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -4) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i1); + ldi_us(r2, i1 + 4); + lshi(r2, r2, 32); + orr(r0, r0, r2); + if (sign) + ldi_c(r2, i1 + 6); + else + ldi_uc(r2, i1 + 6); + lshi(r2, r2, 48); +# else + if (sign) + ldi_i(r0, i1); + else + ldi_ui(r0, i1); + lshi(r0, r0, 24); + ldi_us(r2, i1 + 4); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 6); +# endif + } + else if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + ldi_ui(r2, i1 + 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + if (sign) + ldi_c(r2, i1 + 6); + else + ldi_uc(r2, i1 + 6); + lshi(r2, r2, 48); +# else + if (sign) + ldi_s(r0, i1); + else + ldi_us(r0, i1); + lshi(r0, r0, 40); + ldi_ui(r2, i1 + 2); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 6); +# endif + } + else if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldi_s(r2, i1 + 5); + else + ldi_us(r2, i1 + 5); + lshi(r2, r2, 40); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 48); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldi_us(r2, i1 + 5); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + if (sign) + ldi_i(r2, i1 + 3); + else + ldi_ui(r2, i1 + 3); + lshi(r2, r2, 24); +# else + if (sign) + ldi_c(r0, i1); + else + ldi_uc(r0, i1); + lshi(r0, r0, 48); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 32); + orr(r0, r0, r2); + ldi_ui(r2, i1 + 3); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); +} + +static void +_unldr8(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un8, un4, un2, un7, un6, un5, un3, al, + or, or2, or7, or6, or5, or3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -8); + un8 = fallback_bner(_jit->pc.w, r1, r2); + ldr_l(r0, r1); + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un8, _jit->pc.w); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r1); + ldxi_i(r2, r1, 4); + lshi(r2, r2, 32); +# else + ldr_i(r0, r1); + ldxi_ui(r2, r1, 4); + lshi(r0, r0, 32); +# endif + or = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r1, r2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + ldxi_ui(r2, r1, 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldxi_s(r2, r1, 6); + lshi(r2, r2, 48); +# else + ldr_s(r0, r1); + lshi(r0, r0, 48); + ldxi_ui(r2, r1, 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldxi_us(r2, r1, 6); +# endif + or2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 7); + un7 = fallback_bnei(_jit->pc.w, r2, 7); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_l(r2, r1, 1); + lshi(r2, r2, 8); +# else + ldr_c(r0, r1); + ldxi_l(r2, r1, 1); + rshi_u(r2, r2, 8); + lshi(r0, r0, 56); +# endif + or7 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un7, _jit->pc.w); + un6 = fallback_bnei(_jit->pc.w, r2, 6); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r1); + ldxi_l(r2, r1, 2); + lshi(r2, r2, 16); +# else + ldr_s(r0, r1); + lshi(r0, r0, 48); + ldxi_l(r2, r1, 2); + rshi_u(r2, r2, 16); +# endif + or6 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un6, _jit->pc.w); + un5 = fallback_bnei(_jit->pc.w, r2, 5); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldxi_ui(r0, r1, -1); + rshi_u(r0, r0, 8); + ldxi_ui(r2, r1, 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldxi_c(r2, r1, 7); + lshi(r2, r2, 56); +# else + ldxi_i(r0, r1, -1); + lshi(r0, r0, 40); + ldxi_ui(r2, r1, 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 7); +# endif + or5 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un5, _jit->pc.w); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_i(r2, r1, 5); + lshi(r2, r2, 40); +# else + ldr_c(r0, r1); + lshi(r0, r0, 56); + ldxi_ui(r2, r1, 1); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldxi_ui(r2, r1, 5); + rshi_u(r2, r2, 8); +# endif + or3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_uc(r0, r1); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_ui(r2, r1, 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldxi_c(r2, r1, 7); + lshi(r2, r2, 56); +# else + ldr_c(r0, r1); + lshi(r0, r0, 56); + ldxi_us(r2, r1, 1); + lshi(r2, r2, 40); + orr(r0, r0, r2); + ldxi_ui(r2, r1, 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldxi_uc(r2, r1, 7); +# endif + fallback_flush(); + fallback_patch_jmpi(or, _jit->pc.w); + fallback_patch_jmpi(or2, _jit->pc.w); + fallback_patch_jmpi(or7, _jit->pc.w); + fallback_patch_jmpi(or6, _jit->pc.w); + fallback_patch_jmpi(or5, _jit->pc.w); + fallback_patch_jmpi(or3, _jit->pc.w); + orr(r0, r0, r2); + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unldi8(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if ((i1 & -8) == i1) + ldi_l(r0, i1); + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -4) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i1); + ldi_i(r2, i1 + 4); + lshi(r2, r2, 32); +# else + ldi_i(r0, i1); + ldi_ui(r2, i1 + 4); + lshi(r0, r0, 32); +# endif + } + else if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + ldi_ui(r2, i1 + 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldi_s(r2, i1 + 6); + lshi(r2, r2, 48); +# else + ldi_s(r0, i1); + lshi(r0, r0, 48); + ldi_ui(r2, i1 + 2); + lshi(r2, r2, 16); + orr(r0, r0, r2); + ldi_us(r2, i1 + 6); +# endif + } + else if ((i1 & 7) == 7) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_l(r2, i1 + 1); + lshi(r2, r2, 8); +# else + ldi_c(r0, i1); + ldi_l(r2, i1 + 1); + rshi_u(r2, r2, 8); + lshi(r0, r0, 56); +# endif + } + else if ((i1 & 7) == 6) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i1); + ldi_l(r2, i1 + 2); + lshi(r2, r2, 16); +# else + ldi_s(r0, i1); + lshi(r0, r0, 48); + ldi_l(r2, i1 + 2); + rshi_u(r2, r2, 16); +# endif + } + else if ((i1 & 7) == 5) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i1 - 1); + rshi_u(r0, r0, 8); + ldi_ui(r2, i1 + 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldi_c(r2, i1 + 7); + lshi(r2, r2, 56); +# else + ldi_i(r0, i1 - 1); + lshi(r0, r0, 40); + ldi_ui(r2, i1 + 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 7); +# endif + } + else if ((i1 & 7) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_i(r2, i1 + 5); + lshi(r2, r2, 40); +# else + ldi_c(r0, i1); + lshi(r0, r0, 56); + ldi_ui(r2, i1 + 1); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldi_ui(r2, i1 + 5); + rshi_u(r2, r2, 8); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_uc(r0, i1); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_ui(r2, i1 + 3); + lshi(r2, r2, 24); + orr(r0, r0, r2); + ldi_c(r2, i1 + 7); + lshi(r2, r2, 56); +# else + ldi_c(r0, i1); + lshi(r0, r0, 56); + ldi_us(r2, i1 + 1); + lshi(r2, r2, 40); + orr(r0, r0, r2); + ldi_ui(r2, i1 + 3); + lshi(r2, r2, 8); + orr(r0, r0, r2); + ldi_uc(r2, i1 + 7); +# endif + } + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} +# endif + +static void +_unstr2(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un2, al; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r2, r1); + str_s(r1, r0); + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); +#if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi_u(r2, r0, 8); + stxi_c(1, r1, r2); +#else + stxi_c(1, r1, r0); + rshi_u(r2, r0, 8); + str_c(r1, r2); +#endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti2(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if ((i1 & -2) == i1) + sti_s(i1, r0); + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); +#if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi_u(r2, r0, 8); + sti_c(1 + i1, r2); +#else + sti_c(1 + i1, r0); + rshi_u(r2, r0, 8); + sti_c(i1, r2); +#endif + jit_unget_reg(t0); + } +} + +static void +_unstr3(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un2, al; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r2, r1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_c(2, r1, r2); +# else + stxi_c(2, r1, r0); + rshi(r2, r0, 8); + str_s(r1, r2); +# endif + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); +# else + stxi_s(1, r1, r0); + rshi(r2, r0, 16); + str_c(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti3(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_c(2 + i1, r2); +# else + sti_c(2 + i1, r0); + rshi(r2, r0, 8); + sti_s(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); +# else + sti_s(1 + i1, r0); + rshi(r2, r0, 16); + sti_c(i1, r2); +# endif + } + jit_unget_reg(t0); +} + +static void +_unstr4(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un4, un2, al, al2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r2, r1); + str_i(r1, r0); + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r2, r1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_s(2, r1, r2); +# else + stxi_s(2, r1, r0); + rshi(r2, r0, 16); + str_s(r1, r2); +# endif + al2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + stxi_c(3, r1, r2); +# else + stxi_c(3, r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + str_c(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + fallback_patch_jmpi(al2, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti4(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if ((i1 & -4) == i1) + sti_i(i1, r0); + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_s(2 + i1, r2); +# else + sti_s(2 + i1, r0); + rshi(r2, r0, 16); + sti_s(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(3 + i1, r2); +# else + sti_c(3 + i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(i1, r2); +# endif + } + jit_unget_reg(t0); + } +} + +# if __WORDSIZE == 64 +static void +_unstr5(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un3, un2, un1, al, al2, al1; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_i(1, r1, r2); +# else + stxi_i(1, r1, r0); + rshi(r2, r0, 32); + str_c(r1, r2); +# endif + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); + un2 = fallback_bnei(_jit->pc.w, r2, 2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_s(2, r1, r2); + rshi(r2, r2, 16); + stxi_c(4, r1, r2); +# else + stxi_c(4, r1, r0); + rshi(r2, r0, 8); + stxi_s(2, r1, r2); + rshi(r2, r2, 16); + str_s(r1, r2); +# endif + al2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un2, _jit->pc.w); + un1 = fallback_bnei(_jit->pc.w, r2, 1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + stxi_s(3, r1, r2); +# else + stxi_s(3, r1, r0); + rshi(r2, r0, 16); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + str_c(r1, r2); +# endif + al1 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un1, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r1, r0); + rshi(r2, r0, 32); + stxi_c(4, r1, r2); +# else + stxi_c(4, r1, r0); + rshi(r2, r0, 8); + str_i(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + fallback_patch_jmpi(al2, _jit->pc.w); + fallback_patch_jmpi(al1, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti5(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_i(1 + i1, r2); +# else + sti_i(1 + i1, r0); + rshi(r2, r0, 32); + sti_c(i1, r2); +# endif + } + else if ((i1 & 3) == 2) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_s(2 + i1, r2); + rshi(r2, r2, 16); + sti_c(4 + i1, r2); +# else + sti_c(4 + i1, r0); + rshi(r2, r0, 8); + sti_s(2 + i1, r2); + rshi(r2, r2, 16); + sti_s(i1, r2); +# endif + } + else if ((i1 & 3) == 1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_s(3 + i1, r2); +# else + sti_s(3 + i1, r0); + rshi(r2, r0, 16); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i1, r0); + rshi(r2, r0, 32); + sti_c(4 + i1, r2); +# else + sti_c(4 + i1, r0); + rshi(r2, r0, 8); + sti_i(i1, r2); +# endif + } + jit_unget_reg(t0); +} + +static void +_unstr6(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un3, un2, un1, al, al2, al1; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + stxi_c(5, r1, r2); +# else + stxi_c(5, r1, r0); + rshi(r2, r0, 8); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + str_c(r1, r2); +# endif + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); + un2 = fallback_bnei(_jit->pc.w, r2, 2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_s(2, r1, r2); + rshi(r2, r2, 16); + stxi_s(4, r1, r2); +# else + stxi_s(4, r1, r0); + rshi(r2, r0, 16); + stxi_s(2, r1, r2); + rshi(r2, r2, 16); + str_s(r1, r2); +# endif + al2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un2, _jit->pc.w); + un1 = fallback_bnei(_jit->pc.w, r2, 1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + stxi_s(3, r1, r2); + rshi(r2, r2, 16); + stxi_c(5, r1, r2); +# else + stxi_c(5, r1, r0); + rshi(r2, r0, 8); + stxi_s(3, r1, r2); + rshi(r2, r2, 16); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + str_c(r1, r2); +# endif + al1 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un1, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r1, r0); + rshi(r2, r0, 32); + stxi_s(4, r1, r2); +# else + stxi_s(4, r1, r0); + rshi(r2, r0, 16); + str_i(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + fallback_patch_jmpi(al2, _jit->pc.w); + fallback_patch_jmpi(al1, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti6(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_c(5 + i1, r2); +# else + sti_c(5 + i1, r0); + rshi(r2, r0, 8); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_c(i1, r2); +# endif + } + else if ((i1 & 3) == 2) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_s(2 + i1, r2); + rshi(r2, r2, 16); + sti_s(4 + i1, r2); +# else + sti_s(4 + i1, r0); + rshi(r2, r0, 16); + sti_s(2 + i1, r2); + rshi(r2, r2, 16); + sti_s(i1, r2); +# endif + } + else if ((i1 & 3) == 1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_s(3 + i1, r2); + rshi(r2, r2, 16); + sti_c(5 + i1, r2); +# else + sti_c(5 + i1, r0); + rshi(r2, r0, 8); + sti_s(3 + i1, r2); + rshi(r2, r2, 16); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i1, r0); + rshi(r2, r0, 32); + sti_s(4 + i1, r2); +# else + sti_s(4 + i1, r0); + rshi(r2, r0, 16); + sti_i(i1, r2); +# endif + } + jit_unget_reg(t0); +} + +static void +_unstr7(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un3, un2, un1, al, al2, al1; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + stxi_s(5, r1, r2); +# else + stxi_s(5, r1, r0); + rshi(r2, r0, 16); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + str_c(r1, r2); +# endif + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); + un2 = fallback_bnei(_jit->pc.w, r2, 2); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_i(2, r1, r2); + rshi(r2, r2, 32); + stxi_c(6, r1, r2); +# else + stxi_c(6, r1, r0); + rshi(r2, r0, 8); + stxi_i(2, r1, r2); + rshi(r2, r2, 32); + str_s(r1, r2); +# endif + al2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un2, _jit->pc.w); + un1 = fallback_bnei(_jit->pc.w, r2, 1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + stxi_i(3, r1, r2); +# else + stxi_i(3, r1, r0); + rshi(r2, r0, 32); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + str_c(r1, r2); +# endif + al1 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un1, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r1, r0); + rshi(r2, r0, 32); + stxi_s(4, r1, r2); + rshi(r2, r2, 16); + stxi_c(6, r1, r2); +# else + stxi_c(6, r1, r0); + rshi(r2, r0, 8); + stxi_s(4, r1, r2); + rshi(r2, r2, 16); + str_i(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + fallback_patch_jmpi(al2, _jit->pc.w); + fallback_patch_jmpi(al1, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti7(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_s(5 + i1, r2); +# else + sti_s(5 + i1, r0); + rshi(r2, r0, 16); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_c(i1, r2); +# endif + } + else if ((i1 & 3) == 2) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_i(2 + i1, r2); + rshi(r2, r2, 32); + sti_c(6 + i1, r2); +# else + sti_c(6 + i1, r0); + rshi(r2, r0, 8); + sti_i(2 + i1, r2); + rshi(r2, r2, 32); + sti_s(i1, r2); +# endif + } + else if ((i1 & 3) == 1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_i(3 + i1, r2); +# else + sti_i(3 + i1, r0); + rshi(r2, r0, 32); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i1, r0); + rshi(r2, r0, 32); + sti_s(4 + i1, r2); + rshi(r2, r2, 16); + sti_c(6 + i1, r2); +# else + sti_c(6 + i1, r0); + rshi(r2, r0, 8); + sti_s(4 + i1, r2); + rshi(r2, r2, 16); + sti_i(i1, r2); +# endif + } + jit_unget_reg(t0); +} + +static void +_unstr8(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_int32_t t0, r2; + jit_word_t un8, un4, un2, un3, al, al4, al2, al3; + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + andi(r2, r1, -8); + un8 = fallback_bner(_jit->pc.w, r2, r1); + str_l(r1, r0); + al = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un8, _jit->pc.w); + andi(r2, r1, -4); + un4 = fallback_bner(_jit->pc.w, r2, r1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r1, r0); + rshi(r2, r0, 32); + stxi_i(4, r1, r2); +# else + stxi_i(4, r1, r0); + rshi(r2, r0, 32); + str_i(r1, r2); +# endif + al4 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un4, _jit->pc.w); + andi(r2, r1, -2); + un2 = fallback_bner(_jit->pc.w, r2, r1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r1, r0); + rshi(r2, r0, 16); + stxi_i(2, r1, r2); + rshi(r2, r2, 32); + stxi_s(6, r1, r2); +# else + stxi_s(6, r1, r0); + rshi(r2, r0, 16); + stxi_i(2, r1, r2); + rshi(r2, r2, 32); + str_s(r1, r2); +# endif + al2 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bner(un2, _jit->pc.w); + andi(r2, r1, 3); + un3 = fallback_bnei(_jit->pc.w, r2, 3); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + stxi_s(5, r1, r2); + rshi(r2, r2, 16); + stxi_c(7, r1, r2); +# else + stxi_c(7, r1, r0); + rshi(r2, r0, 8); + stxi_s(5, r1, r2); + rshi(r2, r2, 16); + stxi_i(1, r1, r2); + rshi(r2, r2, 32); + str_c(r1, r2); +# endif + al3 = fallback_jmpi(_jit->pc.w); + fallback_flush(); + fallback_patch_bnei(un3, _jit->pc.w); +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_c(r1, r0); + rshi(r2, r0, 8); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + stxi_i(3, r1, r2); + rshi(r2, r2, 32); + stxi_c(7, r1, r2); +# else + stxi_c(7, r1, r0); + rshi(r2, r0, 8); + stxi_i(3, r1, r2); + rshi(r2, r2, 32); + stxi_s(1, r1, r2); + rshi(r2, r2, 16); + str_c(r1, r2); +# endif + fallback_flush(); + fallback_patch_jmpi(al, _jit->pc.w); + fallback_patch_jmpi(al4, _jit->pc.w); + fallback_patch_jmpi(al2, _jit->pc.w); + fallback_patch_jmpi(al3, _jit->pc.w); + jit_unget_reg(t0); +} + +static void +_unsti8(jit_state_t *_jit, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if ((i1 & -8) == i1) + sti_l(i1, r0); + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if ((i1 & -4) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i1, r0); + rshi(r2, r0, 32); + sti_i(4 + i1, r2); +# else + sti_i(4 + i1, r0); + rshi(r2, r0, 32); + sti_i(i1, r2); +# endif + } + else if ((i1 & -2) == i1) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i1, r0); + rshi(r2, r0, 16); + sti_i(2 + i1, r2); + rshi(r2, r2, 32); + sti_s(6 + i1, r2); +# else + sti_s(6 + i1, r0); + rshi(r2, r0, 16); + sti_i(2 + i1, r2); + rshi(r2, r2, 32); + sti_s(i1, r2); +# endif + } + else if ((i1 & 3) == 3) { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_s(5 + i1, r2); + rshi(r2, r2, 16); + sti_c(7 + i1, r2); +# else + sti_c(7 + i1, r0); + rshi(r2, r0, 8); + sti_s(5 + i1, r2); + rshi(r2, r2, 16); + sti_i(1 + i1, r2); + rshi(r2, r2, 32); + sti_c(i1, r2); +# endif + } + else { +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_c(i1, r0); + rshi(r2, r0, 8); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_i(3 + i1, r2); + rshi(r2, r2, 32); + sti_c(7 + i1, r2); +# else + sti_c(7 + i1, r0); + rshi(r2, r0, 8); + sti_i(3 + i1, r2); + rshi(r2, r2, 32); + sti_s(1 + i1, r2); + rshi(r2, r2, 16); + sti_c(i1, r2); +# endif + } + jit_unget_reg(t0); + } +} +# endif + + +static void +_unldrw(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_word_t cross, done; + jit_int32_t t0, t1, t2, t3; + t0 = fallback_jit_get_reg(jit_class_gpr); + if (r0 == r1) { + t1 = fallback_jit_get_reg(jit_class_gpr); + movr(rn(t1), r1); + r1 = rn(t1); + } + else + t1 = JIT_NOREG; + andi(rn(t0), r1, -(jit_word_t)sizeof(jit_word_t)); + ldr(r0, rn(t0)); + done = fallback_beqr(_jit->pc.w, rn(t0), r1); + t2 = fallback_jit_get_reg(jit_class_gpr); + andi(rn(t2), r1, sizeof(jit_word_t) - 1); + t3 = fallback_jit_get_reg(jit_class_gpr); + addi(rn(t3), rn(t2), i0); + cross = fallback_blei(_jit->pc.w, rn(t3), sizeof(jit_word_t)); + ldxi(rn(t0), rn(t0), sizeof(jit_word_t)); + fallback_flush(); + fallback_patch_blei(cross, _jit->pc.w); + jit_unget_reg(t3); + lshi(rn(t2), rn(t2), 3); +#if __BYTE_ORDER == __LITTLE_ENDIAN + rshr_u(r0, r0, rn(t2)); + rsbi(rn(t2), rn(t2), __WORDSIZE); + lshr(rn(t0), rn(t0), rn(t2)); +#else + lshr(r0, r0, rn(t2)); + rsbi(rn(t2), rn(t2), __WORDSIZE); + rshr_u(rn(t0), rn(t0), rn(t2)); +#endif + jit_unget_reg(t2); + orr(r0, r0, rn(t0)); + fallback_flush(); + fallback_patch_beqr(done, _jit->pc.w); + jit_unget_reg(t0); + if (t1 != JIT_NOREG) + jit_unget_reg(t1); +} + +static void +_unldiw(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_word_t addr; + jit_int32_t t0, sh; + addr = i0 & -(jit_word_t)sizeof(jit_word_t); + ldi(r0, addr); + if (i0 != addr) { + sh = (i0 & (sizeof(jit_word_t) - 1)) << 3; + if (sh + i1 > sizeof(jit_word_t)) { + t0 = fallback_jit_get_reg(jit_class_gpr); + ldi(rn(t0), addr + sizeof(jit_word_t)); +#if __BYTE_ORDER == __LITTLE_ENDIAN + rshi_u(r0, r0, sh); + lshi(rn(t0), rn(t0), __WORDSIZE - sh); +#else + lshi(r0, r0, sh); + rshi_u(rn(t0), rn(t0), __WORDSIZE - sh); +#endif + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } + } +} + +static void +_unldx(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + switch (i0) { + case 2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + extr_s(r0, r0); +#else + rshi(r0, r0, __WORDSIZE - 16); +#endif + break; + case 3: +#if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 24); +#endif + rshi(r0, r0, __WORDSIZE - 24); + break; +#if __WORDSIZE == 32 + default: +#else + case 4: +# if __BYTE_ORDER == __LITTLE_ENDIAN + extr_i(r0, r0); +# else + rshi(r0, r0, __WORDSIZE - 32); +# endif +#endif + break; +#if __WORDSIZE == 64 + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 40); +# endif + rshi(r0, r0, __WORDSIZE - 40); + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 48); +# endif + rshi(r0, r0, __WORDSIZE - 48); + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 56); +# endif + rshi(r0, r0, __WORDSIZE - 56); + break; + default: + break; +#endif + } +} + +static void +_unldx_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + switch (i0) { + case 2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + extr_us(r0, r0); +#else + rshi_u(r0, r0, __WORDSIZE - 16); +#endif + break; + case 3: +#if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 24); +#endif + rshi_u(r0, r0, __WORDSIZE - 24); + break; +#if __WORDSIZE == 32 + default: +#else + case 4: +# if __BYTE_ORDER == __LITTLE_ENDIAN + extr_ui(r0, r0); +# else + rshi_u(r0, r0, __WORDSIZE - 32); +# endif +#endif + break; +#if __WORDSIZE == 64 + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 40); +# endif + rshi_u(r0, r0, __WORDSIZE - 40); + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 48); +# endif + rshi_u(r0, r0, __WORDSIZE - 48); + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 56); +# endif + rshi_u(r0, r0, __WORDSIZE - 56); + break; + default: + break; +#endif + } +} + +static void +_fallback_unldr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + assert(i0 >= 1 && i0 <= (__WORDSIZE >> 3)); + if (i0 == 1) + ldr_c(r0, r1); + else if (_jitc->unld_algorithm != 0) { + if (r0 == r1) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r0); + } + else + r2 = r1; + switch (i0) { + case 2: unldr2(r0, r2, 1); break; + case 3: unldr3(r0, r2, 1); break; +# if __WORDSIZE == 32 + default: unldr4(r0, r2); break; +# else + case 4: unldr4(r0, r2, 1); break; + case 5: unldr5(r0, r2, 1); break; + case 6: unldr6(r0, r2, 1); break; + case 7: unldr7(r0, r2, 1); break; + default: unldr8(r0, r2); break; +# endif + } + if (i0 > 1 && r0 == r1) + jit_unget_reg(t0); + } + else { + unldrw(r0, r1, i0); + unldx(r0, i0); + } +} + +static void +_fallback_unldi(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + assert(i1 >= 1 && i1 <= (__WORDSIZE >> 3)); + if (i1 == 1) + ldi_c(r0, i0); + else if (_jitc->unld_algorithm != 0) { + switch (i1) { + case 2: unldi2(r0, i0, 1); break; + case 3: unldi3(r0, i0, 1); break; +# if __WORDSIZE == 32 + default: unldi4(r0, i0); break; +# else + case 4: unldi4(r0, i0, 1); break; + case 5: unldi5(r0, i0, 1); break; + case 6: unldi6(r0, i0, 1); break; + case 7: unldi7(r0, i0, 1); break; + default: unldi8(r0, i0); break; +# endif + } + } + else { + unldiw(r0, i0, i1); + unldx(r0, i1); + } +} + +static void +_fallback_unldr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + assert(i0 >= 1 && i0 <= (__WORDSIZE >> 3)); + if (i0 == 1) + ldr_uc(r0, r1); + else if (_jitc->unld_algorithm != 0) { + if (r0 == r1) { + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r0); + } + else + r2 = r1; + switch (i0) { + case 2: unldr2(r0, r2, 0); break; + case 3: unldr3(r0, r2, 0); break; +# if __WORDSIZE == 32 + default: unldr4(r0, r2); break; +# else + case 4: unldr4(r0, r2, 0); break; + case 5: unldr5(r0, r2, 0); break; + case 6: unldr6(r0, r2, 0); break; + case 7: unldr7(r0, r2, 0); break; + default: unldr8(r0, r2); break; +# endif + } + if (i0 > 1 && r0 == r1) + jit_unget_reg(t0); + } + else { + unldrw(r0, r1, i0); + unldx_u(r0, i0); + } +} + +static void +_fallback_unldi_u(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + assert(i1 >= 1 && i1 <= (__WORDSIZE >> 3)); + if (i1 == 1) + ldi_uc(r0, i0); + else if (_jitc->unld_algorithm != 0) { + switch (i1) { + case 2: unldi2(r0, i0, 0); break; + case 3: unldi3(r0, i0, 0); break; +# if __WORDSIZE == 32 + default: unldi4(r0, i0); break; +# else + case 4: unldi4(r0, i0, 0); break; + case 5: unldi5(r0, i0, 0); break; + case 6: unldi6(r0, i0, 0); break; + case 7: unldi7(r0, i0, 0); break; + default: unldi8(r0, i0); break; +# endif + } + + } + else { + unldiw(r0, i0, i1); + unldx_u(r0, i1); + } +} + +static void +_fallback_unstr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_word_t done; + jit_int32_t t0, t1, t2, t3, t4, t5; + assert(i0 > 0 && i0 <= (__WORDSIZE >> 3)); + if (i0 == 1) + str_c(r0, r1); + else if (_jitc->unst_algorithm == 0) { + switch (i0) { + case 2: unstr2(r1, r0); break; + case 3: unstr3(r1, r0); break; +# if __WORDSIZE == 32 + default: unstr4(r1, r0); break; +# else + case 4: unstr4(r1, r0); break; + case 5: unstr5(r1, r0); break; + case 6: unstr6(r1, r0); break; + case 7: unstr7(r1, r0); break; + default: unstr8(r1, r0); break; +# endif + } + } + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + t1 = fallback_jit_get_reg(jit_class_gpr); + t2 = fallback_jit_get_reg(jit_class_gpr); + t3 = fallback_jit_get_reg(jit_class_gpr); + /* Zero out top bits and keep value to store in t0 */ + if (i0 != sizeof(jit_word_t)) { + lshi(rn(t3), r1, (sizeof(jit_word_t) - i0) << 3); +#if __BYTE_ORDER == __LITTLE_ENDIAN + rshi_u(rn(t3), rn(t3), (sizeof(jit_word_t) - i0) << 3); +#endif + } + else + movr(rn(t3), r1); + /* Check alignment */ + andi(rn(t2), r0, sizeof(jit_word_t) - 1); + /* Multiply by 8 */ + lshi(rn(t2), rn(t2), 3); + /* Split values to store (assume will need two stores) */ +#if __BYTE_ORDER == __LITTLE_ENDIAN + qlshr_u(rn(t0), rn(t1), rn(t3), rn(t2)); +#else + qrshr_u(rn(t0), rn(t1), rn(t3), rn(t2)); +#endif + /* Generate masks for values in memory */ + if (i0 == sizeof(jit_word_t)) + movi(rn(t3), -1); + else { +#if __BYTE_ORDER == __BIG_ENDIAN + movi(rn(t3), ((1L << (i0 << 3)) - 1) << + ((sizeof(jit_word_t) - i0) << 3)); +#else + movi(rn(t3), (1L << (i0 << 3)) - 1); +#endif + } +#if __BYTE_ORDER == __LITTLE_ENDIAN + qlshr_u(rn(t2), rn(t3), rn(t3), rn(t2)); +#else + qrshr_u(rn(t2), rn(t3), rn(t3), rn(t2)); +#endif + comr(rn(t2), rn(t2)); + comr(rn(t3), rn(t3)); + /* Allocate two extra registers later in case need temps for *q?shr_u */ + t4 = fallback_jit_get_reg(jit_class_gpr); + t5 = fallback_jit_get_reg(jit_class_gpr); + /* Store words */ + andi(rn(t4), r0, -(jit_word_t)sizeof(jit_word_t)); + ldr(rn(t5), rn(t4)); + andr(rn(t5), rn(t5), rn(t2)); + orr(rn(t0), rn(t0), rn(t5)); + str(rn(t4), rn(t0)); + /* Make sure to not read/write on possibly unmaped memory */ + addi(rn(t5), rn(t4), i0); + done = fallback_blei(_jit->pc.w, rn(t5), sizeof(jit_word_t)); + /* Store second word if vlaue crosses a word boundary */ + ldxi(rn(t5), rn(t4), sizeof(jit_word_t)); + andr(rn(t5), rn(t5), rn(t3)); + orr(rn(t1), rn(t1), rn(t5)); + stxi(sizeof(jit_word_t), rn(t4), rn(t1)); + /* Finished */ + fallback_flush(); + fallback_patch_blei(done, _jit->pc.w); + /* Generic/simple algorithm needs 6 temporaries, as it cannot + * change any of the argument registers, might need to truncate + * the value to store, and need a pair for values to store and + * another for the masks. */ + jit_unget_reg(t5); + jit_unget_reg(t4); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); + } +} + +static void +_fallback_unsti(jit_state_t *_jit, + jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t done, address; + jit_int32_t t0, t1, t2, t3, t4; + assert(i1 > 0 && i1 <= (__WORDSIZE >> 3)); + if (i1 == 1) + sti_c(i0, r0); + else if (_jitc->unst_algorithm == 0) { + switch (i1) { + case 1: sti_c(i0, r0); break; + case 2: unsti2(r0, i0); break; + case 3: unsti3(r0, i0); break; +# if __WORDSIZE == 32 + default: unsti4(r0, i0); break; +# else + case 4: unsti4(r0, i0); break; + case 5: unsti5(r0, i0); break; + case 6: unsti6(r0, i0); break; + case 7: unsti7(r0, i0); break; + default: unsti8(r0, i0); break; +# endif + } + } + else { + t0 = fallback_jit_get_reg(jit_class_gpr); + t1 = fallback_jit_get_reg(jit_class_gpr); + t2 = fallback_jit_get_reg(jit_class_gpr); + t3 = fallback_jit_get_reg(jit_class_gpr); + t4 = fallback_jit_get_reg(jit_class_gpr); + /* Zero out top bits and keep value to store in t0 */ + if (i1 != sizeof(jit_word_t)) { + lshi(rn(t2), r0, (sizeof(jit_word_t) - i1) << 3); +#if __BYTE_ORDER == __LITTLE_ENDIAN + rshi_u(rn(t2), rn(t2), (sizeof(jit_word_t) - i1) << 3); + qlshi_u(rn(t0), rn(t1), rn(t2), + (i0 & (sizeof(jit_word_t) - 1)) << 3); +#else + qrshi_u(rn(t0), rn(t1), rn(t2), + (i0 & (sizeof(jit_word_t)) - 1) << 3); +#endif + } + else { +#if __BYTE_ORDER == __LITTLE_ENDIAN + qlshi_u(rn(t0), rn(t1), r0, + (i0 & (sizeof(jit_word_t)) - 1) << 3); +#else + qrshi_u(rn(t0), rn(t1), r0, + (i0 & (sizeof(jit_word_t)) - 1) << 3); +#endif + } + /* Generate masks for values in memory */ + if (i1 == sizeof(jit_word_t)) + movi(rn(t2), -1); + else { +#if __BYTE_ORDER == __BIG_ENDIAN + movi(rn(t2), ((1L << (i1 << 3)) - 1) << + ((sizeof(jit_word_t) - i1) << 3)); +#else + movi(rn(t2), (1L << (i1 << 3)) - 1); +#endif + } +#if __BYTE_ORDER == __LITTLE_ENDIAN + qlshi_u(rn(t2), rn(t3), rn(t2), (i0 & (sizeof(jit_word_t)) - 1) << 3); +#else + qrshi_u(rn(t2), rn(t3), rn(t2), (i0 & (sizeof(jit_word_t)) - 1) << 3); +#endif + comr(rn(t2), rn(t2)); + comr(rn(t3), rn(t3)); + /* Store words */ + address = i0 & -(jit_word_t)sizeof(jit_word_t); + ldi(rn(t4), address); + andr(rn(t4), rn(t4), rn(t2)); + orr(rn(t0), rn(t0), rn(t4)); + sti(address, rn(t0)); + if (address + i1 > sizeof(jit_word_t)) { + address += sizeof(jit_word_t); + ldi(rn(t4), address); + andr(rn(t4), rn(t4), rn(t3)); + orr(rn(t1), rn(t1), rn(t4)); + sti(address, rn(t1)); + } + jit_unget_reg(t4); + jit_unget_reg(t3); + jit_unget_reg(t2); + jit_unget_reg(t1); + jit_unget_reg(t0); + } +} + +# ifdef fallback_unldr_x +static void +_fallback_unldr_x(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + assert(i0 == 4 || i0 == 8); + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + unldr(r2, r1, 4); + movr_w_f(r0, r2); + } + else { +# if __WORDSIZE == 32 + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unldr(r2, r1, 4); + addi(r3, r1, 4); + unldr(r3, r3, 4); +# else + unldr(r3, r1, 4); + addi(r2, r1, 4); + unldr(r2, r2, 4); +# endif + movr_ww_d(r0, r2, r3); + jit_unget_reg(t1); +# else + unldr(r2, r1, 8); + movr_w_d(r0, r2); +# endif + } + jit_unget_reg(t0); +} +# endif + +# ifdef fallback_unldi_x +static void +_fallback_unldi_x(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + assert(i1 == 4 || i1 == 8); + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + unldi(r2, i0, 4); + movr_w_f(r0, r2); + } + else { +# if __WORDSIZE == 32 + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unldi(r2, i0, 4); + unldi(r3, i0 + 4, 4); +# else + unldi(r3, i0, 4); + unldi(r2, i0 + 4, 4); +# endif + movr_ww_d(r0, r3, r2); + jit_unget_reg(t1); +# else + unldi(r2, i0, 8); + movr_w_d(r0, r2); +# endif + } + jit_unget_reg(t0); +} +# endif + +# ifdef fallback_unstr_x +static void +_fallback_unstr_x(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + assert(i0 == 4 || i0 == 8); + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + movr_f_w(r2, r1); + unstr(r0, r2, 4); + } + else { +# if __WORDSIZE == 32 + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); + movr_d_ww(r2, r3, r1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unstr(r0, r2, 4); + addi(r2, r0, 4); + unstr(r2, r3, 4); +# else + unstr(r0, r3, 4); + addi(r3, r0, 4); + unstr(r3, r2, 4); +# endif + jit_unget_reg(t1); +# else + movr_d_w(r2, r1); + unstr(r0, r2, 8); +# endif + } + jit_unget_reg(t0); +} +# endif + +# ifdef fallback_unsti_x +static void +_fallback_unsti_x(jit_state_t *_jit, + jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + assert(i1 == 4 || i1 == 8); + t0 = fallback_jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + movr_f_w(r2, r0); + unsti(i0, r2, 4); + } + else { +# if __WORDSIZE == 32 + t1 = fallback_jit_get_reg(jit_class_gpr); + r3 = rn(t1); + movr_d_ww(r2, r3, r0); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unsti(i0, r3, 4); + unsti(i0 + 4, r2, 4); +# else + unsti(i0, r2, 4); + unsti(i0 + 4, r3, 4); +# endif + jit_unget_reg(t1); +# else + movr_d_w(r2, r0); + unsti(i0, r2, 8); +# endif + } + jit_unget_reg(t0); +} +# endif #endif diff --git a/deps/lightning/lib/jit_hppa-cpu.c b/deps/lightning/lib/jit_hppa-cpu.c index ebb01fd2..4db79d8d 100644 --- a/deps/lightning/lib/jit_hppa-cpu.c +++ b/deps/lightning/lib/jit_hppa-cpu.c @@ -28,6 +28,8 @@ typedef struct udiv { unsigned int rem; } udiv_t; +#define jit_imm_idx_p() jit_cpu.imm_idx + /* 16 spill bytes; -52 for first actual stack argument */ #define params_offset -32 /* Assume all callee save registers may need to be spilled */ @@ -47,6 +49,14 @@ typedef struct udiv { #define _R31_REGNO 31 #define _CR11_REGNO 11 #define ii(v) *_jit->pc.ui++ = v +#define ldr(r0,r1) ldr_ui(r0,r1) +#define ldi(r0,i0) ldi_ui(r0,i0) +#define ldxr(r0,r1,r2) ldxr_ui(r0,r1,r2) +#define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0) +#define str(r0,r1) str_i(r0,r1) +#define sti(i0,r0) sti_i(i0,r0) +#define stxr(r0,r1,r2) stxr_i(r0,r1,r2) +#define stxi(i0,r0,r1) stxi_i(i0,r0,r1) #define f1(o,b,t,i) _f1(_jit,o,b,t,i) static void _f1(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); @@ -663,6 +673,12 @@ static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t, #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0) #define comr(r0,r1) UADDCM(_R0_REGNO,r1,r0) #define negr(r0,r1) SUB(_R0_REGNO,r1,r0) +#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); #define extr_c(r0,r1) EXTRWR(r1,31,8,r0) #define extr_uc(r0,r1) EXTRWR_U(r1,31,8,r0) #define extr_s(r0,r1) EXTRWR(r1,31,16,r0) @@ -691,6 +707,10 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2) +#define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0) +#define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2) +#define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0) static long long __llmul(int, int); #define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3) static void _qmulr(jit_state_t*, @@ -756,6 +776,13 @@ static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2) static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define rshi_u(r0,r1,i0) SHRWI_U(r1,i0,r0) +#define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2) +static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define lroti(r0,r1,i0) rroti(r0,r1,32-i0) +#define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2) +static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +#define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0) +static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); #define cmpr(c,r0,r1,r2) _cmpr(_jit,c,r0,r1,r2) static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t); #define cmpi(c,ci,r0,r1,i0) _cmpi(_jit,c,ci,r0,r1,i0) @@ -809,7 +836,6 @@ static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t); #define ldxr_us(r0,r1,r2) LDH(r2,r1,r0) #define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0) static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); -#define ldr(r0,r1) ldr_ui(r0,r1) #define ldr_i(r0,r1) ldr_ui(r0,r1) #define ldr_ui(r0,r1) LDWI(_R0_REGNO,r1,r0) #define ldi_i(r0,i0) ldi_ui(r0,i0) @@ -817,7 +843,6 @@ static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t); #define ldxr_i(r0,r1,r2) ldxr_ui(r0,r1,r2) #define ldxr_ui(r0,r1,r2) LDW(r2,r1,r0) -#define ldxi(r0,r1,i0) ldxi_ui(r0,r1,i0) #define ldxi_i(r0,r1,i0) ldxi_ui(r0,r1,i0) #define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0) static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -840,7 +865,6 @@ static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t); #define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2) static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); -#define stxi(i0,r0,r1) stxi_i(i0,r0,r1) #define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1) static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); #define bcmpr(c,i0,r0,r1) _bcmpr(_jit,c,i0,r0,r1) @@ -933,6 +957,8 @@ static void _vastart(jit_state_t*, jit_int32_t); static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t); #define patch_at(i,l) _patch_at(_jit,i,l) static void _patch_at(jit_state_t*,jit_word_t,jit_word_t); + +# define NEED_FALLBACK_CASX 1 #endif #if CODE @@ -1694,6 +1720,53 @@ _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) patch_at(w, _jit->pc.w); } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if ( i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + EXTRWR(r1, 32 - (i0 + 1), i1, r0); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + EXTRWR_U(r1, 32 - (i0 + 1), i1, r0); + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + DEPWR(r1, 32 - (i0 + 1), i1, r0); + } +} + static void _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_word_t i0) @@ -1870,7 +1943,8 @@ _qmulr(jit_state_t *_jit, movr(_R26_REGNO, r2); movr(_R25_REGNO, r3); calli((jit_word_t)__llmul); - movr(r0, _R29_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _R29_REGNO); movr(r1, _R28_REGNO); } @@ -1881,7 +1955,8 @@ _qmuli(jit_state_t *_jit, movr(_R26_REGNO, r2); movi(_R25_REGNO, i0); calli((jit_word_t)__llmul); - movr(r0, _R29_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _R29_REGNO); movr(r1, _R28_REGNO); } @@ -1898,7 +1973,8 @@ _qmulr_u(jit_state_t *_jit, ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8); XMPYU(rn(t0), rn(t1), rn(t0)); stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0)); - ldxi(r0, _FP_REGNO, alloca_offset - 4); + if (r0 != JIT_NOREG) + ldxi(r0, _FP_REGNO, alloca_offset - 4); ldxi(r1, _FP_REGNO, alloca_offset - 8); jit_unget_reg(t1); jit_unget_reg(t0); @@ -2127,6 +2203,25 @@ _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) EXTRW_U(r1, 32, r0); } +static void +_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) +{ + fallback_lrotr(r0, r1, r2); +} + +static void +_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2) +{ + fallback_rrotr(r0, r1, r2); +} + +static void +_rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_word_t i0) +{ + movr(r0, r1); + SHRPWI(r0, r0, i0, r0); +} + static void _cmpr(jit_state_t *_jit, jit_word_t c, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -2183,12 +2278,20 @@ static void _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - LDBL(i0, _R0_REGNO, r0); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + LDBL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDBL(sign_extend(i0, 11), rn(reg), r0); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - LDBL(sign_extend(i0, 11), rn(reg), r0); + movi(rn(reg), i0); + ldr_uc(r0, rn(reg)); jit_unget_reg(reg); } } @@ -2197,9 +2300,9 @@ static void _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) LDBI(i0, r1, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) LDBL(i0, r1, r0); else { reg = jit_get_reg(jit_class_gpr); @@ -2241,12 +2344,20 @@ static void _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - LDHL(i0, _R0_REGNO, r0); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + LDHL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDHL(sign_extend(i0, 11), rn(reg), r0); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - LDHL(sign_extend(i0, 11), rn(reg), r0); + movi(rn(reg), i0); + ldr_us(r0, rn(reg)); jit_unget_reg(reg); } } @@ -2255,9 +2366,9 @@ static void _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) LDHI(i0, r1, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) LDHL(i0, r1, r0); else { reg = jit_get_reg(jit_class_gpr); @@ -2271,12 +2382,20 @@ static void _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - LDWL(i0, _R0_REGNO, r0); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + LDWL(i0, _R0_REGNO, r0); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + LDWL(sign_extend(i0, 11), rn(reg), r0); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - LDWL(sign_extend(i0, 11), rn(reg), r0); + movi(rn(reg), i0); + ldr_ui(r0, rn(reg)); jit_unget_reg(reg); } } @@ -2285,9 +2404,9 @@ static void _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) LDWI(i0, r1, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) LDWL(i0, r1, r0); else { reg = jit_get_reg(jit_class_gpr); @@ -2301,12 +2420,20 @@ static void _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - STBL(r0, i0, _R0_REGNO); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + STBL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STBL(r0, sign_extend(i0, 11), rn(reg)); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - STBL(r0, sign_extend(i0, 11), rn(reg)); + movi(rn(reg), i0); + str_c(rn(reg), r0); jit_unget_reg(reg); } } @@ -2325,9 +2452,9 @@ static void _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) STBI(r1, i0, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) STBL(r1, i0, r0); else { reg = jit_get_reg(jit_class_gpr); @@ -2341,12 +2468,20 @@ static void _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - STHL(r0, i0, _R0_REGNO); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + STHL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STHL(r0, sign_extend(i0, 11), rn(reg)); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - STHL(r0, sign_extend(i0, 11), rn(reg)); + movi(rn(reg), i0); + str_s(rn(reg), r0); jit_unget_reg(reg); } } @@ -2365,9 +2500,9 @@ static void _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) STHI(r1, i0, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) STHL(r1, i0, r0); else { reg = jit_get_reg(jit_class_gpr); @@ -2381,12 +2516,20 @@ static void _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { jit_int32_t reg; - if (i0 >= -8182 && i0 <= 8191) - STWL(r0, i0, _R0_REGNO); + if (jit_imm_idx_p()) { + if (i0 >= -8182 && i0 <= 8191) + STWL(r0, i0, _R0_REGNO); + else { + reg = jit_get_reg(jit_class_gpr); + LDIL(i0 & ~0x7ff, rn(reg)); + STWL(r0, sign_extend(i0, 11), rn(reg)); + jit_unget_reg(reg); + } + } else { reg = jit_get_reg(jit_class_gpr); - LDIL(i0 & ~0x7ff, rn(reg)); - STWL(r0, sign_extend(i0, 11), rn(reg)); + movi(rn(reg), i0); + str_i(rn(reg), r0); jit_unget_reg(reg); } } @@ -2405,9 +2548,9 @@ static void _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { jit_int32_t reg; - if (i0 >= -16 && i0 <= 15) + if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15)) STWI(r1, i0, r0); - else if (i0 >= -8182 && i0 <= 8191) + else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191)) STWL(r1, i0, r0); else { reg = jit_get_reg(jit_class_gpr); diff --git a/deps/lightning/lib/jit_hppa-fpu.c b/deps/lightning/lib/jit_hppa-fpu.c index ed141a73..699d31e9 100644 --- a/deps/lightning/lib/jit_hppa-fpu.c +++ b/deps/lightning/lib/jit_hppa-fpu.c @@ -271,7 +271,31 @@ static void _f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, #define negr_f(r0,r1) FNEG_S(r1,r0) #define negr_d(r0,r1) FNEG_D(r1,r0) #define sqrtr_f(r0,r1) FSQRT_S(r1,r0) +#define fmar_f(r0,r1,r2,r3) _fmar_f(_jit,r0,r1,r2,r3) +static void _fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fmsr_f(r0,r1,r2,r3) _fmsr_f(_jit,r0,r1,r2,r3) +static void _fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fnmar_f(r0,r1,r2,r3) _fnmar_f(_jit,r0,r1,r2,r3) +static void _fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fnmsr_f(r0,r1,r2,r3) _fnmsr_f(_jit,r0,r1,r2,r3) +static void _fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); #define sqrtr_d(r0,r1) FSQRT_D(r1,r0) +#define fmar_d(r0,r1,r2,r3) _fmar_d(_jit,r0,r1,r2,r3) +static void _fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fmsr_d(r0,r1,r2,r3) _fmsr_d(_jit,r0,r1,r2,r3) +static void _fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fnmar_d(r0,r1,r2,r3) _fnmar_d(_jit,r0,r1,r2,r3) +static void _fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +#define fnmsr_d(r0,r1,r2,r3) _fnmsr_d(_jit,r0,r1,r2,r3) +static void _fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); #define extr_f(r0,r1) _extr_f(_jit,r0,r1) static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t); #define extr_d(r0,r1) _extr_d(_jit,r0,r1) @@ -287,9 +311,13 @@ static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); #define movr_f(r0,r1) FCPY_S(r1,r0) #define movi_f(r0,i0) _movi_f(_jit,r0,i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); +#define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); #define movr_d(r0,r1) FCPY_D(r1,r0) #define movi_d(r0,i0) _movi_d(_jit,r0,i0) static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); +#define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) +static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); #define absr_f(r0,r1) FABS_S(r1,r0) #define absr_d(r0,r1) FABS_D(r1,r0) #define addr_f(r0,r1,r2) FADD_S(r1,r2,r0) @@ -695,6 +723,68 @@ _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) jit_unget_reg(reg); } +static void +_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ +#if 1 + jit_int32_t reg; + if (r0 != r3) { + mulr_f(r0, r1, r2); + addr_f(r0, r0, r3); + } + else { + reg = jit_get_reg(jit_class_fpr); + mulr_f(rn(reg), r1, r2); + addr_f(r0, rn(reg), r3); + jit_unget_reg(reg); + } +#else + FMPYFADD_S(r1, r2, r3, r0); +#endif +} + +static void +_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t reg; + if (r0 != r3) { + mulr_f(r0, r1, r2); + subr_f(r0, r0, r3); + } + else { + reg = jit_get_reg(jit_class_fpr); + mulr_f(rn(reg), r1, r2); + subr_f(r0, rn(reg), r3); + jit_unget_reg(reg); + } +} + +static void +_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) { @@ -716,6 +806,78 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) ldi_f(r0, (jit_word_t)i0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + +static void +_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ +#if 1 + jit_int32_t reg; + if (r0 != r3) { + mulr_d(r0, r1, r2); + addr_d(r0, r0, r3); + } + else { + reg = jit_get_reg(jit_class_fpr); + mulr_d(rn(reg), r1, r2); + addr_d(r0, rn(reg), r3); + jit_unget_reg(reg); + } +#else + FMPYFADD_D(r1, r2, r3, r0); +#endif +} + +static void +_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t reg; + if (r0 != r3) { + mulr_d(r0, r1, r2); + subr_d(r0, r0, r3); + } + else { + reg = jit_get_reg(jit_class_fpr); + mulr_d(rn(reg), r1, r2); + subr_d(r0, rn(reg), r3); + jit_unget_reg(reg); + } +} + +static void +_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) { @@ -741,6 +903,19 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) ldi_d(r0, (jit_word_t)i0); } +static void +_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + movr_ww_d(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + #define fpr_opi(name, type, size) \ static void \ _##name##i_##type(jit_state_t *_jit, \ diff --git a/deps/lightning/lib/jit_hppa-sz.c b/deps/lightning/lib/jit_hppa-sz.c index e41f89cb..7a23ebda 100644 --- a/deps/lightning/lib/jit_hppa-sz.c +++ b/deps/lightning/lib/jit_hppa-sz.c @@ -1,12 +1,11 @@ - #if __WORDSIZE == 32 #define JIT_INSTR_MAX 196 0, /* data */ 0, /* live */ - 28, /* align */ + 16, /* align */ 0, /* save */ 0, /* load */ - 0, /* skip */ + 4, /* skip */ 0, /* #name */ 0, /* #note */ 0, /* label */ @@ -42,53 +41,55 @@ 0, /* putargi_l */ 4, /* va_start */ 8, /* va_arg */ - 20, /* va_arg_d */ + 20, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 12, /* addi */ + 12, /* addi */ 4, /* addcr */ - 12, /* addci */ + 12, /* addci */ 4, /* addxr */ 8, /* addxi */ 4, /* subr */ - 12, /* subi */ + 12, /* subi */ 4, /* subcr */ - 12, /* subci */ + 12, /* subci */ 4, /* subxr */ 8, /* subxi */ - 12, /* rsbi */ - 48, /* mulr */ - 56, /* muli */ - 40, /* qmulr */ - 44, /* qmuli */ - 52, /* qmulr_u */ - 60, /* qmuli_u */ - 36, /* divr */ - 40, /* divi */ - 36, /* divr_u */ - 40, /* divi_u */ - 40, /* qdivr */ - 40, /* qdivi */ - 40, /* qdivr_u */ - 40, /* qdivi_u */ - 36, /* remr */ - 40, /* remi */ - 36, /* remr_u */ - 40, /* remi_u */ + 12, /* rsbi */ + 48, /* mulr */ + 56, /* muli */ + 40, /* qmulr */ + 44, /* qmuli */ + 52, /* qmulr_u */ + 60, /* qmuli_u */ + 36, /* divr */ + 40, /* divi */ + 36, /* divr_u */ + 40, /* divi_u */ + 40, /* qdivr */ + 40, /* qdivi */ + 40, /* qdivr_u */ + 40, /* qdivi_u */ + 36, /* remr */ + 40, /* remi */ + 36, /* remr_u */ + 40, /* remi_u */ 4, /* andr */ - 12, /* andi */ + 12, /* andi */ 4, /* orr */ - 12, /* ori */ + 12, /* ori */ 4, /* xorr */ - 12, /* xori */ - 12, /* lshr */ + 12, /* xori */ + 12, /* lshr */ 4, /* lshi */ - 12, /* rshr */ + 12, /* rshr */ 4, /* rshi */ - 12, /* rshr_u */ + 12, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 8, /* ltr */ 8, /* lti */ 8, /* ltr_u */ @@ -98,7 +99,7 @@ 8, /* ler_u */ 8, /* lei_u */ 8, /* eqr */ - 12, /* eqi */ + 12, /* eqi */ 8, /* ger */ 8, /* gei */ 8, /* ger_u */ @@ -111,28 +112,40 @@ 8, /* nei */ 4, /* movr */ 8, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 88, /* casr */ - 96, /* casi */ + 12, /* movnr */ + 12, /* movzr */ + 0, /* casr */ + 0, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ - 12, /* bswapr_us */ - 16, /* bswapr_ui */ + 0, /* exti_ui */ + 12, /* bswapr_us */ + 8, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 8, /* ldr_c */ - 12, /* ldi_c */ + 12, /* ldi_c */ 4, /* ldr_uc */ 8, /* ldi_uc */ 8, /* ldr_s */ - 12, /* ldi_s */ + 12, /* ldi_s */ 4, /* ldr_us */ 8, /* ldi_us */ 4, /* ldr_i */ @@ -142,11 +155,11 @@ 0, /* ldr_l */ 0, /* ldi_l */ 8, /* ldxr_c */ - 12, /* ldxi_c */ + 12, /* ldxi_c */ 4, /* ldxr_uc */ 8, /* ldxi_uc */ 8, /* ldxr_s */ - 12, /* ldxi_s */ + 12, /* ldxi_s */ 4, /* ldxr_us */ 8, /* ldxi_us */ 4, /* ldxr_i */ @@ -164,23 +177,23 @@ 0, /* str_l */ 0, /* sti_l */ 8, /* stxr_c */ - 12, /* stxi_c */ + 12, /* stxi_c */ 8, /* stxr_s */ - 12, /* stxi_s */ + 12, /* stxi_s */ 8, /* stxr_i */ - 12, /* stxi_i */ + 12, /* stxi_i */ 0, /* stxr_l */ 0, /* stxi_l */ 8, /* bltr */ - 8, /* blti */ + 12, /* blti */ 8, /* bltr_u */ 8, /* blti_u */ 8, /* bler */ - 12, /* blei */ + 12, /* blei */ 8, /* bler_u */ 8, /* blei_u */ 8, /* beqr */ - 16, /* beqi */ + 16, /* beqi */ 8, /* bger */ 8, /* bgei */ 8, /* bger_u */ @@ -190,11 +203,11 @@ 8, /* bgtr_u */ 8, /* bgti_u */ 8, /* bner */ - 16, /* bnei */ - 12, /* bmsr */ - 16, /* bmsi */ - 12, /* bmcr */ - 16, /* bmci */ + 16, /* bnei */ + 12, /* bmsr */ + 16, /* bmsi */ + 12, /* bmcr */ + 16, /* bmci */ 8, /* boaddr */ 8, /* boaddi */ 8, /* boaddr_u */ @@ -203,18 +216,18 @@ 8, /* bxaddi */ 8, /* bxaddr_u */ 8, /* bxaddi_u */ - 12, /* bosubr */ - 16, /* bosubi */ - 16, /* bosubr_u */ - 20, /* bosubi_u */ - 12, /* bxsubr */ - 16, /* bxsubi */ - 16, /* bxsubr_u */ - 20, /* bxsubi_u */ + 12, /* bosubr */ + 16, /* bosubi */ + 16, /* bosubr_u */ + 20, /* bosubi_u */ + 12, /* bxsubr */ + 16, /* bxsubi */ + 16, /* bxsubr_u */ + 20, /* bxsubi_u */ 4, /* jmpr */ - 12, /* jmpi */ - 40, /* callr */ - 44, /* calli */ + 12, /* jmpi */ + 40, /* callr */ + 44, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -260,87 +273,90 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 24, /* addi_f */ + 24, /* addi_f */ 4, /* subr_f */ - 24, /* subi_f */ - 24, /* rsbi_f */ + 24, /* subi_f */ + 24, /* rsbi_f */ 4, /* mulr_f */ - 24, /* muli_f */ + 24, /* muli_f */ 4, /* divr_f */ - 24, /* divi_f */ + 24, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 16, /* ltr_f */ - 36, /* lti_f */ - 16, /* ler_f */ - 36, /* lei_f */ - 16, /* eqr_f */ - 36, /* eqi_f */ - 16, /* ger_f */ - 36, /* gei_f */ - 16, /* gtr_f */ - 36, /* gti_f */ - 16, /* ner_f */ - 36, /* nei_f */ - 16, /* unltr_f */ - 36, /* unlti_f */ - 16, /* unler_f */ - 36, /* unlei_f */ - 16, /* uneqr_f */ - 36, /* uneqi_f */ - 16, /* unger_f */ - 36, /* ungei_f */ - 16, /* ungtr_f */ - 36, /* ungti_f */ - 16, /* ltgtr_f */ - 36, /* ltgti_f */ - 16, /* ordr_f */ - 36, /* ordi_f */ - 16, /* unordr_f */ - 36, /* unordi_f */ - 16, /* truncr_f_i */ + 0, /* sqrti_f */ + 16, /* ltr_f */ + 36, /* lti_f */ + 16, /* ler_f */ + 36, /* lei_f */ + 16, /* eqr_f */ + 36, /* eqi_f */ + 16, /* ger_f */ + 36, /* gei_f */ + 16, /* gtr_f */ + 36, /* gti_f */ + 16, /* ner_f */ + 36, /* nei_f */ + 16, /* unltr_f */ + 36, /* unlti_f */ + 16, /* unler_f */ + 36, /* unlei_f */ + 16, /* uneqr_f */ + 36, /* uneqi_f */ + 16, /* unger_f */ + 36, /* ungei_f */ + 16, /* ungtr_f */ + 36, /* ungti_f */ + 16, /* ltgtr_f */ + 36, /* ltgti_f */ + 16, /* ordr_f */ + 36, /* ordi_f */ + 16, /* unordr_f */ + 36, /* unordi_f */ + 16, /* truncr_f_i */ 0, /* truncr_f_l */ - 20, /* extr_f */ + 20, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 20, /* movi_f */ + 20, /* movi_f */ 4, /* ldr_f */ - 12, /* ldi_f */ + 12, /* ldi_f */ 8, /* ldxr_f */ - 12, /* ldxi_f */ + 12, /* ldxi_f */ 4, /* str_f */ - 12, /* sti_f */ + 12, /* sti_f */ 8, /* stxr_f */ - 12, /* stxi_f */ - 16, /* bltr_f */ - 36, /* blti_f */ - 16, /* bler_f */ - 36, /* blei_f */ - 16, /* beqr_f */ - 36, /* beqi_f */ - 16, /* bger_f */ - 36, /* bgei_f */ - 16, /* bgtr_f */ - 36, /* bgti_f */ - 16, /* bner_f */ - 36, /* bnei_f */ - 16, /* bunltr_f */ - 36, /* bunlti_f */ - 16, /* bunler_f */ - 36, /* bunlei_f */ - 16, /* buneqr_f */ - 36, /* buneqi_f */ - 16, /* bunger_f */ - 36, /* bungei_f */ - 16, /* bungtr_f */ - 36, /* bungti_f */ - 16, /* bltgtr_f */ - 36, /* bltgti_f */ - 16, /* bordr_f */ - 36, /* bordi_f */ - 16, /* bunordr_f */ - 36, /* bunordi_f */ + 12, /* stxi_f */ + 16, /* bltr_f */ + 36, /* blti_f */ + 16, /* bler_f */ + 36, /* blei_f */ + 16, /* beqr_f */ + 36, /* beqi_f */ + 16, /* bger_f */ + 36, /* bgei_f */ + 16, /* bgtr_f */ + 36, /* bgti_f */ + 16, /* bner_f */ + 36, /* bnei_f */ + 16, /* bunltr_f */ + 36, /* bunlti_f */ + 16, /* bunler_f */ + 36, /* bunlei_f */ + 16, /* buneqr_f */ + 36, /* buneqi_f */ + 16, /* bunger_f */ + 36, /* bungei_f */ + 16, /* bungtr_f */ + 36, /* bungti_f */ + 16, /* bltgtr_f */ + 36, /* bltgti_f */ + 16, /* bordr_f */ + 36, /* bordi_f */ + 16, /* bunordr_f */ + 36, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -351,103 +367,165 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 32, /* addi_d */ + 32, /* addi_d */ 4, /* subr_d */ - 32, /* subi_d */ - 32, /* rsbi_d */ + 32, /* subi_d */ + 32, /* rsbi_d */ 4, /* mulr_d */ - 32, /* muli_d */ + 32, /* muli_d */ 4, /* divr_d */ - 32, /* divi_d */ + 32, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 16, /* ltr_d */ - 44, /* lti_d */ - 16, /* ler_d */ - 44, /* lei_d */ - 16, /* eqr_d */ - 44, /* eqi_d */ - 16, /* ger_d */ - 44, /* gei_d */ - 16, /* gtr_d */ - 44, /* gti_d */ - 16, /* ner_d */ - 44, /* nei_d */ - 16, /* unltr_d */ - 44, /* unlti_d */ - 16, /* unler_d */ - 44, /* unlei_d */ - 16, /* uneqr_d */ - 44, /* uneqi_d */ - 16, /* unger_d */ - 44, /* ungei_d */ - 16, /* ungtr_d */ - 44, /* ungti_d */ - 16, /* ltgtr_d */ - 44, /* ltgti_d */ - 16, /* ordr_d */ - 44, /* ordi_d */ - 16, /* unordr_d */ - 44, /* unordi_d */ - 16, /* truncr_d_i */ + 0, /* sqrti_d */ + 16, /* ltr_d */ + 44, /* lti_d */ + 16, /* ler_d */ + 44, /* lei_d */ + 16, /* eqr_d */ + 44, /* eqi_d */ + 16, /* ger_d */ + 44, /* gei_d */ + 16, /* gtr_d */ + 44, /* gti_d */ + 16, /* ner_d */ + 44, /* nei_d */ + 16, /* unltr_d */ + 44, /* unlti_d */ + 16, /* unler_d */ + 44, /* unlei_d */ + 16, /* uneqr_d */ + 44, /* uneqi_d */ + 16, /* unger_d */ + 44, /* ungei_d */ + 16, /* ungtr_d */ + 44, /* ungti_d */ + 16, /* ltgtr_d */ + 44, /* ltgti_d */ + 16, /* ordr_d */ + 44, /* ordi_d */ + 16, /* unordr_d */ + 44, /* unordi_d */ + 16, /* truncr_d_i */ 0, /* truncr_d_l */ - 20, /* extr_d */ + 20, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 28, /* movi_d */ + 28, /* movi_d */ 4, /* ldr_d */ - 12, /* ldi_d */ + 12, /* ldi_d */ 8, /* ldxr_d */ - 12, /* ldxi_d */ + 12, /* ldxi_d */ 4, /* str_d */ - 12, /* sti_d */ + 12, /* sti_d */ 8, /* stxr_d */ - 12, /* stxi_d */ - 16, /* bltr_d */ - 44, /* blti_d */ - 16, /* bler_d */ - 44, /* blei_d */ - 16, /* beqr_d */ - 44, /* beqi_d */ - 16, /* bger_d */ - 44, /* bgei_d */ - 16, /* bgtr_d */ - 44, /* bgti_d */ - 16, /* bner_d */ - 44, /* bnei_d */ - 16, /* bunltr_d */ - 44, /* bunlti_d */ - 16, /* bunler_d */ - 44, /* bunlei_d */ - 16, /* buneqr_d */ - 44, /* buneqi_d */ - 16, /* bunger_d */ - 44, /* bungei_d */ - 16, /* bungtr_d */ - 44, /* bungti_d */ - 16, /* bltgtr_d */ - 44, /* bltgti_d */ - 16, /* bordr_d */ - 44, /* bordi_d */ - 16, /* bunordr_d */ - 44, /* bunordi_d */ + 12, /* stxi_d */ + 16, /* bltr_d */ + 44, /* blti_d */ + 16, /* bler_d */ + 44, /* blei_d */ + 16, /* beqr_d */ + 44, /* beqi_d */ + 16, /* bger_d */ + 44, /* bgei_d */ + 16, /* bgtr_d */ + 44, /* bgti_d */ + 16, /* bner_d */ + 44, /* bnei_d */ + 16, /* bunltr_d */ + 44, /* bunlti_d */ + 16, /* bunler_d */ + 44, /* bunlei_d */ + 16, /* buneqr_d */ + 44, /* buneqi_d */ + 16, /* bunger_d */ + 44, /* bungei_d */ + 16, /* bungtr_d */ + 44, /* bungti_d */ + 16, /* bltgtr_d */ + 44, /* bltgti_d */ + 16, /* bordr_d */ + 44, /* bordi_d */ + 16, /* bunordr_d */ + 44, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 16, /* movr_w_f */ + 20, /* movi_w_f */ + 20, /* movr_ww_d */ + 28, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 12, /* movr_f_w */ + 4, /* movi_f_w */ + 16, /* movr_d_ww */ + 8, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 160, /* clo */ - 140, /* clz */ - 164, /* cto */ - 144, /* ctz */ + 80, /* clor */ + 4, /* cloi */ + 60, /* clzr */ + 4, /* clzi */ + 76, /* ctor */ + 4, /* ctoi */ + 56, /* ctzr */ + 4, /* ctzi */ + 68, /* rbitr */ + 8, /* rbiti */ + 64, /* popcntr */ + 4, /* popcnti */ + 32, /* lrotr */ + 8, /* lroti */ + 32, /* rrotr */ + 8, /* rroti */ + 4, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 72, /* qlshr */ + 8, /* qlshi */ + 72, /* qlshr_u */ + 8, /* qlshi_u */ + 72, /* qrshr */ + 8, /* qrshi */ + 72, /* qrshr_u */ + 8, /* qrshi_u */ + 0, /* unldr */ + 0, /* unldi */ + 0, /* unldr_u */ + 0, /* unldi_u */ + 0, /* unstr */ + 0, /* unsti */ + 0, /* unldr_x */ + 0, /* unldi_x */ + 0, /* unstr_x */ + 0, /* unsti_x */ + 8, /* fmar_f */ + 0, /* fmai_f */ + 8, /* fmsr_f */ + 0, /* fmsi_f */ + 8, /* fmar_d */ + 0, /* fmai_d */ + 8, /* fmsr_d */ + 0, /* fmsi_d */ + 12, /* fnmar_f */ + 0, /* fnmai_f */ + 12, /* fnmsr_f */ + 0, /* fnmsi_f */ + 12, /* fnmar_d */ + 0, /* fnmai_d */ + 12, /* fnmsr_d */ + 0, /* fnmsi_d */ + 36, /* hmulr */ + 40, /* hmuli */ + 48, /* hmulr_u */ + 56, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_hppa.c b/deps/lightning/lib/jit_hppa.c index d3c5ef7f..6330bf68 100644 --- a/deps/lightning/lib/jit_hppa.c +++ b/deps/lightning/lib/jit_hppa.c @@ -49,6 +49,7 @@ extern void __clear_cache(void *, void *); /* * Initialization */ +jit_cpu_t jit_cpu; jit_register_t _rvs[] = { { 0, "r0" }, /* Zero */ /* Not register starved, so, avoid allocating r1 and rp @@ -135,6 +136,12 @@ void jit_get_cpu(void) { /* FIXME Expecting PARISC 2.0, for PARISC 1.0 should not use fr16-fr31 */ + + /* Set to zero to pass all tests in unldst.tst */ + /* Note that it only fails for instructions with an immediate, and + * it does not look like an encoding error, as even if only generating + * the encoding if ((immediate & 3) == 0) it still fails. */ + jit_cpu.imm_idx = 1; } void @@ -164,6 +171,7 @@ _jit_prolog(jit_state_t *_jit) _jitc->function->self.argi = _jitc->function->self.alen = 0; /* float conversion */ _jitc->function->self.aoff = alloca_offset; + _jitc->function->cvt_offset = alloca_offset - 8; _jitc->function->self.call = jit_call_default; jit_alloc((jit_pointer_t *)&_jitc->function->regoff, _jitc->reglen * sizeof(jit_int32_t)); @@ -898,6 +906,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.w), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrrr(name, type) \ case jit_code_##name##r##type: \ name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ @@ -1010,6 +1024,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1034,10 +1052,31 @@ _emit_code(jit_state_t *_jit) case_rrw(xor,); case_rrr(lsh,); case_rrw(lsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rrr(movn,); case_rrr(movz,); case jit_code_casr: @@ -1072,10 +1111,26 @@ _emit_code(jit_state_t *_jit) #define clzr(r0, r1) fallback_clz(r0, r1) #define ctor(r0, r1) fallback_cto(r0, r1) #define ctzr(r0, r1) fallback_ctz(r0, r1) +#define rbitr(r0, r1) fallback_rbit(r0, r1) +#define popcntr(r0, r1) fallback_popcnt(r0, r1) case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); + case_rr(popcnt,); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1124,6 +1179,22 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _us); case_rrr(ldx, _i); case_rrw(ldx, _i); +#define unldr(r0, r1, i0) fallback_unldr(r0, r1, i0) + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi(r0, i0, i1) fallback_unldi(r0, i0, i1) + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; +#define unldr_u(r0, r1, i0) fallback_unldr_u(r0, r1, i0) + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_u(r0, i0, i1) fallback_unldi_u(r0, i0, i1) + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1136,6 +1207,14 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _s); case_rrr(stx, _i); case_wrr(stx, _i); +#define unstr(r0, r1, i0) fallback_unstr(r0, r1, i0) + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti(i0, r0, i1) fallback_unsti(i0, r0, i1) + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_brr(blt,); case_brw(blt,); case_brr(blt, _u); @@ -1197,7 +1276,15 @@ _emit_code(jit_state_t *_jit) case_rr(neg, _f); case_rr(neg, _d); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rrr(add, _f); case_rrf(add, _f, 32); case_rrr(add, _d); @@ -1280,6 +1367,14 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _f); case_rrr(ldx, _d); case_rrw(ldx, _d); +#define unldr_x(r0, r1, i0) fallback_unldr_x(r0, r1, i0) + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_x(r0, i0, i1) fallback_unldi_x(r0, i0, i1) + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rr(st, _d); @@ -1288,6 +1383,14 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _f); case_rrr(stx, _d); case_wrr(stx, _d); +#define unstr_x(r0, r1, i0) fallback_unstr_x(r0, r1, i0) + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti_x(i0, r0, i1) fallback_unsti_x(i0, r0, i1) + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_brr(blt, _f); case_brf(blt, _f, 32); case_brr(blt, _d); @@ -1421,6 +1524,8 @@ _emit_code(jit_state_t *_jit) /* allocar information also does not need to be undone */ undo.func.aoffoff = _jitc->function->aoffoff; undo.func.allocar = _jitc->function->allocar; + /* cvt_offset must also not be undone */ + undo.func.cvt_offset = _jitc->function->cvt_offset; memcpy(_jitc->function, &undo.func, sizeof(undo.func)); #if DEVEL_DISASSEMBLER prevw = undo.prevw; @@ -1434,6 +1539,33 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; + case jit_code_movr_ww_d: + movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movr_d_ww: + movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movi_d_ww: + assert(node->flag & jit_flag_data); + movi_d_ww(rn(node->u.w), rn(node->v.w), + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + break; case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1482,6 +1614,63 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_ia64-cpu.c b/deps/lightning/lib/jit_ia64-cpu.c index 98a10c39..a4ec58df 100644 --- a/deps/lightning/lib/jit_ia64-cpu.c +++ b/deps/lightning/lib/jit_ia64-cpu.c @@ -18,6 +18,7 @@ */ #if PROTO +#define jit_unaligned_p() (jit_cpu.unaligned) #define stack_framesize 144 #define params_offset 16 #define INST_NONE 0 /* should never be generated */ @@ -206,10 +207,10 @@ typedef enum { #define ldr(r0,r1) ldr_l(r0,r1) #define ldi(r0,i0) ldi_l(r0,i0) -#define str(r0,r1) str_l(r0,r1) -#define sti(i0,r0) str_l(i0,r0) #define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) #define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) +#define str(r0,r1) str_l(r0,r1) +#define sti(i0,r0) sti_l(i0,r0) #define stxr(r0,r1,r2) stxr_l(r0,r1,r2) #define stxi(i0,r0,r1) stxi_l(i0,r0,r1) @@ -735,8 +736,8 @@ static void _X5(jit_state_t*,jit_word_t, /* dep */ #define DEP_Z(r1,r2,pos,len) I12(len,pos,r2,r1) #define DEPI_Z(r1,im,pos,len) I13(len,pos,im,r1) -#define DEPs(r1,r2,r3,pos,len) I14(1,len,r3,pos,r1) -#define DEPu(r1,r2,r3,pos,len) I14(0,len,r3,pos,r1) +#define DEPs(r1,r3,pos,len) I14(1,len,r3,pos,r1) +#define DEPu(r1,r3,pos,len) I14(0,len,r3,pos,r1) #define DEP(r1,r2,r3,pos,len) I15(pos,len,r3,r2,r1) /* epc */ #define EPC() B8(0x10) @@ -1205,6 +1206,12 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define hmulr(r0,r1,r2) mulh(r0,r1,r2,1) +#define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0) +static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define hmulr_u(r0,r1,r2) mulh(r0,r1,r2,0) +#define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0) +static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); #define divr(r0,r1,r2) _divr(_jit,r0,r1,r2) static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define divi(r0,r1,i0) _divi(_jit,r0,r1,i0) @@ -1261,6 +1268,26 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); #define rshr_u(r0,r1,r2) SHR_U(r0,r1,r2) #define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3) +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); #define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2) static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define lti(r0,r1,i0) _lti(_jit,r0,r1,i0) @@ -1301,8 +1328,6 @@ static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define nei(r0,r1,i0) _nei(_jit,r0,r1,i0) static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); -#define bitswap(r0, r1) _bitswap(_jit, r0, r1) -static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t); #define clor(r0, r1) _clor(_jit, r0, r1) static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); #define clzr(r0, r1) _clzr(_jit, r0, r1) @@ -1311,6 +1336,7 @@ static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); #define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +#define popcntr(r0, r1) POPCNT(r0, r1) #define negr(r0,r1) subr(r0,0,r1) #define comr(r0,r1) ANDCMI(r0,-1,r1) #define movr(r0,r1) _movr(_jit,r0,r1) @@ -1333,6 +1359,12 @@ static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ul(r0,r1) MUX1(r0,r1,MUX_REV) +#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); #define extr_c(r0,r1) SXT1(r0,r1) #define extr_uc(r0,r1) ZXT1(r0,r1) #define extr_s(r0,r1) SXT2(r0,r1) @@ -1479,6 +1511,14 @@ static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0) static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); #define str_c(r0,r1) ST1(r0,r1) #define sti_c(i0,r0) _sti_c(_jit,i0,r0) static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); @@ -1507,6 +1547,10 @@ static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1) static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); #define jmpr(r0) _jmpr(_jit,r0) static void _jmpr(jit_state_t*,jit_int32_t); #define jmpi(i0) _jmpi(_jit,i0) @@ -2495,7 +2539,7 @@ _I11(jit_state_t *_jit, jit_word_t _p, assert(!(_p & ~0x3fL)); assert(!(len & ~0x3fL)); assert(!(r3 & ~0x7fL)); - assert(!(pos & ~0x1fL)); + assert(!(pos & ~0x3fL)); assert(!(y & ~0x1L)); assert(!(r1 & ~0x7fL)); TSTREG1(r3); @@ -3475,52 +3519,6 @@ _nop(jit_state_t *_jit, jit_int32_t i0) assert(i0 == 0); } -static void -_bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) -{ - jit_int32_t t0, t1, t2, t3, t4; - movr(r0, r1); - t0 = jit_get_reg(jit_class_gpr); - t1 = jit_get_reg(jit_class_gpr); - t2 = jit_get_reg(jit_class_gpr); - movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L); - rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L); - rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL); - rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL); - rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), 0x0000ffff0000ffffL); - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */ - lshi(rn(t2), r0, 32); /* t2 = v << 32 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - jit_unget_reg(t2); - jit_unget_reg(t1); - jit_unget_reg(t0); -} - static void _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -3545,8 +3543,8 @@ static void _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { if (jit_cpu.clz) { - bitswap(r0, r1); - clor(r0, r0); + comr(r0, r1); + ctzr(r0, r0); } else fallback_cto(r0, r1); @@ -3555,9 +3553,17 @@ _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) static void _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { + jit_int32_t t0, t1; if (jit_cpu.clz) { - bitswap(r0, r1); - clzr(r0, r0); + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + negr(rn(t0), r1); + andr(rn(t0), rn(t0), r1); + clzr(r0, rn(t0)); + xori(rn(t1), r0, __WORDSIZE - 1); + movnr(r0, rn(t1), rn(t0)); + jit_unget_reg(t0); + jit_unget_reg(t1); } else fallback_ctz(r0, r1); @@ -3610,6 +3616,63 @@ _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) MOV_p(r0, r1, PR_6); } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if ( i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + EXTR(r0, r1, i0, i1 - 1); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + EXTR_U(r0, r1, i0, i1 - 1); + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (i1 <16) + DEP(r0, r1, r0, 63 - i0, i1 - 1); + else { + t0 = jit_get_reg(jit_class_gpr); + mask = ((1L << i1) - 1) << i0; + movr(rn(t0), r0); + DEP_Z(r0, r1, 63 - i0, i1 - 1); + andi(rn(t0), rn(t0), ~mask); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } + } +} + static void _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_word_t i0) @@ -3833,6 +3896,26 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + #if !defined(__GNUC__) static long __divdi3(long u, long v) @@ -4139,6 +4222,208 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + if (sign) + rshr(r1, t2, t0); + else + rshr_u(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(jit_code_beqi, over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(jit_code_beqi, zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(jit_code_jmpi, done, _jit->pc.w); + patch_at(jit_code_jmpi, done_over, _jit->pc.w); + } + else { + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + /* zero? */ + movzr(r1, t0, t3); + /* Branchless but 4 bytes longer than branching fallback */ + if (sign) + movi(t0, 0); + /* overflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + if (sign) + rshr(r0, t2, t3); + else + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(jit_code_beqi, over, _jit->pc.w); + /* underflow */ + if (sign) + rshi(r0, t2, __WORDSIZE - 1); + else + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(jit_code_beqi, zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(jit_code_jmpi, done, _jit->pc.w); + patch_at(jit_code_jmpi, done_over, _jit->pc.w); + jit_unget_reg(s1); + } + else { + /* zero? */ + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + movzr(r1, t0, t3); + /* underflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + static void _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { @@ -4614,6 +4899,44 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) ldr_l(r0, r1); } +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr(r0, r1, i0); + else + generic_unldr(r0, r1, i0); +} + +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi(r0, i0, i1); + else + generic_unldi(r0, i0, i1); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_u(r0, r1, i0); + else + generic_unldr_u(r0, r1, i0); +} + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi_u(r0, i0, i1); + else + generic_unldi_u(r0, i0, i1); +} + static void _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -4750,6 +5073,24 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) str_l(r0, r1); } +static void +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr(r0, r1, i0); + else + generic_unstr(r0, r1, i0); +} + +static void +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti(i0, r0, i1); + else + generic_unsti(i0, r0, i1); +} + static jit_word_t _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_ia64-fpu.c b/deps/lightning/lib/jit_ia64-fpu.c index f0fb32c7..bca90b70 100644 --- a/deps/lightning/lib/jit_ia64-fpu.c +++ b/deps/lightning/lib/jit_ia64-fpu.c @@ -439,22 +439,34 @@ static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); static void _movr_w_f(jit_state_t*,jit_int32_t,jit_int32_t); #define movr_f_w(r0,r1) _movr_f_w(_jit,r0,r1) static void _movr_f_w(jit_state_t*,jit_int32_t,jit_int32_t); +#define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); #define movr_w_d(r0,r1) _movr_w_d(_jit,r0,r1) static void _movr_w_d(jit_state_t*,jit_int32_t,jit_int32_t); #define movr_d_w(r0,r1) _movr_d_w(_jit,r0,r1) static void _movr_d_w(jit_state_t*,jit_int32_t,jit_int32_t); -#define movi_f_w(r0,i0) _movi_f_w(_jit,r0,i0) -static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*); -#define movi_d_w(r0,i0) _movi_d_w(_jit,r0,i0) -static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*); +#define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); #define absr_f(r0,r1) absr_d(r0,r1) #define absr_d(r0,r1) FABS(r0,r1) #define negr_f(r0,r1) negr_d(r0,r1) #define negr_d(r0,r1) FNEG(r0,r1) #define sqrtr_f(r0,r1) _sqrtr_f(_jit,r0,r1) static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t); +#define fmar_f(r0,r1,r2,r3) FMA_S(r0,r1,r2,r3) +#define fmsr_f(r0,r1,r2,r3) FMS_S(r0,r1,r2,r3) +#define fnmsr_f(r0,r1,r2,r3) FNMA_S(r0,r1,r2,r3) +#define fnmar_f(r0,r1,r2,r3) _fnmar_f(_jit,r0,r1,r2,r3) +static void _fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); #define sqrtr_d(r0,r1) _sqrtr_d(_jit,r0,r1) static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t); +#define fmar_d(r0,r1,r2,r3) FMA_D(r0,r1,r2,r3) +#define fmsr_d(r0,r1,r2,r3) FMS_D(r0,r1,r2,r3) +#define fnmsr_d(r0,r1,r2,r3) FNMA_D(r0,r1,r2,r3) +#define fnmar_d(r0,r1,r2,r3) _fnmar_d(_jit,r0,r1,r2,r3) +static void _fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); #define extr_f_d(r0,r1) FNORM_D(r0,r1) #define extr_d_f(r0,r1) FNORM_S(r0,r1) #define extr_f(r0,r1) _extr_f(_jit,r0,r1) @@ -603,6 +615,10 @@ static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t); static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0) static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr_x(r0, r1, i0) _unldr_x(_jit, r0, r1, i0) +static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_x(r0, i0, i1) _unldi_x(_jit, r0, i0, i1) +static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); #define ldr_d(r0,r1) LDFD(r0,r1) #define ldi_d(r0,i0) _ldi_d(_jit,r0,i0) static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t); @@ -617,6 +633,10 @@ static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); #define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1) static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define unstr_x(r0, r1, i0) _unstr_x(_jit, r0, r1, i0) +static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti_x(i0, r0, i1) _unsti_x(_jit, i0, r0, i1) +static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); #define str_d(r0,r1) STFD(r0,r1) #define sti_d(i0,r0) _sti_d(_jit,i0,r0) static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t); @@ -1072,19 +1092,13 @@ _movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } static void -_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - jit_data_t data; - - /* Should be used only in this case (with out0 == 120) */ - if (r0 >= 120) - r0 = _jitc->rout + (r0 - 120); - if (_jitc->no_data) { - data.f = *i0; - movi(r0, data.q.l); - } - else - ldi_i(r0, (jit_word_t)i0); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); } static void @@ -1106,22 +1120,13 @@ _movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } static void -_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - union { - jit_word_t w; - jit_float64_t d; - } data; - - /* Should be used only in this case (with out0 == 120) */ - if (r0 >= 120) - r0 = _jitc->rout + (r0 - 120); - if (_jitc->no_data) { - data.d = *i0; - movi(r0, data.w); - } - else - ldi_l(r0, (jit_word_t)i0); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); } #define fpr_opi(name, type, size) \ @@ -1421,6 +1426,24 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) ldr_f(r0, r1); } +static void +_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_x(r0, r1, i0); + else + generic_unldr_x(r0, r1, i0); +} + +static void +_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unldi_x(r0, i0, i1); + else + generic_unldi_x(r0, i0, i1); +} + static void _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { @@ -1489,6 +1512,24 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) str_f(r0, r1); } +static void +_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr_x(r0, r1, i0); + else + generic_unstr_x(r0, r1, i0); +} + +static void +_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti_x(i0, r0, i1); + else + fallback_unsti_x(i0, r0, i1); +} + static void _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -1531,6 +1572,14 @@ _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) MOVF(r0, GR_8); } +static void +_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + fmar_f(r0, r1, r2, r3); + negr_f(r0, r0); +} + static void _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -1539,6 +1588,14 @@ _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) MOVF(r0, GR_8); } +static void +_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + fmar_d(r0, r1, r2, r3); + negr_d(r0, r0); +} + static jit_word_t _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_ia64-sz.c b/deps/lightning/lib/jit_ia64-sz.c index e1d973c7..9033334b 100644 --- a/deps/lightning/lib/jit_ia64-sz.c +++ b/deps/lightning/lib/jit_ia64-sz.c @@ -1,15 +1,15 @@ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 608 +#define JIT_INSTR_MAX 144 0, /* data */ 0, /* live */ - 48, /* align */ + 32, /* align */ 0, /* save */ 0, /* load */ 16, /* skip */ 0, /* #name */ 0, /* #note */ 0, /* label */ - 224, /* prolog */ + 80, /* prolog */ 0, /* ellipsis */ 0, /* va_push */ 0, /* allocai */ @@ -40,46 +40,46 @@ 0, /* putargr_l */ 0, /* putargi_l */ 16, /* va_start */ - 32, /* va_arg */ - 32, /* va_arg_d */ + 16, /* va_arg */ + 16, /* va_arg_d */ 0, /* va_end */ 16, /* addr */ - 32, /* addi */ - 32, /* addcr */ - 48, /* addci */ - 64, /* addxr */ - 64, /* addxi */ + 16, /* addi */ + 16, /* addcr */ + 32, /* addci */ + 32, /* addxr */ + 32, /* addxi */ 16, /* subr */ - 32, /* subi */ - 32, /* subcr */ - 48, /* subci */ - 64, /* subxr */ - 64, /* subxi */ - 32, /* rsbi */ - 48, /* mulr */ - 64, /* muli */ - 112, /* qmulr */ - 112, /* qmuli */ - 112, /* qmulr_u */ - 112, /* qmuli_u */ - 80, /* divr */ - 96, /* divi */ - 80, /* divr_u */ - 96, /* divi_u */ - 144, /* qdivr */ - 144, /* qdivi */ - 144, /* qdivr_u */ - 144, /* qdivi_u */ - 80, /* remr */ - 96, /* remi */ - 80, /* remr_u */ - 96, /* remi_u */ + 16, /* subi */ + 16, /* subcr */ + 32, /* subci */ + 32, /* subxr */ + 32, /* subxi */ + 16, /* rsbi */ + 32, /* mulr */ + 32, /* muli */ + 48, /* qmulr */ + 48, /* qmuli */ + 48, /* qmulr_u */ + 48, /* qmuli_u */ + 32, /* divr */ + 48, /* divi */ + 32, /* divr_u */ + 48, /* divi_u */ + 64, /* qdivr */ + 64, /* qdivi */ + 64, /* qdivr_u */ + 64, /* qdivi_u */ + 32, /* remr */ + 48, /* remi */ + 32, /* remr_u */ + 48, /* remi_u */ 16, /* andr */ - 32, /* andi */ + 16, /* andi */ 16, /* orr */ - 32, /* ori */ + 16, /* ori */ 16, /* xorr */ - 32, /* xori */ + 16, /* xori */ 16, /* lshr */ 16, /* lshi */ 16, /* rshr */ @@ -87,133 +87,147 @@ 16, /* rshr_u */ 16, /* rshi_u */ 16, /* negr */ + 16, /* negi */ 16, /* comr */ - 32, /* ltr */ - 32, /* lti */ - 32, /* ltr_u */ - 32, /* lti_u */ - 32, /* ler */ - 32, /* lei */ - 32, /* ler_u */ - 32, /* lei_u */ - 32, /* eqr */ - 32, /* eqi */ - 32, /* ger */ - 32, /* gei */ - 32, /* ger_u */ - 32, /* gei_u */ - 32, /* gtr */ - 32, /* gti */ - 32, /* gtr_u */ - 32, /* gti_u */ - 32, /* ner */ - 32, /* nei */ + 16, /* comi */ + 16, /* ltr */ + 16, /* lti */ + 16, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 16, /* eqr */ + 16, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 16, /* gtr */ + 16, /* gti */ + 16, /* gtr_u */ + 16, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 16, /* movr */ 16, /* movi */ 16, /* movnr */ 16, /* movzr */ - 48, /* casr */ - 64, /* casi */ + 32, /* casr */ + 32, /* casi */ 16, /* extr_c */ + 16, /* exti_c */ 16, /* extr_uc */ + 16, /* exti_uc */ 16, /* extr_s */ + 16, /* exti_s */ 16, /* extr_us */ + 16, /* exti_us */ 16, /* extr_i */ + 16, /* exti_i */ 16, /* extr_ui */ - 32, /* bswapr_us */ - 32, /* bswapr_ui */ + 16, /* exti_ui */ + 16, /* bswapr_us */ + 16, /* bswapi_us */ + 16, /* bswapr_ui */ + 16, /* bswapi_ui */ 16, /* bswapr_ul */ - 32, /* htonr_us */ - 32, /* htonr_ui */ + 16, /* bswapi_ul */ + 16, /* htonr_us */ + 16, /* htoni_us */ + 16, /* htonr_ui */ + 16, /* htoni_ui */ 16, /* htonr_ul */ + 16, /* htoni_ul */ 16, /* ldr_c */ - 32, /* ldi_c */ + 16, /* ldi_c */ 16, /* ldr_uc */ - 32, /* ldi_uc */ + 16, /* ldi_uc */ 16, /* ldr_s */ - 32, /* ldi_s */ + 16, /* ldi_s */ 16, /* ldr_us */ - 32, /* ldi_us */ + 16, /* ldi_us */ 16, /* ldr_i */ - 32, /* ldi_i */ + 16, /* ldi_i */ 16, /* ldr_ui */ - 32, /* ldi_ui */ + 16, /* ldi_ui */ 16, /* ldr_l */ - 32, /* ldi_l */ - 32, /* ldxr_c */ - 48, /* ldxi_c */ + 16, /* ldi_l */ + 16, /* ldxr_c */ + 32, /* ldxi_c */ 16, /* ldxr_uc */ - 32, /* ldxi_uc */ - 32, /* ldxr_s */ - 48, /* ldxi_s */ + 16, /* ldxi_uc */ + 16, /* ldxr_s */ + 32, /* ldxi_s */ 16, /* ldxr_us */ - 32, /* ldxi_us */ - 32, /* ldxr_i */ - 48, /* ldxi_i */ + 16, /* ldxi_us */ + 16, /* ldxr_i */ + 32, /* ldxi_i */ 16, /* ldxr_ui */ - 32, /* ldxi_ui */ + 16, /* ldxi_ui */ 16, /* ldxr_l */ - 32, /* ldxi_l */ + 16, /* ldxi_l */ 16, /* str_c */ - 32, /* sti_c */ + 16, /* sti_c */ 16, /* str_s */ - 32, /* sti_s */ + 16, /* sti_s */ 16, /* str_i */ - 32, /* sti_i */ + 16, /* sti_i */ 16, /* str_l */ - 32, /* sti_l */ + 16, /* sti_l */ 16, /* stxr_c */ - 32, /* stxi_c */ + 16, /* stxi_c */ 16, /* stxr_s */ - 32, /* stxi_s */ + 16, /* stxi_s */ 16, /* stxr_i */ - 32, /* stxi_i */ + 16, /* stxi_i */ 16, /* stxr_l */ - 32, /* stxi_l */ - 32, /* bltr */ - 32, /* blti */ - 32, /* bltr_u */ - 32, /* blti_u */ - 32, /* bler */ - 32, /* blei */ - 32, /* bler_u */ - 32, /* blei_u */ - 32, /* beqr */ - 48, /* beqi */ - 32, /* bger */ - 32, /* bgei */ - 32, /* bger_u */ - 32, /* bgei_u */ - 32, /* bgtr */ - 32, /* bgti */ - 32, /* bgtr_u */ - 32, /* bgti_u */ - 32, /* bner */ - 48, /* bnei */ - 32, /* bmsr */ - 48, /* bmsi */ - 32, /* bmcr */ - 48, /* bmci */ - 96, /* boaddr */ - 112, /* boaddi */ - 64, /* boaddr_u */ - 64, /* boaddi_u */ - 96, /* bxaddr */ - 112, /* bxaddi */ - 64, /* bxaddr_u */ - 64, /* bxaddi_u */ - 112, /* bosubr */ - 112, /* bosubi */ - 64, /* bosubr_u */ - 64, /* bosubi_u */ - 112, /* bxsubr */ - 112, /* bxsubi */ - 64, /* bxsubr_u */ - 64, /* bxsubi_u */ + 16, /* stxi_l */ + 16, /* bltr */ + 16, /* blti */ + 16, /* bltr_u */ + 16, /* blti_u */ + 16, /* bler */ + 16, /* blei */ + 16, /* bler_u */ + 16, /* blei_u */ + 16, /* beqr */ + 32, /* beqi */ + 16, /* bger */ + 16, /* bgei */ + 16, /* bger_u */ + 16, /* bgei_u */ + 16, /* bgtr */ + 16, /* bgti */ + 16, /* bgtr_u */ + 16, /* bgti_u */ + 16, /* bner */ + 32, /* bnei */ + 16, /* bmsr */ + 32, /* bmsi */ + 16, /* bmcr */ + 32, /* bmci */ + 48, /* boaddr */ + 48, /* boaddi */ + 32, /* boaddr_u */ + 32, /* boaddi_u */ + 48, /* bxaddr */ + 48, /* bxaddi */ + 32, /* bxaddr_u */ + 32, /* bxaddi_u */ + 48, /* bosubr */ + 48, /* bosubi */ + 32, /* bosubr_u */ + 32, /* bosubi_u */ + 48, /* bxsubr */ + 48, /* bxsubi */ + 32, /* bxsubr_u */ + 32, /* bxsubi_u */ 16, /* jmpr */ 16, /* jmpi */ - 32, /* callr */ - 48, /* calli */ + 16, /* callr */ + 32, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -253,93 +267,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 128, /* epilog */ + 48, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ 16, /* addr_f */ - 48, /* addi_f */ + 32, /* addi_f */ 16, /* subr_f */ - 48, /* subi_f */ - 48, /* rsbi_f */ + 32, /* subi_f */ + 32, /* rsbi_f */ 16, /* mulr_f */ - 48, /* muli_f */ - 160, /* divr_f */ - 192, /* divi_f */ + 32, /* muli_f */ + 64, /* divr_f */ + 80, /* divi_f */ 16, /* negr_f */ + 0, /* negi_f */ 16, /* absr_f */ - 80, /* sqrtr_f */ - 32, /* ltr_f */ - 64, /* lti_f */ - 32, /* ler_f */ - 64, /* lei_f */ - 32, /* eqr_f */ - 64, /* eqi_f */ - 32, /* ger_f */ - 64, /* gei_f */ - 32, /* gtr_f */ - 64, /* gti_f */ - 32, /* ner_f */ - 64, /* nei_f */ - 32, /* unltr_f */ - 64, /* unlti_f */ - 32, /* unler_f */ - 64, /* unlei_f */ - 48, /* uneqr_f */ - 96, /* uneqi_f */ - 32, /* unger_f */ - 64, /* ungei_f */ - 32, /* ungtr_f */ - 64, /* ungti_f */ - 48, /* ltgtr_f */ - 96, /* ltgti_f */ - 32, /* ordr_f */ - 64, /* ordi_f */ - 32, /* unordr_f */ - 64, /* unordi_f */ - 32, /* truncr_f_i */ - 32, /* truncr_f_l */ - 48, /* extr_f */ + 0, /* absi_f */ + 32, /* sqrtr_f */ + 0, /* sqrti_f */ + 16, /* ltr_f */ + 32, /* lti_f */ + 16, /* ler_f */ + 32, /* lei_f */ + 16, /* eqr_f */ + 32, /* eqi_f */ + 16, /* ger_f */ + 32, /* gei_f */ + 16, /* gtr_f */ + 32, /* gti_f */ + 16, /* ner_f */ + 32, /* nei_f */ + 16, /* unltr_f */ + 32, /* unlti_f */ + 16, /* unler_f */ + 32, /* unlei_f */ + 32, /* uneqr_f */ + 48, /* uneqi_f */ + 16, /* unger_f */ + 32, /* ungei_f */ + 16, /* ungtr_f */ + 32, /* ungti_f */ + 32, /* ltgtr_f */ + 48, /* ltgti_f */ + 16, /* ordr_f */ + 32, /* ordi_f */ + 16, /* unordr_f */ + 32, /* unordi_f */ + 16, /* truncr_f_i */ + 16, /* truncr_f_l */ + 32, /* extr_f */ 16, /* extr_d_f */ 16, /* movr_f */ - 32, /* movi_f */ + 16, /* movi_f */ 16, /* ldr_f */ - 32, /* ldi_f */ + 16, /* ldi_f */ 16, /* ldxr_f */ - 32, /* ldxi_f */ + 16, /* ldxi_f */ 16, /* str_f */ - 32, /* sti_f */ + 16, /* sti_f */ 16, /* stxr_f */ - 32, /* stxi_f */ - 32, /* bltr_f */ - 64, /* blti_f */ - 32, /* bler_f */ - 64, /* blei_f */ - 32, /* beqr_f */ - 64, /* beqi_f */ - 32, /* bger_f */ - 64, /* bgei_f */ - 32, /* bgtr_f */ - 64, /* bgti_f */ - 32, /* bner_f */ - 64, /* bnei_f */ - 32, /* bunltr_f */ - 64, /* bunlti_f */ - 32, /* bunler_f */ - 64, /* bunlei_f */ - 80, /* buneqr_f */ - 112, /* buneqi_f */ - 32, /* bunger_f */ - 64, /* bungei_f */ - 32, /* bungtr_f */ - 64, /* bungti_f */ - 80, /* bltgtr_f */ - 112, /* bltgti_f */ - 32, /* bordr_f */ - 64, /* bordi_f */ - 32, /* bunordr_f */ - 64, /* bunordi_f */ + 16, /* stxi_f */ + 16, /* bltr_f */ + 32, /* blti_f */ + 16, /* bler_f */ + 32, /* blei_f */ + 16, /* beqr_f */ + 32, /* beqi_f */ + 16, /* bger_f */ + 32, /* bgei_f */ + 16, /* bgtr_f */ + 32, /* bgti_f */ + 16, /* bner_f */ + 32, /* bnei_f */ + 16, /* bunltr_f */ + 32, /* bunlti_f */ + 16, /* bunler_f */ + 32, /* bunlei_f */ + 32, /* buneqr_f */ + 48, /* buneqi_f */ + 16, /* bunger_f */ + 32, /* bungei_f */ + 16, /* bungtr_f */ + 32, /* bungti_f */ + 32, /* bltgtr_f */ + 48, /* bltgti_f */ + 16, /* bordr_f */ + 32, /* bordi_f */ + 16, /* bunordr_f */ + 32, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -350,103 +367,165 @@ 0, /* putargr_d */ 0, /* putargi_d */ 16, /* addr_d */ - 48, /* addi_d */ + 32, /* addi_d */ 16, /* subr_d */ - 48, /* subi_d */ - 48, /* rsbi_d */ + 32, /* subi_d */ + 32, /* rsbi_d */ 16, /* mulr_d */ - 48, /* muli_d */ - 160, /* divr_d */ - 192, /* divi_d */ + 32, /* muli_d */ + 64, /* divr_d */ + 80, /* divi_d */ 16, /* negr_d */ + 0, /* negi_d */ 16, /* absr_d */ - 80, /* sqrtr_d */ - 32, /* ltr_d */ - 64, /* lti_d */ - 32, /* ler_d */ - 64, /* lei_d */ - 32, /* eqr_d */ - 64, /* eqi_d */ - 32, /* ger_d */ - 64, /* gei_d */ - 32, /* gtr_d */ - 64, /* gti_d */ - 32, /* ner_d */ - 64, /* nei_d */ - 32, /* unltr_d */ - 64, /* unlti_d */ - 32, /* unler_d */ - 64, /* unlei_d */ - 48, /* uneqr_d */ - 96, /* uneqi_d */ - 32, /* unger_d */ - 64, /* ungei_d */ - 32, /* ungtr_d */ - 64, /* ungti_d */ - 48, /* ltgtr_d */ - 96, /* ltgti_d */ - 32, /* ordr_d */ - 64, /* ordi_d */ - 32, /* unordr_d */ - 64, /* unordi_d */ - 32, /* truncr_d_i */ - 32, /* truncr_d_l */ - 48, /* extr_d */ + 0, /* absi_d */ + 32, /* sqrtr_d */ + 0, /* sqrti_d */ + 16, /* ltr_d */ + 32, /* lti_d */ + 16, /* ler_d */ + 32, /* lei_d */ + 16, /* eqr_d */ + 32, /* eqi_d */ + 16, /* ger_d */ + 32, /* gei_d */ + 16, /* gtr_d */ + 32, /* gti_d */ + 16, /* ner_d */ + 32, /* nei_d */ + 16, /* unltr_d */ + 32, /* unlti_d */ + 16, /* unler_d */ + 32, /* unlei_d */ + 32, /* uneqr_d */ + 48, /* uneqi_d */ + 16, /* unger_d */ + 32, /* ungei_d */ + 16, /* ungtr_d */ + 32, /* ungti_d */ + 32, /* ltgtr_d */ + 48, /* ltgti_d */ + 16, /* ordr_d */ + 32, /* ordi_d */ + 16, /* unordr_d */ + 32, /* unordi_d */ + 16, /* truncr_d_i */ + 16, /* truncr_d_l */ + 32, /* extr_d */ 16, /* extr_f_d */ 16, /* movr_d */ - 32, /* movi_d */ + 16, /* movi_d */ 16, /* ldr_d */ - 32, /* ldi_d */ + 16, /* ldi_d */ 16, /* ldxr_d */ - 32, /* ldxi_d */ + 16, /* ldxi_d */ 16, /* str_d */ - 32, /* sti_d */ + 16, /* sti_d */ 16, /* stxr_d */ - 32, /* stxi_d */ - 32, /* bltr_d */ - 64, /* blti_d */ - 32, /* bler_d */ - 64, /* blei_d */ - 32, /* beqr_d */ - 64, /* beqi_d */ - 32, /* bger_d */ - 64, /* bgei_d */ - 32, /* bgtr_d */ - 64, /* bgti_d */ - 32, /* bner_d */ - 64, /* bnei_d */ - 32, /* bunltr_d */ - 64, /* bunlti_d */ - 32, /* bunler_d */ - 64, /* bunlei_d */ - 80, /* buneqr_d */ - 112, /* buneqi_d */ - 32, /* bunger_d */ - 64, /* bungei_d */ - 32, /* bungtr_d */ - 64, /* bungti_d */ - 80, /* bltgtr_d */ - 112, /* bltgti_d */ - 32, /* bordr_d */ - 64, /* bordi_d */ - 32, /* bunordr_d */ - 64, /* bunordi_d */ + 16, /* stxi_d */ + 16, /* bltr_d */ + 32, /* blti_d */ + 16, /* bler_d */ + 32, /* blei_d */ + 16, /* beqr_d */ + 32, /* beqi_d */ + 16, /* bger_d */ + 32, /* bgei_d */ + 16, /* bgtr_d */ + 32, /* bgti_d */ + 16, /* bner_d */ + 32, /* bnei_d */ + 16, /* bunltr_d */ + 32, /* bunlti_d */ + 16, /* bunler_d */ + 32, /* bunlei_d */ + 32, /* buneqr_d */ + 48, /* buneqi_d */ + 16, /* bunger_d */ + 32, /* bungei_d */ + 16, /* bungtr_d */ + 32, /* bungti_d */ + 32, /* bltgtr_d */ + 48, /* bltgti_d */ + 16, /* bordr_d */ + 32, /* bordi_d */ + 16, /* bunordr_d */ + 32, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 16, /* movr_w_f */ + 16, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 16, /* movr_w_d */ + 16, /* movi_w_d */ + 16, /* movr_f_w */ + 16, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ 16, /* movr_d_w */ - 32, /* movi_d_w */ - 608, /* clo */ - 544, /* clz */ - 608, /* cto */ - 544, /* ctz */ + 16, /* movi_d_w */ + 96, /* clor */ + 16, /* cloi */ + 64, /* clzr */ + 16, /* clzi */ + 64, /* ctor */ + 16, /* ctoi */ + 48, /* ctzr */ + 16, /* ctzi */ + 64, /* rbitr */ + 16, /* rbiti */ + 16, /* popcntr */ + 16, /* popcnti */ + 32, /* lrotr */ + 32, /* lroti */ + 32, /* rrotr */ + 32, /* rroti */ + 16, /* extr */ + 16, /* exti */ + 16, /* extr_u */ + 16, /* exti_u */ + 32, /* depr */ + 16, /* depi */ + 48, /* qlshr */ + 16, /* qlshi */ + 48, /* qlshr_u */ + 16, /* qlshi_u */ + 48, /* qrshr */ + 16, /* qrshi */ + 48, /* qrshr_u */ + 16, /* qrshi_u */ + 96, /* unldr */ + 48, /* unldi */ + 96, /* unldr_u */ + 48, /* unldi_u */ + 128, /* unstr */ + 96, /* unsti */ + 80, /* unldr_x */ + 48, /* unldi_x */ + 144, /* unstr_x */ + 112, /* unsti_x */ + 16, /* fmar_f */ + 0, /* fmai_f */ + 16, /* fmsr_f */ + 0, /* fmsi_f */ + 16, /* fmar_d */ + 0, /* fmai_d */ + 16, /* fmsr_d */ + 0, /* fmsi_d */ + 16, /* fnmar_f */ + 0, /* fnmai_f */ + 16, /* fnmsr_f */ + 0, /* fnmsi_f */ + 16, /* fnmar_d */ + 0, /* fnmai_d */ + 16, /* fnmsr_d */ + 0, /* fnmsi_d */ + 32, /* hmulr */ + 32, /* hmuli */ + 32, /* hmulr_u */ + 32, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_ia64.c b/deps/lightning/lib/jit_ia64.c index 29682785..f689231e 100644 --- a/deps/lightning/lib/jit_ia64.c +++ b/deps/lightning/lib/jit_ia64.c @@ -245,6 +245,8 @@ jit_get_cpu(void) : "=r" (clz)); assert(clz == 0 || clz == 1); jit_cpu.clz = clz; + /* By default assume kernel or cpu will not handle unaligned load/store */ + jit_cpu.unaligned = 1; } void @@ -1046,6 +1048,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1163,6 +1171,10 @@ _emit_code(jit_state_t *_jit) case_rrw(subc,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1187,16 +1199,35 @@ _emit_code(jit_state_t *_jit) case_rrw(xor,); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define lrotr(r0,r1,r2) fallback_lrotr(r0,r1,r2) +#define lroti(r0,r1,i0) fallback_lroti(r0,r1,i0) +#define rrotr(r0,r1,r2) fallback_rrotr(r0,r1,r2) +#define rroti(r0,r1,i0) fallback_rroti(r0,r1,i0) + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); +#define rbitr(r0, r1) fallback_rbit(r0, r1) + case_rr(rbit,); + case_rr(popcnt,); case jit_code_casr: casr(rn(node->u.w), rn(node->v.w), rn(node->w.q.l), rn(node->w.q.h)); @@ -1231,6 +1262,18 @@ _emit_code(jit_state_t *_jit) case_rr(bswap, _us); case_rr(bswap, _ui); case_rr(bswap, _ul); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1289,6 +1332,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _ui); case_rrr(ldx, _l); case_rrw(ldx, _l); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1305,6 +1360,12 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _i); case_rrr(stx, _l); case_wrr(stx, _l); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_brr(blt,); case_brw(blt,); case_brr(blt, _u); @@ -1358,10 +1419,26 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); @@ -1441,6 +1518,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ld, _d); case_rw(ld, _d); case_rrr(ldx, _d); @@ -1682,6 +1763,9 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: break; case jit_code_movr_w_f: movr_w_f(rn(node->u.w), rn(node->v.w)); @@ -1696,10 +1780,84 @@ _emit_code(jit_state_t *_jit) movr_d_w(rn(node->u.w), rn(node->v.w)); break; case jit_code_movi_f_w: - movi_f_w(rn(node->u.w), node->v.n->u.p); + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); break; case jit_code_movi_d_w: - movi_d_w(rn(node->u.w), node->v.n->u.p); + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_loongarch-cpu.c b/deps/lightning/lib/jit_loongarch-cpu.c index ab058521..22ca0f09 100644 --- a/deps/lightning/lib/jit_loongarch-cpu.c +++ b/deps/lightning/lib/jit_loongarch-cpu.c @@ -18,6 +18,7 @@ */ #if PROTO +# define jit_unaligned_p() (jit_cpu.unaligned) # define ii(i) *_jit->pc.ui++ = (i) # define can_sign_extend_si12_p(s12) ((s12) <= 2047 && (s12) >= -2048) # define can_zero_extend_u12_p(u12) ((u12) <= 4095 && (u12) >= 0) @@ -33,8 +34,11 @@ # define _FP_REGNO 22 # define ldr(u, v) ldr_l(u, v) # define ldi(u, v) ldi_l(u, v) +# define ldxr(u, v, w) ldxr_l(u, v, w) # define ldxi(u, v, w) ldxi_l(u, v, w) +# define str(u, v) str_l(u, v) # define sti(u, v) sti_l(u, v) +# define stxr(u, v, w) stxr_l(u, v, w) # define stxi(u, v, w) stxi_l(u, v, w) # define orrr(op, rk, rj, rd) _orrr(_jit, op, rk, rj, rd) # define ou5rr(op, i5, rj, rd) _orrr(_jit, op, i5, rj, rd) @@ -338,6 +342,7 @@ static void _oj26(jit_state_t*, jit_int32_t,jit_int32_t); # define clzr(r0, r1) CLZ_D(r0, r1) # define ctor(r0, r1) CTO_D(r0, r1) # define ctzr(r0, r1) CTZ_D(r0, r1) +# define rbitr(r0, r1) BITREV_D(r0, r1) static void _nop(jit_state_t*,jit_int32_t); # define movr(r0, r1) _movr(_jit, r0, r1) static void _movr(jit_state_t*, jit_int32_t, jit_int32_t); @@ -381,6 +386,12 @@ static void _rsbi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); # define mulr(r0, r1, r2) MUL_D(r0, r1, r2) # define muli(r0, r1, i0) _muli(_jit, r0, r1, i0) static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define hmulr(r0, r1, r2) MULH_D(r0, r1, r2) +# define hmuli(r0, r1, i0) _hmuli(_jit, r0, r1, i0) +static void _hmuli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define hmulr_u(r0, r1, r2) MULH_DU(r0, r1, r2) +# define hmuli_u(r0, r1, i0) _hmuli_u(_jit, r0, r1, i0) +static void _hmuli_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); # define qmulr(r0, r1, r2, r3) iqmulr(r0, r1, r2, r3, 1) # define qmulr_u(r0, r1, r2, r3) iqmulr(r0, r1, r2, r3, 0) # define iqmulr(r0, r1, r2, r3, sign) _iqmulr(_jit, r0, r1, r2, r3, sign) @@ -419,6 +430,11 @@ static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); # define rshi(r0, r1, i0) SRAI_D(r0, r1, i0) # define rshr_u(r0, r1, r2) SRL_D(r0, r1, r2) # define rshi_u(r0, r1, i0) SRLI_D(r0, r1, i0) +# define lrotr(r0, r1, r2) _lrotr(_jit, r0, r1, r2) +static void _lrotr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); +# define lroti(r0, r1, i0) rroti(r0, r1, __WORDSIZE - i0) +# define rrotr(r0, r1, r2) ROTR_D(r0, r1, r2) +# define rroti(r0, r1, i0) ROTRI_D(r0, r1, i0) # define andr(r0, r1, r2) AND(r0, r1, r2) # define andi(r0, r1, i0) _andi(_jit, r0, r1, i0) static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); @@ -470,6 +486,14 @@ static void _ldxi_ui(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); # define ldxr_l(r0, r1, r2) LDX_D(r0, r1, r2) # define ldxi_l(r0, r1, i0) _ldxi_l(_jit, r0, r1, i0) static void _ldxi_l(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_c(r0, r1) ST_B(r1, r0, 0) # define sti_c(i0, r0) _sti_c(_jit, i0, r0) static void _sti_c(jit_state_t*, jit_word_t, jit_int32_t); @@ -494,11 +518,19 @@ static void _stxi_i(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); # define stxr_l(r0, r1, r2) STX_D(r2, r1, r0) # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1) static void _stxi_l(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); +#define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1) static void _bswapr_us(jit_state_t*, jit_int32_t, jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) static void _bswapr_ui(jit_state_t*, jit_int32_t, jit_int32_t); # define bswapr_ul(r0, r1) REVB_D(r0, r1) +# define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_u(r0,r1,i0,i1) BSTRPICK_D(r0, r1, i0 + i1 - 1, i0) +# define depr(r0,r1,i0,i1) BSTRINS_D(r0, r1, i0 + i1 - 1, i0) # define extr_c(r0, r1) EXT_W_B(r0, r1) # define extr_uc(r0, r1) BSTRPICK_D(r0, r1, 7, 0) # define extr_s(r0, r1) EXT_W_H(r0, r1) @@ -1217,6 +1249,26 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) @@ -1329,6 +1381,22 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, __WORDSIZE); + rrotr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + rsbi(rn(reg), r2, __WORDSIZE); + rrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + static void _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -1567,6 +1635,44 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr(r0, r1, i0); + else + generic_unldr(r0, r1, i0); +} + +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi(r0, i0, i1); + else + generic_unldi(r0, i0, i1); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_u(r0, r1, i0); + else + generic_unldr_u(r0, r1, i0); +} + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi_u(r0, i0, i1); + else + generic_unldi_u(r0, i0, i1); +} + static void _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -1679,6 +1785,24 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr(r0, r1, i0); + else + generic_unstr(r0, r1, i0); +} + +static void +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti(i0, r0, i1); + else + generic_unsti(i0, r0, i1); +} + static void _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -1693,6 +1817,19 @@ _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) extr_ui(r0, r0); } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); +} + static void _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { diff --git a/deps/lightning/lib/jit_loongarch-fpu.c b/deps/lightning/lib/jit_loongarch-fpu.c index 2871de33..a3fd02a7 100644 --- a/deps/lightning/lib/jit_loongarch-fpu.c +++ b/deps/lightning/lib/jit_loongarch-fpu.c @@ -215,6 +215,10 @@ static void _divi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_float32_t); # define absr_f(r0, r1) FABS_S(r0, r1) # define negr_f(r0, r1) FNEG_S(r0, r1) # define sqrtr_f(r0, r1) FSQRT_S(r0, r1) +# define fmar_f(r0, r1, r2, r3) FMADD_S(r0, r1, r2, r3) +# define fmsr_f(r0, r1, r2, r3) FMSUB_S(r0, r1, r2, r3) +# define fnmar_f(r0, r1, r2, r3) FNMADD_S(r0, r1, r2, r3) +# define fnmsr_f(r0, r1, r2, r3) FNMSUB_S(r0, r1, r2, r3) # define extr_f(r0, r1) _extr_f(_jit, r0, r1) static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t); # define ldr_f(r0, r1) FLD_S(r0, r1, 0) @@ -223,19 +227,27 @@ static void _ldi_f(jit_state_t*, jit_int32_t, jit_word_t); # define ldxr_f(r0, r1, r2) FLDX_S(r0, r1, r2) # define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0) static void _ldxi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldr_x(r0, r1, i0) _unldr_x(_jit, r0, r1, i0) +static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_x(r0, i0, i1) _unldi_x(_jit, r0, i0, i1) +static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_f(r0, r1) FST_S(r1, r0, 0) # define sti_f(i0, r0) _sti_f(_jit, i0, r0) static void _sti_f(jit_state_t*, jit_word_t, jit_int32_t); # define stxr_f(r0, r1, r2) FSTX_S(r2, r1, r0) # define stxi_f(i0, r0, r1) _stxi_f(_jit, i0, r0, r1) static void _stxi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); +#define unstr_x(r0, r1, i0) _unstr_x(_jit, r0, r1, i0) +static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti_x(i0, r0, i1) _unsti_x(_jit, i0, r0, i1) +static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define movr_f(r0, r1) FMOV_S(r0, r1) # define movi_f(r0, i0) _movi_f(_jit, r0, i0) static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t); # define movr_f_w(r0, r1) MOVFR2GR_S(r0, r1) -# define movi_f_w(r0, im) _movi_f_w(_jit, r0, im) -static void _movi_f_w(jit_state_t*, jit_int32_t, jit_float32_t); # define movr_w_f(r0, r1) MOVGR2FR_W(r0, r1) +#define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define extr_d_f(r0, r1) FCVT_S_D(r0, r1) # define ltr_f(r0, r1, r2) _ltr_f(_jit, r0, r1, r2) static void _ltr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); @@ -367,6 +379,10 @@ static void _divi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t); # define absr_d(r0, r1) FABS_D(r0, r1) # define negr_d(r0, r1) FNEG_D(r0, r1) # define sqrtr_d(r0, r1) FSQRT_D(r0, r1) +# define fmar_d(r0, r1, r2, r3) FMADD_D(r0, r1, r2, r3) +# define fmsr_d(r0, r1, r2, r3) FMSUB_D(r0, r1, r2, r3) +# define fnmar_d(r0, r1, r2, r3) FNMADD_D(r0, r1, r2, r3) +# define fnmsr_d(r0, r1, r2, r3) FNMSUB_D(r0, r1, r2, r3) # define extr_d(r0, r1) _extr_d(_jit, r0, r1) static void _extr_d(jit_state_t*, jit_int32_t, jit_int32_t); # define ldr_d(r0, r1) FLD_D(r0, r1, 0) @@ -385,9 +401,9 @@ static void _stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); # define movi_d(r0, i0) _movi_d(_jit, r0, i0) static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t); # define movr_d_w(r0, r1) MOVFR2GR_D(r0, r1) -# define movi_d_w(r0, im) _movi_d_w(_jit, r0, im) -static void _movi_d_w(jit_state_t*, jit_int32_t, jit_float64_t); # define movr_w_d(r0, r1) MOVGR2FR_D(r0, r1) +#define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # define extr_f_d(r0, r1) FCVT_D_S(r0, r1) # define ltr_d(r0, r1, r2) _ltr_d(_jit, r0, r1, r2) static void _ltr_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); @@ -614,6 +630,24 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_x(r0, r1, i0); + else + generic_unldr_x(r0, r1, i0); +} + +static void +_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unldi_x(r0, i0, i1); + else + generic_unldi_x(r0, i0, i1); +} + static void _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -642,6 +676,24 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr_x(r0, r1, i0); + else + generic_unstr_x(r0, r1, i0); +} + +static void +_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti_x(i0, r0, i1); + else + fallback_unsti_x(i0, r0, i1); +} + static void _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) { @@ -662,14 +714,13 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) } static void -_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - union { - jit_int32_t i; - jit_float32_t f; - } data; - data.f = i0; - movi(r0, data.i); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); } static void @@ -1028,14 +1079,13 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) } static void -_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - union { - jit_int64_t l; - jit_float64_t d; - } data; - data.d = i0; - movi(r0, data.l); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); } static void diff --git a/deps/lightning/lib/jit_loongarch-sz.c b/deps/lightning/lib/jit_loongarch-sz.c index 4b950471..18e73aa2 100644 --- a/deps/lightning/lib/jit_loongarch-sz.c +++ b/deps/lightning/lib/jit_loongarch-sz.c @@ -2,7 +2,7 @@ #define JIT_INSTR_MAX 88 0, /* data */ 0, /* live */ - 28, /* align */ + 12, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -87,7 +87,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 4, /* ltr */ 4, /* lti */ 4, /* ltr_u */ @@ -115,17 +117,29 @@ 32, /* casr */ 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 4, /* extr_i */ + 4, /* exti_i */ 4, /* extr_ui */ + 12, /* exti_ui */ 8, /* bswapr_us */ + 8, /* bswapi_us */ 8, /* bswapr_ui */ + 8, /* bswapi_ui */ 4, /* bswapr_ul */ + 16, /* bswapi_ul */ 8, /* htonr_us */ + 8, /* htoni_us */ 8, /* htonr_ui */ + 8, /* htoni_ui */ 4, /* htonr_ul */ + 16, /* htoni_ul */ 4, /* ldr_c */ 20, /* ldi_c */ 4, /* ldr_uc */ @@ -268,8 +282,11 @@ 4, /* divr_f */ 12, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 8, /* ltr_f */ 16, /* lti_f */ 8, /* ler_f */ @@ -359,8 +376,11 @@ 4, /* divr_d */ 20, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 8, /* ltr_d */ 24, /* lti_d */ 8, /* ler_d */ @@ -437,16 +457,75 @@ 0, /* reti_d */ 0, /* retval_d */ 4, /* movr_w_f */ + 8, /* movi_w_f */ 0, /* movr_ww_d */ + 0, /* movi_ww_d */ 4, /* movr_w_d */ - 0, /* movr_f_w */ + 12, /* movi_w_d */ + 4, /* movr_f_w */ 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ 4, /* movr_d_w */ 12, /* movi_d_w */ - 4, /* clo */ - 4, /* clz */ - 4, /* cto */ - 4, /* ctz */ + 4, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 4, /* ctor */ + 4, /* ctoi */ + 4, /* ctzr */ + 4, /* ctzi */ + 4, /* rbitr */ + 16, /* rbiti */ + 52, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 84, /* qlshr */ + 8, /* qlshi */ + 84, /* qlshr_u */ + 8, /* qlshi_u */ + 84, /* qrshr */ + 8, /* qrshi */ + 84, /* qrshr_u */ + 8, /* qrshi_u */ + 24, /* unldr */ + 52, /* unldi */ + 24, /* unldr_u */ + 52, /* unldi_u */ + 20, /* unstr */ + 68, /* unsti */ + 4, /* unldr_x */ + 20, /* unldi_x */ + 4, /* unstr_x */ + 24, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 20, /* hmuli */ + 4, /* hmulr_u */ + 20, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_loongarch.c b/deps/lightning/lib/jit_loongarch.c index c9b5b8ca..cd38c4e5 100644 --- a/deps/lightning/lib/jit_loongarch.c +++ b/deps/lightning/lib/jit_loongarch.c @@ -40,11 +40,13 @@ static void _patch(jit_state_t*,jit_word_t,jit_node_t*); #define PROTO 1 # include "jit_loongarch-cpu.c" # include "jit_loongarch-fpu.c" +# include "jit_fallback.c" #undef PROTO /* * Initialization */ +jit_cpu_t jit_cpu; jit_register_t _rvs[] = { { rc(gpr) | 0x14, "$t8" }, { rc(gpr) | 0x13, "$t7" }, @@ -134,6 +136,8 @@ _jit_init(jit_state_t *_jit) { _jitc->reglen = jit_size(_rvs) - 1; jit_carry = _NOREG; + /* By default assume kernel or cpu will handle unaligned load/store */ + jit_cpu.unaligned = 0; } void @@ -964,6 +968,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1088,6 +1098,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1106,16 +1120,39 @@ _emit_code(jit_state_t *_jit) case_rrrw(qdiv, _u); case_rrr(lsh,); case_rrw(lsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); +#define popcntr(r0, r1) fallback_popcnt(r0, r1) + case_rr(popcnt,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1154,6 +1191,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _ui); case_rrr(ldx, _l); case_rrw(ldx, _l); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1170,12 +1219,30 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _i); case_rrr(stx, _l); case_wrr(stx, _l); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); case_rr(hton, _ul); case_rr(bswap, _us); case_rr(bswap, _ui); case_rr(bswap, _ul); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1282,15 +1349,31 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert_data(node); @@ -1365,6 +1448,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1554,6 +1641,9 @@ _emit_code(jit_state_t *_jit) assert_data(node); movi_f_w(rn(node->u.w), node->v.f); break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; case jit_code_movr_w_d: movr_w_d(rn(node->u.w), rn(node->v.w)); break; @@ -1564,6 +1654,9 @@ _emit_code(jit_state_t *_jit) assert_data(node); movi_d_w(rn(node->u.w), node->v.d); break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1620,6 +1713,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); @@ -1668,6 +1832,7 @@ _emit_code(jit_state_t *_jit) #define CODE 1 # include "jit_loongarch-cpu.c" # include "jit_loongarch-fpu.c" +# include "jit_fallback.c" #undef CODE void diff --git a/deps/lightning/lib/jit_mips-cpu.c b/deps/lightning/lib/jit_mips-cpu.c index 0b1b3b48..6a07e871 100644 --- a/deps/lightning/lib/jit_mips-cpu.c +++ b/deps/lightning/lib/jit_mips-cpu.c @@ -18,11 +18,18 @@ */ #if PROTO +/* FIXME Should need qemu 7.2 -- apparently broken with qemu 7.0 */ +#define PCREL_BROKEN 1 +#define BALC_BROKEN 1 + typedef union { #if __BYTE_ORDER == __LITTLE_ENDIAN struct { jit_uint32_t _:26; jit_uint32_t b : 6; } hc; struct { jit_uint32_t _:21; jit_uint32_t b : 5; } rs; struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fm; + struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fr; + struct { jit_uint32_t _:18; jit_uint32_t b : 3; } pD; + struct { jit_uint32_t _:19; jit_uint32_t b : 2; } pW; struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rt; struct { jit_uint32_t _:16; jit_uint32_t b : 5; } ft; struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rd; @@ -34,11 +41,16 @@ typedef union { struct { jit_uint32_t b : 5; } cn; struct { jit_uint32_t b : 11; } cc; struct { jit_uint32_t b : 16; } is; + struct { jit_uint32_t b : 18; } iD; + struct { jit_uint32_t b : 19; } iW; struct { jit_uint32_t b : 26; } ii; #else struct { jit_uint32_t b : 6; } hc; struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } rs; struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fm; + struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fr; + struct { jit_uint32_t _:11; jit_uint32_t b : 3; } pD; + struct { jit_uint32_t _:11; jit_uint32_t b : 2; } pW; struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rt; struct { jit_uint32_t _:11; jit_uint32_t b : 5; } ft; struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rd; @@ -50,12 +62,15 @@ typedef union { struct { jit_uint32_t _:27; jit_uint32_t b : 5; } cn; struct { jit_uint32_t _:21; jit_uint32_t b : 11; } cc; struct { jit_uint32_t _:16; jit_uint32_t b : 16; } is; + struct { jit_uint32_t _:14; jit_uint32_t b : 18; } iD; + struct { jit_uint32_t _:13; jit_uint32_t b : 19; } iW; struct { jit_uint32_t _: 6; jit_uint32_t b : 26; } ii; #endif int op; } jit_instr_t; #define jit_mips2_p() (jit_cpu.release >= 2) #define jit_mips6_p() (jit_cpu.release >= 6) +#define jit_unaligned_p() (jit_cpu.unaligned) # define _ZERO_REGNO 0 # define _T0_REGNO 0x08 # define _T1_REGNO 0x09 @@ -89,20 +104,31 @@ typedef union { # if __WORDSIZE == 32 # define ldr(u,v) ldr_i(u,v) # define ldi(u,v) ldi_i(u,v) +# define ldxr(u,v,w) ldxr_i(u,v,w) # define ldxi(u,v,w) ldxi_i(u,v,w) +# define str(u,v) str_i(u,v) # define sti(u,v) sti_i(u,v) +# define stxr(u,v,w) stxr_i(u,v,w) # define stxi(u,v,w) stxi_i(u,v,w) # else # define ldr(u,v) ldr_l(u,v) # define ldi(u,v) ldi_l(u,v) +# define ldxr(u,v,w) ldxr_l(u,v,w) # define ldxi(u,v,w) ldxi_l(u,v,w) +# define str(u,v) str_l(u,v) # define sti(u,v) sti_l(u,v) +# define stxr(u,v,w) stxr_l(u,v,w) # define stxi(u,v,w) stxi_l(u,v,w) # endif /* can_relative_jump_p(im) => can_sign_extend_short_p(im << 2) */ # define can_relative_jump_p(im) ((im) >= -130712 && (im) <= 131068) -# define can_sign_extend_short_p(im) ((im) >= -32678 && (im) <= 32767) +/* can_compact_jump_p(im) => can_sign_extend_i26_p(im << 2) */ +# define can_compact_jump_p(im) ((im) >= -268435456 && (im) <= 268435452) +# define can_sign_extend_short_p(im) ((im) >= -32768 && (im) <= 32767) # define can_zero_extend_short_p(im) ((im) >= 0 && (im) <= 65535) +# define can_sign_extend_i18_p(im) ((im) >= -262144 && (im) <= 262143) +# define can_sign_extend_i19_p(im) ((im) >= -524288 && (im) <= 524287) +# define can_sign_extend_i26_p(im) ((im) >= -67108864 && (im) <= 67108863) # define is_low_mask(im) (((im) & 1) ? (__builtin_popcountl((im) + 1) <= 1) : 0) # define is_middle_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0) # define is_high_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) == 0) : 0) @@ -149,6 +175,7 @@ typedef union { # define MIPS_LDR 0x1b # define MIPS_SPECIAL2 0x1c # define MIPS_JALX 0x1d +# define MIPS_DAUI 0x1d # define MIPS_SPECIAL3 0x1f # define MIPS_LB 0x20 # define MIPS_LH 0x21 @@ -162,6 +189,8 @@ typedef union { # define MIPS_SH 0x29 # define MIPS_SWL 0x2a # define MIPS_SW 0x2b +# define MIPS_SDL 0x2c +# define MIPS_SDR 0x2d # define MIPS_SWR 0x2e # define MIPS_CACHE 0x2f # define MIPS_LL 0x30 @@ -173,6 +202,9 @@ typedef union { # define MIPS_LDC2 0x36 # define MIPS_LD 0x37 # define MIPS_SC 0x38 +# define MIPS_BC_R6 0x32 +# define MIPS_BALC 0x3a +# define MIPS_PCREL 0x3b # define MIPS_SCD 0x3c # define MIPS_SDC1 0x3d # define MIPS_SDC2 0x3e @@ -213,7 +245,7 @@ typedef union { # define MIPS_BGEZALL 0x13 # define MIPS_SYNCI 0x1f # define MIPS_WSBH 0x02 -# define MIPS_DBSH 0x02 +# define MIPS_DSBH 0x02 # define MIPS_DSHD 0x05 # define MIPS_SEB 0x10 # define MIPS_SEH 0x18 @@ -321,6 +353,10 @@ static void _hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define hrri9(hc,rs,rt,i9,tc) _hrri9(_jit,hc,rs,rt,i9,tc) static void _hrri9(jit_state_t*,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); +# define hriD(hc,rs,pD,iD) _hriD(_jit,hc,rs,pD,iD) +static void _hriD(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define hriW(hc,rs,pW,iW) _hriW(_jit,hc,rs,pW,iW) +static void _hriW(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define hi(hc,im) _hi(_jit,hc,im) static void _hi(jit_state_t*,jit_int32_t,jit_int32_t); # define NOP(i0) instr(0) @@ -328,7 +364,11 @@ static void _hi(jit_state_t*,jit_int32_t,jit_int32_t); static void _nop(jit_state_t*,jit_int32_t); # define h_ri(hc,rt,im) _hrri(_jit,hc,0,rt,im) # define rrit(rt,rd,im,tc) _hrrrit(_jit,0,0,rt,rd,im,tc) +# define AUIPC(rs,im) hrri(MIPS_PCREL,rs,30,im) +# define ALUIPC(rs,im) hrri(MIPS_PCREL,rs,31,im) +# define ADDIUPC(rs,im) hriW(MIPS_PCREL,rs,0,im) # define LUI(rt,im) h_ri(MIPS_LUI,rt,im) +# define AUI(rs,rt) hrri(MIPS_LUI,rs,rt,im) /* mips r6 */ # define ADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_ADDU) # define DADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DADDU) # define ADDIU(rt,rs,im) hrri(MIPS_ADDIU,rs,rt,im) @@ -384,7 +424,10 @@ static void _nop(jit_state_t*,jit_int32_t); # define DEXTU(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos-32,MIPS_DEXTU) # define DEXTM(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-32-1,pos,MIPS_DEXTM) # define ROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_SRL) +# define ROTRV(rd,rt,rs) hrrrit(MIPS_SPECIAL,rs,rt,rd,1,MIPS_SRLV) # define DROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL) +# define DROTR32(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL32) +# define DROTRV(rd,rt,rs) hrrrit(MIPS_SPECIAL,rs,rt,rd,1,MIPS_DSRLV) # define SYNC() rrr_t(_ZERO_REGNO,_ZERO_REGNO,_ZERO_REGNO,MIPS_SYNC) # define MFHI(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFHI) # define MFLO(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFLO) @@ -402,27 +445,43 @@ static void _nop(jit_state_t*,jit_int32_t); # define LH(rt,of,rb) hrri(MIPS_LH,rb,rt,of) # define LHU(rt,of,rb) hrri(MIPS_LHU,rb,rt,of) # define LW(rt,of,rb) hrri(MIPS_LW,rb,rt,of) +# define LWPC(rs,im) hriW(MIPS_PCREL,rs,1,im) # define LWU(rt,of,rb) hrri(MIPS_LWU,rb,rt,of) +# define LWUPC(rs,im) hriW(MIPS_PCREL,rs,2,im) +# define LWL(rt,of,rb) hrri(MIPS_LWL,rb,rt,of) +# define LWR(rt,of,rb) hrri(MIPS_LWR,rb,rt,of) # define LD(rt,of,rb) hrri(MIPS_LD,rb,rt,of) +# define LDPC(rs,im) hriD(MIPS_PCREL,rs,6,im) # define LL(rt,of,rb) hrri(MIPS_LL,rb,rt,of) # define LL_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,54) # define LLD(rt,of,rb) hrri(MIPS_LLD,rb,rt,of) # define LLD_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,55) +# define LDL(rt,of,rb) hrri(MIPS_LDL,rb,rt,of) +# define LDR(rt,of,rb) hrri(MIPS_LDR,rb,rt,of) # define SB(rt,of,rb) hrri(MIPS_SB,rb,rt,of) # define SH(rt,of,rb) hrri(MIPS_SH,rb,rt,of) # define SW(rt,of,rb) hrri(MIPS_SW,rb,rt,of) +# define SWL(rt,of,rb) hrri(MIPS_SWL,rb,rt,of) +# define SWR(rt,of,rb) hrri(MIPS_SWR,rb,rt,of) # define SD(rt,of,rb) hrri(MIPS_SD,rb,rt,of) # define SC(rt,of,rb) hrri(MIPS_SC,rb,rt,of) # define SC_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,38) # define SCD(rt,of,rb) hrri(MIPS_SCD,rb,rt,of) # define SCD_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,39) +# define SDL(rt,of,rb) hrri(MIPS_SDL,rb,rt,of) +# define SDR(rt,of,rb) hrri(MIPS_SDR,rb,rt,of) # define WSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_WSBH,MIPS_BSHFL) # define SEB(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEB,MIPS_BSHFL) # define SEH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEH,MIPS_BSHFL) +# define DSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_DSBH,MIPS_DBSHFL) +# define DSHD(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_DSHD,MIPS_DBSHFL) # define SLT(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLT) # define SLTU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLTU) # define SLTI(rt,rs,im) hrri(MIPS_SLTI,rs,rt,im) # define SLTIU(rt,rs,im) hrri(MIPS_SLTIU,rs,rt,im) +# define DAUI(rt,rs,im) hrri(MIPS_DAUI,rs,rt,im) +# define DAHI(rs,im) hrri(MIPS_REGIMM,rs,6,im) +# define DATI(rs,im) hrri(MIPS_REGIMM,rs,30,im) # define BLTZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BLTZ,im) # define BLEZ(rs,im) hrri(MIPS_BLEZ,rs,_ZERO_REGNO,im) # define BEQ(rs,rt,im) hrri(MIPS_BEQ,rs,rt,im) @@ -448,14 +507,14 @@ static void _nop(jit_state_t*,jit_int32_t); # define DCLZ(rd,rs) hrrrit(MIPS_SPECIAL2,rs,rd,rd,0,MIPS_DCLZ) # define J(i0) hi(MIPS_J,i0) # define JAL(i0) hi(MIPS_JAL,i0) +# define BC_R6(i0) hi(MIPS_BC_R6,i0) +# define BALC(i0) hi(MIPS_BALC,i0) # define MOVN(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVN) # define MOVZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVZ) # define SELEQZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,53) # define SELNEZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,55) # define comr(r0,r1) xori(r0,r1,-1) # define negr(r0,r1) subr(r0,_ZERO_REGNO,r1) -# define bitswap(r0,r1) _bitswap(_jit, r0, r1); -static void _bitswap(jit_state_t*,jit_int32_t,jit_int32_t); # define clor(r0, r1) _clor(_jit, r0, r1) static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); # define clzr(r0, r1) _clzr(_jit, r0, r1) @@ -464,6 +523,8 @@ static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +# define rbitr(r0, r1) _rbitr(_jit, r0, r1) +static void _rbitr(jit_state_t*, jit_int32_t, jit_int32_t); # if __WORDSIZE == 32 # define addr(rd,rs,rt) ADDU(rd,rs,rt) # define addiu(r0,r1,i0) ADDIU(r0,r1,i0) @@ -497,8 +558,8 @@ static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); # define mod_r6(rd,rs,rt) DMOD_R6(rd,rs,rt) # define modu_r6(rd,rs,rt) DMODU_R6(rd,rs,rt) # endif -# define extr(rd,rt,lsb,nb) _extr(_jit,rd,rt,lsb,nb) -static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define mips_extr(rd,rt,lsb,nb) _mips_extr(_jit,rd,rt,lsb,nb) +static void _mips_extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define insr(rd,rt,lsb,nb) _insr(_jit,rd,rt,lsb,nb) static void _insr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0) @@ -527,6 +588,14 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0,r1,r2) _hmulr(_jit,r0,r1,r2) +static void _hmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0) +static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr_u(r0,r1,r2) _hmulr_u(_jit,r0,r1,r2) +static void _hmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0) +static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc) @@ -581,6 +650,33 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # endif +# define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3) +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2) +static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define lroti(r0,r1,i0) rroti(r0,r1,__WORDSIZE-i0) +# define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2) +static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0) +static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define andr(r0,r1,r2) AND(r0,r1,r2) # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0) static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -658,6 +754,14 @@ static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0) static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # endif +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_c(r0,r1) SB(r1,0,r0) # define sti_c(i0,r0) _sti_c(_jit,i0,r0) static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); @@ -690,13 +794,24 @@ static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1) static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); # endif +# define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1) static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t); # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1) static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t); # if __WORDSIZE == 64 -# define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1) +# define bswapr_ul(r0,r1) _bswapr_ul(_jit,r0,r1) +static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t); # endif +#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0,r1) _extr_c(_jit,r0,r1) static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t); # define extr_uc(r0,r1) ANDI(r0,r1,0xff) @@ -891,7 +1006,7 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, jit_int32_t reg0, jit_int32_t reg1) { jit_instr_t i; - jit_int32_t reg, r0, r1, r2, regs[3]; + jit_int32_t reg, r0, r1, r2/*, xreg*/, regs[3]; /* If will emit a pending instruction */ if (_jitc->inst.pend) i.op = _jitc->inst.op; @@ -901,7 +1016,7 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, /* Else, a nop */ else i.op = 0; - regs[0] = regs[1] = regs[2] = -1; + regs[0] = regs[1] = regs[2]/* = xreg*/ = -1; switch (i.hc.b) { case MIPS_SPECIAL: /* 00 */ switch (i.tc.b) { @@ -993,6 +1108,9 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, } break; case MIPS_SLL: /* 00 */ + /* If cannot have a shift in delay slot */ + if (!jit_cpu.sll_delay) + flush(); case MIPS_SRL: /* 02 */ case MIPS_SRA: /* 03 */ case MIPS_DSLL: /* 38 */ @@ -1012,7 +1130,7 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, case MIPS_SYNC: /* 0f */ assert(i.rs.b == 0 && i.rt.b == 0 && i.rd.b == 0); if (mask & jit_class_gpr) - regs[0] = regs[1] = regs[1] = 0; + regs[0] = regs[1] = regs[2] = 0; break; case MIPS_MOVZ: /* 0a */ case MIPS_MOVN: /* 0b */ @@ -1040,6 +1158,11 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, break; case MIPS_REGIMM: /* 01 */ switch (i.rt.b) { + /* DAHI */ + case 6: /* 06 */ + /* DATI */ + case 15: /* 1e */ + assert(jit_mips6_p()); case MIPS_BLTZ: /* 00 */ case MIPS_BGEZ: /* 01 */ case MIPS_BGEZAL: /* 11 */ @@ -1052,16 +1175,20 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, regs[1] = regs[2] = 0; } break; + case MIPS_BC_R6: /* 32 */ + case MIPS_BALC: /* 3a */ + assert(jit_mips6_p()); case MIPS_J: /* 02 */ case MIPS_JAL: /* 03 */ if (mask & jit_class_gpr) regs[0] = regs[1] = regs[2] = 0; break; case MIPS_LUI: /* 0f */ - assert(i.rs.b == 0); + assert(jit_mips6_p() || i.rs.b == 0); if (mask & jit_class_gpr) { regs[0] = i.rt.b; - regs[1] = regs[1] = 0; + regs[1] = i.rs.b; /* AUI if non zero */ + regs[1] = 0; } break; case MIPS_SPECIAL2: /* 1c */ @@ -1110,7 +1237,9 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, /* DBITSWAP */ case MIPS_DBSHFL: /* 24 */ switch (i.ic.b) { + /* DSBH */ case MIPS_WSBH: /* 02 */ + case MIPS_DSHD: /* 05 */ case MIPS_SEB: /* 10 */ case MIPS_SEH: /* 18 */ if (mask & jit_class_gpr) { @@ -1162,6 +1291,10 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, case MIPS_DMT: /* 05 */ case MIPS_MTH: /* 07 */ assert(i.ic.b == 0); + /* If these cop1 instructions in delay slot + * wont work */ + if (!jit_cpu.cop1_delay) + flush(); if (mask & jit_class_gpr) { regs[0] = i.rt.b; regs[1] = regs[2] = 0; @@ -1173,6 +1306,9 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, goto three_fprs; } break; + case MIPS_MADDF: /* 18 */ + case MIPS_MSUBF: /* 19 */ + assert(jit_mips6_p()); case MIPS_SUB_fmt: /* 01 */ case MIPS_MUL_fmt: /* 02 */ case MIPS_DIV_fmt: /* 03 */ @@ -1313,6 +1449,36 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, break; } break; + case MIPS_COP1X: /* 13 */ + switch (i.tc.b) { + case MIPS_MADD_fmt_S: + case MIPS_MADD_fmt_D: + case MIPS_MSUB_fmt_S: + case MIPS_MSUB_fmt_D: + case MIPS_NMADD_fmt_S: + case MIPS_NMADD_fmt_D: + case MIPS_NMSUB_fmt_S: + case MIPS_NMSUB_fmt_D: + assert(!jit_mips6_p()); + if (mask & jit_class_gpr) + regs[0] = regs[1] = regs[2] = 0; + else { + regs[0] = i.ft.b; + regs[1] = i.fs.b; + regs[2] = i.fd.b; + /* FIXME No need to compute and check it. + * If asking for a tmeporary fpr, code will + * be flushed. */ + /* xreg = i.fr.b; */ + } + break; + default: + abort(); + } + break; + case MIPS_DAUI: /* JALX */ /* 1d */ + /* Do not generate JALX. No microMIPS64 or MIPS16e support */ + assert(jit_mips6_p() && i.rs.b != 0); case MIPS_ADDIU: /* 09 */ case MIPS_SLTI: /* 0a */ case MIPS_SLTIU: /* 0b */ @@ -1320,6 +1486,8 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, case MIPS_ORI: /* 0d */ case MIPS_XORI: /* 0e */ case MIPS_DADDIU: /* 18 */ + case MIPS_LDL: /* 1a */ + case MIPS_LDR: /* 1b */ case MIPS_LB: /* 20 */ case MIPS_LH: /* 21 */ case MIPS_LW: /* 23 */ @@ -1337,6 +1505,21 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, regs[2] = 0; } break; + case MIPS_LWL: /* 22 */ + case MIPS_LWR: /* 26 */ + if (!jit_cpu.lwl_lwr_delay) + flush(); + case MIPS_SWL: /* 2a */ + case MIPS_SWR: /* 2e */ + case MIPS_SDL: /* 2c */ + case MIPS_SDR: /* 2d */ + assert(!(jit_mips6_p())); + if (mask & jit_class_gpr) { + regs[0] = i.rs.b; + regs[1] = i.rt.b; + regs[2] = 0; + } + break; case MIPS_LL: /* 30 */ case MIPS_LLD: /* 34 */ case MIPS_SC: /* 38 */ @@ -1356,13 +1539,13 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, regs[1] = regs[2] = 0; } break; - case MIPS_BEQ: /* 04 */ - case MIPS_BNE: /* 05 */ - assert(i.rt.b == 0); case MIPS_LWC1: /* 31 */ case MIPS_LDC1: /* 35 */ case MIPS_SWC1: /* 39 */ case MIPS_SDC1: /* 3d */ + /* If these cop1 instructions in delay wont not work */ + if (!jit_cpu.cop1_delay) + flush(); if (mask & jit_class_gpr) { regs[0] = i.rs.b; regs[1] = i.rt.b; @@ -1371,6 +1554,35 @@ _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask, else regs[0] = i.rt.b; break; + case MIPS_BEQ: /* 04 */ + case MIPS_BNE: /* 05 */ + assert(i.rt.b == 0); + if (mask & jit_class_gpr) { + regs[0] = i.rs.b; + regs[1] = i.rt.b; + regs[2] = 0; + } + else + regs[0] = i.rt.b; + break; + case MIPS_PCREL: /* 0x3b */ + assert(jit_mips6_p()); + switch (i.rt.b) { + case 0x1e: /* AUIPC */ + case 0x1f: /* ALUIPC */ + break; + default: + assert(i.pD.b == 1 ||/* LDPC */ + i.pW.b == 0 ||/* ADDIUPC */ + i.pW.b == 1 ||/* LWPC */ + i.pW.b == 2); /* LWUPC */ + break; + } + if (mask & jit_class_gpr) { + regs[0] = i.rs.b; + regs[1] = regs[2] = 0; + } + break; default: abort(); } @@ -1460,6 +1672,30 @@ _hrri9(jit_state_t *_jit, jit_int32_t hc, instr(i.op); } +static void +_hriD(jit_state_t *_jit, jit_int32_t hc, + jit_int32_t rs, jit_int32_t pD, jit_int32_t iD) +{ + jit_instr_t i; + i.iD.b = iD; + i.pD.b = pD; + i.rs.b = rs; + i.hc.b = hc; + instr(i.op); +} + +static void +_hriW(jit_state_t *_jit, jit_int32_t hc, + jit_int32_t rs, jit_int32_t pW, jit_int32_t iW) +{ + jit_instr_t i; + i.iW.b = iW; + i.pD.b = pW; + i.rs.b = rs; + i.hc.b = hc; + instr(i.op); +} + static void _hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im) { @@ -1478,7 +1714,7 @@ _nop(jit_state_t *_jit, jit_int32_t i0) } static void -_extr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, +_mips_extr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t pos, jit_int32_t size) { assert(size > 0); @@ -1509,58 +1745,18 @@ _insr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, DINS(r0, r1, pos, size); } -/* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */ -/* -unsigned int s = sizeof(v) * CHAR_BIT; // bit size; must be power of 2 -unsigned int mask = ~0; -while ((s >>= 1) > 0) -{ - mask ^= (mask << s); - v = ((v >> s) & mask) | ((v << s) & ~mask); -} -*/ -static void -_bitswap(jit_state_t *_jit, jit_int32_t v, jit_int32_t r1) -{ - jit_int32_t s, mask; - jit_word_t loop, done, t0, t1; - movr(v, r1); - s = jit_get_reg(jit_class_gpr); - movi(rn(s), __WORDSIZE); /* s = sizeof(v) * CHAR_BIT; */ - mask = jit_get_reg(jit_class_gpr); - movi(rn(mask), ~0L); /* mask = ~0; */ - flush(); - loop = _jit->pc.w; /* while ((s >>= 1) > 0) */ - rshi(rn(s), rn(s), 1); /* (s >>= 1) */ - done = blei(_jit->pc.w, rn(s), 0); /* no loop if s <= 0 */ - t0 = jit_get_reg(jit_class_gpr); - lshr(rn(t0), rn(mask), rn(s)); /* t0 = (mask << s) */ - xorr(rn(mask), rn(mask), rn(t0)); /* mask ^= t0 */ - rshr(rn(t0), v, rn(s)); /* t0 = v >> s */ - andr(rn(t0), rn(t0), rn(mask)); /* t0 = t0 & mask */ - t1 = jit_get_reg(jit_class_gpr); - lshr(rn(t1), v, rn(s)); /* t1 = v << s */ - comr(v, rn(mask)); /* v = ~mask */ - andr(rn(t1), v, rn(t1)); /* t1 = t1 & v */ - orr(v, rn(t0), rn(t1)); /* v = t0 | t1 */ - jmpi(loop, 0); - flush(); - patch_at(done, _jit->pc.w); - jit_unget_reg(t1); - jit_unget_reg(t0); - jit_unget_reg(mask); - jit_unget_reg(s); -} - static void _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { #if __WORDSIZE == 32 if (jit_mips6_p()) CLO_R6(r0, r1); - else + else if (jit_mips2_p()) CLO(r0, r1); + else + fallback_clo(r0, r1); #else + assert(jit_mips2_p()); if (jit_mips6_p()) DCLO_R6(r0, r1); else @@ -1574,9 +1770,12 @@ _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) #if __WORDSIZE == 32 if (jit_mips6_p()) CLZ_R6(r0, r1); - else + else if (jit_mips2_p()) CLZ(r0, r1); + else + fallback_clz(r0, r1); #else + assert(jit_mips2_p()); if (jit_mips6_p()) DCLZ_R6(r0, r1); else @@ -1588,40 +1787,53 @@ static void _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { if (jit_mips6_p()) { -#if __WORDSIZE == 32 - BITSWAP(r0, r1); - bswapr_ui(r0, r0); - CLO_R6(r0, r0); -#else - DBITSWAP(r0, r1); - bswapr_ul(r0, r0); - DCLO_R6(r0, r0); -#endif + rbitr(r0, r1); + clor(r0, r0); } else { - bitswap(r0, r1); - clor(r0, r0); + comr(r0, r1); + ctzr(r0, r0); } } static void _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (jit_mips6_p()) { + rbitr(r0, r1); + clzr(r0, r0); + } + else { + jit_int32_t t0, t1; + + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + + negr(rn(t0), r1); + andr(rn(t0), rn(t0), r1); + clzr(r0, rn(t0)); + xori(rn(t1), r0, __WORDSIZE - 1); + movnr(r0, rn(t1), rn(t0)); + + jit_unget_reg(t0); + jit_unget_reg(t1); + } +} + +static void +_rbitr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { if (jit_mips6_p()) { #if __WORDSIZE == 32 BITSWAP(r0, r1); bswapr_ui(r0, r0); - CLZ_R6(r0, r0); #else DBITSWAP(r0, r1); bswapr_ul(r0, r0); - DCLZ_R6(r0, r0); #endif } - else { - bitswap(r0, r1); - clzr(r0, r0); - } + else + fallback_rbit(r0, r1); } static void @@ -1633,11 +1845,50 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) else if (can_sign_extend_short_p(i0)) addiu(r0, r1, i0); else { + if (jit_mips6_p()) { + union { + struct { +# if __BYTE_ORDER == __LITTLE_ENDIAN + jit_word_t _ : 16; + jit_word_t aui : 16; +# if __WORDSIZE == 64 + jit_word_t ahi : 16; + jit_word_t ati : 16; +# endif +# else +# if __WORDSIZE == 64 + jit_word_t ati : 16; + jit_word_t ahi : 16; +# endif + jit_word_t aui : 16; + jit_word_t _ : 16; +# endif + } b; + jit_word_t w; + } bits; + bits.w = i0; + if (r0 == r1 && ((jit_word_t)bits.b.aui << 16) == i0) + /* FIXME It should not be required r0 == r1 per + * documentation, but this is now it works in qemu + * for DAUI. Assume AUI has the same restriction. */ + DAUI(r1, r0, bits.b.aui & 0xffff); +#if __WORDSIZE == 64 + else if (r0 == r1 && ((jit_word_t)bits.b.ahi << 32) == i0) + DAHI(r0, bits.b.ahi & 0xffff); + else if (r0 == r1 && ((jit_word_t)bits.b.ati << 48) == i0) + DATI(r0, bits.b.ati & 0xffff); +#endif + else + goto fallback; + goto done; + } + fallback: reg = jit_get_reg(jit_class_gpr); movi(rn(reg), i0); addr(r0, r1, rn(reg)); jit_unget_reg(reg); } +done:; } static void @@ -1841,6 +2092,48 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(reg); } +static void +_hmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (jit_mips6_p()) + muh_r6(r0, r1, r2); + else { + mult(r1, r2); + MFHI(r0); + } +} + +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_hmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (jit_mips6_p()) + muhu_r6(r0, r1, r2); + else { + multu(r1, r2); + MFHI(r0); + } +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) @@ -2056,6 +2349,266 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } #endif +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + if (sign) + rshr(r1, t2, t0); + else + rshr_u(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w, 1); + flush(); + patch_at(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = jmpi(_jit->pc.w, 1); + /* zero */ + flush(); + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + flush(); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + } + else { + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + /* zero? */ + movzr(r1, t0, t3); + /* Branchless but 4 bytes longer than branching fallback */ + if (sign) + movi(t0, 0); + /* overflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_bool_t branch; + jit_word_t over, zero, done, done_over; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) { + t1 = rn(s1); + branch = 0; + } + else + branch = 1; + rsbi(t0, t3, __WORDSIZE); + if (sign) + rshr(r0, t2, t3); + else + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + if (branch) { + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w, 1); + flush(); + patch_at(over, _jit->pc.w); + /* underflow */ + if (sign) + rshi(r0, t2, __WORDSIZE - 1); + else + movi(r0, 0); + done_over = jmpi(_jit->pc.w, 1); + /* zero */ + flush(); + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + flush(); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + jit_unget_reg(s1); + } + else { + /* zero? */ + if (sign) + rshi(t0, t2, __WORDSIZE - 1); + else + movi(t0, 0); + movzr(r1, t0, t3); + /* underflow? */ + eqi(t1, t3, __WORDSIZE); + movnr(r0, t0, t1); + jit_unget_reg(s1); + } + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + +static void +_lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (jit_mips2_p()) { + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, __WORDSIZE); + rrotr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + rsbi(rn(reg), r2, __WORDSIZE); + rrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } + } + else + fallback_lrotr(r0, r1, r2); +} + +static void +_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + if (jit_mips2_p()) { +#if __WORDSIZE == 32 + ROTRV(r0, r1, r2); +#else + DROTRV(r0, r1, r2); +#endif + } + else + fallback_rrotr(r0, r1, r2); +} + +static void +_rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 >= 0 && i0 <= __WORDSIZE - 1); + if (jit_mips2_p()) { +#if __WORDSIZE == 32 + ROTR(r0, r1, i0); +#else + if (i0 < 32) + DROTR(r0, r1, i0); + else + DROTR32(r0, r1, i0 - 32); +#endif + } + else + fallback_rroti(r0, r1, i0); +} + static void _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -2064,7 +2617,7 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) ANDI(r0, r1, i0); else if (is_low_mask(i0)) { if (jit_mips2_p()) - extr(r0, r1, 0, masked_bits_count(i0)); + mips_extr(r0, r1, 0, masked_bits_count(i0)); else { lshi(r0, r1, unmasked_bits_count(i0)); rshi_u(r0, r0, unmasked_bits_count(i0)); @@ -2077,7 +2630,7 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) lshi(r0, r0, unmasked_bits_count(i0)); } } else if (jit_mips2_p() && is_middle_mask(i0)) { - extr(r0, r1, __builtin_ctzl(i0), masked_bits_count(i0)); + mips_extr(r0, r1, __builtin_ctzl(i0), masked_bits_count(i0)); lshi(r0, r0, __builtin_ctzl(i0)); } else if (jit_mips2_p() && is_middle_mask(~i0)) { if (r0 != r1) @@ -2136,6 +2689,28 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) else if (can_zero_extend_short_p(i0)) ORI(r0, _ZERO_REGNO, i0); else { + /* Check if loading some constant reachable address */ + if (jit_mips6_p()) { + jit_word_t w, d; + w = i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0)); +#if !PCREL_BROKEN + if (!(i0 & 3)) { + d = w >> 2; + if (can_sign_extend_i19_p(d)) { + ADDIUPC(r0, d); + goto done; + } + } +#endif + if (can_sign_extend_int_p(w)) { + jit_int32_t lo = (jit_int32_t)w << 16 >> 16; + jit_int32_t hi = w - lo; + AUIPC(r0, hi >> 16); + if (lo) + addiu(r0, r0, lo); + goto done; + } + } if (can_sign_extend_int_p(i0)) LUI(r0, i0 >> 16); else if (can_zero_extend_int_p(i0)) { @@ -2159,6 +2734,7 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) if (i0 & 0xffff) ORI(r0, r0, i0); } +done:; } static jit_word_t @@ -2323,6 +2899,17 @@ static void _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; +#if !PCREL_BROKEN + if (jit_mips6_p()) { + jit_word_t w; + assert(!(i0 & 3)); + w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2; + if (can_sign_extend_i19_p(w)) { + LWPC(r0, w); + goto done; + } + } +#endif if (can_sign_extend_short_p(i0)) LW(r0, i0, _ZERO_REGNO); else { @@ -2331,6 +2918,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) ldr_i(r0, rn(reg)); jit_unget_reg(reg); } +#if !PCREL_BROKEN +done:; +#endif } #if __WORDSIZE == 64 @@ -2338,6 +2928,17 @@ static void _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { jit_int32_t reg; +#if !PCREL_BROKEN + if (jit_mips6_p()) { + jit_word_t w; + assert(!(i0 & 3)); + w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2; + if (can_sign_extend_i19_p(w)) { + LWUPC(r0, w); + goto done; + } + } +#endif if (can_sign_extend_short_p(i0)) LWU(r0, i0, _ZERO_REGNO); else { @@ -2346,12 +2947,24 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) ldr_ui(r0, rn(reg)); jit_unget_reg(reg); } +#if !PCREL_BROKEN +done:; +#endif } static void _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { + jit_word_t w; jit_int32_t reg; + if (jit_mips6_p()) { + assert(!(i0 & 7)); + w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 3; + if (can_sign_extend_i18_p(w)) { + LDPC(r0, w); + goto done; + } + } if (can_sign_extend_short_p(i0)) LD(r0, i0, _ZERO_REGNO); else { @@ -2360,6 +2973,7 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) ldr_l(r0, rn(reg)); jit_unget_reg(reg); } +done:; } #endif @@ -2491,6 +3105,201 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } #endif +#if __WORDSIZE == 32 +# define LOAD_LEFT LWL +# define LOAD_RIGHT LWR +#else +# define LOAD_LEFT LDL +# define LOAD_RIGHT LDR +#endif +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) { + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 == 1) + ldr_c(r0, r1); + else { + if (r0 == r1) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r1); + } + else + r2 = r1; +#if __BYTE_ORDER == __LITTLE_ENDIAN + LOAD_LEFT(r0, sizeof(jit_word_t) - 1, r2); + LOAD_RIGHT(r0, 0, r2); +#else + LOAD_LEFT(r0, 0, r2); + LOAD_RIGHT(r0, sizeof(jit_word_t) - 1, r2); +#endif + if (r0 == r1) + jit_unget_reg(t0); + switch (i0) { + case 2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + extr_s(r0, r0); +#else + rshi(r0, r0, __WORDSIZE - 16); +#endif + break; + case 3: +#if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 24); +#endif + rshi(r0, r0, __WORDSIZE - 24); + break; +#if __WORDSIZE == 32 + default: +#else + case 4: +# if __BYTE_ORDER == __LITTLE_ENDIAN + extr_i(r0, r0); +# else + rshi(r0, r0, __WORDSIZE - 32); +# endif +#endif + break; +#if __WORDSIZE == 64 + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 40); +# endif + rshi(r0, r0, __WORDSIZE - 40); + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 48); +# endif + rshi(r0, r0, __WORDSIZE - 48); + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 56); +# endif + rshi(r0, r0, __WORDSIZE - 56); + break; + default: + break; +#endif + } + } + } + else + generic_unldr(r0, r1, i0); +} + +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + if (jit_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + unldr(r0, rn(t0), i1); + jit_unget_reg(t0); + } + else + generic_unldi(r0, i0, i1); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) { + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 == 1) + ldr_uc(r0, r1); + else { + if (r0 == r1) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r1); + } + else + r2 = r1; +#if __BYTE_ORDER == __LITTLE_ENDIAN + LOAD_LEFT(r0, sizeof(jit_word_t) - 1, r2); + LOAD_RIGHT(r0, 0, r2); +#else + LOAD_LEFT(r0, 0, r2); + LOAD_RIGHT(r0, sizeof(jit_word_t) - 1, r2); +#endif + if (r0 == r1) + jit_unget_reg(t0); + switch (i0) { + case 2: +#if __BYTE_ORDER == __LITTLE_ENDIAN + extr_us(r0, r0); +#else + rshi_u(r0, r0, __WORDSIZE - 16); +#endif + break; + case 3: +#if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 24); +#endif + rshi_u(r0, r0, __WORDSIZE - 24); + break; +#if __WORDSIZE == 32 + default: +#else + case 4: +# if __BYTE_ORDER == __LITTLE_ENDIAN + extr_ui(r0, r0); +# else + rshi_u(r0, r0, __WORDSIZE - 32); +# endif +#endif + break; +#if __WORDSIZE == 64 + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 40); +# endif + rshi_u(r0, r0, __WORDSIZE - 40); + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 48); +# endif + rshi_u(r0, r0, __WORDSIZE - 48); + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + lshi(r0, r0, __WORDSIZE - 56); +# endif + rshi_u(r0, r0, __WORDSIZE - 56); + break; + default: + break; +#endif + } + } + } + else + generic_unldr_u(r0, r1, i0); +} +#undef LOAD_LEFT +#undef LOAD_RIGHT + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + if (jit_unaligned_p()) { + t0 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + unldr_u(r0, rn(t0), i1); + jit_unget_reg(t0); + } + else + generic_unldi_u(r0, i0, i1); +} + static void _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -2647,6 +3456,63 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } #endif +static void +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 > 0 && i0 <= sizeof(jit_word_t)); + if (jit_unaligned_p()) { + switch (i0) { + case 4: +#if __BYTE_ORDER == __LITTLE_ENDIAN + SWL(r1, 3, r0); + SWR(r1, 0, r0); +#else + SWL(r1, 0, r0); + SWR(r1, 3, r0); +#endif + break; +#if __WORDSIZE == 64 + case 8: +# if __BYTE_ORDER == __LITTLE_ENDIAN + SDL(r1, 7, r0); + SDR(r1, 0, r0); +# else + SDL(r1, 0, r0); + SDR(r1, 7, r0); +# endif + break; +#endif + default: + /* FIXME Cost of loading memory contents, creating masks, + * and'ing, and or'ing values to use SW* or SD* might + * larger than using fallback. */ + /* FIXME Probably not, and would be without branches. */ + fallback_unstr(r0, r1, i0); + break; + } + } + else + generic_unstr(r0, r1, i0); +} + +static void +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_int32_t reg; + if (jit_unaligned_p()) { + if (i1 == 4 || i1 == 8) { + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + unstr(rn(reg), r0, i1); + jit_unget_reg(reg); + } + else + fallback_unsti(i0, r0, i1); + } + else + generic_unsti(i0, r0, i1); +} + static void _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -2666,7 +3532,7 @@ _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) SLL(r0, r1, 0); WSBH(r0, r0); ROTR(r0, r0, 16); - extr(r0, r0, 0, 32); + mips_extr(r0, r0, 0, 32); } else { WSBH(r0, r1); ROTR(r0, r0, 16); @@ -2676,6 +3542,99 @@ _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } } +#if __WORDSIZE == 64 +static void +_bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + if (jit_mips2_p()) { + DSBH(r0, r1); + DSHD(r0, r0); + } + else + generic_bswapr_ul(_jit, r0, r1); +} +#endif + +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if ( i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (jit_mips2_p()) { + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif +#if __WORDSIZE == 32 + EXT(r0, r1, i0, i1); +#else + if (i0 < 32 && i1 <= 32) + DEXT(r0, r1, i0, i1); + else if (i0 < 32 && i1 > 32) + DEXTM(r0, r1, i0, i1); + else { + assert(i0 >= 32 && i1 <= 32); + DEXTU(r0, r1, i0, i1); + } +#endif + } + } + else + fallback_ext_u(r0, r1, i0, i1); +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (jit_mips2_p()) { + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif +#if __WORDSIZE == 32 + INS(r0, r1, i0, i1); +#else + if (i0 < 32 && i1 <= 32 && (i0 + i1) <= 32) + DINS(r0, r1, i0, i1); + else if (i0 < 32 && i1 >= 2 && (i0 + i1) > 32) + DINSM(r0, r1, i0, i1); + else { + assert(i0 >= 32 && i1 >= 1 && i1 <= 32 && (i0 + i1) > 32); + DINSU(r0, r1, i0, i1); + } +#endif + } + } + else + fallback_dep(r0, r1, i0, i1); +} + static void _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -3139,6 +4098,18 @@ _jmpi(jit_state_t *_jit, jit_word_t i0, jit_bool_t patch) { jit_int32_t op, t0; jit_word_t w, disp; +#if !BALC_BROKEN + if (jit_mips6_p() && !(i0 & 3)) { + disp = ((i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2) - 1; + if (patch || can_sign_extend_i26_p(disp)) { + flush(); + w = _jit->pc.w; + /* Compact branch instructions do not have a delay slot */ + BC_R6(disp); + goto done_without_delay; + } + } +#endif /* try to get a pending instruction before the jump */ t0 = jit_get_reg_for_delay_slot(jit_class_gpr, _ZERO_REGNO, _ZERO_REGNO); op = pending(); @@ -3163,6 +4134,9 @@ _jmpi(jit_state_t *_jit, jit_word_t i0, jit_bool_t patch) done: delay(op); jit_unget_reg(t0); +#if !BALC_BROKEN +done_without_delay: +#endif return (w); } @@ -3171,9 +4145,9 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0) { jit_word_t w; jit_int32_t op, t0; - /* make sure delay slot does not use _T9_REGNO */ - t0 = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk, - _T9_REGNO, _ZERO_REGNO); + /* Get a register without side effects in delay slot */ + t0 = jit_get_reg_for_delay_slot(jit_class_gpr, _ZERO_REGNO, _ZERO_REGNO); + /* Check for a instruction that can be executed in the delay slot */ op = pending(); /* implicit flush() */ w = _jit->pc.w; @@ -3181,8 +4155,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0) flush(); /* movi_p will be patched */ JR(rn(t0)); delay(op); - if (t0 != JIT_NOREG) - jit_unget_reg(t0); + jit_unget_reg(t0); return (w); } @@ -3764,8 +4737,20 @@ _calli(jit_state_t *_jit, jit_word_t i0, jit_bool_t patch) jit_int32_t op, t0; jit_word_t w, disp; w = _jit->pc.w; +#if !BALC_BROKEN + if (jit_mips6_p() && !(i0 & 3)) { + disp = ((i0 - (w + (_jitc->inst.pend ? 4 : 0))) >> 2) - 1; + if (patch || can_sign_extend_i26_p(disp)) { + flush(); + w = _jit->pc.w; + /* Compact branch instructions do not have a delay slot */ + BALC(disp); + goto done; + } + } +#endif if (jit_mips2_p()) { - disp = ((i0 - w) >> 2) - 1; + disp = ((i0 - (w + _jitc->inst.pend ? 4 : 0)) >> 2) - 1; if (patch || can_sign_extend_short_p(disp)) { op = pending(); BGEZAL(_ZERO_REGNO, disp); /* Renamed to BAL in mips release 6 */ @@ -4112,6 +5097,12 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label) u.i[0] = i.op; break; + case MIPS_BALC: case MIPS_BC_R6: + assert(jit_mips6_p()); + i.ii.b = ((label - instr) >> 2) - 1; + u.i[0] = i.op; + break; + default: assert(!"unhandled branch opcode"); break; diff --git a/deps/lightning/lib/jit_mips-fpu.c b/deps/lightning/lib/jit_mips-fpu.c index 8e3df869..61db30e3 100644 --- a/deps/lightning/lib/jit_mips-fpu.c +++ b/deps/lightning/lib/jit_mips-fpu.c @@ -53,6 +53,8 @@ # define MIPS_FLOOR_fmt_W 0x0f # define MIPS_RECIP 0x15 # define MIPS_RSQRT 0x16 +# define MIPS_MADDF 0x18 +# define MIPS_MSUBF 0x19 # define MIPS_ALNV_PS 0x1e # define MIPS_CVT_fmt_S 0x20 # define MIPS_CVT_fmt_D 0x21 @@ -62,18 +64,18 @@ # define MIPS_PLU 0x2d # define MIPS_PUL 0x2e # define MIPS_PUU 0x2f -# define MIPS_MADD_fmt_S (0x20 | MIPS_fmt_S) -# define MIPS_MADD_fmt_D (0x20 | MIPS_fmt_D) -# define MIPS_MADD_fmt_PS (0x20 | MIPS_fmt_PS) -# define MIPS_MSUB_fmt_S (0x28 | MIPS_fmt_S) -# define MIPS_MSUB_fmt_D (0x28 | MIPS_fmt_D) -# define MIPS_MSUB_fmt_PS (0x28 | MIPS_fmt_PS) -# define MIPS_NMADD_fmt_S (0x30 | MIPS_fmt_S) -# define MIPS_NMADD_fmt_D (0x30 | MIPS_fmt_D) -# define MIPS_NMADD_fmt_PS (0x30 | MIPS_fmt_PS) -# define MIPS_NMSUB_fmt_S (0x38 | MIPS_fmt_S) -# define MIPS_NMSUB_fmt_D (0x38 | MIPS_fmt_D) -# define MIPS_NMSUB_fmt_PS (0x38 | MIPS_fmt_PS) +# define MIPS_MADD_fmt_S 0x20 +# define MIPS_MADD_fmt_D 0x21 +# define MIPS_MADD_fmt_PS 0x22 +# define MIPS_MSUB_fmt_S 0x28 +# define MIPS_MSUB_fmt_D 0x29 +# define MIPS_MSUB_fmt_PS 0x2a +# define MIPS_NMADD_fmt_S 0x30 +# define MIPS_NMADD_fmt_D 0x31 +# define MIPS_NMADD_fmt_PS 0x32 +# define MIPS_NMSUB_fmt_S 0x38 +# define MIPS_NMSUB_fmt_D 0x39 +# define MIPS_NMSUB_fmt_PS 0x3a # define MIPS_cond_F 0x30 # define MIPS_cond_UN 0x31 # define MIPS_cond_EQ 0x32 @@ -144,6 +146,20 @@ # define TRUNC_L_D(fd,fs) hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_L) # define TRUNC_W_S(fd,fs) hrrrit(MIPS_COP1,MIPS_fmt_S,0,fs,fd,MIPS_TRUNC_fmt_W) # define TRUNC_W_D(fd,fs) hrrrit(MIPS_COP1,MIPS_fmt_D,0,fs,fd,MIPS_TRUNC_fmt_W) +# define MADD_S(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MADD_fmt_S) +# define MADD_D(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MADD_fmt_D) +# define MSUB_S(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MSUB_fmt_S) +# define MSUB_D(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_MSUB_fmt_D) +# define NMADD_S(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMADD_fmt_S) +# define NMADD_D(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMADD_fmt_D) +# define NMSUB_S(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMSUB_fmt_S) +# define NMSUB_D(fd,fr,fs,ft) hrrrit(MIPS_COP1X,fr,ft,fs,fd,MIPS_NMSUB_fmt_D) +/* fd = fd + (fs * ft) */ +# define MADDF_S(fd,fs,ft) hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MADDF) +# define MADDF_D(fd,fs,ft) hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MADDF) +/* fd = fd - (fs * ft) */ +# define MSUBF_S(fd,fs,ft) hrrrit(MIPS_COP1,MIPS_fmt_S,ft,fs,fd,MIPS_MSUBF) +# define MSUBF_D(fd,fs,ft) hrrrit(MIPS_COP1,MIPS_fmt_D,ft,fs,fd,MIPS_MSUBF) # define LWC1(rt, of, rb) hrri(MIPS_LWC1, rb, rt, of) # define SWC1(rt, of, rb) hrri(MIPS_SWC1, rb, rt, of) # define LDC1(rt, of, rb) hrri(MIPS_LDC1, rb, rt, of) @@ -280,8 +296,8 @@ static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); # define sqrtr_d(r0,r1) SQRT_D(r0,r1) # define movr_w_f(r0, r1) MTC1(r1, r0) # define movr_f_w(r0, r1) MFC1(r0, r1) -# define movi_f_w(r0, i0) _movi_f_w(_jit, r0, i0) -static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*); +# define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define extr_f(r0, r1) _extr_f(_jit, r0, r1) static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1) @@ -298,6 +314,10 @@ static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t); static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0) static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr_x(r0, r1, i0) _unldr_x(_jit, r0, r1, i0) +static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_x(r0, i0, i1) _unldi_x(_jit, r0, i0, i1) +static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_f(r0, r1) SWC1(r1, 0, r0) # define sti_f(i0, r0) _sti_f(_jit, i0, r0) static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); @@ -305,28 +325,47 @@ static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t); static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi_f(i0, r0, r1) _stxi_f(_jit, i0, r0, r1) static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +# define unstr_x(r0, r1, i0) _unstr_x(_jit, r0, r1, i0) +static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unsti_x(i0, r0, i1) _unsti_x(_jit, i0, r0, i1) +static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); +# define fmar_f(r0, r1, r2, r3) _fmar_f(_jit, r0, r1, r2, r3) +static void _fmar_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fmsr_f(r0, r1, r2, r3) _fmsr_f(_jit, r0, r1, r2, r3) +static void _fmsr_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fnmar_f(r0, r1, r2, r3) _fnmar_f(_jit, r0, r1, r2, r3) +static void _fnmar_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fnmsr_f(r0, r1, r2, r3) _fnmsr_f(_jit, r0, r1, r2, r3) +static void _fnmsr_f(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); # define movr_f(r0, r1) _movr_f(_jit, r0, r1) static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_f(r0, i0) _movi_f(_jit, r0, i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); -# if NEW_ABI -# if __WORDSIZE == 32 -# define movi64(r0, i0) _movi64(_jit, r0, i0) +# if NEW_ABI && __WORDSIZE == 32 +# define movi64(r0, i0) _movi64(_jit, r0, i0) static void _movi64(jit_state_t*,jit_int32_t,jit_int64_t); -# else -# define movi64(r0, i0) movi(r0, i0) -# endif +# define movi_d_w(r0, i0) _movi_d_w(_jit, r0, i0) +static void _movi_d_w(jit_state_t*,jit_int32_t,jit_int64_t); +# elif __WORDSIZE == 64 +# define movi64(r0, i0) movi(r0, i0) +# endif +# if __WORDSIZE == 64 || NEW_ABI # define movr_w_d(r0, r1) DMTC1(r1, r0) # define movr_d_w(r0, r1) DMFC1(r0, r1) -# define movi_d_w(r0, i0) _movi_d_w(_jit,r0,i0) -static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*); -# else +# define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); +# endif +# if __WORDSIZE == 32 # define movr_ww_d(r0, r1, r2) _movr_ww_d(_jit, r0, r1, r2) static void _movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define movr_d_ww(r0, r1, r2) _movr_d_ww(_jit, r0, r1, r2) static void _movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); -# define movi_d_ww(r0, r1, i0) _movi_d_ww(_jit, r0, r1, i0) -static void _movi_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); +# define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) +static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # endif # define extr_d(r0, r1) _extr_d(_jit, r0, r1) static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t); @@ -352,6 +391,18 @@ static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t); static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi_d(i0, r0, r1) _stxi_d(_jit, i0, r0, r1) static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +# define fmar_d(r0, r1, r2, r3) _fmar_d(_jit, r0, r1, r2, r3) +static void _fmar_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fmsr_d(r0, r1, r2, r3) _fmsr_d(_jit, r0, r1, r2, r3) +static void _fmsr_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fnmar_d(r0, r1, r2, r3) _fnmar_d(_jit, r0, r1, r2, r3) +static void _fnmar_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); +# define fnmsr_d(r0, r1, r2, r3) _fnmsr_d(_jit, r0, r1, r2, r3) +static void _fnmsr_d(jit_state_t*, + jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); # define movr_d(r0, r1) _movr_d(_jit, r0, r1) static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_d(r0, i0) _movi_d(_jit, r0, i0) @@ -678,18 +729,6 @@ fopi(rsb) fopi(mul) fopi(div) -static void -_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) -{ - union { - jit_int32_t i; - jit_float32_t f; - } data; - - data.f = *i0; - movi(r0, data.i); -} - static void _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -765,6 +804,86 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + if (jit_unaligned_p()) { + assert(i0 == 4 || i0 == 8); + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i0 == 4) { + unldr(r2, r1, 4); + movr_w_f(r0, r2); + } + else { +# if __WORDSIZE == 32 + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unldr(r2, r1, 4); + addi(r3, r1, 4); + unldr(r3, r3, 4); +# else + unldr(r3, r1, 4); + addi(r2, r1, 4); + unldr(r2, r2, 4); +# endif + movr_ww_d(r0, r2, r3); + jit_unget_reg(t1); +# else + unldr(r2, r1, 8); + movr_w_d(r0, r2); +# endif + } + jit_unget_reg(t0); + } + else + generic_unldr_x(r0, r1, i0); +} + +static void +_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; +# if __WORDSIZE == 32 + jit_int32_t t1, r3; +# endif + if (jit_unaligned_p()) { + assert(i1 == 4 || i1 == 8); + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + if (i1 == 4) { + unldi(r2, i0, 4); + movr_w_f(r0, r2); + } + else { +# if __WORDSIZE == 32 + t1 = jit_get_reg(jit_class_gpr); + r3 = rn(t1); +# if __BYTE_ORDER == __LITTLE_ENDIAN + unldi(r2, i0, 4); + unldi(r3, i0 + 4, 4); +# else + unldi(r3, i0, 4); + unldi(r2, i0 + 4, 4); +# endif + movr_ww_d(r0, r3, r2); + jit_unget_reg(t1); +# else + unldi(r2, i0, 8); + movr_w_d(r0, r2); +# endif + } + jit_unget_reg(t0); + } + else + generic_unldi_x(r0, i0, i1); +} + static void _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -803,6 +922,153 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr_x(r0, r1, i0); + else + generic_unstr_x(r0, r1, i0); +} + +static void +_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti_x(i0, r0, i1); + else + fallback_unsti_x(i0, r0, i1); +} + + +static void +_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MADDF_S(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MADDF_S(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else + MADD_S(r0, r3, r2, r1); + } + else { + if (r0 != r3) { + mulr_f(r0, r1, r2); + addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_f(rn(t0), r1, r2); + addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MSUBF_S(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MSUBF_S(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + negr_f(r0, r0); + } + else + MSUB_S(r0, r3, r2, r1); + } + else { + if (r0 != r3) { + mulr_f(r0, r1, r2); + subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_f(rn(t0), r1, r2); + subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MADDF_S(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MADDF_S(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + negr_f(r0, r0); + } + else + NMADD_S(r0, r3, r2, r1); + } + else { + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MSUBF_S(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MSUBF_S(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else + NMSUB_S(r0, r3, r2, r1); + } + else { + t0 = jit_get_reg(jit_class_fpr); + negr_f(rn(t0), r1); + mulr_f(rn(t0), rn(t0), r2); + addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + static void _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -834,13 +1100,23 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) MTC1(_ZERO_REGNO, r0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + dopi(add) dopi(sub) dopi(rsb) dopi(mul) dopi(div) -#if NEW_ABI +#if NEW_ABI && __WORDSIZE == 32 /* n32 abi requires 64 bit cpu */ static void _movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0) @@ -876,33 +1152,33 @@ _movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0) } static void -_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) +_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0) { - jit_word_t w; union { jit_int64_t l; jit_float64_t d; } data; - if (_jitc->no_data) { - data.d = *i0; - movi64(r0, data.l); - } - else { - w = (jit_word_t)i0; - if (can_sign_extend_short_p(w)) - LD(r0, w, _ZERO_REGNO); - else { - movi(r0, w); - LD(r0, 0, r0); - } - } + data.d = i0; + movi64(r0, data.l); +} +#endif + +#if __WORDSIZE == 64 || NEW_ABI +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi64(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); } +#endif -#else +#if __WORDSIZE == 32 static void _movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { - assert(r1 == r2 - 1); if (jit_mips6_p()) { MTC1(r1, r0); MTHC1(r2, r0); @@ -916,7 +1192,6 @@ _movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) static void _movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { - assert(r0 == r1 - 1); if (jit_mips6_p()) { MFC1(r0, r2); MFHC1(r1, r2); @@ -928,17 +1203,17 @@ _movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) } static void -_movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0) -{ - union { - jit_int32_t i[2]; - jit_int64_t l; - jit_float64_t d; - } data; - - data.d = *i0; - movi(r0, data.i[0]); - movi(r1, data.i[1]); +_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + MTC1(rn(t0), r0); + MTC1(rn(t1), r0 + 1); + jit_unget_reg(t1); + jit_unget_reg(t0); } #endif @@ -1124,6 +1399,134 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MADDF_D(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MADDF_D(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else + MADD_D(r0, r3, r2, r1); + } + else { + if (r0 != r3) { + mulr_d(r0, r1, r2); + addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_d(rn(t0), r1, r2); + addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MSUBF_D(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MSUBF_D(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + negr_d(r0, r0); + } + else + MSUB_D(r0, r3, r2, r1); + } + else { + if (r0 != r3) { + mulr_d(r0, r1, r2); + subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + mulr_d(rn(t0), r1, r2); + subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MADDF_D(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MADDF_D(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + negr_d(r0, r0); + } + else + NMADD_D(r0, r3, r2, r1); + } + else { + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_mips2_p()) { + if (jit_mips6_p()) { + if (r0 == r3) + MSUBF_D(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MSUBF_D(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else + NMSUB_D(r0, r3, r2, r1); + } + else { + t0 = jit_get_reg(jit_class_fpr); + negr_d(rn(t0), r1); + mulr_d(rn(t0), rn(t0), r2); + addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + static void _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_mips-sz.c b/deps/lightning/lib/jit_mips-sz.c index 0a7436de..156fc955 100644 --- a/deps/lightning/lib/jit_mips-sz.c +++ b/deps/lightning/lib/jit_mips-sz.c @@ -3,7 +3,7 @@ #define JIT_INSTR_MAX 116 0, /* data */ 0, /* live */ - 20, /* align */ + 12, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -88,7 +88,9 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 8, /* comr */ + 4, /* comi */ 4, /* ltr */ 4, /* lti */ 4, /* ltr_u */ @@ -116,17 +118,29 @@ 36, /* casr */ 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 4, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 8, /* bswapr_us */ + 4, /* bswapi_us */ 8, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 4, /* htonr_us */ + 4, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 4, /* ldr_c */ 12, /* ldi_c */ 4, /* ldr_uc */ @@ -212,7 +226,7 @@ 16, /* bxsubr_u */ 20, /* bxsubi_u */ 8, /* jmpr */ - 8, /* jmpi */ + 16, /* jmpi */ 8, /* callr */ 16, /* calli */ 0, /* prepare */ @@ -269,8 +283,11 @@ 4, /* divr_f */ 16, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 16, /* ltr_f */ 28, /* lti_f */ 16, /* ler_f */ @@ -360,8 +377,11 @@ 4, /* divr_d */ 20, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 16, /* ltr_d */ 40, /* lti_d */ 16, /* ler_d */ @@ -438,25 +458,84 @@ 0, /* reti_d */ 0, /* retval_d */ 4, /* movr_w_f */ + 8, /* movi_w_f */ 8, /* movr_ww_d */ + 16, /* movi_ww_d */ 0, /* movr_w_d */ + 0, /* movi_w_d */ 4, /* movr_f_w */ 4, /* movi_f_w */ 8, /* movr_d_ww */ - 8, /* movi_d_ww */ + 12, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 8, /* clo */ - 8, /* clz */ - 76, /* cto */ - 76, /* ctz */ + 4, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 28, /* ctor */ + 4, /* ctoi */ + 20, /* ctzr */ + 4, /* ctzi */ + 68, /* rbitr */ + 8, /* rbiti */ + 64, /* popcntr */ + 4, /* popcnti */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 48, /* qlshr */ + 8, /* qlshi */ + 44, /* qlshr_u */ + 8, /* qlshi_u */ + 44, /* qrshr */ + 8, /* qrshi */ + 44, /* qrshr_u */ + 8, /* qrshi_u */ + 16, /* unldr */ + 20, /* unldi */ + 16, /* unldr_u */ + 20, /* unldi_u */ + 44, /* unstr */ + 28, /* unsti */ + 32, /* unldr_x */ + 40, /* unldi_x */ + 28, /* unstr_x */ + 40, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 8, /* hmulr */ + 16, /* hmuli */ + 8, /* hmulr_u */ + 16, /* hmuli_u */ #endif /* __WORDSIZE */ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 76 +#define JIT_INSTR_MAX 132 0, /* data */ 0, /* live */ - 24, /* align */ + 8, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -576,7 +655,7 @@ 4, /* extr_ui */ 8, /* bswapr_us */ 16, /* bswapr_ui */ - 44, /* bswapr_ul */ + 8, /* bswapr_ul */ 4, /* htonr_us */ 4, /* htonr_ui */ 4, /* htonr_ul */ @@ -643,7 +722,7 @@ 12, /* bgtr_u */ 16, /* bgti_u */ 8, /* bner */ - 28, /* bnei */ + 36, /* bnei */ 12, /* bmsr */ 12, /* bmsi */ 12, /* bmcr */ @@ -665,7 +744,7 @@ 16, /* bxsubr_u */ 20, /* bxsubi_u */ 8, /* jmpr */ - 8, /* jmpi */ + 32, /* jmpi */ 8, /* callr */ 32, /* calli */ 0, /* prepare */ @@ -890,17 +969,96 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 4, /* movr_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 4, /* movr_w_d */ + 4, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ 4, /* movr_d_w */ - 24, /* movi_d_w */ - 4, /* clo */ - 4, /* clz */ - 72, /* cto */ - 72, /* ctz */ + 12, /* movi_d_w */ + 4, /* clor */ + 4, /* clzr */ + 28, /* ctor */ + 20, /* ctzr */ + 80, /* rbitr */ + 76, /* popcntr */ + 12, /* lrotr */ + 4, /* lroti */ + 4, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* extr_u */ + 4, /* depr */ + 8, /* depi */ + 4, /* negi */ + 4, /* comi */ + 4, /* exti_c */ + 4, /* exti_uc */ + 4, /* exti_s */ + 4, /* exti_us */ + 4, /* exti_i */ + 8, /* exti_ui */ + 4, /* bswapi_us */ + 8, /* bswapi_ui */ + 28, /* bswapi_ul */ + 4, /* htoni_us */ + 8, /* htoni_ui */ + 28, /* htoni_ul */ + 0, /* negi_f */ + 0, /* absi_f */ + 0, /* sqrti_f */ + 0, /* negi_d */ + 0, /* absi_d */ + 0, /* sqrti_d */ + 4, /* cloi */ + 4, /* clzi */ + 4, /* ctoi */ + 4, /* ctzi */ + 28, /* rbiti */ + 4, /* popcnti */ + 4, /* exti */ + 4, /* exti_u */ + 48, /* qlshr */ + 8, /* qlshi */ + 44, /* qlshr_u */ + 8, /* qlshi_u */ + 44, /* qrshr */ + 8, /* qrshi */ + 44, /* qrshr_u */ + 8, /* qrshi_u */ + 16, /* unldr */ + 32, /* unldi */ + 16, /* unldr_u */ + 32, /* unldi_u */ + 132, /* unstr */ + 108, /* unsti */ + 16, /* unldr_x */ + 36, /* unldi_x */ + 12, /* unstr_x */ + 32, /* unsti_x */ + 8, /* movi_w_f */ + 12, /* movi_w_d */ + 0, /* movi_ww_d */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 8, /* hmulr */ + 28, /* hmuli */ + 8, /* hmulr_u */ + 28, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_mips.c b/deps/lightning/lib/jit_mips.c index 6d564238..1fec1092 100644 --- a/deps/lightning/lib/jit_mips.c +++ b/deps/lightning/lib/jit_mips.c @@ -21,6 +21,18 @@ # include #endif +#if __mips_hard_float +# define __mips_soft_float 0 +#elif __mips_soft_float +# define __mips_hard_float 0 +#else +/* Must have a floating point unit and cannot figure + * if can attempt to work with software floats + */ +# define __mips_soft_float 0 +# define __mips_hard_float 1 +#endif + #if NEW_ABI /* callee save + variadic arguments * align16(ra+fp+s[0-7]++f20+f22+f24+f26+f28+f30) + align16(a[0-7]) */ @@ -176,6 +188,10 @@ static jit_int32_t fregs[] = { void jit_get_cpu(void) { + /* By default assume it works or have/need unaligned instructions. */ + jit_cpu.sll_delay = jit_cpu.cop1_delay = jit_cpu.lwl_lwr_delay = + jit_cpu.unaligned = 1; + #if defined(__linux__) FILE *fp; char *ptr; @@ -183,11 +199,25 @@ jit_get_cpu(void) if ((fp = fopen("/proc/cpuinfo", "r")) != NULL) { while (fgets(buf, sizeof(buf), fp)) { - if (strncmp(buf, "isa : ", 8) == 0) { + if (strncmp(buf, "isa\t\t\t: ", 8) == 0) { if ((ptr = strstr(buf + 9, "mips64r"))) jit_cpu.release = strtoul(ptr + 7, NULL, 10); break; } + /* Just for some actual hardware tested. Below check + * for mips 1 would disable these delays anyway. */ + if (strncmp(buf, "cpu model\t\t: ", 13) == 0) { + /* ICT Loongson-2 V0.3 FPU V0.1 */ + if (strstr(buf + 13, "FPU V0.1")) + jit_cpu.sll_delay = jit_cpu.cop1_delay = 0; + /* Cavium Octeon III V0.2 FPU V0.0 */ + else if (strstr(buf + 13, "FPU V0.0")) + jit_cpu.sll_delay = jit_cpu.cop1_delay = 0; + /* Cavium Octeon II V0.1 */ + else if (strstr(buf + 13, " II ")) + jit_cpu.sll_delay = jit_cpu.cop1_delay = 0; + break; + } } fclose(fp); } @@ -202,6 +232,19 @@ jit_get_cpu(void) if (!jit_cpu.release) jit_cpu.release = __mips; #endif + /* Assume all mips 1 and 2, or detected as release 1 or 2 have this + * problem */ + /* Note that jit_cpu is global, and can be overriden, that is, add + * the C code "jit_cpu.cop1_delay = 1;" after the call to init_jit() + * if it is functional. */ + if (jit_cpu.cop1_delay && jit_cpu.release < 3) + jit_cpu.cop1_delay = 0; + if (jit_cpu.sll_delay && jit_cpu.release < 3) + jit_cpu.sll_delay = 0; + if (jit_cpu.lwl_lwr_delay && jit_cpu.release < 2) + jit_cpu.lwl_lwr_delay = 0; + if (jit_cpu.release >= 6) + jit_cpu.unaligned = 0; } void @@ -332,10 +375,16 @@ void _jit_retr_f(jit_state_t *_jit, jit_int32_t u) { jit_inc_synth_w(retr_f, u); +#if __mips_soft_float +# warning *** GNU Lightning will use hard float registers! *** +# warning *** Are you sure about -msoft-float usage? *** + jit_movr_f_w(JIT_RET, u); +#else if (JIT_FRET != u) jit_movr_f(JIT_FRET, u); else jit_live(JIT_FRET); +#endif jit_ret(); jit_dec_synth(); } @@ -344,7 +393,11 @@ void _jit_reti_f(jit_state_t *_jit, jit_float32_t u) { jit_inc_synth_f(reti_f, u); +#if __mips_soft_float + jit_movi_f_w(JIT_RET, u); +#else jit_movi_f(JIT_FRET, u); +#endif jit_ret(); jit_dec_synth(); } @@ -353,10 +406,14 @@ void _jit_retr_d(jit_state_t *_jit, jit_int32_t u) { jit_inc_synth_w(retr_d, u); +#if __mips_soft_float + jit_movr_d_w(JIT_RET, u); +#else if (JIT_FRET != u) jit_movr_d(JIT_FRET, u); else jit_live(JIT_FRET); +#endif jit_ret(); jit_dec_synth(); } @@ -365,7 +422,11 @@ void _jit_reti_d(jit_state_t *_jit, jit_float64_t u) { jit_inc_synth_d(reti_d, u); +#if __mips_soft_float + jit_movi_d_w(JIT_RET, u); +#else jit_movi_d(JIT_FRET, u); +#endif jit_ret(); jit_dec_synth(); } @@ -427,7 +488,8 @@ _jit_make_arg_f(jit_state_t *_jit, jit_node_t *node) #if NEW_ABI if (jit_arg_reg_p(_jitc->function->self.argi)) { offset = _jitc->function->self.argi++; - if (_jitc->function->self.call & jit_call_varargs) + if (__mips_soft_float || + (_jitc->function->self.call & jit_call_varargs)) offset += 8; } else { @@ -470,7 +532,8 @@ _jit_make_arg_d(jit_state_t *_jit, jit_node_t *node) #if NEW_ABI if (jit_arg_reg_p(_jitc->function->self.argi)) { offset = _jitc->function->self.argi++; - if (_jitc->function->self.call & jit_call_varargs) + if (__mips_soft_float || + (_jitc->function->self.call & jit_call_varargs)) offset += 8; } else { @@ -809,7 +872,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) if (jit_arg_reg_p(v->u.w)) jit_movr_d(u, _F12 - v->u.w); else if (jit_arg_reg_p(v->u.w - 8)) - jit_movr_d_w(_A0 - (v->u.w - 8), u); + jit_movr_w_d(u, _A0 - (v->u.w - 8)); #else if (v->u.w < 4) jit_movr_ww_d(u, _A0 - v->u.w, _A0 - (v->u.w + 1)); @@ -964,7 +1027,8 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) jit_link_prepare(); #if NEW_ABI if (jit_arg_reg_p(_jitc->function->call.argi)) { - if (!(_jitc->function->call.call & jit_call_varargs)) + if (__mips_hard_float && + !(_jitc->function->call.call & jit_call_varargs)) jit_movr_f(_F12 - _jitc->function->call.argi, u); else jit_movr_f_w(_A0 - _jitc->function->call.argi, u); @@ -1007,7 +1071,8 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) jit_link_prepare(); #if NEW_ABI if (jit_arg_reg_p(_jitc->function->call.argi)) { - if (!(_jitc->function->call.call & jit_call_varargs)) + if (__mips_hard_float && + !(_jitc->function->call.call & jit_call_varargs)) jit_movi_f(_F12 - _jitc->function->call.argi, u); else jit_movi_f_w(_A0 - _jitc->function->call.argi, u); @@ -1056,7 +1121,8 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) jit_link_prepare(); #if NEW_ABI if (jit_arg_reg_p(_jitc->function->call.argi)) { - if (!(_jitc->function->call.call & jit_call_varargs)) + if (__mips_hard_float && + !(_jitc->function->call.call & jit_call_varargs)) jit_movr_d(_F12 - _jitc->function->call.argi, u); else jit_movr_d_w(_A0 - _jitc->function->call.argi, u); @@ -1106,7 +1172,8 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) jit_link_prepare(); #if NEW_ABI if (jit_arg_reg_p(_jitc->function->call.argi)) { - if (!(_jitc->function->call.call & jit_call_varargs)) + if (__mips_hard_float && + !(_jitc->function->call.call & jit_call_varargs)) jit_movi_d(_F12 - _jitc->function->call.argi, u); else jit_movi_d_w(_A0 - _jitc->function->call.argi, u); @@ -1219,65 +1286,91 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0) void _jit_retval_c(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_c, r0); jit_extr_c(r0, JIT_RET); + jit_dec_synth(); } void _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_uc, r0); jit_extr_uc(r0, JIT_RET); + jit_dec_synth(); } void _jit_retval_s(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_s, r0); jit_extr_s(r0, JIT_RET); + jit_dec_synth(); } void _jit_retval_us(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_us, r0); jit_extr_us(r0, JIT_RET); + jit_dec_synth(); } void _jit_retval_i(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_i, r0); #if __WORDSIZE == 32 if (r0 != JIT_RET) jit_movr(r0, JIT_RET); #else jit_extr_i(r0, JIT_RET); #endif + jit_dec_synth(); } #if __WORDSIZE == 64 void _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_ui, r0); jit_extr_ui(r0, JIT_RET); + jit_dec_synth(); } void _jit_retval_l(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_l, r0); if (r0 != JIT_RET) jit_movr(r0, JIT_RET); + jit_dec_synth(); } #endif void _jit_retval_f(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_f, r0); +#if __mips_soft_float + jit_movr_w_f(r0, JIT_RET); +#else if (r0 != JIT_FRET) jit_movr_f(r0, JIT_FRET); +#endif + jit_dec_synth(); } void _jit_retval_d(jit_state_t *_jit, jit_int32_t r0) { + jit_inc_synth_w(retval_d, r0); +#if __mips_soft_float + jit_movr_w_d(r0, JIT_RET); +#else if (r0 != JIT_FRET) jit_movr_d(r0, JIT_FRET); +#endif + jit_dec_synth(); } jit_pointer_t @@ -1303,6 +1396,7 @@ _emit_code(jit_state_t *_jit) #endif _jitc->function = NULL; + _jitc->inst.pend = 0; jit_reglive_setup(); @@ -1340,6 +1434,12 @@ _emit_code(jit_state_t *_jit) name##i##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), node->w.w); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrf(name, type, size) \ case jit_code_##name##i##type: \ assert(node->flag & jit_flag_data); \ @@ -1402,6 +1502,10 @@ _emit_code(jit_state_t *_jit) #if DEVEL_DISASSEMBLER node->offset = (jit_uword_t)_jit->pc.w - (jit_uword_t)prevw; prevw = _jit->pc.w; + if (_jitc->inst.pend) { + node->offset += 4; + prevw += 4; + } #endif value = jit_classify(node->code); #if GET_JIT_SIZE @@ -1447,6 +1551,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1465,10 +1573,22 @@ _emit_code(jit_state_t *_jit) case_rrw(rem, _u); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1513,6 +1633,18 @@ _emit_code(jit_state_t *_jit) case_rrr(ldx, _l); case_rrw(ldx, _l); #endif + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1533,6 +1665,12 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _l); case_wrr(stx, _l); #endif + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); #if __WORDSIZE == 64 @@ -1543,6 +1681,18 @@ _emit_code(jit_state_t *_jit) #if __WORDSIZE == 64 case_rr(bswap, _ul); #endif + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1585,6 +1735,9 @@ _emit_code(jit_state_t *_jit) case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); +#define popcntr(r0, r1) fallback_popcnt(r0, r1) + case_rr(popcnt,); case_rrr(lt,); case_rrw(lt,); case_rrr(lt, _u); @@ -1657,15 +1810,31 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert(node->flag & jit_flag_data); @@ -1740,6 +1909,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1825,7 +1998,12 @@ _emit_code(jit_state_t *_jit) else { word = _jit->code.length - (_jit->pc.uc - _jit->code.ptr); - if (jit_mips2_p() && can_relative_jump_p(word)) + if ((jit_mips2_p() && can_relative_jump_p(word)) +#if !BALC_BROKEN + || + (jit_mips6_p() && can_compact_jump_p(word)) +#endif + ) word = jmpi(_jit->pc.w, 1); else word = jmpi_p(_jit->pc.w); @@ -1851,7 +2029,12 @@ _emit_code(jit_state_t *_jit) else { word = _jit->code.length - (_jit->pc.uc - _jit->code.ptr); - if (jit_mips2_p() && can_relative_jump_p(word)) + if ((jit_mips2_p() && can_relative_jump_p(word)) +#if !BALC_BROKEN + || + (jit_mips6_p() && can_compact_jump_p(word)) +#endif + ) word = calli(_jit->pc.w, 1); else word = calli_p(_jit->pc.w); @@ -1919,27 +2102,35 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; -#if !NEW_ABI case jit_code_movr_w_f: movr_w_f(rn(node->u.w), rn(node->v.w)); break; -#endif case jit_code_movr_f_w: movr_f_w(rn(node->u.w), rn(node->v.w)); break; case jit_code_movi_f_w: assert(node->flag & jit_flag_data); - movi_f_w(rn(node->u.w), (jit_float32_t *)node->v.n->u.w); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); break; -#if NEW_ABI + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 || NEW_ABI case jit_code_movr_d_w: movr_d_w(rn(node->u.w), rn(node->v.w)); break; case jit_code_movi_d_w: assert(node->flag & jit_flag_data); - movi_d_w(rn(node->u.w), (jit_float64_t *)node->v.n->u.w); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); break; -#else + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; +#endif +#if __WORDSIZE == 32 case jit_code_movr_ww_d: movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); break; @@ -1949,7 +2140,10 @@ _emit_code(jit_state_t *_jit) case jit_code_movi_d_ww: assert(node->flag & jit_flag_data); movi_d_ww(rn(node->u.w), rn(node->v.w), - (jit_float64_t *)node->w.n->u.w); + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + movi_ww_d(rn(node->u.w), node->v.w, node->w.w); break; #endif case jit_code_va_start: @@ -2021,6 +2215,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_names.c b/deps/lightning/lib/jit_names.c index e5985a32..88bc717b 100644 --- a/deps/lightning/lib/jit_names.c +++ b/deps/lightning/lib/jit_names.c @@ -27,10 +27,8 @@ static char *code_name[] = { "prolog", "ellipsis", "va_push", "allocai", "allocar", - "arg_c", - "arg_s", - "arg_i", - "arg_l", + "arg_c", "arg_s", + "arg_i", "arg_l", "getarg_c", "getarg_uc", "getarg_s", "getarg_us", "getarg_i", "getarg_ui", @@ -67,7 +65,8 @@ static char *code_name[] = { "lshr", "lshi", "rshr", "rshi", "rshr_u", "rshi_u", - "negr", "comr", + "negr", "negi", + "comr", "comi", "ltr", "lti", "ltr_u", "lti_u", "ler", "lei", @@ -81,13 +80,18 @@ static char *code_name[] = { "movr", "movi", "movnr", "movzr", "casr", "casi", - "extr_c", "extr_uc", - "extr_s", "extr_us", - "extr_i", "extr_ui", - "bswapr_us", - "bswapr_ui", "bswapr_ul", - "htonr_us", - "htonr_ui", "htonr_ul", + "extr_c", "exti_c", + "extr_uc", "exti_uc", + "extr_s", "exti_s", + "extr_us", "exti_us", + "extr_i", "exti_i", + "extr_ui", "exti_ui", + "bswapr_us", "bswapi_us", + "bswapr_ui", "bswapi_ui", + "bswapr_ul", "bswapi_ul", + "htonr_us", "htoni_us", + "htonr_ui", "htoni_ui", + "htonr_ul", "htoni_ul", "ldr_c", "ldi_c", "ldr_uc", "ldi_uc", "ldr_s", "ldi_s", @@ -161,8 +165,9 @@ static char *code_name[] = { "rsbi_f", "mulr_f", "muli_f", "divr_f", "divi_f", - "negr_f", "absr_f", - "sqrtr_f", + "negr_f", "negi_f", + "absr_f", "absi_f", + "sqrtr_f", "sqrti_f", "ltr_f", "lti_f", "ler_f", "lei_f", "eqr_f", "eqi_f", @@ -208,8 +213,9 @@ static char *code_name[] = { "rsbi_d", "mulr_d", "muli_d", "divr_d", "divi_d", - "negr_d", "absr_d", - "sqrtr_d", + "negr_d", "negi_d", + "absr_d", "absi_d", + "sqrtr_d", "sqrti_d", "ltr_d", "lti_d", "ler_d", "lei_d", "eqr_d", "eqi_d", @@ -224,7 +230,8 @@ static char *code_name[] = { "ltgtr_d", "ltgti_d", "ordr_d", "ordi_d", "unordr_d", "unordi_d", - "truncr_d_i", "truncr_d_l", + "truncr_d_i", + "truncr_d_l", "extr_d", "extr_f_d", "movr_d", "movi_d", "ldr_d", "ldi_d", @@ -248,11 +255,40 @@ static char *code_name[] = { "pushargr_d", "pushargi_d", "retr_d", "reti_d", "retval_d", - "movr_w_f", "movr_ww_d", - "movr_w_d", + "movr_w_f", "movi_w_f", + "movr_ww_d", "movi_ww_d", + "movr_w_d", "movi_w_d", "movr_f_w", "movi_f_w", "movr_d_ww", "movi_d_ww", "movr_d_w", "movi_d_w", - "clo", "clz", - "cto", "ctz", + "clor", "cloi", + "clzr", "clzi", + "ctor", "ctoi", + "ctzr", "ctzi", + "rbitr", "rbiti", + "popcntr", "popcnti", + "lrotr", "lroti", + "rrotr", "rroti", + "extr", "exti", + "extr_u", "exti_u", + "depr", "depi", + "qlshr", "qlshi", + "qlshr_u", "qlshi_u", + "qrshr", "qrshi", + "qrshr_u", "qrshi_u", + "unldr", "unldi", + "unldr_u", "unldi_u", + "unstr", "unsti", + "unldr_x", "unldi_x", + "unstr_x", "unsti_x", + "fmar_f", "fmai_f", + "fmsr_f", "fmsi_f", + "fmar_d", "fmai_d", + "fmsr_d", "fmsi_d", + "fnmar_f", "fnmai_f", + "fnmsr_f", "fnmsi_f", + "fnmar_d", "fnmai_d", + "fnmsr_d", "fnmsi_d", + "hmulr", "hmuli", + "hmulr_u", "hmuli_u", }; diff --git a/deps/lightning/lib/jit_note.c b/deps/lightning/lib/jit_note.c index b0556192..cc225100 100644 --- a/deps/lightning/lib/jit_note.c +++ b/deps/lightning/lib/jit_note.c @@ -135,7 +135,7 @@ _jit_annotate(jit_state_t *_jit) note = _jit->note.ptr + note_offset; if ((length = sizeof(jit_line_t) * note->length) == 0) continue; - assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length); + assert(_jitc->note.base + length <= _jit->data.ptr + _jit->data.length); jit_memcpy(_jitc->note.base, note->lines, length); jit_free((jit_pointer_t *)¬e->lines); note->lines = (jit_line_t *)_jitc->note.base; @@ -148,13 +148,13 @@ _jit_annotate(jit_state_t *_jit) for (line_offset = 0; line_offset < note->length; line_offset++) { line = note->lines + line_offset; length = sizeof(jit_int32_t) * line->length; - assert(_jitc->note.base + length < + assert(_jitc->note.base + length <= _jit->data.ptr + _jit->data.length); jit_memcpy(_jitc->note.base, line->linenos, length); jit_free((jit_pointer_t *)&line->linenos); line->linenos = (jit_int32_t *)_jitc->note.base; _jitc->note.base += length; - assert(_jitc->note.base + length < + assert(_jitc->note.base + length <= _jit->data.ptr + _jit->data.length); jit_memcpy(_jitc->note.base, line->offsets, length); jit_free((jit_pointer_t *)&line->offsets); diff --git a/deps/lightning/lib/jit_ppc-cpu.c b/deps/lightning/lib/jit_ppc-cpu.c index 67874c60..f84998bf 100644 --- a/deps/lightning/lib/jit_ppc-cpu.c +++ b/deps/lightning/lib/jit_ppc-cpu.c @@ -61,14 +61,20 @@ # define _FP_REGNO 31 # if __WORDSIZE == 32 # define ldr(r0,r1) ldr_i(r0,r1) +# define ldi(r0,i0) ldi_i(r0,i0) # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0) # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2) +# define str(r0,r1) str_i(r0,r1) +# define sti(i0,r0) sti_i(i0,r0) # define stxi(i0,r0,r1) stxi_i(i0,r0,r1) # define stxr(r0,r1,r2) stxr_i(r0,r1,r2) # else # define ldr(r0,r1) ldr_l(r0,r1) +# define ldi(r0,i0) ldi_l(r0,i0) # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) +# define str(r0,r1) str_l(r0,r1) +# define sti(i0,r0) sti_l(i0,r0) # define stxi(i0,r0,r1) stxi_l(i0,r0,r1) # define stxr(r0,r1,r2) stxr_l(r0,r1,r2) # endif @@ -295,7 +301,7 @@ static void _FXS(jit_state_t*,int,int,int,int,int,int,int); # define LWZX(d,a,b) FX(31,d,a,b,23) # define LD(d,a,s) FDs(58,d,a,s) # define LDX(d,a,b) FX(31,d,a,b,21) -# define MCRF(d,s) FXL(19,d<<2,(s)<<2,0) +# define MCRF(d,s) FXL(19,((d)<<2),((s)<<2),0) # if DEBUG /* In case instruction is emulated, check the kernel can handle it. Will only generate it if DEBUG is enabled. @@ -327,31 +333,31 @@ instruction will cause the system illegal instruction error handler to be invoked """ */ -# define MCRXR(d) FX(31,d<<2,0,0,512) +# define MCRXR(d) FX(31,((d)<<2),0,0,512) # else # define MCRXR(cr) _MCRXR(_jit,cr); static void _MCRXR(jit_state_t*, jit_int32_t); # endif # define MFCR(d) FX(31,d,0,0,19) # define MFMSR(d) FX(31,d,0,0,83) -# define MFSPR(d,s) FXFX(31,d,s<<5,339) +# define MFSPR(d,s) FXFX(31,d,((s)<<5),339) # define MFXER(d) MFSPR(d,1) # define MFLR(d) MFSPR(d,8) # define MFCTR(d) MFSPR(d,9) # define MFSR(d,s) FX(31,d,s,0,595) # define MFSRIN(d,b) FX(31,d,0,b,659) -# define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371) +# define MFTB(d,x,y) FXFX(31,d,((x)|((y)<<5)),371) # define MFTBL(d) MFTB(d,8,12) # define MFTBU(d) MFTB(d,8,13) -# define MTCRF(c,s) FXFX(31,s,c<<1,144) +# define MTCRF(c,s) FXFX(31,s,((c)<<1),144) # define MTCR(s) MTCRF(0xff,s) # define MTMSR(s) FX(31,s,0,0,146) -# define MTSPR(d,s) FXFX(31,d,s<<5,467) +# define MTSPR(d,s) FXFX(31,d,((s)<<5),467) # define MTXER(d) MTSPR(d,1) # define MTLR(d) MTSPR(d,8) # define MTCTR(d) MTSPR(d,9) -# define MTSR(r,s) FX(31,s<<1,r,0,210) -# define MTSRIN(r,b) FX(31,r<<1,0,b,242) +# define MTSR(r,s) FX(31,((s)<<1),r,0,210) +# define MTSRIN(r,b) FX(31,((r)<<1),0,b,242) # define MULLI(d,a,s) FDs(07,d,a,s) # define MULHW(d,a,b) FXO(31,d,a,b,0,75) # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75) @@ -386,22 +392,23 @@ static void _MCRXR(jit_state_t*, jit_int32_t); # define ORI(d,a,u) FDu(24,a,d,u) # define NOP() ORI(0,0,0) # define ORIS(d,a,u) FDu(25,a,d,u) +# define POPCNTB(a,s) FX(31,s,a,0,122) # define RFI() FXL(19,0,0,50) # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0) # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1) -# define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1) -# define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1) +# define INSLWI(a,s,n,b) RLWIMI(a,s,(32-(b)),b,(((b)+(n))-1)) +# define INSRWI(a,s,n,b) RLWIMI(a,s,(32-((b)+(n))),b,(((b)+(n))-1)) # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0) # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1) -# define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1) -# define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31) +# define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,((n)-1)) +# define EXTRWI(a,s,n,b) RLWINM(a,s,((b)+(n)),(32-(n)),31) # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31) -# define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31) -# define SLWI(a,s,n) RLWINM(a,s,n,0,31-n) -# define SRWI(a,s,n) RLWINM(a,s,32-n,n,31) +# define ROTRWI(a,s,n) RLWINM(a,s,(32-(n)),0,31) +# define SLWI(a,s,n) RLWINM(a,s,n,0,(31-(n))) +# define SRWI(a,s,n) RLWINM(a,s,(32-(n)),n,31) # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31) -# define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n) -# define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n) +# define CLRRWI(a,s,n) RLWINM(a,s,0,0,(31-(n))) +# define CLRLSWI(a,s,b,n) RLWINM(a,s,n,((b)-(n)),(31-(n))) # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0) # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1) # define ROTLW(a,s,b) RLWNM(a,s,b,0,31) @@ -415,33 +422,34 @@ static void _MCRXR(jit_state_t*, jit_int32_t); # define SRW(a,s,b) FX(31,s,a,b,536) # define SRW_(a,s,b) FX_(31,s,a,b,536) # if __WORDSIZE == 64 -# define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5) -# define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5) -# define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n)) -# define SRDI(x,y,n) RLDICL(x,y,(64-n),n) +# define RLDICL(a,s,h,b) FMD(30,s,a,((h)&~32),b,0,((h)>>5)) +# define RLDICL_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,0,((h)>>5)) +# define EXTRDI(x,y,n,b) RLDICL(x,y,((b)+(n)),(64-(n))) +# define SRDI(x,y,n) RLDICL(x,y,(64-(n)),n) # define CLRLDI(x,y,n) RLDICL(x,y,0,n) -# define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5) -# define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5) -# define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1)) -# define SLDI(x,y,n) RLDICR(x,y,n,(63-n)) -# define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n)) -# define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5) -# define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5) -# define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n)) +# define RLDICR(a,s,h,e) FMD(30,s,a,((h)&~32),e,1,((h)>>5)) +# define RLDICR_(a,s,h,e) FMD_(30,s,a,((h)&~32),e,1,((h)>>5)) +# define EXTLDI(x,y,n,b) RLDICR(x,y,b,((n)-1)) +# define SLDI(x,y,n) RLDICR(x,y,n,(63-(n))) +# define CLRRDI(x,y,n) RLDICR(x,y,0,(63-(n))) +# define RLDIC(a,s,h,b) FMD(30,s,a,((h)&~32),b,2,((h)>>5)) +# define RLDIC_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,2,((h)>>5)) +# define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,((b)-(n))) # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8) # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8) # define ROTLD(x,y,z) RLDCL(x,y,z,0) # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0) # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0) -# define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5) -# define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5) -# define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b) +# define RLDIMI(a,s,h,b) FMD(30,s,a,((h)&~32),b,3,((h)>>5)) +# define RLDIMI_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,3,((h)>>5)) +# define INSLDI(x,y,n,b) RLDIMI(x,y,(64-(b)),(((b)+(n))-1)) +# define INSRDI(x,y,n,b) RLDIMI(x,y,(64-((b)+(n))),b) # define SLD(a,s,b) FX(31,s,a,b,27) # define SLD_(a,s,b) FX_(31,s,a,b,27) # define SRD(a,s,b) FX(31,s,a,b,539) # define SRD_(a,s,b) FX_(31,s,a,b,539) -# define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5) -# define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5) +# define SRADI(a,s,h) FXS(31,s,a,((h)&~32),413,((h)>>5)) +# define SRADI_(a,s,h) FXS_(31,s,a,((h)&~32),413,((h)>>5)) # define SRAD(a,s,b) FX(31,s,a,b,794) # define SRAD_(a,s,b) FX_(31,s,a,b,794) # endif @@ -466,7 +474,7 @@ static void _MCRXR(jit_state_t*, jit_int32_t); # define STWX(s,a,b) FX(31,s,a,b,151) # define STD(s,a,d) FDs(62,s,a,d) # define STDX(s,a,b) FX(31,s,a,b,149) -# define STDU(s,a,d) FDs(62,s,a,d|1) +# define STDU(s,a,d) FDs(62,s,a,((d)|1)) # define STDUX(s,a,b) FX(31,s,a,b,181) # define SUBF(d,a,b) FXO(31,d,a,b,0,40) # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40) @@ -476,15 +484,15 @@ static void _MCRXR(jit_state_t*, jit_int32_t); # define SUB_(d,a,b) SUBF_(d,b,a) # define SUBO(d,a,b) SUBFO(d,b,a) # define SUBO_(d,a,b) SUBFO_(d,b,a) -# define SUBI(d,a,s) ADDI(d,a,-s) -# define SUBIS(d,a,s) ADDIS(d,a,-s) +# define SUBI(d,a,s) ADDI(d,a,-(s)) +# define SUBIS(d,a,s) ADDIS(d,a,-(s)) # define SUBFC(d,a,b) FXO(31,d,a,b,0,8) # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8) # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8) # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8) # define SUBC(d,a,b) SUBFC(d,b,a) -# define SUBIC(d,a,s) ADDIC(d,a,-s) -# define SUBIC_(d,a,s) ADDIC_(d,a,-s) +# define SUBIC(d,a,s) ADDIC(d,a,-(s)) +# define SUBIC_(d,a,s) ADDIC_(d,a,-(s)) # define SUBFE(d,a,b) FXO(31,d,a,b,0,136) # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136) # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136) @@ -533,8 +541,6 @@ static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t, #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0) # define negr(r0,r1) NEG(r0,r1) # define comr(r0,r1) NOT(r0,r1) -# define bitswap(r0, r1) _bitswap(_jit, r0, r1) -static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t); # define clor(r0, r1) _clor(_jit, r0, r1) static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); # if __WORDSIZE == 32 @@ -546,6 +552,14 @@ static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +# define popcntr(r0, r1) _popcntr(_jit, r0, r1) +static void _popcntr(jit_state_t*, jit_int32_t, jit_int32_t); +# define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0,r1) EXTSB(r0,r1) # define extr_uc(r0,r1) ANDI_(r0,r1,0xff) # define extr_s(r0,r1) EXTSH(r0,r1) @@ -586,16 +600,20 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # if __WORDSIZE == 32 # define mulr(r0,r1,r2) MULLW(r0,r1,r2) # define mullr(r0,r1,r2) MULLW(r0,r1,r2) -# define mulhr(r0,r1,r2) MULHW(r0,r1,r2) -# define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2) +# define hmulr(r0,r1,r2) MULHW(r0,r1,r2) +# define hmulr_u(r0,r1,r2) MULHWU(r0,r1,r2) # else # define mulr(r0,r1,r2) MULLD(r0,r1,r2) # define mullr(r0,r1,r2) MULLD(r0,r1,r2) -# define mulhr(r0,r1,r2) MULHD(r0,r1,r2) -# define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2) +# define hmulr(r0,r1,r2) MULHD(r0,r1,r2) +# define hmulr_u(r0,r1,r2) MULHDU(r0,r1,r2) # endif # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0) +static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0) +static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc) @@ -652,8 +670,18 @@ static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # else # define lshr(r0,r1,r2) SLD(r0,r1,r2) # endif +#define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3) +#define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0) static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) # if __WORDSIZE == 32 # define rshr(r0,r1,r2) SRAW(r0,r1,r2) # else @@ -668,6 +696,27 @@ static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # endif # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0) static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# if __WORDSIZE == 32 +# define lrotr(r0,r1,r2) ROTLW(r0,r1,r2) +# else +# define lrotr(r0,r1,r2) ROTLD(r0,r1,r2) +# endif +# define lroti(r0,r1,i0) _lroti(_jit,r0,r1,i0) +static void _lroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2) +static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0) +static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2) static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0) @@ -1220,92 +1269,107 @@ _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_unget_reg(r1_reg); } -/* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */ -/* -unsigned int v; // 32-bit word to reverse bit order - -// swap odd and even bits -v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1); -// swap consecutive pairs -v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2); -// swap nibbles ... -v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4); -// swap bytes -v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8); -// swap 2-byte long pairs -v = ( v >> 16 ) | ( v << 16); - */ static void -_bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + comr(r0, r1); + clzr(r0, r0); +} + +static void +_ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + comr(r0, r1); + ctzr(r0, r0); +} + +static void +_ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { - jit_int32_t t0, t1, t2, t3, t4; - movr(r0, r1); + jit_int32_t t0, t1; t0 = jit_get_reg(jit_class_gpr); t1 = jit_get_reg(jit_class_gpr); - t2 = jit_get_reg(jit_class_gpr); - movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L); - rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L); - rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL); - rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL); - rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# if __WORDSIZE == 32 - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - lshi(rn(t2), r0, 16); /* t2 = v << 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# else - movi(rn(t0), 0x0000ffff0000ffffL); - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */ - lshi(rn(t2), r0, 32); /* t2 = v << 32 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# endif - jit_unget_reg(t2); - jit_unget_reg(t1); + negr(rn(t0), r1); + andr(rn(t0), rn(t0), r1); + clzr(r0, rn(t0)); + xori(rn(t1), r0, __WORDSIZE - 1); + movnr(r0, rn(t1), rn(t0)); jit_unget_reg(t0); + jit_unget_reg(t1); } static void -_clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_popcntr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { - comr(r0, r1); - clzr(r0, r0); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + POPCNTB(r0, r1); +#if __WORDSIZE == 32 + movi(rn(reg), 0x01010101); +#else + movi(rn(reg), 0x0101010101010101); +#endif + mullr(r0, r0, rn(reg)); + rshi_u(r0, r0, __WORDSIZE - 8); + jit_unget_reg(reg); } static void -_ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1) { - bitswap(r0, r1); - clor(r0, r0); + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if ( i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } } static void -_ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1) { - bitswap(r0, r1); - clzr(r0, r0); + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif +# if __WORDSIZE == 32 + RLWINM(r0, r1, (32 - i0) & 0x1f, 32 - i1, 31); +# else + RLDICL(r0, r1, (64 - i0) & 0x3f, 64 - i1); +# endif + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { +# if __BYTE_ORDER == __BIG_ENDIAN + i0 = __WORDSIZE - (i0 + i1); +# endif +#if __WORDSIZE == 32 + RLWIMI(r0, r1, i0, 32 - (i0 + i1), 31 - i0); +#else + RLDIMI(r0, r1, i0, 64 - (i0 + i1)); +#endif + } } static void @@ -1475,6 +1539,9 @@ static void _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { jit_int32_t reg; + /* NOTE verified and overflow is correctly computed. + * No need to check for __WORDSIZE == 32. + * Documented as a 32 bit instruction. */ if (can_sign_extend_short_p(i0)) MULLI(r0, r1, i0); else { @@ -1485,6 +1552,26 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + hmulr_u(r0, r1, rn(reg)); + jit_unget_reg(reg); +} + static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) @@ -1497,9 +1584,9 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, else mullr(r0, r2, r3); if (sign) - mulhr(r1, r2, r3); + hmulr(r1, r2, r3); else - mulhr_u(r1, r2, r3); + hmulr_u(r1, r2, r3); if (r0 == r2 || r0 == r3) { movr(r0, rn(reg)); jit_unget_reg(reg); @@ -1710,6 +1797,81 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + lshr(r0, t2, t3); + if (sign) + rshr(r1, t2, t0); + else + rshr_u(r1, t2, t0); + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = fallback_jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* overflow */ + movi(r0, 0); + done_over = fallback_jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + static void _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -1738,6 +1900,131 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0, s0, t2, s2, t3, s3; + jit_word_t over, zero, done, done_over; + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + if (r0 == r2 || r1 == r2) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + rsbi(t0, t3, __WORDSIZE); + if (sign) + rshr(r0, t2, t3); + else + rshr_u(r0, t2, t3); + lshr(r1, t2, t0); + zero = beqi(_jit->pc.w, t3, 0); + over = beqi(_jit->pc.w, t3, __WORDSIZE); + done = jmpi(_jit->pc.w); + patch_at(over, _jit->pc.w); + /* underflow */ + if (sign) + rshi(r0, t2, __WORDSIZE - 1); + else + movi(r0, 0); + done_over = jmpi(_jit->pc.w); + /* zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(r1, t2, __WORDSIZE - 1); + else + movi(r1, 0); + patch_at(done, _jit->pc.w); + patch_at(done_over, _jit->pc.w); + jit_unget_reg(s0); + if (t2 != r2) + jit_unget_reg(s2); + if (t3 != r3) + jit_unget_reg(s3); +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + +static void +_lroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (i0 == 0) + movr(r0, r1); + else { +# if __WORDSIZE == 32 + ROTLWI(r0, r1, i0); +# else + RLDICL(r0, r1, i0, 0); +# endif + } +} + +static void +_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + jit_int32_t reg; + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, __WORDSIZE); + lrotr(r0, r1, r0); + } + else { + reg = jit_get_reg(jit_class_gpr); + rsbi(rn(reg), r2, __WORDSIZE); + lrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } +} + +static void +_rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (i0 == 0) + movr(r0, r1); + else { +# if __WORDSIZE == 32 + ROTRWI(r0, r1, i0); +# else + RLDICL(r0, r1, 64 - i0, 0); +# endif + } +} + static void _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { @@ -2860,9 +3147,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) jit_bool_t inv; jit_int32_t reg; jit_word_t lo, hi; - if (can_sign_extend_short_p(i0)) + if (can_sign_extend_short_p(i0) && !(i0 & 3)) LWA(r0, _R0_REGNO, i0); - else if (can_sign_extend_int_p(i0)) { + else if (can_sign_extend_int_p(i0) && !(i0 & 3)) { hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15)); lo = (jit_int16_t)(i0 - (hi << 16)); reg = jit_get_reg(jit_class_gpr); @@ -2904,7 +3191,7 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_int32_t reg; if (i0 == 0) ldr_i(r0, r1); - else if (can_sign_extend_short_p(i0)) { + else if (can_sign_extend_short_p(i0) && !(i0 & 3)) { if (r1 == _R0_REGNO) { reg = jit_get_reg(jit_class_gpr); movr(rn(reg), r1); @@ -2996,9 +3283,9 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) jit_bool_t inv; jit_int32_t reg; jit_word_t lo, hi; - if (can_sign_extend_short_p(i0)) + if (can_sign_extend_short_p(i0) && !(i0 & 3)) LD(r0, _R0_REGNO, i0); - else if (can_sign_extend_int_p(i0)) { + else if (can_sign_extend_int_p(i0) && !(i0 & 3)) { hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15)); lo = (jit_int16_t)(i0 - (hi << 16)); reg = jit_get_reg(jit_class_gpr); @@ -3040,7 +3327,7 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_int32_t reg; if (i0 == 0) ldr_l(r0, r1); - else if (can_sign_extend_short_p(i0)) { + else if (can_sign_extend_short_p(i0) && !(i0 & 3)) { if (r1 == _R0_REGNO) { reg = jit_get_reg(jit_class_gpr); movr(rn(reg), r1); @@ -3270,9 +3557,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) jit_bool_t inv; jit_int32_t reg; jit_word_t lo, hi; - if (can_sign_extend_short_p(i0)) + if (can_sign_extend_short_p(i0) && !(i0 & 3)) STD(r0, _R0_REGNO, i0); - else if (can_sign_extend_int_p(i0)) { + else if (can_sign_extend_int_p(i0) && !(i0 & 3)) { hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15)); lo = (jit_int16_t)(i0 - (hi << 16)); reg = jit_get_reg(jit_class_gpr); @@ -3314,7 +3601,7 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) jit_int32_t reg; if (i0 == 0) str_l(r0, r1); - else if (can_sign_extend_short_p(i0)) { + else if (can_sign_extend_short_p(i0) && !(i0 & 3)) { if (r0 == _R0_REGNO) { reg = jit_get_reg(jit_class_gpr); movr(rn(reg), i0); @@ -3465,20 +3752,15 @@ _calli_p(jit_state_t *_jit, jit_word_t i0 return (w); } -/* order is not guaranteed to be sequential */ -static jit_int32_t save[] = { - _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22, - _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31, -}; - static void _prolog(jit_state_t *_jit, jit_node_t *node) { - unsigned long regno; + jit_int32_t regno; jit_word_t offset; if (_jitc->function->define_frame || _jitc->function->assume_frame) { jit_int32_t frame = -_jitc->function->frame; + jit_check_frame(); assert(_jitc->function->self.aoff >= frame); if (_jitc->function->assume_frame) return; @@ -3492,36 +3774,66 @@ _prolog(jit_state_t *_jit, jit_node_t *node) _jitc->function->self.size - _jitc->function->self.aoff) + 15) & -16; - /* return address */ - MFLR(_R0_REGNO); + if (_jitc->function->need_frame) + _jitc->function->need_stack = _jitc->function->need_return = 1; + + if (!_jitc->function->need_stack) { + for (regno = 0; regno < jit_size(iregs); regno++) { + if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno])) { + _jitc->function->need_stack = + _jitc->function->need_return = 1; + break; + } + } + if (!_jitc->function->need_stack) { + for (offset = 0; offset < jit_size(fregs); offset++) { + if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset])) { + _jitc->function->need_stack = + _jitc->function->need_return = 1; + break; + } + } + } + } /* params >= %r31+params_offset+(8*sizeof(jit_word_t)) * alloca < %r31-80 */ + /* return address */ + if (_jitc->function->need_return) { + MFLR(_R0_REGNO); #if _CALL_SYSV - stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO); + stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO); #else - stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO); + stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO); #endif - offset = -gpr_save_area; - for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) { - if (jit_regset_tstbit(&_jitc->function->regset, save[regno])) - stxi(offset, _SP_REGNO, rn(save[regno])); - } - for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) - stxi_d(-(gpr_save_area + 8 + offset * 8), - _SP_REGNO, rn(_F14 + offset)); } - stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO); + if (_jitc->function->need_stack) { + offset = -gpr_save_area; + for (regno = 0; regno < jit_size(iregs); + regno++, offset += sizeof(void*)) { + if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno])) + stxi(offset, _SP_REGNO, rn(iregs[regno])); + } + for (offset = 0; offset < jit_size(fregs); offset++) { + if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset])) + stxi_d(-(gpr_save_area + 8 + offset * 8), + _SP_REGNO, rn(fregs[offset])); + } + } - movr(_FP_REGNO, _SP_REGNO); + if (_jitc->function->need_frame) { + stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO); + movr(_FP_REGNO, _SP_REGNO); + } + if (_jitc->function->need_stack) { #if __WORDSIZE == 32 - STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack); + STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack); #else - STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack); + STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack); #endif + } if (_jitc->function->allocar) { regno = jit_get_reg(jit_class_gpr); @@ -3552,33 +3864,44 @@ _prolog(jit_state_t *_jit, jit_node_t *node) static void _epilog(jit_state_t *_jit, jit_node_t *node) { - unsigned long regno; + jit_int32_t regno; jit_word_t offset; if (_jitc->function->assume_frame) return; - if (_jitc->function->allocar) - ldr(_SP_REGNO, _SP_REGNO); - else - addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack); + if (_jitc->function->need_stack) { + if (_jitc->function->allocar) + ldr(_SP_REGNO, _SP_REGNO); + else + addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack); + } + + if (_jitc->function->need_return) { #if _CALL_SYSV - ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t)); + ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t)); #else - ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2); + ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2); #endif - offset = -gpr_save_area; - for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) { - if (jit_regset_tstbit(&_jitc->function->regset, save[regno])) - ldxi(rn(save[regno]), _SP_REGNO, offset); } - for (offset = 0; offset < 8; offset++) { - if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset)) - ldxi_d(rn(_F14 + offset), _SP_REGNO, - -(gpr_save_area + 8 + offset * 8)); + + if (_jitc->function->need_stack) { + offset = -gpr_save_area; + for (regno = 0; regno < jit_size(iregs); + regno++, offset += sizeof(void*)) { + if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno])) + ldxi(rn(iregs[regno]), _SP_REGNO, offset); + } + for (offset = 0; offset < 8; offset++) { + if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset])) + ldxi_d(rn(fregs[offset]), _SP_REGNO, + -(gpr_save_area + 8 + offset * 8)); + } } - MTLR(_R0_REGNO); - ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*))); + if (_jitc->function->need_return) + MTLR(_R0_REGNO); + if (_jitc->function->need_frame) + ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*))); BLR(); } diff --git a/deps/lightning/lib/jit_ppc-fpu.c b/deps/lightning/lib/jit_ppc-fpu.c index 12631cd4..605bd4fa 100644 --- a/deps/lightning/lib/jit_ppc-fpu.c +++ b/deps/lightning/lib/jit_ppc-fpu.c @@ -120,6 +120,8 @@ static void _FXFL(jit_state_t*,int,int,int,int,int) maybe_unused; static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_f(r0,i0) _movi_f(_jit,r0,i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); +#define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define movi_d(r0,i0) _movi_d(_jit,r0,i0) static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); # define extr_f(r0,r1) extr_d(r0,r1) @@ -131,11 +133,15 @@ static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t); static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t); # if __WORDSIZE == 32 # define truncr_d(r0,r1) truncr_d_i(r0,r1) +# define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) +static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # else # define truncr_d(r0,r1) truncr_d_l(r0,r1) # define truncr_f_l(r0,r1) truncr_d_l(r0,r1) # define truncr_d_l(r0,r1) _truncr_d_l(_jit,r0,r1) static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t); +# define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # endif # define extr_d_f(r0,r1) FRSP(r0,r1) # define extr_f_d(r0,r1) movr_d(r0,r1) @@ -154,6 +160,14 @@ extern double sqrt(double); # define sqrtr_d(r0,r1) _sqrtr_d(_jit,r0,r1) static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t); # endif +# define fmar_f(r0,r1,r2,r3) FMADDS(r0,r1,r3,r2) +# define fmar_d(r0,r1,r2,r3) FMADD(r0,r1,r3,r2) +# define fmsr_f(r0,r1,r2,r3) FMSUBS(r0,r1,r3,r2) +# define fmsr_d(r0,r1,r2,r3) FMSUB(r0,r1,r3,r2) +# define fnmar_f(r0,r1,r2,r3) FNMADDS(r0,r1,r3,r2) +# define fnmar_d(r0,r1,r2,r3) FNMADD(r0,r1,r3,r2) +# define fnmsr_f(r0,r1,r2,r3) FNMSUBS(r0,r1,r3,r2) +# define fnmsr_d(r0,r1,r2,r3) FNMSUB(r0,r1,r3,r2) # define addr_f(r0,r1,r2) FADDS(r0,r1,r2) # define addr_d(r0,r1,r2) FADD(r0,r1,r2) # define addi_f(r0,r1,i0) _addi_f(_jit,r0,r1,i0) @@ -453,17 +467,29 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) jit_int32_t reg; if (_jitc->no_data) { + CHECK_CVT_OFFSET(); + jit_check_frame(); data.f = *i0; reg = jit_get_reg(jit_class_gpr); movi(rn(reg), data.i & 0xffffffff); - stxi_i(alloca_offset - 4, _FP_REGNO, rn(reg)); + stxi_i(CVT_OFFSET + 4, _FP_REGNO, rn(reg)); jit_unget_reg(reg); - ldxi_f(r0, _FP_REGNO, alloca_offset - 4); + ldxi_f(r0, _FP_REGNO, CVT_OFFSET + 4); } else ldi_f(r0, (jit_word_t)i0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + static void _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) { @@ -475,36 +501,64 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) jit_int32_t reg; if (_jitc->no_data) { + CHECK_CVT_OFFSET(); + jit_check_frame(); data.d = *i0; reg = jit_get_reg(jit_class_gpr); # if __WORDSIZE == 32 movi(rn(reg), data.i[0]); - stxi(alloca_offset - 8, _FP_REGNO, rn(reg)); + stxi(CVT_OFFSET, _FP_REGNO, rn(reg)); movi(rn(reg), data.i[1]); - stxi(alloca_offset - 4, _FP_REGNO, rn(reg)); + stxi(CVT_OFFSET + 4, _FP_REGNO, rn(reg)); # else movi(rn(reg), data.w); - stxi(alloca_offset - 8, _FP_REGNO, rn(reg)); + stxi(CVT_OFFSET, _FP_REGNO, rn(reg)); # endif jit_unget_reg(reg); - ldxi_d(r0, _FP_REGNO, alloca_offset - 8); + ldxi_d(r0, _FP_REGNO, CVT_OFFSET); } else ldi_d(r0, (jit_word_t)i0); } +# if __WORDSIZE == 32 +static void +_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + movr_ww_d(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); +} +# else +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); +} +# endif + static void _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { # if __WORDSIZE == 32 jit_int32_t reg, freg, off1, off2; - + CHECK_CVT_OFFSET(); + jit_check_frame(); # if __BYTE_ORDER == __BIG_ENDIAN - off1 = alloca_offset - 8; - off2 = alloca_offset - 4; + off1 = CVT_OFFSET; + off2 = CVT_OFFSET + 4; # else - off1 = alloca_offset - 4; - off2 = alloca_offset - 8; + off1 = CVT_OFFSET + 4; + off2 = CVT_OFFSET; # endif reg = jit_get_reg(jit_class_gpr); @@ -514,17 +568,17 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) stxi_i(off1, _FP_REGNO, rn(reg)); movi(rn(reg), 0x80000000); stxi_i(off2, _FP_REGNO, rn(reg)); - ldxi_d(rn(freg), _FP_REGNO, alloca_offset - 8); + ldxi_d(rn(freg), _FP_REGNO, CVT_OFFSET); xorr(rn(reg), r1, rn(reg)); stxi_i(off2, _FP_REGNO, rn(reg)); - ldxi_d(r0, _FP_REGNO, alloca_offset - 8); + ldxi_d(r0, _FP_REGNO, CVT_OFFSET); subr_d(r0, r0, rn(freg)); jit_unget_reg(reg); jit_unget_reg(freg); # else - stxi(alloca_offset - 8, _FP_REGNO, r1); - ldxi_d(r0, _FP_REGNO, alloca_offset - 8); + stxi(CVT_OFFSET, _FP_REGNO, r1); + ldxi_d(r0, _FP_REGNO, CVT_OFFSET); FCFID(r0, r0); # endif } @@ -535,12 +589,13 @@ _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) jit_int32_t reg; reg = jit_get_reg(jit_class_fpr); FCTIWZ(rn(reg), r1); - /* use reserved 8 bytes area */ - stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg)); + CHECK_CVT_OFFSET(); + jit_check_frame(); + stxi_d(CVT_OFFSET, _FP_REGNO, rn(reg)); # if __BYTE_ORDER == __BIG_ENDIAN - ldxi_i(r0, _FP_REGNO, alloca_offset - 4); + ldxi_i(r0, _FP_REGNO, CVT_OFFSET + 4); # else - ldxi_i(r0, _FP_REGNO, alloca_offset - 8); + ldxi_i(r0, _FP_REGNO, CVT_OFFSET); # endif jit_unget_reg(reg); } @@ -552,9 +607,10 @@ _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) jit_int32_t reg; reg = jit_get_reg(jit_class_fpr); FCTIDZ(rn(reg), r1); - /* use reserved 8 bytes area */ - stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg)); - ldxi(r0, _FP_REGNO, alloca_offset - 8); + CHECK_CVT_OFFSET(); + jit_check_frame(); + stxi_d(CVT_OFFSET, _FP_REGNO, rn(reg)); + ldxi(r0, _FP_REGNO, CVT_OFFSET); jit_unget_reg(reg); } # endif diff --git a/deps/lightning/lib/jit_ppc-sz.c b/deps/lightning/lib/jit_ppc-sz.c index c8a4471e..136f1d40 100644 --- a/deps/lightning/lib/jit_ppc-sz.c +++ b/deps/lightning/lib/jit_ppc-sz.c @@ -2,10 +2,10 @@ #if defined(__powerpc__) #if __BYTE_ORDER == __BIG_ENDIAN #if !_CALL_SYSV -#define JIT_INSTR_MAX 136 +#define JIT_INSTR_MAX 152 0, /* data */ 0, /* live */ - 20, /* align */ + 16, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -47,42 +47,42 @@ 8, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 12, /* addi */ + 12, /* addi */ 4, /* addcr */ - 12, /* addci */ + 12, /* addci */ 4, /* addxr */ 8, /* addxi */ 4, /* subr */ - 12, /* subi */ + 12, /* subi */ 4, /* subcr */ - 12, /* subci */ + 12, /* subci */ 4, /* subxr */ 8, /* subxi */ - 16, /* rsbi */ + 16, /* rsbi */ 4, /* mulr */ - 12, /* muli */ - 12, /* qmulr */ - 16, /* qmuli */ - 12, /* qmulr_u */ - 16, /* qmuli_u */ + 12, /* muli */ + 12, /* qmulr */ + 16, /* qmuli */ + 12, /* qmulr_u */ + 16, /* qmuli_u */ 4, /* divr */ - 12, /* divi */ + 12, /* divi */ 4, /* divr_u */ - 12, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ - 12, /* remr */ - 20, /* remi */ - 12, /* remr_u */ - 20, /* remi_u */ + 12, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ + 12, /* remr */ + 20, /* remi */ + 12, /* remr_u */ + 20, /* remi_u */ 4, /* andr */ 4, /* andi */ 4, /* orr */ - 12, /* ori */ + 12, /* ori */ 4, /* xorr */ - 12, /* xori */ + 12, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -90,47 +90,61 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 12, /* ltr */ - 12, /* lti */ - 12, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 12, /* eqr */ - 12, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 12, /* gtr */ - 12, /* gti */ - 12, /* gtr_u */ - 12, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 12, /* ltr */ + 12, /* lti */ + 12, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 12, /* eqr */ + 12, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 12, /* gtr */ + 12, /* gti */ + 12, /* gtr_u */ + 12, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ 8, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 36, /* casr */ - 44, /* casi */ + 12, /* movnr */ + 12, /* movzr */ + 36, /* casr */ + 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 8, /* bswapr_us */ - 16, /* bswapr_ui */ + 4, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 8, /* ldr_c */ - 12, /* ldi_c */ + 12, /* ldi_c */ 4, /* ldr_uc */ 8, /* ldi_uc */ 4, /* ldr_s */ @@ -144,15 +158,15 @@ 0, /* ldr_l */ 0, /* ldi_l */ 8, /* ldxr_c */ - 16, /* ldxi_c */ + 16, /* ldxi_c */ 4, /* ldxr_uc */ - 12, /* ldxi_uc */ + 12, /* ldxi_uc */ 4, /* ldxr_s */ - 12, /* ldxi_s */ + 12, /* ldxi_s */ 4, /* ldxr_us */ - 12, /* ldxi_us */ + 12, /* ldxi_us */ 4, /* ldxr_i */ - 12, /* ldxi_i */ + 12, /* ldxi_i */ 0, /* ldxr_ui */ 0, /* ldxi_ui */ 0, /* ldxr_l */ @@ -166,23 +180,23 @@ 0, /* str_l */ 0, /* sti_l */ 4, /* stxr_c */ - 12, /* stxi_c */ + 12, /* stxi_c */ 4, /* stxr_s */ - 12, /* stxi_s */ + 12, /* stxi_s */ 4, /* stxr_i */ - 12, /* stxi_i */ + 12, /* stxi_i */ 0, /* stxr_l */ 0, /* stxi_l */ 8, /* bltr */ 8, /* blti */ 8, /* bltr_u */ - 12, /* blti_u */ + 12, /* blti_u */ 8, /* bler */ 8, /* blei */ 8, /* bler_u */ - 12, /* blei_u */ + 12, /* blei_u */ 8, /* beqr */ - 16, /* beqi */ + 16, /* beqi */ 8, /* bger */ 8, /* bgei */ 8, /* bger_u */ @@ -192,31 +206,31 @@ 8, /* bgtr_u */ 8, /* bgti_u */ 8, /* bner */ - 16, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 16, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 16, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 16, /* bosubi */ - 12, /* bosubr_u */ - 16, /* bosubi_u */ - 12, /* bxsubr */ - 16, /* bxsubi */ - 12, /* bxsubr_u */ - 16, /* bxsubi_u */ + 16, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 16, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 16, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 16, /* bosubi */ + 12, /* bosubr_u */ + 16, /* bosubi_u */ + 12, /* bxsubr */ + 16, /* bxsubi */ + 12, /* bxsubr_u */ + 16, /* bxsubi_u */ 8, /* jmpr */ 4, /* jmpi */ - 28, /* callr */ - 36, /* calli */ + 28, /* callr */ + 36, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -262,87 +276,90 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 16, /* addi_f */ + 16, /* addi_f */ 4, /* subr_f */ - 16, /* subi_f */ - 16, /* rsbi_f */ + 16, /* subi_f */ + 16, /* rsbi_f */ 4, /* mulr_f */ - 16, /* muli_f */ + 16, /* muli_f */ 4, /* divr_f */ - 16, /* divi_f */ + 16, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 12, /* ltr_f */ - 24, /* lti_f */ - 16, /* ler_f */ - 28, /* lei_f */ - 12, /* eqr_f */ - 24, /* eqi_f */ - 16, /* ger_f */ - 28, /* gei_f */ - 12, /* gtr_f */ - 24, /* gti_f */ - 16, /* ner_f */ - 28, /* nei_f */ - 16, /* unltr_f */ - 28, /* unlti_f */ - 16, /* unler_f */ - 28, /* unlei_f */ - 16, /* uneqr_f */ - 28, /* uneqi_f */ - 16, /* unger_f */ - 28, /* ungei_f */ - 16, /* ungtr_f */ - 28, /* ungti_f */ - 16, /* ltgtr_f */ - 28, /* ltgti_f */ - 16, /* ordr_f */ - 28, /* ordi_f */ - 12, /* unordr_f */ - 24, /* unordi_f */ - 12, /* truncr_f_i */ + 0, /* sqrti_f */ + 12, /* ltr_f */ + 24, /* lti_f */ + 16, /* ler_f */ + 28, /* lei_f */ + 12, /* eqr_f */ + 24, /* eqi_f */ + 16, /* ger_f */ + 28, /* gei_f */ + 12, /* gtr_f */ + 24, /* gti_f */ + 16, /* ner_f */ + 28, /* nei_f */ + 16, /* unltr_f */ + 28, /* unlti_f */ + 16, /* unler_f */ + 28, /* unlei_f */ + 16, /* uneqr_f */ + 28, /* uneqi_f */ + 16, /* unger_f */ + 28, /* ungei_f */ + 16, /* ungtr_f */ + 28, /* ungti_f */ + 16, /* ltgtr_f */ + 28, /* ltgti_f */ + 16, /* ordr_f */ + 28, /* ordi_f */ + 12, /* unordr_f */ + 24, /* unordi_f */ + 12, /* truncr_f_i */ 0, /* truncr_f_l */ - 36, /* extr_f */ + 36, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 12, /* movi_f */ + 12, /* movi_f */ 4, /* ldr_f */ 8, /* ldi_f */ 4, /* ldxr_f */ - 12, /* ldxi_f */ + 12, /* ldxi_f */ 4, /* str_f */ 8, /* sti_f */ 4, /* stxr_f */ - 12, /* stxi_f */ + 12, /* stxi_f */ 8, /* bltr_f */ - 20, /* blti_f */ - 12, /* bler_f */ - 24, /* blei_f */ + 20, /* blti_f */ + 12, /* bler_f */ + 24, /* blei_f */ 8, /* beqr_f */ - 20, /* beqi_f */ - 12, /* bger_f */ - 24, /* bgei_f */ + 20, /* beqi_f */ + 12, /* bger_f */ + 24, /* bgei_f */ 8, /* bgtr_f */ - 20, /* bgti_f */ + 20, /* bgti_f */ 8, /* bner_f */ - 20, /* bnei_f */ - 12, /* bunltr_f */ - 24, /* bunlti_f */ + 20, /* bnei_f */ + 12, /* bunltr_f */ + 24, /* bunlti_f */ 8, /* bunler_f */ - 20, /* bunlei_f */ - 12, /* buneqr_f */ - 24, /* buneqi_f */ + 20, /* bunlei_f */ + 12, /* buneqr_f */ + 24, /* buneqi_f */ 8, /* bunger_f */ - 20, /* bungei_f */ - 12, /* bungtr_f */ - 24, /* bungti_f */ - 12, /* bltgtr_f */ - 24, /* bltgti_f */ + 20, /* bungei_f */ + 12, /* bungtr_f */ + 24, /* bungti_f */ + 12, /* bltgtr_f */ + 24, /* bltgti_f */ 8, /* bordr_f */ - 20, /* bordi_f */ + 20, /* bordi_f */ 8, /* bunordr_f */ - 20, /* bunordi_f */ + 20, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -353,105 +370,167 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 24, /* addi_d */ + 24, /* addi_d */ 4, /* subr_d */ - 24, /* subi_d */ - 24, /* rsbi_d */ + 24, /* subi_d */ + 24, /* rsbi_d */ 4, /* mulr_d */ - 24, /* muli_d */ + 24, /* muli_d */ 4, /* divr_d */ - 24, /* divi_d */ + 24, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 12, /* ltr_d */ - 32, /* lti_d */ - 16, /* ler_d */ - 36, /* lei_d */ - 12, /* eqr_d */ - 32, /* eqi_d */ - 16, /* ger_d */ - 36, /* gei_d */ - 12, /* gtr_d */ - 32, /* gti_d */ - 16, /* ner_d */ - 36, /* nei_d */ - 16, /* unltr_d */ - 36, /* unlti_d */ - 16, /* unler_d */ - 36, /* unlei_d */ - 16, /* uneqr_d */ - 36, /* uneqi_d */ - 16, /* unger_d */ - 36, /* ungei_d */ - 16, /* ungtr_d */ - 36, /* ungti_d */ - 16, /* ltgtr_d */ - 36, /* ltgti_d */ - 16, /* ordr_d */ - 36, /* ordi_d */ - 12, /* unordr_d */ - 32, /* unordi_d */ - 12, /* truncr_d_i */ + 0, /* sqrti_d */ + 12, /* ltr_d */ + 32, /* lti_d */ + 16, /* ler_d */ + 36, /* lei_d */ + 12, /* eqr_d */ + 32, /* eqi_d */ + 16, /* ger_d */ + 36, /* gei_d */ + 12, /* gtr_d */ + 32, /* gti_d */ + 16, /* ner_d */ + 36, /* nei_d */ + 16, /* unltr_d */ + 36, /* unlti_d */ + 16, /* unler_d */ + 36, /* unlei_d */ + 16, /* uneqr_d */ + 36, /* uneqi_d */ + 16, /* unger_d */ + 36, /* ungei_d */ + 16, /* ungtr_d */ + 36, /* ungti_d */ + 16, /* ltgtr_d */ + 36, /* ltgti_d */ + 16, /* ordr_d */ + 36, /* ordi_d */ + 12, /* unordr_d */ + 32, /* unordi_d */ + 12, /* truncr_d_i */ 0, /* truncr_d_l */ - 36, /* extr_d */ + 36, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 28, /* movi_d */ + 28, /* movi_d */ 4, /* ldr_d */ 8, /* ldi_d */ 4, /* ldxr_d */ - 12, /* ldxi_d */ + 12, /* ldxi_d */ 4, /* str_d */ 8, /* sti_d */ 4, /* stxr_d */ - 12, /* stxi_d */ + 12, /* stxi_d */ 8, /* bltr_d */ - 28, /* blti_d */ - 12, /* bler_d */ - 32, /* blei_d */ + 28, /* blti_d */ + 12, /* bler_d */ + 32, /* blei_d */ 8, /* beqr_d */ - 32, /* beqi_d */ - 12, /* bger_d */ - 32, /* bgei_d */ + 32, /* beqi_d */ + 12, /* bger_d */ + 32, /* bgei_d */ 8, /* bgtr_d */ - 28, /* bgti_d */ + 28, /* bgti_d */ 8, /* bner_d */ - 28, /* bnei_d */ - 12, /* bunltr_d */ - 32, /* bunlti_d */ + 28, /* bnei_d */ + 12, /* bunltr_d */ + 32, /* bunlti_d */ 8, /* bunler_d */ - 28, /* bunlei_d */ - 12, /* buneqr_d */ - 32, /* buneqi_d */ + 28, /* bunlei_d */ + 12, /* buneqr_d */ + 32, /* buneqi_d */ 8, /* bunger_d */ - 28, /* bungei_d */ - 12, /* bungtr_d */ - 32, /* bungti_d */ - 12, /* bltgtr_d */ - 32, /* bltgti_d */ + 28, /* bungei_d */ + 12, /* bungtr_d */ + 32, /* bungti_d */ + 12, /* bltgtr_d */ + 32, /* bltgti_d */ 8, /* bordr_d */ - 28, /* bordi_d */ + 28, /* bordi_d */ 8, /* bunordr_d */ - 28, /* bunordi_d */ + 28, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 8, /* movr_w_f */ + 12, /* movi_w_f */ + 12, /* movr_ww_d */ + 20, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 8, /* movr_f_w */ + 4, /* movi_f_w */ + 12, /* movr_d_ww */ + 8, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 136, /* cto */ - 132, /* ctz */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 32, /* ctor */ + 4, /* ctoi */ + 28, /* ctzr */ + 4, /* ctzi */ + 56, /* rbitr */ + 8, /* rbiti */ + 20, /* popcntr */ + 4, /* popcnti */ + 4, /* lrotr */ + 4, /* lroti */ + 12, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 56, /* qlshr_u */ + 8, /* qlshi_u */ + 56, /* qrshr */ + 8, /* qrshi */ + 56, /* qrshr_u */ + 8, /* qrshi_u */ + 68, /* unldr */ + 32, /* unldi */ + 68, /* unldr_u */ + 32, /* unldi_u */ + 68, /* unstr */ + 32, /* unsti */ + 140, /* unldr_x */ + 68, /* unldi_x */ + 152, /* unstr_x */ + 76, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 12, /* hmuli */ + 4, /* hmulr_u */ + 12, /* hmuli_u */ #endif /* !_CALL_SYSV */ #endif /* __BYTE_ORDER */ #endif /* __powerpc__ */ @@ -461,10 +540,10 @@ #if defined(__powerpc__) #if __BYTE_ORDER == __BIG_ENDIAN #if _CALL_SYSV -#define JIT_INSTR_MAX 136 +#define JIT_INSTR_MAX 152 0, /* data */ 0, /* live */ - 28, /* align */ + 28, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -501,47 +580,47 @@ 0, /* putargi_ui */ 0, /* putargr_l */ 0, /* putargi_l */ - 36, /* va_start */ - 52, /* va_arg */ - 64, /* va_arg_d */ + 36, /* va_start */ + 52, /* va_arg */ + 64, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 12, /* addi */ + 12, /* addi */ 4, /* addcr */ - 12, /* addci */ + 12, /* addci */ 4, /* addxr */ 8, /* addxi */ 4, /* subr */ - 12, /* subi */ + 12, /* subi */ 4, /* subcr */ - 12, /* subci */ + 12, /* subci */ 4, /* subxr */ 8, /* subxi */ - 16, /* rsbi */ + 16, /* rsbi */ 4, /* mulr */ - 12, /* muli */ - 12, /* qmulr */ - 16, /* qmuli */ - 12, /* qmulr_u */ - 16, /* qmuli_u */ + 12, /* muli */ + 12, /* qmulr */ + 16, /* qmuli */ + 12, /* qmulr_u */ + 16, /* qmuli_u */ 4, /* divr */ - 12, /* divi */ + 12, /* divi */ 4, /* divr_u */ - 12, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ - 12, /* remr */ - 20, /* remi */ - 12, /* remr_u */ - 20, /* remi_u */ + 12, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ + 12, /* remr */ + 20, /* remi */ + 12, /* remr_u */ + 20, /* remi_u */ 4, /* andr */ 4, /* andi */ 4, /* orr */ - 12, /* ori */ + 12, /* ori */ 4, /* xorr */ - 12, /* xori */ + 12, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -549,47 +628,61 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 12, /* ltr */ - 12, /* lti */ - 12, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 12, /* eqr */ - 12, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 12, /* gtr */ - 12, /* gti */ - 12, /* gtr_u */ - 12, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 12, /* ltr */ + 12, /* lti */ + 12, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 12, /* eqr */ + 12, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 12, /* gtr */ + 12, /* gti */ + 12, /* gtr_u */ + 12, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ 8, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 36, /* casr */ - 44, /* casi */ + 12, /* movnr */ + 12, /* movzr */ + 36, /* casr */ + 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 8, /* bswapr_us */ - 16, /* bswapr_ui */ + 4, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 8, /* ldr_c */ - 12, /* ldi_c */ + 12, /* ldi_c */ 4, /* ldr_uc */ 8, /* ldi_uc */ 4, /* ldr_s */ @@ -603,15 +696,15 @@ 0, /* ldr_l */ 0, /* ldi_l */ 8, /* ldxr_c */ - 16, /* ldxi_c */ + 16, /* ldxi_c */ 4, /* ldxr_uc */ - 12, /* ldxi_uc */ + 12, /* ldxi_uc */ 4, /* ldxr_s */ - 12, /* ldxi_s */ + 12, /* ldxi_s */ 4, /* ldxr_us */ - 12, /* ldxi_us */ + 12, /* ldxi_us */ 4, /* ldxr_i */ - 12, /* ldxi_i */ + 12, /* ldxi_i */ 0, /* ldxr_ui */ 0, /* ldxi_ui */ 0, /* ldxr_l */ @@ -625,23 +718,23 @@ 0, /* str_l */ 0, /* sti_l */ 4, /* stxr_c */ - 12, /* stxi_c */ + 12, /* stxi_c */ 4, /* stxr_s */ - 12, /* stxi_s */ + 12, /* stxi_s */ 4, /* stxr_i */ - 12, /* stxi_i */ + 12, /* stxi_i */ 0, /* stxr_l */ 0, /* stxi_l */ 8, /* bltr */ 8, /* blti */ 8, /* bltr_u */ - 12, /* blti_u */ + 12, /* blti_u */ 8, /* bler */ 8, /* blei */ 8, /* bler_u */ - 12, /* blei_u */ + 12, /* blei_u */ 8, /* beqr */ - 16, /* beqi */ + 16, /* beqi */ 8, /* bger */ 8, /* bgei */ 8, /* bger_u */ @@ -651,31 +744,31 @@ 8, /* bgtr_u */ 8, /* bgti_u */ 8, /* bner */ - 16, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 16, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 16, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 16, /* bosubi */ - 12, /* bosubr_u */ - 16, /* bosubi_u */ - 12, /* bxsubr */ - 16, /* bxsubi */ - 12, /* bxsubr_u */ - 16, /* bxsubi_u */ + 16, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 16, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 16, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 16, /* bosubi */ + 12, /* bosubr_u */ + 16, /* bosubi_u */ + 12, /* bxsubr */ + 16, /* bxsubi */ + 12, /* bxsubr_u */ + 16, /* bxsubi_u */ 8, /* jmpr */ 4, /* jmpi */ - 12, /* callr */ - 20, /* calli */ + 12, /* callr */ + 20, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -721,87 +814,90 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 16, /* addi_f */ + 16, /* addi_f */ 4, /* subr_f */ - 16, /* subi_f */ - 16, /* rsbi_f */ + 16, /* subi_f */ + 16, /* rsbi_f */ 4, /* mulr_f */ - 16, /* muli_f */ + 16, /* muli_f */ 4, /* divr_f */ - 16, /* divi_f */ + 16, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 12, /* ltr_f */ - 24, /* lti_f */ - 16, /* ler_f */ - 28, /* lei_f */ - 12, /* eqr_f */ - 24, /* eqi_f */ - 16, /* ger_f */ - 28, /* gei_f */ - 12, /* gtr_f */ - 24, /* gti_f */ - 16, /* ner_f */ - 28, /* nei_f */ - 16, /* unltr_f */ - 28, /* unlti_f */ - 16, /* unler_f */ - 28, /* unlei_f */ - 16, /* uneqr_f */ - 28, /* uneqi_f */ - 16, /* unger_f */ - 28, /* ungei_f */ - 16, /* ungtr_f */ - 28, /* ungti_f */ - 16, /* ltgtr_f */ - 28, /* ltgti_f */ - 16, /* ordr_f */ - 28, /* ordi_f */ - 12, /* unordr_f */ - 24, /* unordi_f */ - 12, /* truncr_f_i */ + 0, /* sqrti_f */ + 12, /* ltr_f */ + 24, /* lti_f */ + 16, /* ler_f */ + 28, /* lei_f */ + 12, /* eqr_f */ + 24, /* eqi_f */ + 16, /* ger_f */ + 28, /* gei_f */ + 12, /* gtr_f */ + 24, /* gti_f */ + 16, /* ner_f */ + 28, /* nei_f */ + 16, /* unltr_f */ + 28, /* unlti_f */ + 16, /* unler_f */ + 28, /* unlei_f */ + 16, /* uneqr_f */ + 28, /* uneqi_f */ + 16, /* unger_f */ + 28, /* ungei_f */ + 16, /* ungtr_f */ + 28, /* ungti_f */ + 16, /* ltgtr_f */ + 28, /* ltgti_f */ + 16, /* ordr_f */ + 28, /* ordi_f */ + 12, /* unordr_f */ + 24, /* unordi_f */ + 12, /* truncr_f_i */ 0, /* truncr_f_l */ - 36, /* extr_f */ + 36, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 12, /* movi_f */ + 12, /* movi_f */ 4, /* ldr_f */ 8, /* ldi_f */ 4, /* ldxr_f */ - 12, /* ldxi_f */ + 12, /* ldxi_f */ 4, /* str_f */ 8, /* sti_f */ 4, /* stxr_f */ - 12, /* stxi_f */ + 12, /* stxi_f */ 8, /* bltr_f */ - 20, /* blti_f */ - 12, /* bler_f */ - 24, /* blei_f */ + 20, /* blti_f */ + 12, /* bler_f */ + 24, /* blei_f */ 8, /* beqr_f */ - 20, /* beqi_f */ - 12, /* bger_f */ - 24, /* bgei_f */ + 20, /* beqi_f */ + 12, /* bger_f */ + 24, /* bgei_f */ 8, /* bgtr_f */ - 20, /* bgti_f */ + 20, /* bgti_f */ 8, /* bner_f */ - 20, /* bnei_f */ - 12, /* bunltr_f */ - 24, /* bunlti_f */ + 20, /* bnei_f */ + 12, /* bunltr_f */ + 24, /* bunlti_f */ 8, /* bunler_f */ - 20, /* bunlei_f */ - 12, /* buneqr_f */ - 24, /* buneqi_f */ + 20, /* bunlei_f */ + 12, /* buneqr_f */ + 24, /* buneqi_f */ 8, /* bunger_f */ - 20, /* bungei_f */ - 12, /* bungtr_f */ - 24, /* bungti_f */ - 12, /* bltgtr_f */ - 24, /* bltgti_f */ + 20, /* bungei_f */ + 12, /* bungtr_f */ + 24, /* bungti_f */ + 12, /* bltgtr_f */ + 24, /* bltgti_f */ 8, /* bordr_f */ - 20, /* bordi_f */ + 20, /* bordi_f */ 8, /* bunordr_f */ - 20, /* bunordi_f */ + 20, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -812,105 +908,167 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 24, /* addi_d */ + 24, /* addi_d */ 4, /* subr_d */ - 24, /* subi_d */ - 24, /* rsbi_d */ + 24, /* subi_d */ + 24, /* rsbi_d */ 4, /* mulr_d */ - 24, /* muli_d */ + 24, /* muli_d */ 4, /* divr_d */ - 24, /* divi_d */ + 24, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 12, /* ltr_d */ - 32, /* lti_d */ - 16, /* ler_d */ - 36, /* lei_d */ - 12, /* eqr_d */ - 32, /* eqi_d */ - 16, /* ger_d */ - 36, /* gei_d */ - 12, /* gtr_d */ - 32, /* gti_d */ - 16, /* ner_d */ - 36, /* nei_d */ - 16, /* unltr_d */ - 36, /* unlti_d */ - 16, /* unler_d */ - 36, /* unlei_d */ - 16, /* uneqr_d */ - 36, /* uneqi_d */ - 16, /* unger_d */ - 36, /* ungei_d */ - 16, /* ungtr_d */ - 36, /* ungti_d */ - 16, /* ltgtr_d */ - 36, /* ltgti_d */ - 16, /* ordr_d */ - 36, /* ordi_d */ - 12, /* unordr_d */ - 32, /* unordi_d */ - 12, /* truncr_d_i */ + 0, /* sqrti_d */ + 12, /* ltr_d */ + 32, /* lti_d */ + 16, /* ler_d */ + 36, /* lei_d */ + 12, /* eqr_d */ + 32, /* eqi_d */ + 16, /* ger_d */ + 36, /* gei_d */ + 12, /* gtr_d */ + 32, /* gti_d */ + 16, /* ner_d */ + 36, /* nei_d */ + 16, /* unltr_d */ + 36, /* unlti_d */ + 16, /* unler_d */ + 36, /* unlei_d */ + 16, /* uneqr_d */ + 36, /* uneqi_d */ + 16, /* unger_d */ + 36, /* ungei_d */ + 16, /* ungtr_d */ + 36, /* ungti_d */ + 16, /* ltgtr_d */ + 36, /* ltgti_d */ + 16, /* ordr_d */ + 36, /* ordi_d */ + 12, /* unordr_d */ + 32, /* unordi_d */ + 12, /* truncr_d_i */ 0, /* truncr_d_l */ - 36, /* extr_d */ + 36, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 28, /* movi_d */ + 28, /* movi_d */ 4, /* ldr_d */ 8, /* ldi_d */ 4, /* ldxr_d */ - 12, /* ldxi_d */ + 12, /* ldxi_d */ 4, /* str_d */ 8, /* sti_d */ 4, /* stxr_d */ - 12, /* stxi_d */ + 12, /* stxi_d */ 8, /* bltr_d */ - 28, /* blti_d */ - 12, /* bler_d */ - 32, /* blei_d */ + 28, /* blti_d */ + 12, /* bler_d */ + 32, /* blei_d */ 8, /* beqr_d */ - 32, /* beqi_d */ - 12, /* bger_d */ - 32, /* bgei_d */ + 32, /* beqi_d */ + 12, /* bger_d */ + 32, /* bgei_d */ 8, /* bgtr_d */ - 28, /* bgti_d */ + 28, /* bgti_d */ 8, /* bner_d */ - 28, /* bnei_d */ - 12, /* bunltr_d */ - 32, /* bunlti_d */ + 28, /* bnei_d */ + 12, /* bunltr_d */ + 32, /* bunlti_d */ 8, /* bunler_d */ - 28, /* bunlei_d */ - 12, /* buneqr_d */ - 32, /* buneqi_d */ + 28, /* bunlei_d */ + 12, /* buneqr_d */ + 32, /* buneqi_d */ 8, /* bunger_d */ - 28, /* bungei_d */ - 12, /* bungtr_d */ - 32, /* bungti_d */ - 12, /* bltgtr_d */ - 32, /* bltgti_d */ + 28, /* bungei_d */ + 12, /* bungtr_d */ + 32, /* bungti_d */ + 12, /* bltgtr_d */ + 32, /* bltgti_d */ 8, /* bordr_d */ - 28, /* bordi_d */ + 28, /* bordi_d */ 8, /* bunordr_d */ - 28, /* bunordi_d */ + 28, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 8, /* movr_w_f */ + 12, /* movi_w_f */ + 12, /* movr_ww_d */ + 20, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 8, /* movr_f_w */ + 4, /* movi_f_w */ + 12, /* movr_d_ww */ + 8, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 136, /* cto */ - 132, /* ctz */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 32, /* ctor */ + 4, /* ctoi */ + 28, /* ctzr */ + 4, /* ctzi */ + 56, /* rbitr */ + 8, /* rbiti */ + 20, /* popcntr */ + 4, /* popcnti */ + 4, /* lrotr */ + 4, /* lroti */ + 12, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 56, /* qlshr_u */ + 8, /* qlshi_u */ + 56, /* qrshr */ + 8, /* qrshi */ + 56, /* qrshr_u */ + 8, /* qrshi_u */ + 68, /* unldr */ + 32, /* unldi */ + 68, /* unldr_u */ + 32, /* unldi_u */ + 68, /* unstr */ + 32, /* unsti */ + 140, /* unldr_x */ + 68, /* unldi_x */ + 152, /* unstr_x */ + 76, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 12, /* hmuli */ + 4, /* hmulr_u */ + 12, /* hmuli_u */ #endif /* _CALL_SYSV */ #endif /* __BYTE_ORDER */ #endif /* __powerpc__ */ @@ -919,10 +1077,10 @@ #if __WORDSIZE == 64 #if defined(__powerpc__) #if __BYTE_ORDER == __BIG_ENDIAN -#define JIT_INSTR_MAX 236 +#define JIT_INSTR_MAX 176 0, /* data */ 0, /* live */ - 28, /* align */ + 28, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -964,42 +1122,42 @@ 8, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 28, /* addi */ + 28, /* addi */ 4, /* addcr */ - 28, /* addci */ + 28, /* addci */ 4, /* addxr */ 8, /* addxi */ 4, /* subr */ - 28, /* subi */ + 28, /* subi */ 4, /* subcr */ - 28, /* subci */ + 28, /* subci */ 4, /* subxr */ 8, /* subxi */ - 44, /* rsbi */ + 44, /* rsbi */ 4, /* mulr */ - 28, /* muli */ - 12, /* qmulr */ - 28, /* qmuli */ - 12, /* qmulr_u */ - 28, /* qmuli_u */ + 28, /* muli */ + 12, /* qmulr */ + 28, /* qmuli */ + 12, /* qmulr_u */ + 28, /* qmuli_u */ 4, /* divr */ - 28, /* divi */ + 28, /* divi */ 4, /* divr_u */ - 28, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ - 12, /* remr */ - 36, /* remi */ - 12, /* remr_u */ - 36, /* remi_u */ + 28, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ + 12, /* remr */ + 36, /* remi */ + 12, /* remr_u */ + 36, /* remi_u */ 4, /* andr */ - 28, /* andi */ + 28, /* andi */ 4, /* orr */ - 28, /* ori */ + 28, /* ori */ 4, /* xorr */ - 28, /* xori */ + 28, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -1007,99 +1165,113 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 12, /* ltr */ - 12, /* lti */ - 12, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 12, /* eqr */ - 12, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 12, /* gtr */ - 12, /* gti */ - 12, /* gtr_u */ - 12, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 12, /* ltr */ + 12, /* lti */ + 12, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 12, /* eqr */ + 12, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 12, /* gtr */ + 12, /* gti */ + 12, /* gtr_u */ + 12, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ - 36, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 36, /* casr */ - 44, /* casi */ + 36, /* movi */ + 12, /* movnr */ + 12, /* movzr */ + 36, /* casr */ + 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 4, /* extr_i */ + 4, /* exti_i */ 4, /* extr_ui */ + 16, /* exti_ui */ 8, /* bswapr_us */ - 16, /* bswapr_ui */ - 44, /* bswapr_ul */ + 4, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ + 44, /* bswapr_ul */ + 36, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 4, /* htonr_ul */ + 36, /* htoni_ul */ 8, /* ldr_c */ - 28, /* ldi_c */ + 28, /* ldi_c */ 4, /* ldr_uc */ - 24, /* ldi_uc */ + 24, /* ldi_uc */ 4, /* ldr_s */ - 24, /* ldi_s */ + 24, /* ldi_s */ 4, /* ldr_us */ - 24, /* ldi_us */ + 24, /* ldi_us */ 4, /* ldr_i */ - 24, /* ldi_i */ + 24, /* ldi_i */ 4, /* ldr_ui */ - 24, /* ldi_ui */ + 24, /* ldi_ui */ 4, /* ldr_l */ - 24, /* ldi_l */ + 24, /* ldi_l */ 8, /* ldxr_c */ - 16, /* ldxi_c */ + 16, /* ldxi_c */ 4, /* ldxr_uc */ - 12, /* ldxi_uc */ + 12, /* ldxi_uc */ 4, /* ldxr_s */ - 12, /* ldxi_s */ + 12, /* ldxi_s */ 4, /* ldxr_us */ - 12, /* ldxi_us */ + 12, /* ldxi_us */ 4, /* ldxr_i */ - 12, /* ldxi_i */ + 12, /* ldxi_i */ 4, /* ldxr_ui */ - 12, /* ldxi_ui */ + 12, /* ldxi_ui */ 4, /* ldxr_l */ - 12, /* ldxi_l */ + 12, /* ldxi_l */ 4, /* str_c */ - 24, /* sti_c */ + 24, /* sti_c */ 4, /* str_s */ - 24, /* sti_s */ + 24, /* sti_s */ 4, /* str_i */ - 24, /* sti_i */ + 24, /* sti_i */ 4, /* str_l */ - 24, /* sti_l */ + 24, /* sti_l */ 4, /* stxr_c */ - 12, /* stxi_c */ + 12, /* stxi_c */ 4, /* stxr_s */ - 12, /* stxi_s */ + 12, /* stxi_s */ 4, /* stxr_i */ - 12, /* stxi_i */ + 12, /* stxi_i */ 4, /* stxr_l */ - 12, /* stxi_l */ + 12, /* stxi_l */ 8, /* bltr */ 8, /* blti */ 8, /* bltr_u */ - 12, /* blti_u */ + 12, /* blti_u */ 8, /* bler */ 8, /* blei */ 8, /* bler_u */ - 12, /* blei_u */ + 12, /* blei_u */ 8, /* beqr */ - 44, /* beqi */ + 44, /* beqi */ 8, /* bger */ 8, /* bgei */ 8, /* bger_u */ @@ -1109,31 +1281,31 @@ 8, /* bgtr_u */ 8, /* bgti_u */ 8, /* bner */ - 36, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 16, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 16, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 16, /* bosubi */ - 12, /* bosubr_u */ - 16, /* bosubi_u */ - 12, /* bxsubr */ - 16, /* bxsubi */ - 12, /* bxsubr_u */ - 16, /* bxsubi_u */ + 44, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 16, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 16, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 16, /* bosubi */ + 12, /* bosubr_u */ + 16, /* bosubi_u */ + 12, /* bxsubr */ + 16, /* bxsubi */ + 12, /* bxsubr_u */ + 16, /* bxsubi_u */ 8, /* jmpr */ 4, /* jmpi */ - 28, /* callr */ - 52, /* calli */ + 28, /* callr */ + 52, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -1179,87 +1351,90 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 28, /* addi_f */ + 28, /* addi_f */ 4, /* subr_f */ - 28, /* subi_f */ - 28, /* rsbi_f */ + 28, /* subi_f */ + 28, /* rsbi_f */ 4, /* mulr_f */ - 28, /* muli_f */ + 28, /* muli_f */ 4, /* divr_f */ - 28, /* divi_f */ + 28, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 12, /* ltr_f */ - 36, /* lti_f */ - 16, /* ler_f */ - 40, /* lei_f */ - 12, /* eqr_f */ - 36, /* eqi_f */ - 16, /* ger_f */ - 40, /* gei_f */ - 12, /* gtr_f */ - 36, /* gti_f */ - 16, /* ner_f */ - 40, /* nei_f */ - 16, /* unltr_f */ - 40, /* unlti_f */ - 16, /* unler_f */ - 40, /* unlei_f */ - 16, /* uneqr_f */ - 40, /* uneqi_f */ - 16, /* unger_f */ - 40, /* ungei_f */ - 16, /* ungtr_f */ - 40, /* ungti_f */ - 16, /* ltgtr_f */ - 40, /* ltgti_f */ - 16, /* ordr_f */ - 40, /* ordi_f */ - 12, /* unordr_f */ - 36, /* unordi_f */ - 12, /* truncr_f_i */ - 12, /* truncr_f_l */ - 12, /* extr_f */ + 0, /* sqrti_f */ + 12, /* ltr_f */ + 36, /* lti_f */ + 16, /* ler_f */ + 40, /* lei_f */ + 12, /* eqr_f */ + 36, /* eqi_f */ + 16, /* ger_f */ + 40, /* gei_f */ + 12, /* gtr_f */ + 36, /* gti_f */ + 16, /* ner_f */ + 40, /* nei_f */ + 16, /* unltr_f */ + 40, /* unlti_f */ + 16, /* unler_f */ + 40, /* unlei_f */ + 16, /* uneqr_f */ + 40, /* uneqi_f */ + 16, /* unger_f */ + 40, /* ungei_f */ + 16, /* ungtr_f */ + 40, /* ungti_f */ + 16, /* ltgtr_f */ + 40, /* ltgti_f */ + 16, /* ordr_f */ + 40, /* ordi_f */ + 12, /* unordr_f */ + 36, /* unordi_f */ + 12, /* truncr_f_i */ + 12, /* truncr_f_l */ + 12, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 24, /* movi_f */ + 24, /* movi_f */ 4, /* ldr_f */ - 24, /* ldi_f */ + 24, /* ldi_f */ 4, /* ldxr_f */ - 12, /* ldxi_f */ + 12, /* ldxi_f */ 4, /* str_f */ - 24, /* sti_f */ + 24, /* sti_f */ 4, /* stxr_f */ - 12, /* stxi_f */ + 12, /* stxi_f */ 8, /* bltr_f */ - 32, /* blti_f */ - 12, /* bler_f */ - 36, /* blei_f */ + 32, /* blti_f */ + 12, /* bler_f */ + 36, /* blei_f */ 8, /* beqr_f */ - 32, /* beqi_f */ - 12, /* bger_f */ - 36, /* bgei_f */ + 32, /* beqi_f */ + 12, /* bger_f */ + 36, /* bgei_f */ 8, /* bgtr_f */ - 32, /* bgti_f */ + 32, /* bgti_f */ 8, /* bner_f */ - 32, /* bnei_f */ - 12, /* bunltr_f */ - 36, /* bunlti_f */ + 32, /* bnei_f */ + 12, /* bunltr_f */ + 36, /* bunlti_f */ 8, /* bunler_f */ - 32, /* bunlei_f */ - 12, /* buneqr_f */ - 36, /* buneqi_f */ + 32, /* bunlei_f */ + 12, /* buneqr_f */ + 36, /* buneqi_f */ 8, /* bunger_f */ - 32, /* bungei_f */ - 12, /* bungtr_f */ - 36, /* bungti_f */ - 12, /* bltgtr_f */ - 36, /* bltgti_f */ + 32, /* bungei_f */ + 12, /* bungtr_f */ + 36, /* bungti_f */ + 12, /* bltgtr_f */ + 36, /* bltgti_f */ 8, /* bordr_f */ - 32, /* bordi_f */ + 32, /* bordi_f */ 8, /* bunordr_f */ - 32, /* bunordi_f */ + 32, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -1270,105 +1445,167 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 28, /* addi_d */ + 28, /* addi_d */ 4, /* subr_d */ - 28, /* subi_d */ - 32, /* rsbi_d */ + 28, /* subi_d */ + 32, /* rsbi_d */ 4, /* mulr_d */ - 28, /* muli_d */ + 28, /* muli_d */ 4, /* divr_d */ - 28, /* divi_d */ + 28, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 12, /* ltr_d */ - 40, /* lti_d */ - 16, /* ler_d */ - 44, /* lei_d */ - 12, /* eqr_d */ - 40, /* eqi_d */ - 16, /* ger_d */ - 44, /* gei_d */ - 12, /* gtr_d */ - 40, /* gti_d */ - 16, /* ner_d */ - 44, /* nei_d */ - 16, /* unltr_d */ - 44, /* unlti_d */ - 16, /* unler_d */ - 44, /* unlei_d */ - 16, /* uneqr_d */ - 44, /* uneqi_d */ - 16, /* unger_d */ - 44, /* ungei_d */ - 16, /* ungtr_d */ - 44, /* ungti_d */ - 16, /* ltgtr_d */ - 44, /* ltgti_d */ - 16, /* ordr_d */ - 44, /* ordi_d */ - 12, /* unordr_d */ - 40, /* unordi_d */ - 12, /* truncr_d_i */ - 12, /* truncr_d_l */ - 12, /* extr_d */ + 0, /* sqrti_d */ + 12, /* ltr_d */ + 40, /* lti_d */ + 16, /* ler_d */ + 44, /* lei_d */ + 12, /* eqr_d */ + 40, /* eqi_d */ + 16, /* ger_d */ + 44, /* gei_d */ + 12, /* gtr_d */ + 40, /* gti_d */ + 16, /* ner_d */ + 44, /* nei_d */ + 16, /* unltr_d */ + 44, /* unlti_d */ + 16, /* unler_d */ + 44, /* unlei_d */ + 16, /* uneqr_d */ + 44, /* uneqi_d */ + 16, /* unger_d */ + 44, /* ungei_d */ + 16, /* ungtr_d */ + 44, /* ungti_d */ + 16, /* ltgtr_d */ + 44, /* ltgti_d */ + 16, /* ordr_d */ + 44, /* ordi_d */ + 12, /* unordr_d */ + 40, /* unordi_d */ + 12, /* truncr_d_i */ + 12, /* truncr_d_l */ + 12, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 32, /* movi_d */ + 32, /* movi_d */ 4, /* ldr_d */ - 24, /* ldi_d */ + 24, /* ldi_d */ 4, /* ldxr_d */ - 12, /* ldxi_d */ + 12, /* ldxi_d */ 4, /* str_d */ - 24, /* sti_d */ + 24, /* sti_d */ 4, /* stxr_d */ - 12, /* stxi_d */ + 12, /* stxi_d */ 8, /* bltr_d */ - 32, /* blti_d */ - 12, /* bler_d */ - 36, /* blei_d */ + 32, /* blti_d */ + 12, /* bler_d */ + 36, /* blei_d */ 8, /* beqr_d */ - 40, /* beqi_d */ - 12, /* bger_d */ - 40, /* bgei_d */ + 40, /* beqi_d */ + 12, /* bger_d */ + 40, /* bgei_d */ 8, /* bgtr_d */ - 36, /* bgti_d */ + 36, /* bgti_d */ 8, /* bner_d */ - 36, /* bnei_d */ - 12, /* bunltr_d */ - 36, /* bunlti_d */ + 36, /* bnei_d */ + 12, /* bunltr_d */ + 36, /* bunlti_d */ 8, /* bunler_d */ - 32, /* bunlei_d */ - 12, /* buneqr_d */ - 36, /* buneqi_d */ + 32, /* bunlei_d */ + 12, /* buneqr_d */ + 36, /* buneqi_d */ 8, /* bunger_d */ - 36, /* bungei_d */ - 12, /* bungtr_d */ - 40, /* bungti_d */ - 12, /* bltgtr_d */ - 40, /* bltgti_d */ + 36, /* bungei_d */ + 12, /* bungtr_d */ + 40, /* bungti_d */ + 12, /* bltgtr_d */ + 40, /* bltgti_d */ 8, /* bordr_d */ - 36, /* bordi_d */ + 36, /* bordi_d */ 8, /* bunordr_d */ - 32, /* bunordi_d */ + 32, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 8, /* movr_w_f */ + 12, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 8, /* movr_w_d */ + 16, /* movi_w_d */ + 8, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 236, /* cto */ - 232, /* ctz */ + 8, /* movr_d_w */ + 8, /* movi_d_w */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 32, /* ctor */ + 4, /* ctoi */ + 28, /* ctzr */ + 4, /* ctzi */ + 68, /* rbitr */ + 36, /* rbiti */ + 36, /* popcntr */ + 4, /* popcnti */ + 4, /* lrotr */ + 4, /* lroti */ + 12, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 56, /* qlshr_u */ + 8, /* qlshi_u */ + 56, /* qrshr */ + 8, /* qrshi */ + 56, /* qrshr_u */ + 8, /* qrshi_u */ + 72, /* unldr */ + 64, /* unldi */ + 72, /* unldr_u */ + 64, /* unldi_u */ + 168, /* unstr */ + 108, /* unsti */ + 76, /* unldr_x */ + 72, /* unldi_x */ + 176, /* unstr_x */ + 116, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 24, /* hmuli */ + 4, /* hmulr_u */ + 24, /* hmuli_u */ #endif /* __BYTE_ORDER */ #endif /* __powerpc__ */ #endif /* __WORDSIZE */ @@ -1376,10 +1613,10 @@ #if __WORDSIZE == 64 #if defined(__powerpc__) #if __BYTE_ORDER == __LITTLE_ENDIAN -#define JIT_INSTR_MAX 236 +#define JIT_INSTR_MAX 176 0, /* data */ 0, /* live */ - 20, /* align */ + 20, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -1421,42 +1658,42 @@ 8, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 28, /* addi */ + 28, /* addi */ 4, /* addcr */ - 28, /* addci */ + 28, /* addci */ 4, /* addxr */ 8, /* addxi */ 4, /* subr */ - 28, /* subi */ + 28, /* subi */ 4, /* subcr */ - 28, /* subci */ + 28, /* subci */ 4, /* subxr */ 8, /* subxi */ - 44, /* rsbi */ + 44, /* rsbi */ 4, /* mulr */ - 28, /* muli */ - 12, /* qmulr */ - 28, /* qmuli */ - 12, /* qmulr_u */ - 28, /* qmuli_u */ + 28, /* muli */ + 12, /* qmulr */ + 28, /* qmuli */ + 12, /* qmulr_u */ + 28, /* qmuli_u */ 4, /* divr */ - 28, /* divi */ + 28, /* divi */ 4, /* divr_u */ - 28, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ - 12, /* remr */ - 36, /* remi */ - 12, /* remr_u */ - 36, /* remi_u */ + 28, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ + 12, /* remr */ + 36, /* remi */ + 12, /* remr_u */ + 36, /* remi_u */ 4, /* andr */ - 28, /* andi */ + 28, /* andi */ 4, /* orr */ - 28, /* ori */ + 28, /* ori */ 4, /* xorr */ - 28, /* xori */ + 28, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -1464,99 +1701,113 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 12, /* ltr */ - 12, /* lti */ - 12, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 12, /* eqr */ - 12, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 12, /* gtr */ - 12, /* gti */ - 12, /* gtr_u */ - 12, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 12, /* ltr */ + 12, /* lti */ + 12, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 12, /* eqr */ + 12, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 12, /* gtr */ + 12, /* gti */ + 12, /* gtr_u */ + 12, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ - 36, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 36, /* casr */ - 44, /* casi */ + 36, /* movi */ + 12, /* movnr */ + 12, /* movzr */ + 36, /* casr */ + 44, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 4, /* extr_i */ + 4, /* exti_i */ 4, /* extr_ui */ + 16, /* exti_ui */ 8, /* bswapr_us */ - 16, /* bswapr_ui */ - 44, /* bswapr_ul */ + 4, /* bswapi_us */ + 16, /* bswapr_ui */ + 8, /* bswapi_ui */ + 44, /* bswapr_ul */ + 36, /* bswapi_ul */ 8, /* htonr_us */ - 16, /* htonr_ui */ - 44, /* htonr_ul */ + 8, /* htoni_us */ + 16, /* htonr_ui */ + 8, /* htoni_ui */ + 44, /* htonr_ul */ + 36, /* htoni_ul */ 8, /* ldr_c */ - 28, /* ldi_c */ + 28, /* ldi_c */ 4, /* ldr_uc */ - 24, /* ldi_uc */ + 24, /* ldi_uc */ 4, /* ldr_s */ - 24, /* ldi_s */ + 24, /* ldi_s */ 4, /* ldr_us */ - 24, /* ldi_us */ + 24, /* ldi_us */ 4, /* ldr_i */ - 24, /* ldi_i */ + 24, /* ldi_i */ 4, /* ldr_ui */ - 24, /* ldi_ui */ + 24, /* ldi_ui */ 4, /* ldr_l */ - 24, /* ldi_l */ + 24, /* ldi_l */ 8, /* ldxr_c */ - 16, /* ldxi_c */ + 16, /* ldxi_c */ 4, /* ldxr_uc */ - 12, /* ldxi_uc */ + 12, /* ldxi_uc */ 4, /* ldxr_s */ - 12, /* ldxi_s */ + 12, /* ldxi_s */ 4, /* ldxr_us */ - 12, /* ldxi_us */ + 12, /* ldxi_us */ 4, /* ldxr_i */ - 12, /* ldxi_i */ + 12, /* ldxi_i */ 4, /* ldxr_ui */ - 12, /* ldxi_ui */ + 12, /* ldxi_ui */ 4, /* ldxr_l */ - 12, /* ldxi_l */ + 12, /* ldxi_l */ 4, /* str_c */ - 24, /* sti_c */ + 24, /* sti_c */ 4, /* str_s */ - 24, /* sti_s */ + 24, /* sti_s */ 4, /* str_i */ - 24, /* sti_i */ + 24, /* sti_i */ 4, /* str_l */ - 24, /* sti_l */ + 24, /* sti_l */ 4, /* stxr_c */ - 12, /* stxi_c */ + 12, /* stxi_c */ 4, /* stxr_s */ - 12, /* stxi_s */ + 12, /* stxi_s */ 4, /* stxr_i */ - 12, /* stxi_i */ + 12, /* stxi_i */ 4, /* stxr_l */ - 12, /* stxi_l */ + 12, /* stxi_l */ 8, /* bltr */ 8, /* blti */ 8, /* bltr_u */ - 12, /* blti_u */ + 12, /* blti_u */ 8, /* bler */ 8, /* blei */ 8, /* bler_u */ - 12, /* blei_u */ + 12, /* blei_u */ 8, /* beqr */ - 44, /* beqi */ + 44, /* beqi */ 8, /* bger */ 8, /* bgei */ 8, /* bger_u */ @@ -1566,31 +1817,31 @@ 8, /* bgtr_u */ 8, /* bgti_u */ 8, /* bner */ - 36, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 16, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 16, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 16, /* bosubi */ - 12, /* bosubr_u */ - 16, /* bosubi_u */ - 12, /* bxsubr */ - 16, /* bxsubi */ - 12, /* bxsubr_u */ - 16, /* bxsubi_u */ + 44, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 16, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 16, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 16, /* bosubi */ + 12, /* bosubr_u */ + 16, /* bosubi_u */ + 12, /* bxsubr */ + 16, /* bxsubi */ + 12, /* bxsubr_u */ + 16, /* bxsubi_u */ 8, /* jmpr */ 4, /* jmpi */ - 12, /* callr */ - 32, /* calli */ + 12, /* callr */ + 32, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -1636,87 +1887,90 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 28, /* addi_f */ + 28, /* addi_f */ 4, /* subr_f */ - 28, /* subi_f */ - 28, /* rsbi_f */ + 28, /* subi_f */ + 28, /* rsbi_f */ 4, /* mulr_f */ - 28, /* muli_f */ + 28, /* muli_f */ 4, /* divr_f */ - 28, /* divi_f */ + 28, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 12, /* ltr_f */ - 36, /* lti_f */ - 16, /* ler_f */ - 40, /* lei_f */ - 12, /* eqr_f */ - 36, /* eqi_f */ - 16, /* ger_f */ - 40, /* gei_f */ - 12, /* gtr_f */ - 36, /* gti_f */ - 16, /* ner_f */ - 40, /* nei_f */ - 16, /* unltr_f */ - 40, /* unlti_f */ - 16, /* unler_f */ - 40, /* unlei_f */ - 16, /* uneqr_f */ - 40, /* uneqi_f */ - 16, /* unger_f */ - 40, /* ungei_f */ - 16, /* ungtr_f */ - 40, /* ungti_f */ - 16, /* ltgtr_f */ - 40, /* ltgti_f */ - 16, /* ordr_f */ - 40, /* ordi_f */ - 12, /* unordr_f */ - 36, /* unordi_f */ - 12, /* truncr_f_i */ - 12, /* truncr_f_l */ - 12, /* extr_f */ + 0, /* sqrti_f */ + 12, /* ltr_f */ + 36, /* lti_f */ + 16, /* ler_f */ + 40, /* lei_f */ + 12, /* eqr_f */ + 36, /* eqi_f */ + 16, /* ger_f */ + 40, /* gei_f */ + 12, /* gtr_f */ + 36, /* gti_f */ + 16, /* ner_f */ + 40, /* nei_f */ + 16, /* unltr_f */ + 40, /* unlti_f */ + 16, /* unler_f */ + 40, /* unlei_f */ + 16, /* uneqr_f */ + 40, /* uneqi_f */ + 16, /* unger_f */ + 40, /* ungei_f */ + 16, /* ungtr_f */ + 40, /* ungti_f */ + 16, /* ltgtr_f */ + 40, /* ltgti_f */ + 16, /* ordr_f */ + 40, /* ordi_f */ + 12, /* unordr_f */ + 36, /* unordi_f */ + 12, /* truncr_f_i */ + 12, /* truncr_f_l */ + 12, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 24, /* movi_f */ + 24, /* movi_f */ 4, /* ldr_f */ - 24, /* ldi_f */ + 24, /* ldi_f */ 4, /* ldxr_f */ - 12, /* ldxi_f */ + 12, /* ldxi_f */ 4, /* str_f */ - 24, /* sti_f */ + 24, /* sti_f */ 4, /* stxr_f */ - 12, /* stxi_f */ + 12, /* stxi_f */ 8, /* bltr_f */ - 32, /* blti_f */ - 12, /* bler_f */ - 36, /* blei_f */ + 32, /* blti_f */ + 12, /* bler_f */ + 36, /* blei_f */ 8, /* beqr_f */ - 32, /* beqi_f */ - 12, /* bger_f */ - 36, /* bgei_f */ + 32, /* beqi_f */ + 12, /* bger_f */ + 36, /* bgei_f */ 8, /* bgtr_f */ - 32, /* bgti_f */ + 32, /* bgti_f */ 8, /* bner_f */ - 32, /* bnei_f */ - 12, /* bunltr_f */ - 36, /* bunlti_f */ + 32, /* bnei_f */ + 12, /* bunltr_f */ + 36, /* bunlti_f */ 8, /* bunler_f */ - 32, /* bunlei_f */ - 12, /* buneqr_f */ - 36, /* buneqi_f */ + 32, /* bunlei_f */ + 12, /* buneqr_f */ + 36, /* buneqi_f */ 8, /* bunger_f */ - 32, /* bungei_f */ - 12, /* bungtr_f */ - 36, /* bungti_f */ - 12, /* bltgtr_f */ - 36, /* bltgti_f */ + 32, /* bungei_f */ + 12, /* bungtr_f */ + 36, /* bungti_f */ + 12, /* bltgtr_f */ + 36, /* bltgti_f */ 8, /* bordr_f */ - 32, /* bordi_f */ + 32, /* bordi_f */ 8, /* bunordr_f */ - 32, /* bunordi_f */ + 32, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -1727,105 +1981,167 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 28, /* addi_d */ + 28, /* addi_d */ 4, /* subr_d */ - 28, /* subi_d */ - 32, /* rsbi_d */ + 28, /* subi_d */ + 32, /* rsbi_d */ 4, /* mulr_d */ - 28, /* muli_d */ + 28, /* muli_d */ 4, /* divr_d */ - 28, /* divi_d */ + 28, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 12, /* ltr_d */ - 40, /* lti_d */ - 16, /* ler_d */ - 44, /* lei_d */ - 12, /* eqr_d */ - 40, /* eqi_d */ - 16, /* ger_d */ - 44, /* gei_d */ - 12, /* gtr_d */ - 40, /* gti_d */ - 16, /* ner_d */ - 44, /* nei_d */ - 16, /* unltr_d */ - 44, /* unlti_d */ - 16, /* unler_d */ - 44, /* unlei_d */ - 16, /* uneqr_d */ - 44, /* uneqi_d */ - 16, /* unger_d */ - 44, /* ungei_d */ - 16, /* ungtr_d */ - 44, /* ungti_d */ - 16, /* ltgtr_d */ - 44, /* ltgti_d */ - 16, /* ordr_d */ - 44, /* ordi_d */ - 12, /* unordr_d */ - 40, /* unordi_d */ - 12, /* truncr_d_i */ - 12, /* truncr_d_l */ - 12, /* extr_d */ + 0, /* sqrti_d */ + 12, /* ltr_d */ + 40, /* lti_d */ + 16, /* ler_d */ + 44, /* lei_d */ + 12, /* eqr_d */ + 40, /* eqi_d */ + 16, /* ger_d */ + 44, /* gei_d */ + 12, /* gtr_d */ + 40, /* gti_d */ + 16, /* ner_d */ + 44, /* nei_d */ + 16, /* unltr_d */ + 44, /* unlti_d */ + 16, /* unler_d */ + 44, /* unlei_d */ + 16, /* uneqr_d */ + 44, /* uneqi_d */ + 16, /* unger_d */ + 44, /* ungei_d */ + 16, /* ungtr_d */ + 44, /* ungti_d */ + 16, /* ltgtr_d */ + 44, /* ltgti_d */ + 16, /* ordr_d */ + 44, /* ordi_d */ + 12, /* unordr_d */ + 40, /* unordi_d */ + 12, /* truncr_d_i */ + 12, /* truncr_d_l */ + 12, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 32, /* movi_d */ + 32, /* movi_d */ 4, /* ldr_d */ - 24, /* ldi_d */ + 24, /* ldi_d */ 4, /* ldxr_d */ - 12, /* ldxi_d */ + 12, /* ldxi_d */ 4, /* str_d */ - 24, /* sti_d */ + 24, /* sti_d */ 4, /* stxr_d */ - 12, /* stxi_d */ + 12, /* stxi_d */ 8, /* bltr_d */ - 32, /* blti_d */ - 12, /* bler_d */ - 36, /* blei_d */ + 32, /* blti_d */ + 12, /* bler_d */ + 36, /* blei_d */ 8, /* beqr_d */ - 40, /* beqi_d */ - 12, /* bger_d */ - 40, /* bgei_d */ + 40, /* beqi_d */ + 12, /* bger_d */ + 40, /* bgei_d */ 8, /* bgtr_d */ - 36, /* bgti_d */ + 36, /* bgti_d */ 8, /* bner_d */ - 36, /* bnei_d */ - 12, /* bunltr_d */ - 36, /* bunlti_d */ + 36, /* bnei_d */ + 12, /* bunltr_d */ + 36, /* bunlti_d */ 8, /* bunler_d */ - 32, /* bunlei_d */ - 12, /* buneqr_d */ - 36, /* buneqi_d */ + 32, /* bunlei_d */ + 12, /* buneqr_d */ + 36, /* buneqi_d */ 8, /* bunger_d */ - 36, /* bungei_d */ - 12, /* bungtr_d */ - 40, /* bungti_d */ - 12, /* bltgtr_d */ - 40, /* bltgti_d */ + 36, /* bungei_d */ + 12, /* bungtr_d */ + 40, /* bungti_d */ + 12, /* bltgtr_d */ + 40, /* bltgti_d */ 8, /* bordr_d */ - 36, /* bordi_d */ + 36, /* bordi_d */ 8, /* bunordr_d */ - 32, /* bunordi_d */ + 32, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 8, /* movr_w_f */ + 12, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 8, /* movr_w_d */ + 16, /* movi_w_d */ + 8, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 8, /* clo */ - 4, /* clz */ - 236, /* cto */ - 232, /* ctz */ + 8, /* movr_d_w */ + 8, /* movi_d_w */ + 8, /* clor */ + 4, /* cloi */ + 4, /* clzr */ + 4, /* clzi */ + 32, /* ctor */ + 4, /* ctoi */ + 28, /* ctzr */ + 4, /* ctzi */ + 68, /* rbitr */ + 36, /* rbiti */ + 36, /* popcntr */ + 4, /* popcnti */ + 4, /* lrotr */ + 4, /* lroti */ + 12, /* rrotr */ + 4, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 4, /* extr_u */ + 4, /* exti_u */ + 4, /* depr */ + 8, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 56, /* qlshr_u */ + 8, /* qlshi_u */ + 56, /* qrshr */ + 8, /* qrshi */ + 56, /* qrshr_u */ + 8, /* qrshi_u */ + 76, /* unldr */ + 68, /* unldi */ + 76, /* unldr_u */ + 68, /* unldi_u */ + 168, /* unstr */ + 108, /* unsti */ + 76, /* unldr_x */ + 72, /* unldi_x */ + 176, /* unstr_x */ + 116, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 24, /* hmuli */ + 4, /* hmulr_u */ + 24, /* hmuli_u */ #endif /* __BYTE_ORDER */ #endif /* __powerpc__ */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_ppc.c b/deps/lightning/lib/jit_ppc.c index 869e876e..9f98176e 100644 --- a/deps/lightning/lib/jit_ppc.c +++ b/deps/lightning/lib/jit_ppc.c @@ -47,6 +47,15 @@ # define I_DISP (__WORDSIZE >> 3) - sizeof(jit_int32_t) # define F_DISP (__WORDSIZE >> 3) - sizeof(jit_float32_t) #endif +#define CVT_OFFSET _jitc->function->cvt_offset +#define CHECK_CVT_OFFSET() \ + do { \ + if (!_jitc->function->cvt_offset) { \ + _jitc->again = 1; \ + _jitc->function->cvt_offset = \ + jit_allocai(sizeof(jit_float64_t)); \ + } \ + } while (0) /* * Types @@ -97,6 +106,7 @@ extern void __clear_cache(void *, void *); #define PROTO 1 # include "jit_ppc-cpu.c" # include "jit_ppc-fpu.c" +# include "jit_fallback.c" #undef PROTO /* @@ -178,6 +188,15 @@ jit_register_t _rvs[] = { { _NOREG, "" }, }; +static jit_int32_t iregs[] = { + _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22, + _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30 +}; + +static jit_int32_t fregs[] = { + _F14, _F15, _F16, _F17, _F18, _F19, _F20, _F21, +}; + /* * Implementation */ @@ -213,6 +232,7 @@ _jit_prolog(jit_state_t *_jit) _jitc->function->self.argi = _jitc->function->self.argf = _jitc->function->self.alen = 0; /* float conversion */ + _jitc->function->cvt_offset = 0; _jitc->function->self.aoff = alloca_offset - 8; _jitc->function->self.call = jit_call_default; jit_alloc((jit_pointer_t *)&_jitc->function->regoff, @@ -239,6 +259,7 @@ jit_int32_t _jit_allocai(jit_state_t *_jit, jit_int32_t length) { assert(_jitc->function); + jit_check_frame(); switch (length) { case 0: case 1: break; case 2: _jitc->function->self.aoff &= -2; break; @@ -504,8 +525,10 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_c, u, v); if (jit_arg_reg_p(v->u.w)) jit_extr_c(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_c(u, JIT_FP, v->u.w + C_DISP); + } jit_dec_synth(); } @@ -516,8 +539,10 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_uc, u, v); if (jit_arg_reg_p(v->u.w)) jit_extr_uc(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_uc(u, JIT_FP, v->u.w + C_DISP); + } jit_dec_synth(); } @@ -528,8 +553,10 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_s, u, v); if (jit_arg_reg_p(v->u.w)) jit_extr_s(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_s(u, JIT_FP, v->u.w + S_DISP); + } jit_dec_synth(); } @@ -540,8 +567,10 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_us, u, v); if (jit_arg_reg_p(v->u.w)) jit_extr_us(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_us(u, JIT_FP, v->u.w + S_DISP); + } jit_dec_synth(); } @@ -557,8 +586,10 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_extr_i(u, JIT_RA0 - v->u.w); #endif } - else + else { + jit_check_frame(); jit_ldxi_i(u, JIT_FP, v->u.w + I_DISP); + } jit_dec_synth(); } @@ -570,8 +601,10 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_ui, u, v); if (jit_arg_reg_p(v->u.w)) jit_extr_ui(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_ui(u, JIT_FP, v->u.w + I_DISP); + } jit_dec_synth(); } @@ -582,8 +615,10 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_l, u, v); if (jit_arg_reg_p(v->u.w)) jit_movr(u, JIT_RA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_l(u, JIT_FP, v->u.w); + } jit_dec_synth(); } #endif @@ -595,8 +630,10 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v, jit_code_t code) jit_code_inc_synth_wp(code, u, v); if (jit_arg_reg_p(v->u.w)) jit_movr(JIT_RA0 - v->u.w, u); - else + else { + jit_check_frame(); jit_stxi(v->u.w, JIT_FP, u); + } jit_dec_synth(); } @@ -609,6 +646,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v, jit_code_t code) if (jit_arg_reg_p(v->u.w)) jit_movi(JIT_RA0 - v->u.w, u); else { + jit_check_frame(); regno = jit_get_reg(jit_class_gpr); jit_movi(regno, u); jit_stxi(v->u.w, JIT_FP, regno); @@ -624,8 +662,10 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_f, u, v); if (jit_arg_f_reg_p(v->u.w)) jit_movr_d(u, JIT_FA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_f(u, JIT_FP, v->u.w); + } jit_dec_synth(); } @@ -636,8 +676,10 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(putargr_f, u, v); if (jit_arg_f_reg_p(v->u.w)) jit_movr_d(JIT_FA0 - v->u.w, u); - else + else { + jit_check_frame(); jit_stxi_f(v->u.w, JIT_FP, u); + } jit_dec_synth(); } @@ -650,6 +692,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v) if (jit_arg_f_reg_p(v->u.w)) jit_movi_d(JIT_FA0 - v->u.w, u); else { + jit_check_frame(); regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); jit_stxi_f(v->u.w, JIT_FP, regno); @@ -665,8 +708,10 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(getarg_d, u, v); if (jit_arg_f_reg_p(v->u.w)) jit_movr_d(u, JIT_FA0 - v->u.w); - else + else { + jit_check_frame(); jit_ldxi_d(u, JIT_FP, v->u.w); + } jit_dec_synth(); } @@ -677,8 +722,10 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v) jit_inc_synth_wp(putargr_d, u, v); if (jit_arg_f_reg_p(v->u.w)) jit_movr_d(JIT_FA0 - v->u.w, u); - else + else { + jit_check_frame(); jit_stxi_d(v->u.w, JIT_FP, u); + } jit_dec_synth(); } @@ -691,6 +738,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v) if (jit_arg_f_reg_p(v->u.w)) jit_movi_d(JIT_FA0 - v->u.w, u); else { + jit_check_frame(); regno = jit_get_reg(jit_class_fpr); jit_movi_d(regno, u); jit_stxi_d(v->u.w, JIT_FP, regno); @@ -781,14 +829,14 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u) + 1 # endif )) { - /* use reserved 8 bytes area */ - jit_stxi_d(alloca_offset - 8, JIT_FP, u); - jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 8); + CHECK_CVT_OFFSET(); + jit_check_frame(); + jit_stxi_d(CVT_OFFSET, JIT_FP, u); + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, CVT_OFFSET); _jitc->function->call.argi++; # if __WORDSIZE == 32 jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 4); + CVT_OFFSET + 4); _jitc->function->call.argi++; # endif } @@ -838,14 +886,15 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u) + 1 # endif )) { - /* use reserved 8 bytes area */ - jit_stxi_d(alloca_offset - 8, JIT_FP, regno); + CHECK_CVT_OFFSET(); + jit_check_frame(); + jit_stxi_d(CVT_OFFSET, JIT_FP, regno); jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 8); + CVT_OFFSET); _jitc->function->call.argi++; # if __WORDSIZE == 32 jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 4); + CVT_OFFSET + 4); _jitc->function->call.argi++; # endif } @@ -893,14 +942,13 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u) + 1 # endif )) { - /* use reserved 8 bytes area */ - jit_stxi_d(alloca_offset - 8, JIT_FP, u); - jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 8); + CHECK_CVT_OFFSET(); + jit_check_frame(); + jit_stxi_d(CVT_OFFSET, JIT_FP, u); + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, CVT_OFFSET); _jitc->function->call.argi++; # if __WORDSIZE == 32 - jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 4); + jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, CVT_OFFSET + 4); _jitc->function->call.argi++; # endif } @@ -964,14 +1012,15 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u) + 1 # endif )) { - /* use reserved 8 bytes area */ - jit_stxi_d(alloca_offset - 8, JIT_FP, regno); + CHECK_CVT_OFFSET(); + jit_check_frame(); + jit_stxi_d(CVT_OFFSET, JIT_FP, regno); jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 8); + CVT_OFFSET); _jitc->function->call.argi++; # if __WORDSIZE == 32 jit_ldxi(JIT_RA0 - _jitc->function->call.argi, JIT_FP, - alloca_offset - 4); + CVT_OFFSET + 4); _jitc->function->call.argi++; # endif } @@ -1218,6 +1267,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1322,6 +1377,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1346,10 +1405,34 @@ _emit_code(jit_state_t *_jit) case_rrw(xor,); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1378,6 +1461,9 @@ _emit_code(jit_state_t *_jit) case_rr(clz,); case_rr(cto,); case_rr(ctz,); +#define rbitr(r0, r1) fallback_rbit(r0, r1) + case_rr(rbit,); + case_rr(popcnt,); case jit_code_casr: casr(rn(node->u.w), rn(node->v.w), rn(node->w.q.l), rn(node->w.q.h)); @@ -1502,6 +1588,22 @@ _emit_code(jit_state_t *_jit) case_rrr(ldx, _l); case_rrw(ldx, _l); #endif +#define unldr(r0, r1, i0) fallback_unldr(r0, r1, i0) + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi(r0, i0, i1) fallback_unldi(r0, i0, i1) + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; +#define unldr_u(r0, r1, i0) fallback_unldr_u(r0, r1, i0) + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_u(r0, i0, i1) fallback_unldi_u(r0, i0, i1) + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rrr(stx, _c); @@ -1520,6 +1622,14 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _l); case_wrr(stx, _l); #endif +#define unstr(r0, r1, i0) fallback_unstr(r0, r1, i0) + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti(i0, r0, i1) fallback_unsti(i0, r0, i1) + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert(node->flag & jit_flag_data); @@ -1530,6 +1640,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rrr(add, _f); case_rrf(add, _f, 32); case_rrr(sub, _f); @@ -1599,10 +1713,26 @@ _emit_code(jit_state_t *_jit) case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); +#define unldr_x(r0, r1, i0) fallback_unldr_x(r0, r1, i0) + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_x(r0, i0, i1) fallback_unldi_x(r0, i0, i1) + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); +#define unstr_x(r0, r1, i0) fallback_unstr_x(r0, r1, i0) + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti_x(i0, r0, i1) fallback_unsti_x(i0, r0, i1) + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _d); case jit_code_movi_d: assert(node->flag & jit_flag_data); @@ -1613,6 +1743,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rrr(add, _d); case_rrf(add, _d, 64); case_rrr(sub, _d); @@ -1687,6 +1821,7 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _d); case_wrr(stx, _d); case jit_code_jmpr: + jit_check_frame(); jmpr(rn(node->u.w)); break; case jit_code_jmpi: @@ -1710,8 +1845,10 @@ _emit_code(jit_state_t *_jit) patch(word, node); } } - else + else { + jit_check_frame(); jmpi(node->u.w); + } break; case jit_code_callr: #if _CALL_SYSV @@ -1723,11 +1860,13 @@ _emit_code(jit_state_t *_jit) # define xcalli_p(u, v) calli_p(u) # define xcalli(u, v) calli(u) #endif + jit_check_frame(); xcallr(rn(node->u.w), !!(node->flag & jit_flag_varargs)); break; case jit_code_calli: value = !!(node->flag & jit_flag_varargs); if (node->flag & jit_flag_node) { + _jitc->function->need_return = 1; temp = node->u.n; assert(temp->code == jit_code_label || temp->code == jit_code_epilog); @@ -1745,8 +1884,10 @@ _emit_code(jit_state_t *_jit) patch(word, node); } } - else + else { + jit_check_frame(); xcalli(node->u.w, value); + } break; case jit_code_prolog: _jitc->function = _jitc->functions.ptr + node->w.w; @@ -1801,10 +1942,15 @@ _emit_code(jit_state_t *_jit) * the reason of the undo. */ undo.func.self.aoff = _jitc->function->frame + _jitc->function->self.aoff; + undo.func.need_frame = _jitc->function->need_frame; + undo.func.need_stack = _jitc->function->need_stack; + undo.func.need_return = _jitc->function->need_return; jit_regset_set(&undo.func.regset, &_jitc->function->regset); /* allocar information also does not need to be undone */ undo.func.aoffoff = _jitc->function->aoffoff; undo.func.allocar = _jitc->function->allocar; + /* cvt_offset must also not be undone */ + undo.func.cvt_offset = _jitc->function->cvt_offset; memcpy(_jitc->function, &undo.func, sizeof(undo.func)); #if DEVEL_DISASSEMBLER prevw = undo.prevw; @@ -1821,6 +1967,49 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_movr_d_w: + movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; +#else + case jit_code_movr_ww_d: + movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movr_d_ww: + movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movi_d_ww: + assert(node->flag & jit_flag_data); + movi_d_ww(rn(node->u.w), rn(node->v.w), + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + break; +#endif case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1890,6 +2079,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); @@ -1926,6 +2186,7 @@ _emit_code(jit_state_t *_jit) #define CODE 1 # include "jit_ppc-cpu.c" # include "jit_ppc-fpu.c" +# include "jit_fallback.c" #undef CODE void diff --git a/deps/lightning/lib/jit_print.c b/deps/lightning/lib/jit_print.c index f3409fbb..1271360d 100644 --- a/deps/lightning/lib/jit_print.c +++ b/deps/lightning/lib/jit_print.c @@ -22,10 +22,12 @@ #if __WORDSIZE == 32 # define MININT 0x80000000 +# define INT_FMT "%d" # define DEC_FMT "%d" # define HEX_FMT "0x%x" #else # define MININT 0x8000000000000000 +# define INT_FMT "%d" # define DEC_FMT "%ld" # define HEX_FMT "0x%lx" #endif @@ -40,6 +42,7 @@ fprintf(print_stream, HEX_FMT, (jit_uword_t)value); \ } while (0) #define print_dec(value) fprintf(print_stream, DEC_FMT, value) +#define print_int(value) fprintf(print_stream, INT_FMT, value) #define print_flt(value) fprintf(print_stream, "%g", value) #define print_str(value) fprintf(print_stream, "%s", value) #define print_ptr(value) fprintf(print_stream, "%p", value) @@ -123,7 +126,8 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) value = jit_classify(node->code) & (jit_cc_a0_int|jit_cc_a0_flt|jit_cc_a0_dbl|jit_cc_a0_jmp| jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_arg| - jit_cc_a1_reg|jit_cc_a1_int|jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg| + jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a1_int| + jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg| jit_cc_a2_reg|jit_cc_a2_int|jit_cc_a2_flt|jit_cc_a2_dbl|jit_cc_a2_rlh); if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) || node->code == jit_code_finishr || @@ -219,21 +223,33 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) r_r_r: print_chr(' '); print_reg(node->u.w); print_chr(' '); print_reg(node->v.w); - print_chr(' '); print_reg(node->w.w); return; + print_chr(' '); print_reg(node->w.w); return; r_r_w: print_chr(' '); print_reg(node->u.w); print_chr(' '); print_reg(node->v.w); - print_chr(' '); print_hex(node->w.w); return; + print_chr(' '); print_hex(node->w.w); return; + r_w_w: + print_chr(' '); print_reg(node->u.w); + print_chr(' '); print_hex(node->v.w); + print_chr(' '); + if (node->code == jit_code_movi_ww_d) + print_hex(node->w.w); + else + print_dec(node->w.w); return; + w_r_w: + print_chr(' '); print_hex(node->u.w); + print_chr(' '); print_reg(node->v.w); + print_chr(' '); print_dec(node->w.w); return; q_r_r: print_str(" ("); print_reg(node->u.q.l); print_chr(' '); print_reg(node->u.q.h); print_str(") "); print_reg(node->v.w); - print_chr(' '); print_reg(node->w.w); return; + print_chr(' '); print_reg(node->w.w); return; q_r_w: print_str(" ("); print_reg(node->u.q.l); print_chr(' '); print_reg(node->u.q.h); print_str(") "); print_reg(node->v.w); - print_chr(' '); print_hex(node->w.w); return; + print_chr(' '); print_hex(node->w.w); return; r_r_q: print_chr(' '); print_reg(node->u.w); print_chr(' '); print_reg(node->v.w); @@ -246,6 +262,24 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) print_str(" ("); print_reg(node->w.q.l); print_chr(' '); print_reg(node->w.q.h); print_str(") "); return; + r_r_iq: + print_chr(' '); print_reg(node->u.w); + print_chr(' '); print_reg(node->v.w); + print_str(" ("); print_int(node->w.q.l); + print_chr(' '); print_int(node->w.q.h); + print_str(") "); return; + r_w_iq: + print_chr(' '); print_reg(node->u.w); + print_chr(' '); print_hex(node->v.w); + print_str(" ("); print_int(node->w.q.l); + print_chr(' '); print_int(node->w.q.h); + print_str(") "); return; + r_q_r: + print_chr(' '); print_reg(node->u.w); + print_str(" ("); print_reg(node->v.q.l); + print_chr(' '); print_reg(node->v.q.h); + print_str(") "); print_reg(node->w.w); + return; r_r_f: print_chr(' '); print_reg(node->u.w); print_chr(' '); print_reg(node->v.w); @@ -255,6 +289,16 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) else print_flt(node->w.f); return; + r_q_f: + print_chr(' '); print_reg(node->u.w); + print_str(" ("); print_reg(node->v.q.l); + print_chr(' '); print_reg(node->v.q.h); + print_str(") "); + if (node->flag & jit_flag_data) + print_flt(*(jit_float32_t *)node->w.n->u.w); + else + print_flt(node->w.f); + return; r_r_d: print_chr(' '); print_reg(node->u.w); print_chr(' '); print_reg(node->v.w); @@ -264,6 +308,16 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) else print_flt(node->w.d); return; + r_q_d: + print_chr(' '); print_reg(node->u.w); + print_str(" ("); print_reg(node->v.q.l); + print_chr(' '); print_reg(node->v.q.h); + print_str(") "); + if (node->flag & jit_flag_data) + print_flt(*(jit_float64_t *)node->w.n->u.w); + else + print_flt(node->w.d); + return; w_r_r: print_chr(' '); print_hex(node->u.w); print_chr(' '); print_reg(node->v.w); @@ -380,6 +434,10 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) goto r_r_r; case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int: goto r_r_w; + case jit_cc_a0_reg|jit_cc_a1_int|jit_cc_a2_int: + goto r_w_w; + case jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_int: + goto w_r_w; case jit_cc_a0_reg|jit_cc_a0_rlh| jit_cc_a1_reg|jit_cc_a2_reg: goto q_r_r; @@ -392,6 +450,10 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) case jit_cc_a0_reg|jit_cc_a1_int| jit_cc_a2_reg|jit_cc_a2_rlh: goto r_w_q; + case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_rlh: + goto r_r_iq; + case jit_cc_a0_reg|jit_cc_a1_int|jit_cc_a2_rlh: + goto r_w_iq; case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_flt: goto r_r_f; case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_dbl: @@ -406,6 +468,12 @@ _jit_print_node(jit_state_t *_jit, jit_node_t *node) goto n_r_f; case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_dbl: goto n_r_d; + case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_reg: + goto r_q_r; + case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_flt: + goto r_q_f; + case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_dbl: + goto r_q_d; default: abort(); } diff --git a/deps/lightning/lib/jit_riscv-cpu.c b/deps/lightning/lib/jit_riscv-cpu.c index 4fd35a8f..8d6115a8 100644 --- a/deps/lightning/lib/jit_riscv-cpu.c +++ b/deps/lightning/lib/jit_riscv-cpu.c @@ -18,6 +18,7 @@ */ #if PROTO +#define jit_unaligned_p() (jit_cpu.unaligned) #define _ZERO_REGNO 0 #define _RA_REGNO 1 #define _SP_REGNO 2 @@ -301,6 +302,12 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define mulr(r0, r1, r2) MUL(r0, r1, r2) # define muli(r0, r1, im) _muli(_jit, r0, r1, im) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0, r1, r2) MULH(r0, r1, r2) +# define hmuli(r0, r1, im) _hmuli(_jit, r0, r1, im) +static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr_u(r0, r1, r2) MULHU(r0, r1, r2) +# define hmuli_u(r0, r1, im) _hmuli_u(_jit, r0, r1, im) +static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # define divr(r0, r1, r2) DIV(r0, r1, r2) # define divi(r0, r1, im) _divi(_jit, r0, r1, im) static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); @@ -402,6 +409,14 @@ static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ldxi_l(r0, r1, im) _ldxi_l(_jit, r0, r1, im) static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0) +static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1) +static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0) +static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1) +static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_c(r0, r1) SB(r0, r1, 0) # define sti_c(im, r0) _sti_c(_jit, im, r0) static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t); @@ -430,6 +445,10 @@ static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1) static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0) +static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1) +static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1) # define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1) # define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1) @@ -925,6 +944,26 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) jit_unget_reg(t0); } +static void +_hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + hmulr(r0, r1, rn(t0)); + jit_unget_reg(t0); +} + +static void +_hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + hmulr_u(r0, r1, rn(t0)); + jit_unget_reg(t0); +} + static void _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -1201,6 +1240,44 @@ DEFLD(i,W) DEFLD(ui,WU) DEFLD(l,D) +static void +_unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr(r0, r1, i0); + else + generic_unldr(r0, r1, i0); +} + +static void +_unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi(r0, i0, i1); + else + generic_unldi(r0, i0, i1); +} + +static void +_unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_u(r0, r1, i0); + else + generic_unldr_u(r0, r1, i0); +} + +static void +_unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + if (jit_unaligned_p()) + fallback_unldi_u(r0, i0, i1); + else + generic_unldi_u(r0, i0, i1); +} + # define DEFST(T, O) \ static void \ _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) \ @@ -1245,6 +1322,24 @@ DEFST(s, H) DEFST(i, W) DEFST(l, D) +static void +_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr(r0, r1, i0); + else + generic_unstr(r0, r1, i0); +} + +static void +_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti(i0, r0, i1); + else + generic_unsti(i0, r0, i1); +} + static void _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_riscv-fpu.c b/deps/lightning/lib/jit_riscv-fpu.c index 89346e08..bfe64fc4 100644 --- a/deps/lightning/lib/jit_riscv-fpu.c +++ b/deps/lightning/lib/jit_riscv-fpu.c @@ -127,6 +127,10 @@ static void _divi_f(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float32_t); # define absr_f(r0, r1) FABS_S(r0, r1) # define negr_f(r0, r1) FNEG_S(r0, r1) # define sqrtr_f(r0, r1) FSQRT_S(r0, r1) +# define fmar_f(r0, r1, r2, r3) FMADD_S(r0, r1, r2, r3) +# define fmsr_f(r0, r1, r2, r3) FMSUB_S(r0, r1, r2, r3) +# define fnmar_f(r0, r1, r2, r3) FNMADD_S(r0, r1, r2, r3) +# define fnmsr_f(r0, r1, r2, r3) FNMSUB_S(r0, r1, r2, r3) # define extr_f(r0, r1) FCVT_S_L(r0, r1) # define ldr_f(r0, r1) FLW(r0, r1, 0) # define ldi_f(r0, im) _ldi_f(_jit, r0, im) @@ -135,6 +139,10 @@ static void _ldi_f(jit_state_t*, jit_int32_t, jit_word_t); static void _ldxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0) static void _ldxi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldr_x(r0, r1, i0) _unldr_x(_jit, r0, r1, i0) +static void _unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define unldi_x(r0, i0, i1) _unldi_x(_jit, r0, i0, i1) +static void _unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define str_f(r0, r1) FSW(r0, r1, 0) # define sti_f(im, r0) _sti_f(_jit, im, r0) static void _sti_f(jit_state_t*, jit_word_t, jit_int32_t); @@ -142,13 +150,17 @@ static void _sti_f(jit_state_t*, jit_word_t, jit_int32_t); static void _stxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define stxi_f(im, r0, r1) _stxi_f(_jit, im, r0, r1) static void _stxi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); +#define unstr_x(r0, r1, i0) _unstr_x(_jit, r0, r1, i0) +static void _unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define unsti_x(i0, r0, i1) _unsti_x(_jit, i0, r0, i1) +static void _unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define movr_f(r0, r1) FMV_S(r0, r1) # define movi_f(r0, im) _movi_f(_jit, r0, im) static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t); # define movr_f_w(r0, r1) FMV_X_W(r0, r1) -# define movi_f_w(r0, im) _movi_f_w(_jit, r0, im) -static void _movi_f_w(jit_state_t*, jit_int32_t, jit_float32_t); # define movr_w_f(r0, r1) FMV_W_X(r0, r1) +# define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define extr_d_f(r0, r1) FCVT_S_D(r0, r1) # define ltr_f(r0, r1, r2) FLT_S(r0, r1, r2) # define lti_f(r0, r1, im) _lti_f(_jit, r0, r1, im) @@ -275,6 +287,10 @@ static void _divi_d(jit_state_t *_jit,jit_int32_t,jit_int32_t,jit_float64_t); # define absr_d(r0, r1) FABS_D(r0, r1) # define negr_d(r0, r1) FNEG_D(r0, r1) # define sqrtr_d(r0, r1) FSQRT_D(r0, r1) +# define fmar_d(r0, r1, r2, r3) FMADD_D(r0, r1, r2, r3) +# define fmsr_d(r0, r1, r2, r3) FMSUB_D(r0, r1, r2, r3) +# define fnmar_d(r0, r1, r2, r3) FNMADD_D(r0, r1, r2, r3) +# define fnmsr_d(r0, r1, r2, r3) FNMSUB_D(r0, r1, r2, r3) # define extr_d(r0, r1) FCVT_D_L(r0, r1) # define ldr_d(r0, r1) FLD(r0, r1, 0) # define ldi_d(r0, im) _ldi_d(_jit, r0, im) @@ -294,9 +310,9 @@ static void _stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); # define movi_d(r0, im) _movi_d(_jit, r0, im) static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t); # define movr_d_w(r0, r1) FMV_X_D(r0, r1) -# define movi_d_w(r0, im) _movi_d_w(_jit, r0, im) -static void _movi_d_w(jit_state_t*, jit_int32_t, jit_float64_t); # define movr_w_d(r0, r1) FMV_D_X(r0, r1) +#define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # define extr_f_d(r0, r1) FCVT_D_S(r0, r1) # define ltr_d(r0, r1, r2) FLT_D(r0, r1, r2) # define lti_d(r0, r1, r2) _lti_d(_jit, r0, r1, r2) @@ -468,6 +484,24 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unldr_x(r0, r1, i0); + else + generic_unldr_x(r0, r1, i0); +} + +static void +_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unldi_x(r0, i0, i1); + else + generic_unldi_x(r0, i0, i1); +} + static void _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -506,6 +540,24 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + if (jit_unaligned_p()) + fallback_unstr_x(r0, r1, i0); + else + generic_unstr_x(r0, r1, i0); +} + +static void +_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + if (jit_unaligned_p()) + fallback_unsti_x(i0, r0, i1); + else + fallback_unsti_x(i0, r0, i1); +} + static void _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) { @@ -526,14 +578,13 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) } static void -_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - union { - jit_int32_t i; - jit_float32_t f; - } data; - data.f = i0; - movi(r0, data.i); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); } fopi(lt) @@ -960,14 +1011,13 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) } static void -_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { - union { - jit_int64_t l; - jit_float64_t d; - } data; - data.d = i0; - movi(r0, data.l); + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); } dopi(lt) diff --git a/deps/lightning/lib/jit_riscv-sz.c b/deps/lightning/lib/jit_riscv-sz.c index 335d3cfe..c08e5bd5 100644 --- a/deps/lightning/lib/jit_riscv-sz.c +++ b/deps/lightning/lib/jit_riscv-sz.c @@ -1,5 +1,5 @@ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 168 +#define JIT_INSTR_MAX 116 0, /* data */ 0, /* live */ 4, /* align */ @@ -44,42 +44,42 @@ 8, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 16, /* addi */ - 12, /* addcr */ - 24, /* addci */ - 28, /* addxr */ - 28, /* addxi */ + 16, /* addi */ + 12, /* addcr */ + 24, /* addci */ + 28, /* addxr */ + 28, /* addxi */ 4, /* subr */ - 16, /* subi */ - 12, /* subcr */ - 24, /* subci */ - 28, /* subxr */ - 28, /* subxi */ - 20, /* rsbi */ + 16, /* subi */ + 12, /* subcr */ + 24, /* subci */ + 28, /* subxr */ + 28, /* subxi */ + 20, /* rsbi */ 4, /* mulr */ - 16, /* muli */ - 12, /* qmulr */ - 20, /* qmuli */ - 12, /* qmulr_u */ - 20, /* qmuli_u */ + 16, /* muli */ + 12, /* qmulr */ + 20, /* qmuli */ + 12, /* qmulr_u */ + 20, /* qmuli_u */ 4, /* divr */ - 16, /* divi */ + 16, /* divi */ 4, /* divr_u */ - 16, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ + 16, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ 4, /* remr */ - 16, /* remi */ + 16, /* remi */ 4, /* remr_u */ - 16, /* remi_u */ + 16, /* remi_u */ 4, /* andr */ - 16, /* andi */ + 16, /* andi */ 4, /* orr */ - 16, /* ori */ + 16, /* ori */ 4, /* xorr */ - 16, /* xori */ + 16, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -87,21 +87,23 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ + 4, /* comi */ 4, /* ltr */ 4, /* lti */ 4, /* ltr_u */ 4, /* lti_u */ 8, /* ler */ - 12, /* lei */ + 12, /* lei */ 8, /* ler_u */ - 12, /* lei_u */ - 12, /* eqr */ - 12, /* eqi */ + 12, /* lei_u */ + 12, /* eqr */ + 12, /* eqi */ 8, /* ger */ - 12, /* gei */ + 12, /* gei */ 8, /* ger_u */ - 12, /* gei_u */ + 12, /* gei_u */ 4, /* gtr */ 8, /* gti */ 4, /* gtr_u */ @@ -109,67 +111,79 @@ 8, /* ner */ 8, /* nei */ 4, /* movr */ - 12, /* movi */ - 12, /* movnr */ - 12, /* movzr */ - 28, /* casr */ - 40, /* casi */ + 12, /* movi */ + 12, /* movnr */ + 12, /* movzr */ + 28, /* casr */ + 40, /* casi */ 8, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 8, /* extr_s */ + 4, /* exti_s */ 8, /* extr_us */ + 8, /* exti_us */ 4, /* extr_i */ + 4, /* exti_i */ 8, /* extr_ui */ - 20, /* bswapr_us */ - 52, /* bswapr_ui */ + 12, /* exti_ui */ + 20, /* bswapr_us */ + 8, /* bswapi_us */ + 52, /* bswapr_ui */ + 8, /* bswapi_ui */ 116, /* bswapr_ul */ - 20, /* htonr_us */ - 52, /* htonr_ui */ + 12, /* bswapi_ul */ + 20, /* htonr_us */ + 8, /* htoni_us */ + 52, /* htonr_ui */ + 8, /* htoni_ui */ 116, /* htonr_ul */ + 12, /* htoni_ul */ 4, /* ldr_c */ - 16, /* ldi_c */ + 16, /* ldi_c */ 4, /* ldr_uc */ - 16, /* ldi_uc */ + 16, /* ldi_uc */ 4, /* ldr_s */ - 16, /* ldi_s */ + 16, /* ldi_s */ 4, /* ldr_us */ - 16, /* ldi_us */ + 16, /* ldi_us */ 4, /* ldr_i */ - 16, /* ldi_i */ + 16, /* ldi_i */ 4, /* ldr_ui */ - 16, /* ldi_ui */ + 16, /* ldi_ui */ 4, /* ldr_l */ - 16, /* ldi_l */ + 16, /* ldi_l */ 8, /* ldxr_c */ - 16, /* ldxi_c */ + 16, /* ldxi_c */ 8, /* ldxr_uc */ - 16, /* ldxi_uc */ + 16, /* ldxi_uc */ 8, /* ldxr_s */ - 16, /* ldxi_s */ + 16, /* ldxi_s */ 8, /* ldxr_us */ - 16, /* ldxi_us */ + 16, /* ldxi_us */ 8, /* ldxr_i */ - 16, /* ldxi_i */ + 16, /* ldxi_i */ 8, /* ldxr_ui */ - 16, /* ldxi_ui */ + 16, /* ldxi_ui */ 8, /* ldxr_l */ - 16, /* ldxi_l */ + 16, /* ldxi_l */ 4, /* str_c */ - 16, /* sti_c */ + 16, /* sti_c */ 4, /* str_s */ - 16, /* sti_s */ + 16, /* sti_s */ 4, /* str_i */ - 16, /* sti_i */ + 16, /* sti_i */ 4, /* str_l */ - 16, /* sti_l */ + 16, /* sti_l */ 8, /* stxr_c */ - 16, /* stxi_c */ + 16, /* stxi_c */ 8, /* stxr_s */ - 16, /* stxi_s */ + 16, /* stxi_s */ 8, /* stxr_i */ - 16, /* stxi_i */ + 16, /* stxi_i */ 8, /* stxr_l */ - 16, /* stxi_l */ + 16, /* stxi_l */ 4, /* bltr */ 8, /* blti */ 4, /* bltr_u */ @@ -179,7 +193,7 @@ 4, /* bler_u */ 8, /* blei_u */ 4, /* beqr */ - 16, /* beqi */ + 16, /* beqi */ 4, /* bger */ 8, /* bgei */ 4, /* bger_u */ @@ -189,31 +203,31 @@ 4, /* bgtr_u */ 8, /* bgti_u */ 4, /* bner */ - 16, /* bnei */ + 16, /* bnei */ 8, /* bmsr */ - 12, /* bmsi */ + 12, /* bmsi */ 8, /* bmcr */ - 12, /* bmci */ - 32, /* boaddr */ - 36, /* boaddi */ - 16, /* boaddr_u */ - 20, /* boaddi_u */ - 32, /* bxaddr */ - 36, /* bxaddi */ - 16, /* bxaddr_u */ - 20, /* bxaddi_u */ - 32, /* bosubr */ - 36, /* bosubi */ - 16, /* bosubr_u */ - 20, /* bosubi_u */ - 32, /* bxsubr */ - 36, /* bxsubi */ - 16, /* bxsubr_u */ - 20, /* bxsubi_u */ + 12, /* bmci */ + 32, /* boaddr */ + 36, /* boaddi */ + 16, /* boaddr_u */ + 20, /* boaddi_u */ + 32, /* bxaddr */ + 36, /* bxaddi */ + 16, /* bxaddr_u */ + 20, /* bxaddi_u */ + 32, /* bosubr */ + 36, /* bosubi */ + 16, /* bosubr_u */ + 20, /* bosubi_u */ + 32, /* bxsubr */ + 36, /* bxsubi */ + 16, /* bxsubr_u */ + 20, /* bxsubi_u */ 4, /* jmpr */ - 16, /* jmpi */ + 16, /* jmpi */ 4, /* callr */ - 16, /* calli */ + 16, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -259,45 +273,48 @@ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 12, /* addi_f */ + 12, /* addi_f */ 4, /* subr_f */ - 12, /* subi_f */ - 12, /* rsbi_f */ + 12, /* subi_f */ + 12, /* rsbi_f */ 4, /* mulr_f */ - 12, /* muli_f */ + 12, /* muli_f */ 4, /* divr_f */ - 12, /* divi_f */ + 12, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 4, /* ltr_f */ - 12, /* lti_f */ + 12, /* lti_f */ 4, /* ler_f */ - 12, /* lei_f */ + 12, /* lei_f */ 4, /* eqr_f */ - 12, /* eqi_f */ + 12, /* eqi_f */ 4, /* ger_f */ - 12, /* gei_f */ + 12, /* gei_f */ 4, /* gtr_f */ - 12, /* gti_f */ + 12, /* gti_f */ 8, /* ner_f */ - 16, /* nei_f */ - 28, /* unltr_f */ - 36, /* unlti_f */ - 28, /* unler_f */ - 36, /* unlei_f */ - 28, /* uneqr_f */ - 36, /* uneqi_f */ - 28, /* unger_f */ - 36, /* ungei_f */ - 28, /* ungtr_f */ - 36, /* ungti_f */ - 40, /* ltgtr_f */ - 48, /* ltgti_f */ - 28, /* ordr_f */ - 36, /* ordi_f */ - 20, /* unordr_f */ - 28, /* unordi_f */ + 16, /* nei_f */ + 28, /* unltr_f */ + 36, /* unlti_f */ + 28, /* unler_f */ + 36, /* unlei_f */ + 28, /* uneqr_f */ + 36, /* uneqi_f */ + 28, /* unger_f */ + 36, /* ungei_f */ + 28, /* ungtr_f */ + 36, /* ungti_f */ + 40, /* ltgtr_f */ + 48, /* ltgti_f */ + 28, /* ordr_f */ + 36, /* ordi_f */ + 20, /* unordr_f */ + 28, /* unordi_f */ 4, /* truncr_f_i */ 4, /* truncr_f_l */ 4, /* extr_f */ @@ -305,41 +322,41 @@ 4, /* movr_f */ 8, /* movi_f */ 4, /* ldr_f */ - 16, /* ldi_f */ + 16, /* ldi_f */ 8, /* ldxr_f */ - 16, /* ldxi_f */ + 16, /* ldxi_f */ 4, /* str_f */ - 16, /* sti_f */ + 16, /* sti_f */ 8, /* stxr_f */ - 16, /* stxi_f */ + 16, /* stxi_f */ 8, /* bltr_f */ - 16, /* blti_f */ + 16, /* blti_f */ 8, /* bler_f */ - 16, /* blei_f */ + 16, /* blei_f */ 8, /* beqr_f */ - 16, /* beqi_f */ + 16, /* beqi_f */ 8, /* bger_f */ - 16, /* bgei_f */ + 16, /* bgei_f */ 8, /* bgtr_f */ - 16, /* bgti_f */ + 16, /* bgti_f */ 8, /* bner_f */ - 16, /* bnei_f */ - 32, /* bunltr_f */ - 40, /* bunlti_f */ - 32, /* bunler_f */ - 40, /* bunlei_f */ - 32, /* buneqr_f */ - 40, /* buneqi_f */ - 32, /* bunger_f */ - 40, /* bungei_f */ - 32, /* bungtr_f */ - 40, /* bungti_f */ - 44, /* bltgtr_f */ - 52, /* bltgti_f */ - 32, /* bordr_f */ - 40, /* bordi_f */ - 24, /* bunordr_f */ - 32, /* bunordi_f */ + 16, /* bnei_f */ + 32, /* bunltr_f */ + 40, /* bunlti_f */ + 32, /* bunler_f */ + 40, /* bunlei_f */ + 32, /* buneqr_f */ + 40, /* buneqi_f */ + 32, /* bunger_f */ + 40, /* bungei_f */ + 32, /* bungtr_f */ + 40, /* bungti_f */ + 44, /* bltgtr_f */ + 52, /* bltgti_f */ + 32, /* bordr_f */ + 40, /* bordi_f */ + 24, /* bunordr_f */ + 32, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -350,103 +367,165 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 20, /* addi_d */ + 20, /* addi_d */ 4, /* subr_d */ - 20, /* subi_d */ - 20, /* rsbi_d */ + 20, /* subi_d */ + 20, /* rsbi_d */ 4, /* mulr_d */ - 20, /* muli_d */ + 20, /* muli_d */ 4, /* divr_d */ - 20, /* divi_d */ + 20, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 4, /* ltr_d */ - 20, /* lti_d */ + 20, /* lti_d */ 4, /* ler_d */ - 20, /* lei_d */ + 20, /* lei_d */ 4, /* eqr_d */ - 20, /* eqi_d */ + 20, /* eqi_d */ 4, /* ger_d */ - 20, /* gei_d */ + 20, /* gei_d */ 4, /* gtr_d */ - 20, /* gti_d */ + 20, /* gti_d */ 8, /* ner_d */ - 24, /* nei_d */ - 28, /* unltr_d */ - 44, /* unlti_d */ - 28, /* unler_d */ - 44, /* unlei_d */ - 28, /* uneqr_d */ - 44, /* uneqi_d */ - 28, /* unger_d */ - 44, /* ungei_d */ - 28, /* ungtr_d */ - 44, /* ungti_d */ - 40, /* ltgtr_d */ - 56, /* ltgti_d */ - 28, /* ordr_d */ - 44, /* ordi_d */ - 20, /* unordr_d */ - 36, /* unordi_d */ + 24, /* nei_d */ + 28, /* unltr_d */ + 44, /* unlti_d */ + 28, /* unler_d */ + 44, /* unlei_d */ + 28, /* uneqr_d */ + 44, /* uneqi_d */ + 28, /* unger_d */ + 44, /* ungei_d */ + 28, /* ungtr_d */ + 44, /* ungti_d */ + 40, /* ltgtr_d */ + 56, /* ltgti_d */ + 28, /* ordr_d */ + 44, /* ordi_d */ + 20, /* unordr_d */ + 36, /* unordi_d */ 4, /* truncr_d_i */ 4, /* truncr_d_l */ 4, /* extr_d */ 4, /* extr_f_d */ 4, /* movr_d */ - 16, /* movi_d */ + 16, /* movi_d */ 4, /* ldr_d */ - 16, /* ldi_d */ + 16, /* ldi_d */ 8, /* ldxr_d */ - 16, /* ldxi_d */ + 16, /* ldxi_d */ 4, /* str_d */ - 16, /* sti_d */ + 16, /* sti_d */ 8, /* stxr_d */ - 16, /* stxi_d */ + 16, /* stxi_d */ 8, /* bltr_d */ - 24, /* blti_d */ + 24, /* blti_d */ 8, /* bler_d */ - 24, /* blei_d */ + 24, /* blei_d */ 8, /* beqr_d */ - 24, /* beqi_d */ + 24, /* beqi_d */ 8, /* bger_d */ - 24, /* bgei_d */ + 24, /* bgei_d */ 8, /* bgtr_d */ - 24, /* bgti_d */ + 24, /* bgti_d */ 8, /* bner_d */ - 24, /* bnei_d */ - 32, /* bunltr_d */ - 48, /* bunlti_d */ - 32, /* bunler_d */ - 48, /* bunlei_d */ - 32, /* buneqr_d */ - 48, /* buneqi_d */ - 32, /* bunger_d */ - 48, /* bungei_d */ - 32, /* bungtr_d */ - 48, /* bungti_d */ - 44, /* bltgtr_d */ - 60, /* bltgti_d */ - 32, /* bordr_d */ - 48, /* bordi_d */ - 24, /* bunordr_d */ - 40, /* bunordi_d */ + 24, /* bnei_d */ + 32, /* bunltr_d */ + 48, /* bunlti_d */ + 32, /* bunler_d */ + 48, /* bunlei_d */ + 32, /* buneqr_d */ + 48, /* buneqi_d */ + 32, /* bunger_d */ + 48, /* bungei_d */ + 32, /* bungtr_d */ + 48, /* bungti_d */ + 44, /* bltgtr_d */ + 60, /* bltgti_d */ + 32, /* bordr_d */ + 48, /* bordi_d */ + 24, /* bunordr_d */ + 40, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ 4, /* movr_w_f */ + 8, /* movi_w_f */ 0, /* movr_ww_d */ + 0, /* movi_ww_d */ 4, /* movr_w_d */ + 16, /* movi_w_d */ 4, /* movr_f_w */ 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ 4, /* movr_d_w */ - 12, /* movi_d_w */ - 168, /* clo */ - 148, /* clz */ - 168, /* cto */ - 148, /* ctz */ + 12, /* movi_d_w */ + 84, /* clor */ + 4, /* cloi */ + 64, /* clzr */ + 4, /* clzi */ + 56, /* ctor */ + 4, /* ctoi */ + 36, /* ctzr */ + 4, /* ctzi */ + 68, /* rbitr */ + 12, /* rbiti */ + 64, /* popcntr */ + 4, /* popcnti */ + 20, /* lrotr */ + 12, /* lroti */ + 20, /* rrotr */ + 12, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 20, /* extr_u */ + 4, /* exti_u */ + 40, /* depr */ + 20, /* depi */ + 56, /* qlshr */ + 8, /* qlshi */ + 56, /* qlshr_u */ + 8, /* qlshi_u */ + 56, /* qrshr */ + 8, /* qrshi */ + 56, /* qrshr_u */ + 8, /* qrshi_u */ + 24, /* unldr */ + 44, /* unldi */ + 24, /* unldr_u */ + 44, /* unldi_u */ + 20, /* unstr */ + 56, /* unsti */ + 4, /* unldr_x */ + 16, /* unldi_x */ + 4, /* unstr_x */ + 20, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 4, /* hmulr */ + 16, /* hmuli */ + 4, /* hmulr_u */ + 16, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_riscv.c b/deps/lightning/lib/jit_riscv.c index 63a5cd9b..27b0c5ad 100644 --- a/deps/lightning/lib/jit_riscv.c +++ b/deps/lightning/lib/jit_riscv.c @@ -55,6 +55,7 @@ static void _patch(jit_state_t*,jit_word_t,jit_node_t*); /* * Initialization */ +jit_cpu_t jit_cpu; jit_register_t _rvs[] = { { 0x00, "zero" }, { 0x01, "ra" }, @@ -140,6 +141,8 @@ static jit_int32_t fregs[] = { void jit_get_cpu(void) { + /* By default generate extra instructions for unaligned load/store. */ + jit_cpu.unaligned = 0; } void @@ -1017,6 +1020,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1140,6 +1149,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1160,18 +1173,46 @@ _emit_code(jit_state_t *_jit) case_rrw(lsh,); case_rrr(rsh,); case_rrw(rsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); +#define lrotr(r0,r1,r2) fallback_lrotr(r0,r1,r2) +#define lroti(r0,r1,i0) fallback_lroti(r0,r1,i0) +#define rrotr(r0,r1,r2) fallback_rrotr(r0,r1,r2) +#define rroti(r0,r1,i0) fallback_rroti(r0,r1,i0) + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); #define clor(r0, r1) fallback_clo(r0, r1) #define clzr(r0, r1) fallback_clz(r0, r1) #define ctor(r0, r1) fallback_cto(r0, r1) #define ctzr(r0, r1) fallback_ctz(r0, r1) +#define rbitr(r0, r1) fallback_rbit(r0, r1) +#define popcntr(r0, r1) fallback_popcnt(r0, r1) case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); + case_rr(popcnt,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1210,6 +1251,18 @@ _emit_code(jit_state_t *_jit) case_rrw(ldx, _ui); case_rrr(ldx, _l); case_rrw(ldx, _l); + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1226,12 +1279,33 @@ _emit_code(jit_state_t *_jit) case_wrr(stx, _i); case_rrr(stx, _l); case_wrr(stx, _l); + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); case_rr(hton, _ul); case_rr(bswap, _us); case_rr(bswap, _ui); case_rr(bswap, _ul); +#define extr(r0, r1, i0, i1) fallback_ext(r0, r1, i0, i1) +#define extr_u(r0, r1, i0, i1) fallback_ext_u(r0, r1, i0, i1) +#define depr(r0, r1, i0, i1) fallback_dep(r0, r1, i0, i1) + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1338,15 +1412,31 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert_data(node); @@ -1421,6 +1511,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1552,6 +1646,7 @@ _emit_code(jit_state_t *_jit) #if DEVEL_DISASSEMBLER undo.prevw = prevw; #endif + undo.const_offset = _jitc->consts.vector.offset; undo.patch_offset = _jitc->patches.offset; restart_function: compute_framesize(); @@ -1589,6 +1684,7 @@ _emit_code(jit_state_t *_jit) prevw = undo.prevw; #endif _jitc->patches.offset = undo.patch_offset; + _jitc->consts.vector.offset = undo.const_offset; patch_alist(1); goto restart_function; } @@ -1608,6 +1704,9 @@ _emit_code(jit_state_t *_jit) assert_data(node); movi_f_w(rn(node->u.w), node->v.f); break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; case jit_code_movr_w_d: movr_w_d(rn(node->u.w), rn(node->v.w)); break; @@ -1618,6 +1717,9 @@ _emit_code(jit_state_t *_jit) assert_data(node); movi_d_w(rn(node->u.w), node->v.d); break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1675,6 +1777,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_s390-cpu.c b/deps/lightning/lib/jit_s390-cpu.c index 2e9e074f..23f7346d 100644 --- a/deps/lightning/lib/jit_s390-cpu.c +++ b/deps/lightning/lib/jit_s390-cpu.c @@ -20,13 +20,21 @@ #if PROTO # if __WORDSIZE == 32 # define ldr(r0,r1) ldr_i(r0,r1) +# define ldi(r0,i0) ldi_i(r0,i0) # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2) # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0) +# define str(r0,r1) str_i(r0,r1) +# define sti(i0,r0) sti_i(i0,r0) +# define stxr(r0,r1,r2) stxr_i(r0,r1,r2) # define stxi(i0,r0,r1) stxi_i(i0,r0,r1) # else # define ldr(r0,r1) ldr_l(r0,r1) +# define ldi(r0,i0) ldi_l(r0,i0) # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2) # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0) +# define str(r0,r1) str_l(r0,r1) +# define sti(i0,r0) sti_l(i0,r0) +# define stxr(r0,r1,r2) stxr_l(r0,r1,r2) # define stxi(i0,r0,r1) stxi_l(i0,r0,r1) # endif # define is(i) *_jit->pc.us++ = i @@ -1015,6 +1023,10 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0) static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +# define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2) +# define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0) +# define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2) +# define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0) # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3) static void _qmulr(jit_state_t*,jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); @@ -1078,11 +1090,16 @@ static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # endif # if __WORDSIZE == 32 # define negr(r0,r1) LCR(r0,r1) +# define lrotr(r0,r1,r2) RLL(r0,r1,0,r2) +# define lroti(r0,r1,i0) RLL(r0,r1,i0,0) # else # define negr(r0,r1) LCGR(r0,r1) +# define lrotr(r0,r1,r2) RLLG(r0,r1,0,r2) +# define lroti(r0,r1,i0) RLLG(r0,r1,i0,0) # endif -# define bitswap(r0, r1) _bitswap(_jit, r0, r1) -static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t); +# define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2) +static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); +# define rroti(r0,r1,i0) lroti(r0,r1,__WORDSIZE-i0) # define clor(r0, r1) _clor(_jit, r0, r1) static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); # define clzr(r0, r1) _clzr(_jit, r0, r1) @@ -1105,6 +1122,12 @@ static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0) static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); +#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +#define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0,r1) LGBR(r0,r1) # define extr_uc(r0,r1) LLGCR(r0,r1) # define extr_s(r0,r1) LGHR(r0,r1) @@ -2746,14 +2769,14 @@ _qmulr(jit_state_t *_jit, jit_int32_t reg; /* The only invalid condition is r0 == r1 */ jit_int32_t t2, t3, s2, s3; - if (r2 == r0 || r2 == r1) { + if ((r0 != JIT_NOREG && r2 == r0) || r2 == r1) { s2 = jit_get_reg(jit_class_gpr); t2 = rn(s2); movr(t2, r2); } else t2 = r2; - if (r3 == r0 || r3 == r1) { + if ((r0 != JIT_NOREG && r3 == r0) || r3 == r1) { s3 = jit_get_reg(jit_class_gpr); t3 = rn(s3); movr(t3, r3); @@ -2796,7 +2819,8 @@ _qmulr_u(jit_state_t *_jit, regno = jit_get_reg_pair(); movr(rn(regno) + 1, r2); MULU_(rn(regno), r3); - movr(r0, rn(regno) + 1); + if (r0 != JIT_NOREG) + movr(r0, rn(regno) + 1); movr(r1, rn(regno)); jit_unget_reg_pair(regno); } @@ -2810,7 +2834,8 @@ _qmuli_u(jit_state_t *_jit, movr(rn(regno) + 1, r2); movi(rn(regno), i0); MULU_(rn(regno), rn(regno)); - movr(r0, rn(regno) + 1); + if (r0 != JIT_NOREG) + movr(r0, rn(regno) + 1); movr(r1, rn(regno)); jit_unget_reg_pair(regno); } @@ -2994,55 +3019,19 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) #endif static void -_bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { - jit_int32_t t0, t1, t2, t3, t4; - movr(r0, r1); - t0 = jit_get_reg(jit_class_gpr); - t1 = jit_get_reg(jit_class_gpr); - t2 = jit_get_reg(jit_class_gpr); - movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L); - rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L); - rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL); - rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL); - rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# if __WORDSIZE == 32 - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - lshi(rn(t2), r0, 16); /* t2 = v << 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# else - movi(rn(t0), 0x0000ffff0000ffffL); - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */ - lshi(rn(t2), r0, 32); /* t2 = v << 32 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# endif - jit_unget_reg(t2); - jit_unget_reg(t1); - jit_unget_reg(t0); + jit_int32_t reg; + if (r0 != r1 && r0 != r2) { + rsbi(r0, r2, __WORDSIZE); + lrotr(r0, r1, r0); + } + else { + reg = jit_get_reg_but_zero(0); + rsbi(rn(reg), r2, __WORDSIZE); + lrotr(r0, r1, rn(reg)); + jit_unget_reg(reg); + } } static void @@ -3097,8 +3086,8 @@ _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) #if CHECK_FLOGR if (jit_cpu.flogr) { #endif - bitswap(r0, r1); - clor(r0, r0); + comr(r0, r1); + ctzr(r0, r0); #if CHECK_FLOGR } else @@ -3109,11 +3098,19 @@ _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) static void _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { + jit_int32_t t0, t1; #if CHECK_FLOGR if (jit_cpu.flogr) { #endif - bitswap(r0, r1); - clzr(r0, r0); + t0 = jit_get_reg_but_zero(0); + t1 = jit_get_reg_but_zero(0); + negr(rn(t0), r1); + andr(rn(t0), rn(t0), r1); + clzr(r0, rn(t0)); + xori(rn(t1), r0, __WORDSIZE - 1); + movnr(r0, rn(t1), rn(t0)); + jit_unget_reg(t0); + jit_unget_reg(t1); #if CHECK_FLOGR } else @@ -3121,6 +3118,65 @@ _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) #endif } +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + /* Big Endian always */ + i0 = __WORDSIZE - (i0 + i1); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + /* Big Endian always */ + i0 = __WORDSIZE - (i0 + i1); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { + if (i0) + rshi_u(r0, r1, i0); + andi(r0, r0, (1L << i1) - 1); + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + /* Big Endian always */ + i0 = __WORDSIZE - (i0 + i1); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { + mask = (1L << i1) - 1; + t0 = jit_get_reg(jit_class_gpr); + andi(rn(t0), r1, mask); + if (i0) { + lshi(rn(t0), rn(t0), i0); + mask <<= i0; + } + andi(r0, r0, ~mask); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } +} + static void _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { diff --git a/deps/lightning/lib/jit_s390-fpu.c b/deps/lightning/lib/jit_s390-fpu.c index 6c3c4ac2..b43f4f60 100644 --- a/deps/lightning/lib/jit_s390-fpu.c +++ b/deps/lightning/lib/jit_s390-fpu.c @@ -342,6 +342,8 @@ static jit_word_t _bltgti(jit_state_t*,jit_int32_t, static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_f(r0,i0) _movi_f(_jit,r0,i0) static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*); +#define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define movr_d(r0,r1) _movr_d(_jit,r0,r1) static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define movi_d(r0,i0) _movi_d(_jit,r0,i0) @@ -351,7 +353,31 @@ static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); # define negr_f(r0,r1) LCEBR(r0,r1) # define negr_d(r0,r1) LCDBR(r0,r1) # define sqrtr_f(r0,r1) SQEBR(r0,r1) +# define fmar_f(r0,r1,r2,r3) _fmar_f(_jit,r0,r1,r2,r3) +static void _fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fmsr_f(r0,r1,r2,r3) _fmsr_f(_jit,r0,r1,r2,r3) +static void _fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmar_f(r0,r1,r2,r3) _fnmar_f(_jit,r0,r1,r2,r3) +static void _fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmsr_f(r0,r1,r2,r3) _fnmsr_f(_jit,r0,r1,r2,r3) +static void _fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define sqrtr_d(r0,r1) SQDBR(r0,r1) +# define fmar_d(r0,r1,r2,r3) _fmar_d(_jit,r0,r1,r2,r3) +static void _fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fmsr_d(r0,r1,r2,r3) _fmsr_d(_jit,r0,r1,r2,r3) +static void _fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmar_d(r0,r1,r2,r3) _fnmar_d(_jit,r0,r1,r2,r3) +static void _fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define fnmsr_d(r0,r1,r2,r3) _fnmsr_d(_jit,r0,r1,r2,r3) +static void _fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define truncr_f_i(r0,r1) CFEBR(r0,RND_ZERO,r1) # define truncr_d_i(r0,r1) CFDBR(r0,RND_ZERO,r1) # if __WORDSIZE == 64 @@ -361,9 +387,13 @@ static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*); # if __WORDSIZE == 32 # define extr_f(r0,r1) CEFBR(r0,r1) # define extr_d(r0,r1) CDFBR(r0,r1) +# define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) +static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # else # define extr_f(r0,r1) CEGBR(r0,r1) # define extr_d(r0,r1) CDGBR(r0,r1) +# define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # endif # define extr_d_f(r0,r1) LEDBR(r0,r1) # define extr_f_d(r0,r1) LDEBR(r0,r1) @@ -887,6 +917,16 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) ldi_f(r0, (jit_word_t)i0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + static void _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -928,6 +968,167 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) ldi_d(r0, (jit_word_t)i0); } +#if __WORDSIZE == 32 +static void +_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + movr_ww_d(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); +} +#else +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); +} +#endif + +static void +_fmar_f(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) + MAEBR(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MAEBR(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fmsr_f(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) + MSEBR(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MSEBR(rn(t0), r2, r1); + movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fnmar_f(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) { + MAEBR(r0, r2, r1); + negr_f(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MAEBR(rn(t0), r2, r1); + negr_f(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fnmsr_f(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) { + MSEBR(r0, r2, r1); + negr_f(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MSEBR(rn(t0), r2, r1); + negr_f(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fmar_d(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) + MADBR(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MADBR(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fmsr_d(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) + MSDBR(r0, r2, r1); + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MSDBR(rn(t0), r2, r1); + movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fnmar_d(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) { + MADBR(r0, r2, r1); + negr_d(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + movr_f(rn(t0), r3); + MADBR(rn(t0), r2, r1); + negr_d(r0, rn(t0)); + jit_unget_reg(t0); + } +} + +static void +_fnmsr_d(jit_state_t* _jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 == r3) { + MSDBR(r0, r2, r1); + negr_d(r0, r0); + } + else { + t0 = jit_get_reg(jit_class_fpr); + movr_d(rn(t0), r3); + MSDBR(rn(t0), r2, r1); + negr_d(r0, rn(t0)); + jit_unget_reg(t0); + } +} + static void _addr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) { diff --git a/deps/lightning/lib/jit_s390-sz.c b/deps/lightning/lib/jit_s390-sz.c index ee304473..b8a87e85 100644 --- a/deps/lightning/lib/jit_s390-sz.c +++ b/deps/lightning/lib/jit_s390-sz.c @@ -1,5 +1,5 @@ #if __WORDSIZE == 32 -#define JIT_INSTR_MAX 164 +#define JIT_INSTR_MAX 630 0, /* data */ 0, /* live */ 4, /* align */ @@ -87,7 +87,9 @@ 8, /* rshr_u */ 6, /* rshi_u */ 2, /* negr */ + 4, /* negi */ 8, /* comr */ + 4, /* comi */ 16, /* ltr */ 20, /* lti */ 16, /* ltr_u */ @@ -115,17 +117,29 @@ 22, /* casr */ 28, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 12, /* bswapr_us */ + 4, /* bswapi_us */ 4, /* bswapr_ui */ + 6, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 2, /* htonr_ui */ + 6, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 6, /* ldr_c */ 12, /* ldi_c */ 6, /* ldr_uc */ @@ -268,8 +282,11 @@ 8, /* divr_f */ 24, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 16, /* ltr_f */ 36, /* lti_f */ 16, /* ler_f */ @@ -359,8 +376,11 @@ 8, /* divr_d */ 34, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 16, /* ltr_d */ 46, /* lti_d */ 16, /* ler_d */ @@ -436,23 +456,82 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 12, /* movr_w_f */ + 18, /* movi_w_f */ + 18, /* movr_ww_d */ + 28, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 12, /* movr_f_w */ + 6, /* movi_f_w */ + 18, /* movr_d_ww */ + 10, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 36, /* clo */ - 28, /* clz */ - 164, /* cto */ - 158, /* ctz */ + 36, /* clor */ + 4, /* cloi */ + 28, /* clzr */ + 4, /* clzi */ + 62, /* ctor */ + 4, /* ctoi */ + 54, /* ctzr */ + 4, /* ctzi */ + 64, /* rbitr */ + 6, /* rbiti */ + 60, /* popcntr */ + 4, /* popcnti */ + 6, /* lrotr */ + 6, /* lroti */ + 16, /* rrotr */ + 6, /* rroti */ + 10, /* extr */ + 4, /* exti */ + 14, /* extr_u */ + 4, /* exti_u */ + 24, /* depr */ + 28, /* depi */ + 68, /* qlshr */ + 12, /* qlshi */ + 66, /* qlshr_u */ + 12, /* qlshi_u */ + 70, /* qrshr */ + 12, /* qrshi */ + 66, /* qrshr_u */ + 12, /* qrshi_u */ + 86, /* unldr */ + 38, /* unldi */ + 86, /* unldr_u */ + 38, /* unldi_u */ + 238, /* unstr */ + 100, /* unsti */ + 200, /* unldr_x */ + 86, /* unldi_x */ + 630, /* unstr_x */ + 294, /* unsti_x */ + 8, /* fmar_f */ + 0, /* fmai_f */ + 8, /* fmsr_f */ + 0, /* fmsi_f */ + 8, /* fmar_d */ + 0, /* fmai_d */ + 8, /* fmsr_d */ + 0, /* fmsi_d */ + 10, /* fnmar_f */ + 0, /* fnmai_f */ + 10, /* fnmsr_f */ + 0, /* fnmsi_f */ + 10, /* fnmar_d */ + 0, /* fnmai_d */ + 10, /* fnmsr_d */ + 0, /* fnmsi_d */ + 34, /* hmulr */ + 42, /* hmuli */ + 8, /* hmulr_u */ + 16, /* hmuli_u */ #endif /* __WORDSIZE */ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 280 +#define JIT_INSTR_MAX 364 0, /* data */ 0, /* live */ 20, /* align */ @@ -540,7 +619,9 @@ 6, /* rshr_u */ 6, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 12, /* comr */ + 4, /* comi */ 20, /* ltr */ 24, /* lti */ 20, /* ltr_u */ @@ -568,17 +649,29 @@ 30, /* casr */ 42, /* casi */ 4, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 4, /* extr_s */ + 4, /* exti_s */ 4, /* extr_us */ + 8, /* exti_us */ 4, /* extr_i */ + 16, /* exti_i */ 4, /* extr_ui */ + 8, /* exti_ui */ 12, /* bswapr_us */ + 4, /* bswapi_us */ 8, /* bswapr_ui */ + 12, /* bswapi_ui */ 4, /* bswapr_ul */ + 16, /* bswapi_ul */ 4, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 12, /* htoni_ui */ 4, /* htonr_ul */ + 16, /* htoni_ul */ 6, /* ldr_c */ 18, /* ldi_c */ 6, /* ldr_uc */ @@ -721,8 +814,11 @@ 8, /* divr_f */ 26, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ + 0, /* sqrti_f */ 16, /* ltr_f */ 36, /* lti_f */ 16, /* ler_f */ @@ -812,8 +908,11 @@ 8, /* divr_d */ 26, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ + 0, /* sqrti_d */ 16, /* ltr_d */ 36, /* lti_d */ 16, /* ler_d */ @@ -889,17 +988,76 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 12, /* movr_w_f */ + 20, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 12, /* movr_w_d */ + 20, /* movi_w_d */ + 12, /* movr_f_w */ + 8, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 24, /* clo */ - 12, /* clz */ - 280, /* cto */ - 272, /* ctz */ + 12, /* movr_d_w */ + 8, /* movi_d_w */ + 24, /* clor */ + 4, /* cloi */ + 12, /* clzr */ + 4, /* clzi */ + 62, /* ctor */ + 4, /* ctoi */ + 50, /* ctzr */ + 4, /* ctzi */ + 78, /* rbitr */ + 16, /* rbiti */ + 72, /* popcntr */ + 4, /* popcnti */ + 6, /* lrotr */ + 6, /* lroti */ + 16, /* rrotr */ + 6, /* rroti */ + 12, /* extr */ + 4, /* exti */ + 22, /* extr_u */ + 4, /* exti_u */ + 46, /* depr */ + 50, /* depi */ + 76, /* qlshr */ + 12, /* qlshi */ + 74, /* qlshr_u */ + 12, /* qlshi_u */ + 78, /* qrshr */ + 12, /* qrshi */ + 74, /* qrshr_u */ + 12, /* qrshi_u */ + 122, /* unldr */ + 58, /* unldi */ + 122, /* unldr_u */ + 58, /* unldi_u */ + 296, /* unstr */ + 150, /* unsti */ + 130, /* unldr_x */ + 70, /* unldi_x */ + 364, /* unstr_x */ + 194, /* unsti_x */ + 8, /* fmar_f */ + 0, /* fmai_f */ + 8, /* fmsr_f */ + 0, /* fmsi_f */ + 8, /* fmar_d */ + 0, /* fmai_d */ + 8, /* fmsr_d */ + 0, /* fmsi_d */ + 10, /* fnmar_f */ + 0, /* fnmai_f */ + 10, /* fnmsr_f */ + 0, /* fnmsi_f */ + 10, /* fnmar_d */ + 0, /* fnmai_d */ + 10, /* fnmsr_d */ + 0, /* fnmsi_d */ + 44, /* hmulr */ + 60, /* hmuli */ + 12, /* hmulr_u */ + 28, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_s390.c b/deps/lightning/lib/jit_s390.c index 6934b11f..851d0d0b 100644 --- a/deps/lightning/lib/jit_s390.c +++ b/deps/lightning/lib/jit_s390.c @@ -94,9 +94,7 @@ extern void __clear_cache(void *, void *); #define PROTO 1 # include "jit_s390-cpu.c" # include "jit_s390-fpu.c" -# if CHECK_FLOGR -# include "jit_fallback.c" -# endif +# include "jit_fallback.c" #undef PROTO /* @@ -980,6 +978,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), rn(node->v.w), node->w.w); \ @@ -1111,6 +1115,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1129,16 +1137,40 @@ _emit_code(jit_state_t *_jit) case_rrrw(qdiv, _u); case_rrr(lsh,); case_rrw(lsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); +#define rbitr(r0, r1) fallback_rbit(r0, r1) +#define popcntr(r0, r1) fallback_popcnt(r0, r1) + case_rr(rbit,); + case_rr(popcnt,); case_rrr(and,); case_rrw(and,); case_rrr(or,); @@ -1183,6 +1215,22 @@ _emit_code(jit_state_t *_jit) case_rrr(ldx, _l); case_rrw(ldx, _l); #endif +#define unldr(r0, r1, i0) fallback_unldr(r0, r1, i0) + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi(r0, i0, i1) fallback_unldi(r0, i0, i1) + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; +#define unldr_u(r0, r1, i0) fallback_unldr_u(r0, r1, i0) + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_u(r0, i0, i1) fallback_unldi_u(r0, i0, i1) + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1203,6 +1251,14 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _l); case_wrr(stx, _l); #endif +#define unstr(r0, r1, i0) fallback_unstr(r0, r1, i0) + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti(i0, r0, i1) fallback_unsti(i0, r0, i1) + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); #if __WORDSIZE == 64 @@ -1213,6 +1269,18 @@ _emit_code(jit_state_t *_jit) #if __WORDSIZE == 64 case_rr(bswap, _ul); #endif + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1321,15 +1389,35 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ld, _f); case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); +#define unldr_x(r0, r1, i0) fallback_unldr_x(r0, r1, i0) + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_x(r0, i0, i1) fallback_unldi_x(r0, i0, i1) + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); +#define unstr_x(r0, r1, i0) fallback_unstr_x(r0, r1, i0) + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti_x(i0, r0, i1) fallback_unsti_x(i0, r0, i1) + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert_data(node); @@ -1404,6 +1492,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ld, _d); case_rw(ld, _d); @@ -1559,6 +1651,8 @@ _emit_code(jit_state_t *_jit) /* allocar information also does not need to be undone */ undo.func.aoffoff = _jitc->function->aoffoff; undo.func.allocar = _jitc->function->allocar; + /* cvt_offset must also not be undone */ + undo.func.cvt_offset = _jitc->function->cvt_offset; memcpy(_jitc->function, &undo.func, sizeof(undo.func)); #if DEVEL_DISASSEMBLER prevw = undo.prevw; @@ -1574,6 +1668,49 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 32 + case jit_code_movr_ww_d: + movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movr_d_ww: + movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movi_d_ww: + assert(node->flag & jit_flag_data); + movi_d_ww(rn(node->u.w), rn(node->v.w), + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + break; +#else + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_d_w: + movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; +#endif case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1643,6 +1780,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); @@ -1675,9 +1883,7 @@ _emit_code(jit_state_t *_jit) #define CODE 1 # include "jit_s390-cpu.c" # include "jit_s390-fpu.c" -# if CHECK_FLOGR -# include "jit_fallback.c" -# endif +# include "jit_fallback.c" #undef CODE void diff --git a/deps/lightning/lib/jit_sparc-cpu.c b/deps/lightning/lib/jit_sparc-cpu.c index f4ce6213..65628678 100644 --- a/deps/lightning/lib/jit_sparc-cpu.c +++ b/deps/lightning/lib/jit_sparc-cpu.c @@ -65,14 +65,16 @@ typedef union { struct { jit_uint32_t _: 13; jit_uint32_t b: 5; } rs1; struct { jit_uint32_t _: 18; jit_uint32_t b: 1; } i; struct { jit_uint32_t _: 18; jit_uint32_t b: 9; } opf; + struct { jit_uint32_t _: 18; jit_uint32_t b: 5; } rs3; struct { jit_uint32_t _: 19; jit_uint32_t b: 1; } x; struct { jit_uint32_t _: 19; jit_uint32_t b: 8; } asi; struct { jit_uint32_t _: 19; jit_uint32_t b: 6; } res; struct { jit_uint32_t _: 19; jit_uint32_t b: 13; } simm13; struct { jit_uint32_t _: 20; jit_uint32_t b: 7; } asix; struct { jit_uint32_t _: 20; jit_uint32_t b: 6; } asis; - struct { jit_uint32_t _: 26; jit_uint32_t b: 6; } shim; + struct { jit_uint32_t _: 23; jit_uint32_t b: 4; } op5; struct { jit_uint32_t _: 25; jit_uint32_t b: 7; } imm7; + struct { jit_uint32_t _: 26; jit_uint32_t b: 6; } shim; struct { jit_uint32_t _: 27; jit_uint32_t b: 5; } rs2; jit_int32_t v; } jit_instr_t; @@ -99,7 +101,7 @@ _f2bp(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t, # define f3r(op, rd, op3, rs1, rs2) _f3r(_jit, op, rd, op3, rs1, rs2) static void _f3r(jit_state_t*, jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); -# if __WORDSIZE == 64 +# if __WORDSIZE == 64 || CHECK_LZCNT # define f3ri(op, rd, op3, rs1, rs2) _f3ri(_jit, op, rd, op3, rs1, rs2) static void _f3ri(jit_state_t*, jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); @@ -243,7 +245,7 @@ _f2c1(jit_state_t*,jit_int32_t, jit_int32_t, # define SRLI(rs1, imm, rd) f3i(2, rd, 38, rs1, imm) # define SRA(rs1, rs2, rd) f3r(2, rd, 39, rs1, rs2) # define SRAI(rs1, imm, rd) f3i(2, rd, 39, rs1, imm) -# if __WORDSIZE == 64 +# if __WORDSIZE == 64 || CHECK_LZCNT # define SLLX(rs1, rs2, rd) f3rx(2, rd, 37, rs1, rs2) # define SLLXI(rs1, imm, rd) f3s(2, rd, 37, rs1, imm) # define SRLX(rs1, rs2, rd) f3rx(2, rd, 38, rs1, rs2) @@ -573,8 +575,6 @@ static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t, #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0) # define comr(r0, r1) XNOR(r1, 0, r0) # define negr(r0, r1) NEG(r1, r0) -# define bitswap(r0, r1) _bitswap(_jit, r0, r1) -static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t); # define clor(r0, r1) _clor(_jit, r0, r1) static void _clor(jit_state_t*, jit_int32_t, jit_int32_t); # define clzr(r0, r1) _clzr(_jit, r0, r1) @@ -630,6 +630,10 @@ static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t); # endif # define muli(r0, r1, i0) _muli(_jit, r0, r1, i0) static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2) +# define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0) +# define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2) +# define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0) # if __WORDSIZE == 32 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1) # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0) @@ -1205,7 +1209,7 @@ _f2c1(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_instr_t v; assert(!(op & 0xfffffffc)); assert(!(rd & 0xffffffe0)); - assert(!(res & 0xffffffc0)); + assert(!(op3 & 0xffffffc0)); assert(!(rs1 & 0xffffffe0)); assert(!(opf & 0xfffffe00)); assert(!(rs2 & 0xfffffe00)); @@ -1332,58 +1336,6 @@ _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_unget_reg(r1_reg); } -static void -_bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) -{ - jit_int32_t t0, t1, t2, t3, t4; - movr(r0, r1); - t0 = jit_get_reg(jit_class_gpr); - t1 = jit_get_reg(jit_class_gpr); - t2 = jit_get_reg(jit_class_gpr); - movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L); - rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L); - rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL); - rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL); - rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# if __WORDSIZE == 32 - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - lshi(rn(t2), r0, 16); /* t2 = v << 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# else - movi(rn(t0), 0x0000ffff0000ffffL); - rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */ - andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */ - andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/ - lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ - rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */ - lshi(rn(t2), r0, 32); /* t2 = v << 32 */ - orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */ -# endif - jit_unget_reg(t2); - jit_unget_reg(t1); - jit_unget_reg(t0); -} - static void _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -1398,20 +1350,21 @@ _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) static void _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { +# if CHECK_LZCNT if (jit_cpu.lzcnt) { -#if __WORDSIZE == 32 +# if __WORDSIZE == 32 jit_word_t w; SLLXI(r1, 32, r0); LZCNT(r0, r0); -#if __WORDSIZE == 32 w = blei(_jit->pc.w, r0, 31); rshi(r0, r0, 1); /* r0 is 64 */ patch_at(w, _jit->pc.w); -#endif -#else +# else LZCNT(r1, r0); +# endif } else +# endif fallback_clz(r0, r1); } @@ -1419,8 +1372,8 @@ static void _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { if (jit_cpu.lzcnt) { - bitswap(r0, r1); - clor(r0, r0); + comr(r0, r1); + ctzr(r0, r0); } else fallback_cto(r0, r1); @@ -1429,9 +1382,17 @@ _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) static void _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { + jit_int32_t t0, t1; if (jit_cpu.lzcnt) { - bitswap(r0, r1); - clzr(r0, r0); + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + negr(rn(t0), r1); + andr(rn(t0), rn(t0), r1); + clzr(r0, rn(t0)); + xori(rn(t1), r0, __WORDSIZE - 1); + movnr(r0, rn(t1), rn(t0)); + jit_unget_reg(t0); + jit_unget_reg(t1); } else fallback_ctz(r0, r1); @@ -1676,6 +1637,8 @@ static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) { + if (r0 == JIT_NOREG) + r0 = r1; if (sign) SMUL(r2, r3, r0); else @@ -1689,6 +1652,8 @@ _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, { jit_int32_t reg; if (s13_p(i0)) { + if (r0 == JIT_NOREG) + r0 = r1; if (sign) SMULI(r2, i0, r0); else @@ -1741,7 +1706,8 @@ _qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, movr(_O0_REGNO, r3); movr(_O1_REGNO, r2); calli((jit_word_t)__llmul); - movr(r0, _O1_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _O1_REGNO); movr(r1, _O0_REGNO); QMUL_EPILOG(); } @@ -1754,7 +1720,8 @@ _qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, movi(_O0_REGNO, i0); movr(_O1_REGNO, r2); calli((jit_word_t)__llmul); - movr(r0, _O1_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _O1_REGNO); movr(r1, _O0_REGNO); QMUL_EPILOG(); } @@ -1772,7 +1739,8 @@ _qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, movr(_O0_REGNO, r3); movr(_O1_REGNO, r2); calli((jit_word_t)__ullmul); - movr(r0, _O1_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _O1_REGNO); movr(r1, _O0_REGNO); QMUL_EPILOG(); } @@ -1785,7 +1753,8 @@ _qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, movi(_O0_REGNO, i0); movr(_O1_REGNO, r2); calli((jit_word_t)__ullmul); - movr(r0, _O1_REGNO); + if (r0 != JIT_NOREG) + movr(r0, _O1_REGNO); movr(r1, _O0_REGNO); QMUL_EPILOG(); } diff --git a/deps/lightning/lib/jit_sparc-fpu.c b/deps/lightning/lib/jit_sparc-fpu.c index d0e7e813..3cdb8708 100644 --- a/deps/lightning/lib/jit_sparc-fpu.c +++ b/deps/lightning/lib/jit_sparc-fpu.c @@ -93,6 +93,11 @@ # define f3f(rd, op3, rs1, opf, rs2) _f3f(_jit, rd, op3, rs1, opf, rs2) static void _f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t); +# define FPop3(rd, rs1, rs3, op5, rs2) f4f(rd, 55, rs1, rs3, op5, rs2) +# define f4f(rd,op3,rs1,rs3,op5,rs2) _f4f(_jit, rd,op3,rs1,rs3,op5,rs2) +static void +_f4f(jit_state_t*,jit_int32_t,jit_int32_t, + jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t); # define FITOS(rs2, rd) FPop1(rd, 0, 196, rs2) # define FITOD(rs2, rd) FPop1(rd, 0, 200, rs2) # define FITOQ(rs2, rd) FPop1(rd, 0, 204, rs2) @@ -139,6 +144,22 @@ _f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t); # define SPARC_FDIVS 77 # define SPARC_FDIVD 78 # define SPARC_FDIVQ 79 +# define SPARC_FMADDS 1 +# define SPARC_FMADDD 2 +# define SPARC_FMSUBS 5 +# define SPARC_FMSUBD 6 +# define SPARC_FNMSUBS 9 +# define SPARC_FNMSUBD 10 +# define SPARC_FNMADDS 13 +# define SPARC_FNMADDD 14 +# define FMADDS(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMADDS, rs2) +# define FMADDD(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMADDD, rs2) +# define FMSUBS(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMSUBS, rs2) +# define FMSUBD(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMSUBD, rs2) +# define FNMSUBS(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMSUBS,rs2) +# define FNMSUBD(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMSUBD,rs2) +# define FNMADDS(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMADDS,rs2) +# define FNMADDD(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMADDD,rs2) # define FADDS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDS, rs2) # define FADDD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDD, rs2) # define FADDQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDQ, rs2) @@ -171,10 +192,10 @@ _f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t); static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t); # if __WORDSIZSE == 32 # define truncr_f(r0, r1) truncr_f_i(r0, r1) -# define truncr_d(r0, r1) truncr_d_i(r0, r1) +# define truncr_d(r0, r1) truncr_d_i(r0, r1) # else # define truncr_f(r0, r1) truncr_f_l(r0, r1) -# define truncr_d(r0, r1) truncr_d_l(r0, r1) +# define truncr_d(r0, r1) truncr_d_l(r0, r1) # endif # define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1) static void _truncr_f_i(jit_state_t*, jit_int32_t, jit_int32_t); @@ -196,6 +217,8 @@ static void _extr_d_f(jit_state_t*, jit_int32_t, jit_int32_t); static void _movr_f(jit_state_t*, jit_int32_t, jit_int32_t); # endif static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t*); +# define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0) +static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # if __WORDSIZE == 32 # define negr_f(r0, r1) FNEGS(r1, r0) # define absr_f(r0, r1) FABSS(r1, r0) @@ -208,6 +231,28 @@ static void _absr_f(jit_state_t*, jit_int32_t, jit_int32_t); # define sqrtr_f(r0, r1) _sqrtr_f(_jit, r0, r1) static void _sqrtr_f(jit_state_t*, jit_int32_t, jit_int32_t); # endif +# if __WORDSIZE == 32 +# define fmar_f(r0, r1, r2, r3) FMADDS(r1, r2, r3, r0) +# define fmsr_f(r0, r1, r2, r3) FMSUBS(r1, r2, r3, r0) +# define fmar_d(r0, r1, r2, r3) FMADDD(r1, r2, r3, r0) +# define fmsr_d(r0, r1, r2, r3) FMSUBD(r1, r2, r3, r0) +# define fnmar_f(r0, r1, r2, r3) FNMADDS(r1, r2, r3, r0) +# define fnmsr_f(r0, r1, r2, r3) FNMSUBS(r1, r2, r3, r0) +# define fnmar_d(r0, r1, r2, r3) FNMADDD(r1, r2, r3, r0) +# define fnmsr_d(r0, r1, r2, r3) FNMSUBD(r1, r2, r3, r0) +# else +# define fop3f(op, r0, r1, r2, r3) _fop3f(_jit, op, r0, r1, r2, r3) +static void _fop3f(jit_state_t*, jit_int32_t, jit_int32_t, + jit_int32_t, jit_int32_t, jit_int32_t); +# define fmar_f(r0, r1, r2, r3) fop3f(SPARC_FMADDS, r0, r1, r2, r3) +# define fmsr_f(r0, r1, r2, r3) fop3f(SPARC_FMSUBS, r0, r1, r2, r3) +# define fmar_d(r0, r1, r2, r3) fop3f(SPARC_FMADDD, r0, r1, r2, r3) +# define fmsr_d(r0, r1, r2, r3) fop3f(SPARC_FMSUBD, r0, r1, r2, r3) +# define fnmar_f(r0, r1, r2, r3) fop3f(SPARC_FNMADDS, r0, r1, r2, r3) +# define fnmsr_f(r0, r1, r2, r3) fop3f(SPARC_FNMSUBS, r0, r1, r2, r3) +# define fnmar_d(r0, r1, r2, r3) fop3f(SPARC_FNMADDD, r0, r1, r2, r3) +# define fnmsr_d(r0, r1, r2, r3) fop3f(SPARC_FNMSUBD, r0, r1, r2, r3) +# endif # define extr_d(r0, r1) _extr_d(_jit, r0, r1) static void _extr_d(jit_state_t*, jit_int32_t, jit_int32_t); # define truncr_d_i(r0, r1) _truncr_d_i(_jit, r0, r1) @@ -225,14 +270,18 @@ static void _extr_f_d(jit_state_t*, jit_int32_t, jit_int32_t); # define movi_d(r0, i0) _movi_d(_jit, r0, i0) static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t*); # if __WORDSIZE == 32 -# define movr_d(r0, r1) _movr_d(_jit, r0, r1) +# define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1) +static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define movr_d(r0, r1) _movr_d(_jit, r0, r1) static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t); -# define negr_d(r0, r1) _negr_d(_jit, r0, r1) +# define negr_d(r0, r1) _negr_d(_jit, r0, r1) static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t); -# define absr_d(r0, r1) _absr_d(_jit, r0, r1) +# define absr_d(r0, r1) _absr_d(_jit, r0, r1) static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t); # else # define movr_d(r0, r1) FMOVD(r1, r0) +# define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0) +static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); # define negr_d(r0, r1) FNEGD(r1, r0) # define absr_d(r0, r1) FABSD(r1, r0) # endif @@ -497,6 +546,45 @@ _f3f(jit_state_t *_jit, jit_int32_t rd, ii(v.v); } +static void +_f4f(jit_state_t *_jit, jit_int32_t rd, jit_int32_t op3, + jit_int32_t rs1, jit_int32_t rs3, jit_int32_t op5, jit_int32_t rs2) +{ + jit_instr_t v; +# if __WORDSIZE == 64 + if (rd > 31) { + assert(rd <= 63 && (rd & 1) == 0); + rd -= 31; + } + if (rs1 > 31) { + assert(rs1 <= 63 && (rs1 & 1) == 0); + rs1 -= 31; + } + if (rs2 > 31) { + assert(rs2 <= 63 && (rs2 & 1) == 0); + rs2 -= 31; + } + if (rs3 > 31) { + assert(rs3 <= 63 && (rs3 & 1) == 0); + rs3 -= 31; + } +# endif + assert(!(rd & 0xffffffe0)); + assert(!(op3 & 0xffffffc0)); + assert(!(rs1 & 0xffffffe0)); + assert(!(rs3 & 0xffffffe0)); + assert(!(op5 & 0xfffffff0)); + assert(!(rs2 & 0xffffffe0)); + v.op.b = 2; + v.rd.b = rd; + v.op3.b = op3; + v.rs1.b = rs1; + v.rs3.b = rs3; + v.op5.b = op5; + v.rs2.b = rs2; + ii(v.v); +} + # if __WORDSIZE == 64 /* Handle the special case of using all float registers, as exercised * in check/carg.c. @@ -701,6 +789,16 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) ldi_f(r0, (jit_word_t)i0); } +static void +_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_f(r0, rn(reg)); + jit_unget_reg(reg); +} + # if __WORDSIZE == 64 static void _extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) @@ -751,6 +849,19 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) } # if __WORDSIZE == 32 +static void +_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, t1; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), i0); + movi(rn(t1), i1); + movr_ww_d(r0, rn(t0), rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); +} + static void _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -781,6 +892,16 @@ _absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) if (r0 != r1) FMOVS(r1 + 1, r0 + 1); } +# else +static void +_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movr_w_d(r0, rn(reg)); + jit_unget_reg(reg); +} # endif # if __WORDSIZE == 64 @@ -893,6 +1014,83 @@ _fop2f(jit_state_t *_jit, jit_int32_t op, if (mask & 4) jit_unget_reg(t2); } + +static void +_fop3f(jit_state_t *_jit, jit_int32_t op, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t x0, t0, x1, t1, x2, t2, x3, t3, mask = 0; + if (!single_precision_p(r0)) { + mask |= 1; + t0 = jit_get_reg(CLASS_SNG); + x0 = rn(t0); + if (r0 == r1) { + x1 = x0; + movr_d(x1, r1); + if (r0 == r2) + x2 = x0; + if (r0 == r3) + x3 = x0; + } + else if (r0 == r2) { + x2 = x0; + movr_d(x2, r2); + } + else if (r0 == r3) { + x3 = x0; + movr_d(x3, r3); + } + } + else + x0 = r0; + if (!single_precision_p(r1)) { + if (r0 != r1) { + mask |= 2; + t1 = jit_get_reg(CLASS_SNG); + x1 = rn(t1); + movr_d(x1, r1); + if (r1 == r2) + x2 = x1; + if (r1 == r3) + x3 = x1; + } + } + else + x1 = r1; + if (!single_precision_p(r2)) { + if (r0 != r2 && r1 != r2) { + mask |= 4; + t2 = jit_get_reg(CLASS_SNG); + x2 = rn(t2); + movr_d(x2, r2); + if (r2 == r3) + x3 = x2; + } + } + else + x2 = r2; + if (!single_precision_p(r3)) { + if (r0 != r3 && r1 != r3 && r2 != r3) { + mask |= 8; + t3 = jit_get_reg(CLASS_SNG); + x3 = rn(t3); + movr_d(x3, r3); + } + } + else + x3 = r3; + FPop3(x0, x1, x3, op, x2); + if (mask & 1) { + movr_d(r0, x0); + jit_unget_reg(t0); + } + if (mask & 2) + jit_unget_reg(t1); + if (mask & 4) + jit_unget_reg(t2); + if (mask & 8) + jit_unget_reg(t3); +} # endif static void diff --git a/deps/lightning/lib/jit_sparc-sz.c b/deps/lightning/lib/jit_sparc-sz.c index 95954d93..8a4ce7bf 100644 --- a/deps/lightning/lib/jit_sparc-sz.c +++ b/deps/lightning/lib/jit_sparc-sz.c @@ -1,5 +1,5 @@ #if __WORDSIZE == 32 -#define JIT_INSTR_MAX 180 +#define JIT_INSTR_MAX 184 0, /* data */ 0, /* live */ 0, /* align */ @@ -9,7 +9,7 @@ 0, /* #name */ 0, /* #note */ 0, /* label */ - 36, /* prolog */ + 36, /* prolog */ 0, /* ellipsis */ 0, /* va_push */ 0, /* allocai */ @@ -41,45 +41,45 @@ 0, /* putargi_l */ 4, /* va_start */ 8, /* va_arg */ - 12, /* va_arg_d */ + 12, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 12, /* addi */ + 12, /* addi */ 4, /* addcr */ - 12, /* addci */ + 12, /* addci */ 4, /* addxr */ 4, /* addxi */ 4, /* subr */ - 12, /* subi */ + 12, /* subi */ 4, /* subcr */ - 12, /* subci */ + 12, /* subci */ 4, /* subxr */ 4, /* subxi */ - 16, /* rsbi */ + 16, /* rsbi */ 4, /* mulr */ - 12, /* muli */ + 12, /* muli */ 8, /* qmulr */ - 16, /* qmuli */ + 16, /* qmuli */ 8, /* qmulr_u */ - 16, /* qmuli_u */ - 12, /* divr */ - 20, /* divi */ + 16, /* qmuli_u */ + 12, /* divr */ + 20, /* divi */ 8, /* divr_u */ - 16, /* divi_u */ - 28, /* qdivr */ - 24, /* qdivi */ - 24, /* qdivr_u */ - 20, /* qdivi_u */ - 20, /* remr */ - 28, /* remi */ - 16, /* remr_u */ - 24, /* remi_u */ + 16, /* divi_u */ + 28, /* qdivr */ + 24, /* qdivi */ + 24, /* qdivr_u */ + 20, /* qdivi_u */ + 20, /* remr */ + 28, /* remi */ + 16, /* remr_u */ + 24, /* remi_u */ 4, /* andr */ - 12, /* andi */ + 12, /* andi */ 4, /* orr */ - 12, /* ori */ + 12, /* ori */ 4, /* xorr */ - 12, /* xori */ + 12, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -87,55 +87,69 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 16, /* ltr */ - 16, /* lti */ - 16, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 16, /* eqr */ - 16, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 16, /* gtr */ - 16, /* gti */ - 16, /* gtr_u */ - 16, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 16, /* ltr */ + 16, /* lti */ + 16, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 16, /* eqr */ + 16, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 16, /* gtr */ + 16, /* gti */ + 16, /* gtr_u */ + 16, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ 8, /* movi */ - 16, /* movnr */ - 16, /* movzr */ - 24, /* casr */ - 32, /* casi */ + 16, /* movnr */ + 16, /* movzr */ + 24, /* casr */ + 32, /* casi */ 8, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 8, /* extr_s */ + 4, /* exti_s */ 8, /* extr_us */ + 8, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ - 20, /* bswapr_us */ - 52, /* bswapr_ui */ + 0, /* exti_ui */ + 20, /* bswapr_us */ + 8, /* bswapi_us */ + 52, /* bswapr_ui */ + 8, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 8, /* htonr_us */ + 8, /* htoni_us */ 4, /* htonr_ui */ + 8, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 4, /* ldr_c */ - 12, /* ldi_c */ + 12, /* ldi_c */ 4, /* ldr_uc */ - 12, /* ldi_uc */ + 12, /* ldi_uc */ 4, /* ldr_s */ - 12, /* ldi_s */ + 12, /* ldi_s */ 4, /* ldr_us */ - 12, /* ldi_us */ + 12, /* ldi_us */ 4, /* ldr_i */ - 12, /* ldi_i */ + 12, /* ldi_i */ 0, /* ldr_ui */ 0, /* ldi_ui */ 0, /* ldr_l */ @@ -155,11 +169,11 @@ 0, /* ldxr_l */ 0, /* ldxi_l */ 4, /* str_c */ - 12, /* sti_c */ + 12, /* sti_c */ 4, /* str_s */ - 12, /* sti_s */ + 12, /* sti_s */ 4, /* str_i */ - 12, /* sti_i */ + 12, /* sti_i */ 0, /* str_l */ 0, /* sti_l */ 4, /* stxr_c */ @@ -170,46 +184,46 @@ 8, /* stxi_i */ 0, /* stxr_l */ 0, /* stxi_l */ - 12, /* bltr */ - 12, /* blti */ - 12, /* bltr_u */ - 12, /* blti_u */ - 12, /* bler */ - 12, /* blei */ - 12, /* bler_u */ - 12, /* blei_u */ - 12, /* beqr */ - 20, /* beqi */ - 12, /* bger */ - 12, /* bgei */ - 12, /* bger_u */ - 12, /* bgei_u */ - 12, /* bgtr */ - 12, /* bgti */ - 12, /* bgtr_u */ - 12, /* bgti_u */ - 12, /* bner */ - 20, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 12, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 12, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 12, /* bosubi */ - 12, /* bosubr_u */ - 12, /* bosubi_u */ - 12, /* bxsubr */ - 12, /* bxsubi */ - 12, /* bxsubr_u */ - 12, /* bxsubi_u */ + 12, /* bltr */ + 12, /* blti */ + 12, /* bltr_u */ + 12, /* blti_u */ + 12, /* bler */ + 12, /* blei */ + 12, /* bler_u */ + 12, /* blei_u */ + 12, /* beqr */ + 20, /* beqi */ + 12, /* bger */ + 12, /* bgei */ + 12, /* bger_u */ + 12, /* bgei_u */ + 12, /* bgtr */ + 12, /* bgti */ + 12, /* bgtr_u */ + 12, /* bgti_u */ + 12, /* bner */ + 20, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 12, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 12, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 12, /* bosubi */ + 12, /* bosubr_u */ + 12, /* bosubi_u */ + 12, /* bxsubr */ + 12, /* bxsubi */ + 12, /* bxsubr_u */ + 12, /* bxsubi_u */ 8, /* jmpr */ 8, /* jmpi */ 8, /* callr */ @@ -253,93 +267,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 44, /* epilog */ + 44, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ 4, /* addr_f */ - 16, /* addi_f */ + 16, /* addi_f */ 4, /* subr_f */ - 16, /* subi_f */ - 16, /* rsbi_f */ + 16, /* subi_f */ + 16, /* rsbi_f */ 4, /* mulr_f */ - 16, /* muli_f */ + 16, /* muli_f */ 4, /* divr_f */ - 16, /* divi_f */ + 16, /* divi_f */ 4, /* negr_f */ + 0, /* negi_f */ 4, /* absr_f */ + 0, /* absi_f */ 4, /* sqrtr_f */ - 16, /* ltr_f */ - 32, /* lti_f */ - 16, /* ler_f */ - 32, /* lei_f */ - 16, /* eqr_f */ - 32, /* eqi_f */ - 16, /* ger_f */ - 32, /* gei_f */ - 16, /* gtr_f */ - 32, /* gti_f */ - 16, /* ner_f */ - 32, /* nei_f */ - 16, /* unltr_f */ - 32, /* unlti_f */ - 16, /* unler_f */ - 32, /* unlei_f */ - 16, /* uneqr_f */ - 32, /* uneqi_f */ - 16, /* unger_f */ - 32, /* ungei_f */ - 16, /* ungtr_f */ - 32, /* ungti_f */ - 16, /* ltgtr_f */ - 32, /* ltgti_f */ - 16, /* ordr_f */ - 32, /* ordi_f */ - 16, /* unordr_f */ - 32, /* unordi_f */ - 12, /* truncr_f_i */ + 0, /* sqrti_f */ + 16, /* ltr_f */ + 32, /* lti_f */ + 16, /* ler_f */ + 32, /* lei_f */ + 16, /* eqr_f */ + 32, /* eqi_f */ + 16, /* ger_f */ + 32, /* gei_f */ + 16, /* gtr_f */ + 32, /* gti_f */ + 16, /* ner_f */ + 32, /* nei_f */ + 16, /* unltr_f */ + 32, /* unlti_f */ + 16, /* unler_f */ + 32, /* unlei_f */ + 16, /* uneqr_f */ + 32, /* uneqi_f */ + 16, /* unger_f */ + 32, /* ungei_f */ + 16, /* ungtr_f */ + 32, /* ungti_f */ + 16, /* ltgtr_f */ + 32, /* ltgti_f */ + 16, /* ordr_f */ + 32, /* ordi_f */ + 16, /* unordr_f */ + 32, /* unordi_f */ + 12, /* truncr_f_i */ 0, /* truncr_f_l */ - 12, /* extr_f */ + 12, /* extr_f */ 4, /* extr_d_f */ 4, /* movr_f */ - 16, /* movi_f */ + 16, /* movi_f */ 4, /* ldr_f */ - 12, /* ldi_f */ + 12, /* ldi_f */ 4, /* ldxr_f */ 8, /* ldxi_f */ 4, /* str_f */ - 12, /* sti_f */ + 12, /* sti_f */ 4, /* stxr_f */ 8, /* stxi_f */ - 12, /* bltr_f */ - 24, /* blti_f */ - 12, /* bler_f */ - 24, /* blei_f */ - 12, /* beqr_f */ - 24, /* beqi_f */ - 12, /* bger_f */ - 24, /* bgei_f */ - 12, /* bgtr_f */ - 24, /* bgti_f */ - 12, /* bner_f */ - 28, /* bnei_f */ - 12, /* bunltr_f */ - 28, /* bunlti_f */ - 12, /* bunler_f */ - 28, /* bunlei_f */ - 12, /* buneqr_f */ - 28, /* buneqi_f */ - 12, /* bunger_f */ - 28, /* bungei_f */ - 12, /* bungtr_f */ - 28, /* bungti_f */ - 12, /* bltgtr_f */ - 24, /* bltgti_f */ - 12, /* bordr_f */ - 24, /* bordi_f */ - 12, /* bunordr_f */ - 28, /* bunordi_f */ + 12, /* bltr_f */ + 24, /* blti_f */ + 12, /* bler_f */ + 24, /* blei_f */ + 12, /* beqr_f */ + 24, /* beqi_f */ + 12, /* bger_f */ + 24, /* bgei_f */ + 12, /* bgtr_f */ + 24, /* bgti_f */ + 12, /* bner_f */ + 28, /* bnei_f */ + 12, /* bunltr_f */ + 28, /* bunlti_f */ + 12, /* bunler_f */ + 28, /* bunlei_f */ + 12, /* buneqr_f */ + 28, /* buneqi_f */ + 12, /* bunger_f */ + 28, /* bungei_f */ + 12, /* bungtr_f */ + 28, /* bungti_f */ + 12, /* bltgtr_f */ + 24, /* bltgti_f */ + 12, /* bordr_f */ + 24, /* bordi_f */ + 12, /* bunordr_f */ + 28, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -350,119 +367,181 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 24, /* addi_d */ + 24, /* addi_d */ 4, /* subr_d */ - 24, /* subi_d */ - 24, /* rsbi_d */ + 24, /* subi_d */ + 24, /* rsbi_d */ 4, /* mulr_d */ - 24, /* muli_d */ + 24, /* muli_d */ 4, /* divr_d */ - 24, /* divi_d */ + 24, /* divi_d */ 8, /* negr_d */ + 0, /* negi_d */ 8, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 16, /* ltr_d */ - 40, /* lti_d */ - 16, /* ler_d */ - 40, /* lei_d */ - 16, /* eqr_d */ - 40, /* eqi_d */ - 16, /* ger_d */ - 40, /* gei_d */ - 16, /* gtr_d */ - 40, /* gti_d */ - 16, /* ner_d */ - 40, /* nei_d */ - 16, /* unltr_d */ - 40, /* unlti_d */ - 16, /* unler_d */ - 40, /* unlei_d */ - 16, /* uneqr_d */ - 40, /* uneqi_d */ - 16, /* unger_d */ - 40, /* ungei_d */ - 16, /* ungtr_d */ - 40, /* ungti_d */ - 16, /* ltgtr_d */ - 40, /* ltgti_d */ - 16, /* ordr_d */ - 40, /* ordi_d */ - 16, /* unordr_d */ - 40, /* unordi_d */ - 12, /* truncr_d_i */ + 0, /* sqrti_d */ + 16, /* ltr_d */ + 40, /* lti_d */ + 16, /* ler_d */ + 40, /* lei_d */ + 16, /* eqr_d */ + 40, /* eqi_d */ + 16, /* ger_d */ + 40, /* gei_d */ + 16, /* gtr_d */ + 40, /* gti_d */ + 16, /* ner_d */ + 40, /* nei_d */ + 16, /* unltr_d */ + 40, /* unlti_d */ + 16, /* unler_d */ + 40, /* unlei_d */ + 16, /* uneqr_d */ + 40, /* uneqi_d */ + 16, /* unger_d */ + 40, /* ungei_d */ + 16, /* ungtr_d */ + 40, /* ungti_d */ + 16, /* ltgtr_d */ + 40, /* ltgti_d */ + 16, /* ordr_d */ + 40, /* ordi_d */ + 16, /* unordr_d */ + 40, /* unordi_d */ + 12, /* truncr_d_i */ 0, /* truncr_d_l */ - 16, /* extr_d */ + 16, /* extr_d */ 4, /* extr_f_d */ 8, /* movr_d */ - 24, /* movi_d */ + 24, /* movi_d */ 4, /* ldr_d */ - 12, /* ldi_d */ + 12, /* ldi_d */ 4, /* ldxr_d */ 8, /* ldxi_d */ 4, /* str_d */ - 12, /* sti_d */ + 12, /* sti_d */ 4, /* stxr_d */ 8, /* stxi_d */ - 12, /* bltr_d */ - 32, /* blti_d */ - 12, /* bler_d */ - 32, /* blei_d */ - 12, /* beqr_d */ - 32, /* beqi_d */ - 12, /* bger_d */ - 32, /* bgei_d */ - 12, /* bgtr_d */ - 32, /* bgti_d */ - 12, /* bner_d */ - 36, /* bnei_d */ - 12, /* bunltr_d */ - 36, /* bunlti_d */ - 12, /* bunler_d */ - 36, /* bunlei_d */ - 12, /* buneqr_d */ - 36, /* buneqi_d */ - 12, /* bunger_d */ - 36, /* bungei_d */ - 12, /* bungtr_d */ - 36, /* bungti_d */ - 12, /* bltgtr_d */ - 32, /* bltgti_d */ - 12, /* bordr_d */ - 32, /* bordi_d */ - 12, /* bunordr_d */ - 36, /* bunordi_d */ + 12, /* bltr_d */ + 32, /* blti_d */ + 12, /* bler_d */ + 32, /* blei_d */ + 12, /* beqr_d */ + 32, /* beqi_d */ + 12, /* bger_d */ + 32, /* bgei_d */ + 12, /* bgtr_d */ + 32, /* bgti_d */ + 12, /* bner_d */ + 36, /* bnei_d */ + 12, /* bunltr_d */ + 36, /* bunlti_d */ + 12, /* bunler_d */ + 36, /* bunlei_d */ + 12, /* buneqr_d */ + 36, /* buneqi_d */ + 12, /* bunger_d */ + 36, /* bungei_d */ + 12, /* bungtr_d */ + 36, /* bungti_d */ + 12, /* bltgtr_d */ + 32, /* bltgti_d */ + 12, /* bordr_d */ + 32, /* bordi_d */ + 12, /* bunordr_d */ + 36, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 8, /* movr_w_f */ + 12, /* movi_w_f */ + 12, /* movr_ww_d */ + 20, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 8, /* movr_f_w */ + 4, /* movi_f_w */ + 12, /* movr_d_ww */ + 8, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 176, /* clo */ - 148, /* clz */ - 180, /* cto */ - 152, /* ctz */ + 92, /* clor */ + 4, /* cloi */ + 64, /* clzr */ + 4, /* clzi */ + 68, /* ctor */ + 4, /* ctoi */ + 40, /* ctzr */ + 4, /* ctzi */ + 60, /* rbitr */ + 8, /* rbiti */ + 56, /* popcntr */ + 4, /* popcnti */ + 20, /* lrotr */ + 12, /* lroti */ + 20, /* rrotr */ + 12, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 16, /* extr_u */ + 4, /* exti_u */ + 32, /* depr */ + 20, /* depi */ + 72, /* qlshr */ + 8, /* qlshi */ + 72, /* qlshr_u */ + 8, /* qlshi_u */ + 72, /* qrshr */ + 8, /* qrshi */ + 72, /* qrshr_u */ + 8, /* qrshi_u */ + 76, /* unldr */ + 40, /* unldi */ + 76, /* unldr_u */ + 40, /* unldi_u */ + 84, /* unstr */ + 44, /* unsti */ + 156, /* unldr_x */ + 84, /* unldi_x */ + 184, /* unstr_x */ + 100, /* unsti_x */ + 4, /* fmar_f */ + 0, /* fmai_f */ + 4, /* fmsr_f */ + 0, /* fmsi_f */ + 4, /* fmar_d */ + 0, /* fmai_d */ + 4, /* fmsr_d */ + 0, /* fmsi_d */ + 4, /* fnmar_f */ + 0, /* fnmai_f */ + 4, /* fnmsr_f */ + 0, /* fnmsi_f */ + 4, /* fnmar_d */ + 0, /* fnmai_d */ + 4, /* fnmsr_d */ + 0, /* fnmsi_d */ + 8, /* hmulr */ + 16, /* hmuli */ + 8, /* hmulr_u */ + 16, /* hmuli_u */ #endif /* __WORDSIZE */ #if __WORDSIZE == 64 -#define JIT_INSTR_MAX 216 +#define JIT_INSTR_MAX 196 0, /* data */ 0, /* live */ - 24, /* align */ + 24, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ 0, /* #name */ 0, /* #note */ 4, /* label */ - 36, /* prolog */ + 36, /* prolog */ 0, /* ellipsis */ 0, /* va_push */ 0, /* allocai */ @@ -497,42 +576,42 @@ 8, /* va_arg_d */ 0, /* va_end */ 4, /* addr */ - 28, /* addi */ - 24, /* addcr */ - 48, /* addci */ - 52, /* addxr */ - 52, /* addxi */ + 28, /* addi */ + 24, /* addcr */ + 48, /* addci */ + 52, /* addxr */ + 52, /* addxi */ 4, /* subr */ - 28, /* subi */ - 24, /* subcr */ - 48, /* subci */ - 52, /* subxr */ - 52, /* subxi */ - 32, /* rsbi */ + 28, /* subi */ + 24, /* subcr */ + 48, /* subci */ + 52, /* subxr */ + 52, /* subxi */ + 32, /* rsbi */ 4, /* mulr */ - 28, /* muli */ - 48, /* qmulr */ - 64, /* qmuli */ - 48, /* qmulr_u */ - 64, /* qmuli_u */ + 28, /* muli */ + 48, /* qmulr */ + 64, /* qmuli */ + 48, /* qmulr_u */ + 64, /* qmuli_u */ 4, /* divr */ - 28, /* divi */ + 28, /* divi */ 4, /* divr_u */ - 28, /* divi_u */ - 20, /* qdivr */ - 16, /* qdivi */ - 20, /* qdivr_u */ - 16, /* qdivi_u */ - 12, /* remr */ - 36, /* remi */ - 12, /* remr_u */ - 36, /* remi_u */ + 28, /* divi_u */ + 20, /* qdivr */ + 16, /* qdivi */ + 20, /* qdivr_u */ + 16, /* qdivi_u */ + 12, /* remr */ + 36, /* remi */ + 12, /* remr_u */ + 36, /* remi_u */ 4, /* andr */ - 28, /* andi */ + 28, /* andi */ 4, /* orr */ - 28, /* ori */ + 28, /* ori */ 4, /* xorr */ - 28, /* xori */ + 28, /* xori */ 4, /* lshr */ 4, /* lshi */ 4, /* rshr */ @@ -540,133 +619,147 @@ 4, /* rshr_u */ 4, /* rshi_u */ 4, /* negr */ + 4, /* negi */ 4, /* comr */ - 16, /* ltr */ - 16, /* lti */ - 16, /* ltr_u */ - 16, /* lti_u */ - 16, /* ler */ - 16, /* lei */ - 16, /* ler_u */ - 16, /* lei_u */ - 16, /* eqr */ - 16, /* eqi */ - 16, /* ger */ - 16, /* gei */ - 16, /* ger_u */ - 16, /* gei_u */ - 16, /* gtr */ - 16, /* gti */ - 16, /* gtr_u */ - 16, /* gti_u */ - 16, /* ner */ - 16, /* nei */ + 4, /* comi */ + 16, /* ltr */ + 16, /* lti */ + 16, /* ltr_u */ + 16, /* lti_u */ + 16, /* ler */ + 16, /* lei */ + 16, /* ler_u */ + 16, /* lei_u */ + 16, /* eqr */ + 16, /* eqi */ + 16, /* ger */ + 16, /* gei */ + 16, /* ger_u */ + 16, /* gei_u */ + 16, /* gtr */ + 16, /* gti */ + 16, /* gtr_u */ + 16, /* gti_u */ + 16, /* ner */ + 16, /* nei */ 4, /* movr */ - 24, /* movi */ - 16, /* movnr */ - 16, /* movzr */ - 24, /* casr */ - 44, /* casi */ + 24, /* movi */ + 16, /* movnr */ + 16, /* movzr */ + 24, /* casr */ + 44, /* casi */ 8, /* extr_c */ + 4, /* exti_c */ 4, /* extr_uc */ + 4, /* exti_uc */ 8, /* extr_s */ + 4, /* exti_s */ 8, /* extr_us */ + 8, /* exti_us */ 8, /* extr_i */ + 20, /* exti_i */ 8, /* extr_ui */ - 20, /* bswapr_us */ - 52, /* bswapr_ui */ + 4, /* exti_ui */ + 20, /* bswapr_us */ + 8, /* bswapi_us */ + 52, /* bswapr_ui */ + 8, /* bswapi_ui */ 116, /* bswapr_ul */ + 24, /* bswapi_ul */ 8, /* htonr_us */ + 8, /* htoni_us */ 8, /* htonr_ui */ + 8, /* htoni_ui */ 4, /* htonr_ul */ + 24, /* htoni_ul */ 4, /* ldr_c */ - 24, /* ldi_c */ + 24, /* ldi_c */ 4, /* ldr_uc */ - 28, /* ldi_uc */ + 28, /* ldi_uc */ 4, /* ldr_s */ - 28, /* ldi_s */ + 28, /* ldi_s */ 4, /* ldr_us */ - 28, /* ldi_us */ + 28, /* ldi_us */ 4, /* ldr_i */ - 28, /* ldi_i */ + 28, /* ldi_i */ 4, /* ldr_ui */ - 28, /* ldi_ui */ + 28, /* ldi_ui */ 4, /* ldr_l */ - 28, /* ldi_l */ + 28, /* ldi_l */ 4, /* ldxr_c */ - 24, /* ldxi_c */ + 24, /* ldxi_c */ 4, /* ldxr_uc */ - 24, /* ldxi_uc */ + 24, /* ldxi_uc */ 4, /* ldxr_s */ - 24, /* ldxi_s */ + 24, /* ldxi_s */ 4, /* ldxr_us */ - 24, /* ldxi_us */ + 24, /* ldxi_us */ 4, /* ldxr_i */ - 24, /* ldxi_i */ + 24, /* ldxi_i */ 4, /* ldxr_ui */ - 24, /* ldxi_ui */ + 24, /* ldxi_ui */ 4, /* ldxr_l */ - 24, /* ldxi_l */ + 24, /* ldxi_l */ 4, /* str_c */ - 28, /* sti_c */ + 28, /* sti_c */ 4, /* str_s */ - 28, /* sti_s */ + 28, /* sti_s */ 4, /* str_i */ - 28, /* sti_i */ + 28, /* sti_i */ 4, /* str_l */ - 28, /* sti_l */ + 28, /* sti_l */ 4, /* stxr_c */ - 24, /* stxi_c */ + 24, /* stxi_c */ 4, /* stxr_s */ - 24, /* stxi_s */ + 24, /* stxi_s */ 4, /* stxr_i */ - 24, /* stxi_i */ + 24, /* stxi_i */ 4, /* stxr_l */ - 24, /* stxi_l */ - 12, /* bltr */ - 12, /* blti */ - 12, /* bltr_u */ - 12, /* blti_u */ - 12, /* bler */ - 12, /* blei */ - 12, /* bler_u */ - 12, /* blei_u */ - 12, /* beqr */ - 36, /* beqi */ - 12, /* bger */ - 12, /* bgei */ - 12, /* bger_u */ - 12, /* bgei_u */ - 12, /* bgtr */ - 12, /* bgti */ - 12, /* bgtr_u */ - 12, /* bgti_u */ - 12, /* bner */ - 36, /* bnei */ - 12, /* bmsr */ - 12, /* bmsi */ - 12, /* bmcr */ - 12, /* bmci */ - 12, /* boaddr */ - 12, /* boaddi */ - 12, /* boaddr_u */ - 12, /* boaddi_u */ - 12, /* bxaddr */ - 12, /* bxaddi */ - 12, /* bxaddr_u */ - 12, /* bxaddi_u */ - 12, /* bosubr */ - 12, /* bosubi */ - 12, /* bosubr_u */ - 12, /* bosubi_u */ - 12, /* bxsubr */ - 12, /* bxsubi */ - 12, /* bxsubr_u */ - 12, /* bxsubi_u */ + 24, /* stxi_l */ + 12, /* bltr */ + 12, /* blti */ + 12, /* bltr_u */ + 12, /* blti_u */ + 12, /* bler */ + 12, /* blei */ + 12, /* bler_u */ + 12, /* blei_u */ + 12, /* beqr */ + 36, /* beqi */ + 12, /* bger */ + 12, /* bgei */ + 12, /* bger_u */ + 12, /* bgei_u */ + 12, /* bgtr */ + 12, /* bgti */ + 12, /* bgtr_u */ + 12, /* bgti_u */ + 12, /* bner */ + 36, /* bnei */ + 12, /* bmsr */ + 12, /* bmsi */ + 12, /* bmcr */ + 12, /* bmci */ + 12, /* boaddr */ + 12, /* boaddi */ + 12, /* boaddr_u */ + 12, /* boaddi_u */ + 12, /* bxaddr */ + 12, /* bxaddi */ + 12, /* bxaddr_u */ + 12, /* bxaddi_u */ + 12, /* bosubr */ + 12, /* bosubi */ + 12, /* bosubr_u */ + 12, /* bosubi_u */ + 12, /* bxsubr */ + 12, /* bxsubi */ + 12, /* bxsubr_u */ + 12, /* bxsubi_u */ 8, /* jmpr */ 8, /* jmpi */ 8, /* callr */ - 40, /* calli */ + 40, /* calli */ 0, /* prepare */ 0, /* pushargr_c */ 0, /* pushargi_c */ @@ -706,93 +799,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 44, /* epilog */ + 44, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ - 16, /* addr_f */ - 40, /* addi_f */ - 24, /* subr_f */ - 40, /* subi_f */ - 40, /* rsbi_f */ - 16, /* mulr_f */ - 40, /* muli_f */ - 16, /* divr_f */ - 40, /* divi_f */ - 12, /* negr_f */ - 12, /* absr_f */ - 12, /* sqrtr_f */ - 24, /* ltr_f */ - 48, /* lti_f */ - 24, /* ler_f */ - 48, /* lei_f */ - 24, /* eqr_f */ - 48, /* eqi_f */ - 24, /* ger_f */ - 48, /* gei_f */ - 24, /* gtr_f */ - 48, /* gti_f */ - 24, /* ner_f */ - 48, /* nei_f */ - 24, /* unltr_f */ - 48, /* unlti_f */ - 24, /* unler_f */ - 48, /* unlei_f */ - 24, /* uneqr_f */ - 48, /* uneqi_f */ - 24, /* unger_f */ - 48, /* ungei_f */ - 24, /* ungtr_f */ - 48, /* ungti_f */ - 24, /* ltgtr_f */ - 48, /* ltgti_f */ - 24, /* ordr_f */ - 48, /* ordi_f */ - 24, /* unordr_f */ - 48, /* unordi_f */ - 16, /* truncr_f_i */ - 16, /* truncr_f_l */ - 20, /* extr_f */ - 12, /* extr_d_f */ - 24, /* movr_f */ - 32, /* movi_f */ + 16, /* addr_f */ + 40, /* addi_f */ + 24, /* subr_f */ + 40, /* subi_f */ + 40, /* rsbi_f */ + 16, /* mulr_f */ + 40, /* muli_f */ + 16, /* divr_f */ + 40, /* divi_f */ + 12, /* negr_f */ + 0, /* negi_f */ + 12, /* absr_f */ + 0, /* absi_f */ + 12, /* sqrtr_f */ + 0, /* sqrti_f */ + 24, /* ltr_f */ + 48, /* lti_f */ + 24, /* ler_f */ + 48, /* lei_f */ + 24, /* eqr_f */ + 48, /* eqi_f */ + 24, /* ger_f */ + 48, /* gei_f */ + 24, /* gtr_f */ + 48, /* gti_f */ + 24, /* ner_f */ + 48, /* nei_f */ + 24, /* unltr_f */ + 48, /* unlti_f */ + 24, /* unler_f */ + 48, /* unlei_f */ + 24, /* uneqr_f */ + 48, /* uneqi_f */ + 24, /* unger_f */ + 48, /* ungei_f */ + 24, /* ungtr_f */ + 48, /* ungti_f */ + 24, /* ltgtr_f */ + 48, /* ltgti_f */ + 24, /* ordr_f */ + 48, /* ordi_f */ + 24, /* unordr_f */ + 48, /* unordi_f */ + 16, /* truncr_f_i */ + 16, /* truncr_f_l */ + 20, /* extr_f */ + 12, /* extr_d_f */ + 24, /* movr_f */ + 32, /* movi_f */ 8, /* ldr_f */ - 32, /* ldi_f */ + 32, /* ldi_f */ 8, /* ldxr_f */ - 28, /* ldxi_f */ + 28, /* ldxi_f */ 8, /* str_f */ - 32, /* sti_f */ + 32, /* sti_f */ 8, /* stxr_f */ - 28, /* stxi_f */ - 20, /* bltr_f */ - 44, /* blti_f */ - 20, /* bler_f */ - 44, /* blei_f */ - 28, /* beqr_f */ - 52, /* beqi_f */ - 20, /* bger_f */ - 44, /* bgei_f */ - 20, /* bgtr_f */ - 44, /* bgti_f */ - 20, /* bner_f */ - 60, /* bnei_f */ - 20, /* bunltr_f */ - 44, /* bunlti_f */ - 20, /* bunler_f */ - 44, /* bunlei_f */ - 20, /* buneqr_f */ - 44, /* buneqi_f */ - 20, /* bunger_f */ - 44, /* bungei_f */ - 20, /* bungtr_f */ - 44, /* bungti_f */ - 20, /* bltgtr_f */ - 44, /* bltgti_f */ - 20, /* bordr_f */ - 44, /* bordi_f */ - 20, /* bunordr_f */ - 44, /* bunordi_f */ + 28, /* stxi_f */ + 20, /* bltr_f */ + 44, /* blti_f */ + 20, /* bler_f */ + 44, /* blei_f */ + 28, /* beqr_f */ + 52, /* beqi_f */ + 20, /* bger_f */ + 44, /* bgei_f */ + 20, /* bgtr_f */ + 44, /* bgti_f */ + 20, /* bner_f */ + 60, /* bnei_f */ + 20, /* bunltr_f */ + 44, /* bunlti_f */ + 20, /* bunler_f */ + 44, /* bunlei_f */ + 20, /* buneqr_f */ + 44, /* buneqi_f */ + 20, /* bunger_f */ + 44, /* bungei_f */ + 20, /* bungtr_f */ + 44, /* bungti_f */ + 20, /* bltgtr_f */ + 44, /* bltgti_f */ + 20, /* bordr_f */ + 44, /* bordi_f */ + 20, /* bunordr_f */ + 44, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -803,103 +899,165 @@ 0, /* putargr_d */ 0, /* putargi_d */ 4, /* addr_d */ - 32, /* addi_d */ + 32, /* addi_d */ 4, /* subr_d */ - 32, /* subi_d */ - 32, /* rsbi_d */ + 32, /* subi_d */ + 32, /* rsbi_d */ 4, /* mulr_d */ - 32, /* muli_d */ + 32, /* muli_d */ 4, /* divr_d */ - 32, /* divi_d */ + 32, /* divi_d */ 4, /* negr_d */ + 0, /* negi_d */ 4, /* absr_d */ + 0, /* absi_d */ 4, /* sqrtr_d */ - 16, /* ltr_d */ - 48, /* lti_d */ - 16, /* ler_d */ - 48, /* lei_d */ - 16, /* eqr_d */ - 48, /* eqi_d */ - 16, /* ger_d */ - 48, /* gei_d */ - 16, /* gtr_d */ - 48, /* gti_d */ - 16, /* ner_d */ - 48, /* nei_d */ - 16, /* unltr_d */ - 48, /* unlti_d */ - 16, /* unler_d */ - 48, /* unlei_d */ - 16, /* uneqr_d */ - 48, /* uneqi_d */ - 16, /* unger_d */ - 48, /* ungei_d */ - 16, /* ungtr_d */ - 48, /* ungti_d */ - 16, /* ltgtr_d */ - 48, /* ltgti_d */ - 16, /* ordr_d */ - 48, /* ordi_d */ - 16, /* unordr_d */ - 48, /* unordi_d */ - 16, /* truncr_d_i */ - 12, /* truncr_d_l */ - 12, /* extr_d */ + 0, /* sqrti_d */ + 16, /* ltr_d */ + 48, /* lti_d */ + 16, /* ler_d */ + 48, /* lei_d */ + 16, /* eqr_d */ + 48, /* eqi_d */ + 16, /* ger_d */ + 48, /* gei_d */ + 16, /* gtr_d */ + 48, /* gti_d */ + 16, /* ner_d */ + 48, /* nei_d */ + 16, /* unltr_d */ + 48, /* unlti_d */ + 16, /* unler_d */ + 48, /* unlei_d */ + 16, /* uneqr_d */ + 48, /* uneqi_d */ + 16, /* unger_d */ + 48, /* ungei_d */ + 16, /* ungtr_d */ + 48, /* ungti_d */ + 16, /* ltgtr_d */ + 48, /* ltgti_d */ + 16, /* ordr_d */ + 48, /* ordi_d */ + 16, /* unordr_d */ + 48, /* unordi_d */ + 16, /* truncr_d_i */ + 12, /* truncr_d_l */ + 12, /* extr_d */ 8, /* extr_f_d */ 4, /* movr_d */ - 32, /* movi_d */ + 32, /* movi_d */ 4, /* ldr_d */ - 28, /* ldi_d */ + 28, /* ldi_d */ 4, /* ldxr_d */ - 24, /* ldxi_d */ + 24, /* ldxi_d */ 4, /* str_d */ - 28, /* sti_d */ + 28, /* sti_d */ 4, /* stxr_d */ - 24, /* stxi_d */ - 12, /* bltr_d */ - 40, /* blti_d */ - 12, /* bler_d */ - 40, /* blei_d */ - 12, /* beqr_d */ - 40, /* beqi_d */ - 12, /* bger_d */ - 40, /* bgei_d */ - 12, /* bgtr_d */ - 40, /* bgti_d */ - 12, /* bner_d */ - 44, /* bnei_d */ - 12, /* bunltr_d */ - 44, /* bunlti_d */ - 12, /* bunler_d */ - 44, /* bunlei_d */ - 12, /* buneqr_d */ - 44, /* buneqi_d */ - 12, /* bunger_d */ - 44, /* bungei_d */ - 12, /* bungtr_d */ - 44, /* bungti_d */ - 12, /* bltgtr_d */ - 40, /* bltgti_d */ - 12, /* bordr_d */ - 40, /* bordi_d */ - 12, /* bunordr_d */ - 44, /* bunordi_d */ + 24, /* stxi_d */ + 12, /* bltr_d */ + 40, /* blti_d */ + 12, /* bler_d */ + 40, /* blei_d */ + 12, /* beqr_d */ + 40, /* beqi_d */ + 12, /* bger_d */ + 40, /* bgei_d */ + 12, /* bgtr_d */ + 40, /* bgti_d */ + 12, /* bner_d */ + 44, /* bnei_d */ + 12, /* bunltr_d */ + 44, /* bunlti_d */ + 12, /* bunler_d */ + 44, /* bunlei_d */ + 12, /* buneqr_d */ + 44, /* buneqi_d */ + 12, /* bunger_d */ + 44, /* bungei_d */ + 12, /* bungtr_d */ + 44, /* bungti_d */ + 12, /* bltgtr_d */ + 40, /* bltgti_d */ + 12, /* bordr_d */ + 40, /* bordi_d */ + 12, /* bunordr_d */ + 44, /* bunordi_d */ 0, /* pushargr_d */ 0, /* pushargi_d */ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 12, /* movr_w_f */ + 16, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 8, /* movr_w_d */ + 24, /* movi_w_d */ + 12, /* movr_f_w */ + 4, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 216, /* clo */ - 188, /* clz */ - 204, /* cto */ - 176, /* ctz */ + 8, /* movr_d_w */ + 16, /* movi_d_w */ + 108, /* clor */ + 4, /* cloi */ + 80, /* clzr */ + 4, /* clzi */ + 80, /* ctor */ + 4, /* ctoi */ + 52, /* ctzr */ + 4, /* ctzi */ + 76, /* rbitr */ + 24, /* rbiti */ + 72, /* popcntr */ + 4, /* popcnti */ + 20, /* lrotr */ + 12, /* lroti */ + 20, /* rrotr */ + 12, /* rroti */ + 8, /* extr */ + 4, /* exti */ + 32, /* extr_u */ + 4, /* exti_u */ + 60, /* depr */ + 20, /* depi */ + 72, /* qlshr */ + 8, /* qlshi */ + 72, /* qlshr_u */ + 8, /* qlshi_u */ + 72, /* qrshr */ + 8, /* qrshi */ + 72, /* qrshr_u */ + 8, /* qrshi_u */ + 76, /* unldr */ + 64, /* unldi */ + 76, /* unldr_u */ + 64, /* unldi_u */ + 84, /* unstr */ + 44, /* unsti */ + 84, /* unldr_x */ + 76, /* unldi_x */ + 196, /* unstr_x */ + 116, /* unsti_x */ + 20, /* fmar_f */ + 0, /* fmai_f */ + 20, /* fmsr_f */ + 0, /* fmsi_f */ + 20, /* fmar_d */ + 0, /* fmai_d */ + 20, /* fmsr_d */ + 0, /* fmsi_d */ + 20, /* fnmar_f */ + 0, /* fnmai_f */ + 20, /* fnmsr_f */ + 0, /* fnmsi_f */ + 20, /* fnmar_d */ + 0, /* fnmai_d */ + 20, /* fnmsr_d */ + 0, /* fnmsi_d */ + 44, /* hmulr */ + 60, /* hmuli */ + 44, /* hmulr_u */ + 60, /* hmuli_u */ #endif /* __WORDSIZE */ diff --git a/deps/lightning/lib/jit_sparc.c b/deps/lightning/lib/jit_sparc.c index 9e837d8a..bd8756d2 100644 --- a/deps/lightning/lib/jit_sparc.c +++ b/deps/lightning/lib/jit_sparc.c @@ -1292,6 +1292,12 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + name##r##type(rn(node->u.w), rn(node->v.q.l), \ + rn(node->v.q.h), rn(node->w.w)); \ + case jit_code_##name##i##type: \ + break; #define case_rrw(name, type) \ case jit_code_##name##i##type: \ name##i##type(rn(node->u.w), \ @@ -1403,6 +1409,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1427,10 +1437,34 @@ _emit_code(jit_state_t *_jit) case_rrw(xor,); case_rrr(lsh,); case_rrw(lsh,); +#define qlshr(r0, r1, r2, r3) fallback_qlshr(r0, r1, r2, r3) +#define qlshi(r0, r1, r2, i0) fallback_qlshi(r0, r1, r2, i0) +#define qlshr_u(r0, r1, r2, r3) fallback_qlshr_u(r0, r1, r2, r3) +#define qlshi_u(r0, r1, r2, i0) fallback_qlshi_u(r0, r1, r2, i0) + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); +#define qrshr(r0, r1, r2, r3) fallback_qrshr(r0, r1, r2, r3) +#define qrshi(r0, r1, r2, i0) fallback_qrshi(r0, r1, r2, i0) +#define qrshr_u(r0, r1, r2, r3) fallback_qrshr_u(r0, r1, r2, r3) +#define qrshi_u(r0, r1, r2, i0) fallback_qrshi_u(r0, r1, r2, i0) + case_rrrr(qrsh,); + case_rrrw(qrsh,); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); +#define lrotr(r0,r1,r2) fallback_lrotr(r0,r1,r2) +#define lroti(r0,r1,i0) fallback_lroti(r0,r1,i0) +#define rrotr(r0,r1,r2) fallback_rrotr(r0,r1,r2) +#define rroti(r0,r1,i0) fallback_rroti(r0,r1,i0) + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(trunc, _f_i); case_rr(trunc, _d_i); #if __WORDSIZE == 64 @@ -1489,6 +1523,22 @@ _emit_code(jit_state_t *_jit) case_rrr(ldx, _l); case_rrw(ldx, _l); #endif +#define unldr(r0, r1, i0) fallback_unldr(r0, r1, i0) + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi(r0, i0, i1) fallback_unldi(r0, i0, i1) + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; +#define unldr_u(r0, r1, i0) fallback_unldr_u(r0, r1, i0) + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_u(r0, i0, i1) fallback_unldi_u(r0, i0, i1) + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1509,6 +1559,14 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _l); case_wrr(stx, _l); #endif +#define unstr(r0, r1, i0) fallback_unstr(r0, r1, i0) + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti(i0, r0, i1) fallback_unsti(i0, r0, i1) + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(hton, _us); case_rr(hton, _ui); #if __WORDSIZE == 64 @@ -1519,6 +1577,21 @@ _emit_code(jit_state_t *_jit) #if __WORDSIZE == 64 case_rr(bswap, _ul); #endif +#define extr(r0, r1, i0, i1) fallback_ext(r0, r1, i0, i1) +#define extr_u(r0, r1, i0, i1) fallback_ext_u(r0, r1, i0, i1) +#define depr(r0, r1, i0, i1) fallback_dep(r0, r1, i0, i1) + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1561,6 +1634,10 @@ _emit_code(jit_state_t *_jit) case_rr(clz,); case_rr(cto,); case_rr(ctz,); +#define rbitr(r0, r1) fallback_rbit(r0, r1) +#define popcntr(r0, r1) fallback_popcnt(r0, r1) + case_rr(rbit,); + case_rr(popcnt,); case_brr(blt,); case_brw(blt,); case_brr(blt, _u); @@ -1613,6 +1690,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _f); case_rr(neg, _f); case_rr(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_rr(ext, _f); case_rr(ext, _d_f); case_rrr(lt, _f); @@ -1647,10 +1728,26 @@ _emit_code(jit_state_t *_jit) case_rw(ld, _f); case_rrr(ldx, _f); case_rrw(ldx, _f); +#define unldr_x(r0, r1, i0) fallback_unldr_x(r0, r1, i0) + case jit_code_unldr_x: + unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unldi_x(r0, i0, i1) fallback_unldi_x(r0, i0, i1) + case jit_code_unldi_x: + unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _f); case_wr(st, _f); case_rrr(stx, _f); case_wrr(stx, _f); +#define unstr_x(r0, r1, i0) fallback_unstr_x(r0, r1, i0) + case jit_code_unstr_x: + unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; +#define unsti_x(i0, r0, i1) fallback_unsti_x(i0, r0, i1) + case jit_code_unsti_x: + unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_rr(mov, _f); case jit_code_movi_f: assert(node->flag & jit_flag_data); @@ -1696,6 +1793,10 @@ _emit_code(jit_state_t *_jit) case_rr(abs, _d); case_rr(neg, _d); case_rr(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_rr(ext, _d); case_rr(ext, _f_d); case_rrr(lt, _d); @@ -1847,6 +1948,8 @@ _emit_code(jit_state_t *_jit) /* allocar information also does not need to be undone */ undo.func.aoffoff = _jitc->function->aoffoff; undo.func.allocar = _jitc->function->allocar; + /* cvt_offset must also not be undone */ + undo.func.cvt_offset = _jitc->function->cvt_offset; memcpy(_jitc->function, &undo.func, sizeof(undo.func)); #if DEVEL_DISASSEMBLER prevw = undo.prevw; @@ -1860,6 +1963,49 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + movi_w_f(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 32 + case jit_code_movr_ww_d: + movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movr_d_ww: + movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movi_d_ww: + assert(node->flag & jit_flag_data); + movi_d_ww(rn(node->u.w), rn(node->v.w), + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + break; +#else + case jit_code_movr_w_d: + movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_d_w: + movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movi_w_d: + movi_w_d(rn(node->u.w), node->v.w); + break; +#endif case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -1929,6 +2075,77 @@ _emit_code(jit_state_t *_jit) case jit_code_retval_f: case jit_code_retval_d: case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __WORDSIZE == 64 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); break; default: abort(); diff --git a/deps/lightning/lib/jit_x86-cpu.c b/deps/lightning/lib/jit_x86-cpu.c index f0e41554..44f5b45b 100644 --- a/deps/lightning/lib/jit_x86-cpu.c +++ b/deps/lightning/lib/jit_x86-cpu.c @@ -21,13 +21,20 @@ #define USE_INC_DEC 0 #if PROTO +# if __WORDSIZE == 64 && _WIN32 +# define ONE 1LL +# else +# define ONE 1L +# endif # if __X32 || __X64_32 # define WIDE 0 # define ldi(u, v) ldi_i(u, v) # define ldr(u, v) ldr_i(u, v) # define ldxr(u, v, w) ldxr_i(u, v, w) # define ldxi(u, v, w) ldxi_i(u, v, w) +# define str(u, v) str_i(u, v) # define sti(u, v) sti_i(u, v) +# define stxr(u, v, w) stxr_i(u, v, w) # define stxi(u, v, w) stxi_i(u, v, w) # define can_sign_extend_int_p(im) 1 # define can_zero_extend_int_p(im) 1 @@ -38,11 +45,13 @@ # define ldr(u, v) ldr_l(u, v) # define ldxr(u, v, w) ldxr_l(u, v, w) # define ldxi(u, v, w) ldxi_l(u, v, w) +# define str(u, v) str_l(u, v) # define sti(u, v) sti_l(u, v) +# define stxr(u, v, w) stxr_l(u, v, w) # define stxi(u, v, w) stxi_l(u, v, w) # define can_sign_extend_int_p(im) \ - (((im) >= 0 && (long long)(im) <= 0x7fffffffLL) || \ - ((im) < 0 && (long long)(im) > -0x80000000LL)) + (((long long)(im) >= 0 && (long long)(im) <= 0x7fffffffLL) || \ + ((long long)(im) < 0 && (long long)(im) > -0x80000000LL)) # define can_zero_extend_int_p(im) \ ((im) >= 0 && (im) < 0x80000000LL) # define fits_uint32_p(im) (((im) & 0xffffffff00000000LL) == 0) @@ -142,6 +151,40 @@ _rex(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define rx(rd, md, rb, ri, ms) _rx(_jit, rd, md, rb, ri, ms) static void _rx(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +/* + * prefix 8 bits 0xc4 Three byte VEX + * 0xc5 Two byte VEX + * 0x8f Three byte XOP + * ~R 1 bit Inverted REX.R + * ~X 1 bit Inverted REX.X + * ~B 1 bit Inverted REX.B + * map 5 bits Opcode map to use + * W 1 bit REX.W for integer, otherwise opcode extension + * ~vvvv 4 bits Inverted XMM or YMM registers + * L 1 bit 128 bit vector if 0, 256 otherwise + * pp 2 bits Mandatory prefix + * 00 none + * 01 0x66 + * 10 0xf3 + * 11 0xf2 + * + * Three byte VEX: + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + * | 1 1 0 0 0 1 0 0 | |~R |~X |~B | map | | W | ~vvvv | L | pp | + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + * Three byte XOP: + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + * | 1 0 0 0 1 1 1 1 | |~R |~X |~B | map | | W | ~vvvv | L | pp | + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + * Two byte VEX: + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + * | 1 1 0 0 0 1 0 1 | |~R | ~vvvv | L | pp | + * +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+ + */ +# define vex(r,x,b,map,w,vvvv,l,pp) _vex(_jit,r,x,b,map,w,vvvv,l,pp) +static void +_vex(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define nop(n) _nop(_jit, n) static void _nop(jit_state_t*, jit_int32_t); # define emms() is(0x770f) @@ -213,6 +256,10 @@ static void _imuli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); static void _mulr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define muli(r0, r1, i0) _muli(_jit, r0, r1, i0) static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define hmulr(r0, r1, r2) _iqmulr(_jit, JIT_NOREG, r0, r1, r2, 1) +# define hmulr_u(r0, r1, r2) _iqmulr(_jit, JIT_NOREG, r0, r1, r2, 0) +# define hmuli(r0, r1, i0) _iqmuli(_jit, JIT_NOREG, r0, r1, i0, 1) +# define hmuli_u(r0, r1, i0) _iqmuli(_jit, JIT_NOREG, r0, r1, i0, 0) # define umulr(r0) unr(X86_IMUL, r0) # define umulr_u(r0) unr(X86_MUL, r0) # define qmulr(r0, r1, r2, r3) _iqmulr(_jit, r0, r1, r2, r3, 1) @@ -283,12 +330,36 @@ static void _irotshi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); static void _rotshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); # define lshr(r0, r1, r2) rotshr(X86_SHL, r0, r1, r2) +# define qlshr(r0, r1, r2, r3) xlshr(1, r0, r1, r2, r3) +# define xlshr(s, r0, r1, r2, r3) _xlshr(_jit, s, r0, r1, r2, r3) +static void +_xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define lshi(r0, r1, i0) _lshi(_jit, r0, r1, i0) static void _lshi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0) +# define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0) +static void +_xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3) +# define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0) # define rshr(r0, r1, r2) rotshr(X86_SAR, r0, r1, r2) # define rshi(r0, r1, i0) rotshi(X86_SAR, r0, r1, i0) # define rshr_u(r0, r1, r2) rotshr(X86_SHR, r0, r1, r2) # define rshi_u(r0, r1, i0) rotshi(X86_SHR, r0, r1, i0) +# define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3) +# define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3) +# define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3) +static void +_xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0) +# define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0) +# define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0) +static void +_xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t); +# define lrotr(r0, r1, r2) rotshr(X86_ROL, r0, r1, r2) +# define lroti(r0, r1, i0) rotshi(X86_ROL, r0, r1, i0) +# define rrotr(r0, r1, r2) rotshr(X86_ROR, r0, r1, r2) +# define rroti(r0, r1, i0) rotshi(X86_ROR, r0, r1, i0) # define unr(code, r0) _unr(_jit, code, r0) static void _unr(jit_state_t*, jit_int32_t, jit_int32_t); # define inegr(r0) unr(X86_NEG, r0) @@ -311,6 +382,10 @@ static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t); static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t); # define ctzr(r0, r1) _ctzr(_jit, r0, r1) static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t); +# define rbitr(r0, r1) _rbitr(_jit, r0, r1) +static void _rbitr(jit_state_t*, jit_int32_t, jit_int32_t); +# define popcntr(r0, r1) _popcntr(_jit, r0, r1) +static void _popcntr(jit_state_t*, jit_int32_t, jit_int32_t); # define cr(code, r0, r1, r2) _cr(_jit, code, r0, r1, r2) static void _cr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t); @@ -401,6 +476,12 @@ static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t); #define bswapr_ul(r0, r1) _bswapr_ul(_jit, r0, r1) static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t); #endif +# define extr(r0, r1, i0, i1) _extr(_jit, r0, r1, i0, i1) +static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define extr_u(r0, r1, i0, i1) _extr_u(_jit, r0, r1, i0, i1) +static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); +# define depr(r0, r1, i0, i1) _depr(_jit, r0, r1, i0, i1) +static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t); # define extr_c(r0, r1) _extr_c(_jit, r0, r1) static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t); # define extr_uc(r0, r1) _extr_uc(_jit, r0, r1) @@ -489,6 +570,10 @@ static void _ldxr_l(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); static void _ldxi_l(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); # endif # endif +# define unldr(r0, r1, i0) generic_unldr(r0, r1, i0) +# define unldi(r0, i0, i1) generic_unldi(r0, i0, i1) +# define unldr_u(r0, r1, i0) generic_unldr_u(r0, r1, i0) +# define unldi_u(r0, i0, i1) generic_unldi_u(r0, i0, i1) # define str_c(r0, r1) _str_c(_jit, r0, r1) static void _str_c(jit_state_t*, jit_int32_t, jit_int32_t); # define sti_c(i0, r0) _sti_c(_jit, i0, r0) @@ -525,6 +610,8 @@ static void _stxr_l(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1) static void _stxi_l(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t); # endif +#define unstr(r0, r1, i0) generic_unstr(r0, r1, i0) +#define unsti(i0, r0, i1) generic_unsti(i0, r0, i1) # define jcc(code, i0) _jcc(_jit, code, i0) # define jo(i0) jcc(X86_CC_O, i0) # define jno(i0) jcc(X86_CC_NO, i0) @@ -815,6 +902,48 @@ _rx(jit_state_t *_jit, jit_int32_t rd, jit_int32_t md, } } +static void +_vex(jit_state_t *_jit, jit_int32_t r, jit_int32_t x, jit_int32_t b, + jit_int32_t map, jit_int32_t w, jit_int32_t vvvv, jit_int32_t l, + jit_int32_t pp) +{ + jit_int32_t v; + if (r == _NOREG) r = 0; + if (x == _NOREG) x = 0; + if (b == _NOREG) b = 0; + if (map == 1 && w == 0 && ((x|b) & 8) == 0) { + /* Two byte prefix */ + ic(0xc5); + /* ~R */ + v = (r & 8) ? 0 : 0x80; + } + else { + /* Three byte prefix */ + if (map >= 8) + ic(0x8f); + else + ic(0xc4); + /* map_select */ + v = map; + /* ~R */ + if (!(r & 8)) v |= 0x80; + /* ~X */ + if (!(x & 8)) v |= 0x40; + /* ~B */ + if (!(b & 8)) v |= 0x20; + ic(v); + /* W */ + v = w ? 0x80 : 0; + } + /* ~vvvv */ + v |= (~vvvv & 0x0f) << 3; + /* L */ + if (l) v |= 0x04; + /* pp */ + v |= pp; + ic(v); +} + static void _nop(jit_state_t *_jit, jit_int32_t count) { @@ -1332,38 +1461,49 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } #define savset(rn) \ - if (r0 != rn) { \ - sav |= 1 << rn; \ - if (r1 != rn && r2 != rn) \ - set |= 1 << rn; \ - } + do { \ + if (r0 != rn) { \ + sav |= 1 << rn; \ + if (r1 != rn && r2 != rn) \ + set |= 1 << rn; \ + } \ + } while (0) #define isavset(rn) \ - if (r0 != rn) { \ - sav |= 1 << rn; \ - if (r1 != rn) \ - set |= 1 << rn; \ - } + do { \ + if (r0 != rn) { \ + sav |= 1 << rn; \ + if (r1 != rn) \ + set |= 1 << rn; \ + } \ + } while (0) #define qsavset(rn) \ - if (r0 != rn && r1 != rn) { \ - sav |= 1 << rn; \ - if (r2 != rn && r3 != rn) \ - set |= 1 << rn; \ - } + do { \ + if (r0 != rn && r1 != rn) { \ + sav |= 1 << rn; \ + if (r2 != rn && r3 != rn) \ + set |= 1 << rn; \ + } \ + } while (0) #define allocr(rn, rv) \ - if (set & (1 << rn)) \ - (void)jit_get_reg(rv|jit_class_gpr|jit_class_named); \ - if (sav & (1 << rn)) { \ - if ( jit_regset_tstbit(&_jitc->regsav, rv) || \ - !jit_regset_tstbit(&_jitc->reglive, rv)) \ - sav &= ~(1 << rn); \ - else \ - save(rv); \ - } + do { \ + if (set & (1 << rn)) \ + (void)jit_get_reg(rv|jit_class_gpr|jit_class_named); \ + if (sav & (1 << rn)) { \ + if ( jit_regset_tstbit(&_jitc->regsav, rv) || \ + !jit_regset_tstbit(&_jitc->reglive, rv)) \ + sav &= ~(1 << rn); \ + else \ + save(rv); \ + } \ + } while (0) #define clear(rn, rv) \ - if (set & (1 << rn)) \ - jit_unget_reg(rv); \ - if (sav & (1 << rn)) \ - load(rv); + do { \ + if (set & (1 << rn)) \ + jit_unget_reg(rv); \ + if (sav & (1 << rn)) \ + load(rv); \ + } while (0) + static void _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3, jit_bool_t sign) @@ -1389,14 +1529,20 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, else umulr_u(mul); - if (r0 == _RDX_REGNO && r1 == _RAX_REGNO) - xchgr(_RAX_REGNO, _RDX_REGNO); + if (r0 != JIT_NOREG) { + if (r0 == _RDX_REGNO && r1 == _RAX_REGNO) + xchgr(_RAX_REGNO, _RDX_REGNO); + else { + if (r0 != _RDX_REGNO) + movr(r0, _RAX_REGNO); + movr(r1, _RDX_REGNO); + if (r0 == _RDX_REGNO) + movr(r0, _RAX_REGNO); + } + } else { - if (r0 != _RDX_REGNO) - movr(r0, _RAX_REGNO); + assert(r1 != JIT_NOREG); movr(r1, _RDX_REGNO); - if (r0 == _RDX_REGNO) - movr(r0, _RAX_REGNO); } clear(_RDX_REGNO, _RDX); @@ -1710,9 +1856,6 @@ _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, qdivr_u(r0, r1, r2, rn(reg)); jit_unget_reg(reg); } -#undef clear -#undef allocr -#undef savset static void _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -1912,6 +2055,115 @@ _rotshi(jit_state_t *_jit, jit_int32_t code, irotshi(code, r0, i0); } +static void +_xlshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t sav, set; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + jit_word_t over, zero, over_done, done; + sav = set = 0; + /* %RCX must be used for shift. */ + qsavset(_RCX_REGNO); + allocr(_RCX_REGNO, _RCX); + /* Almost certainly not %RCX */ + t1 = r1; + if (r0 == _RCX_REGNO) { + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + } + else { + t0 = r0; + /* r0 == r1 is undefined behavior */ + if (r1 == _RCX_REGNO) { + s1 = jit_get_reg(jit_class_gpr); + t1 = rn(s1); + } + } + /* Allocate a temporary if a register is used more than once, or if + * the value to shift is %RCX */ + if (r0 == r2 || r1 == r2 || r2 == _RCX_REGNO) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + /* Allocate temporary if shift is also one of the outputs */ + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + /* Bits to shift right */ + movi(t1, 0); + /* Shift in %RCX */ + /* Shift < 0 or > __WORDSIZE is undefined behavior and not tested */ + movr(_RCX_REGNO, t3); + /* Copy value to low register */ + movr(t0, t2); + /* SHLD shifts t0 left pulling extra bits in the right from t1. + * It is very handly to shift bignums, but lightning does not support + * these, nor 128 bit integers. The use of q{l,}sh{r,i} is to verify + * if there precision loss in a shift and/or have it as a quick way + * to multiply or divide by powers of two. */ + /* SHLD */ + rex(0, WIDE, t1, _NOREG, t0); + ic(0xf); + ic(0xa5); + mrm(0x03, r7(t1), r7(t0)); + /* Must swap results if shift value is __WORDSIZE */ + alui(X86_CMP, t3, __WORDSIZE); + over = jes(_jit->pc.w); + /* Calculate bits to shift right and fill high register */ + rsbi(_RCX_REGNO, _RCX_REGNO, __WORDSIZE); + if (sign) + rshr(t1, t2, _RCX_REGNO); + else + rshr_u(t1, t2, _RCX_REGNO); + /* FIXME t3 == %rcx only happens in 32 bit as %a3 (JIT_A3) is not + * available -- it might be made available at some point, to + * allow optimizing usage or arguments in registers. For now + * keep the code, as one might cheat and use _RCX directly, + * what is not officially supported, but *must* work. */ + /* Need to sign extend high register if shift value is zero */ + if (t3 == _RCX_REGNO) + alui(X86_CMP, t3, __WORDSIZE); + else + alui(X86_CMP, t3, 0); + /* Finished. */ + zero = jes(_jit->pc.w); + done = jmpsi(_jit->pc.w); + /* Swap registers if shift is __WORDSIZE */ + patch_at(over, _jit->pc.w); + xchgr(t0, t1); + over_done = jmpsi(_jit->pc.w); + /* If shift value is zero */ + patch_at(zero, _jit->pc.w); + if (sign) + rshi(t1, t2, __WORDSIZE - 1); + else + movi(t1, 0); + patch_at(over_done, _jit->pc.w); + patch_at(done, _jit->pc.w); + /* Release %RCX (if spilled) after branches */ + clear(_RCX_REGNO, _RCX); + if (t3 != r3) + jit_unget_reg(s3); + if (t2 != r2) + jit_unget_reg(s2); + if (t1 != r1) { + movr(r1, t1); + jit_unget_reg(s1); + } + if (t0 != r0) { + movr(r0, t0); + jit_unget_reg(s0); + } +} + static void _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) { @@ -1923,6 +2175,149 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) rotshi(X86_SHL, r0, r1, i0); } +static void +_xlshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + if (sign) + rshi(r1, r2, __WORDSIZE - i0); + else + rshi_u(r1, r2, __WORDSIZE - i0); + lshi(r0, r2, i0); + } +} + +static void +_xrshr(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t sav, set; + jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3; + jit_word_t over, zero, done; + sav = set = 0; + /* %RCX must be used for shift. */ + qsavset(_RCX_REGNO); + allocr(_RCX_REGNO, _RCX); + /* Almost certainly not %RCX */ + t1 = r1; + if (r0 == _RCX_REGNO) { + s0 = jit_get_reg(jit_class_gpr); + t0 = rn(s0); + } + else { + t0 = r0; + /* r0 == r1 is undefined behavior */ + if (r1 == _RCX_REGNO) { + s1 = jit_get_reg(jit_class_gpr); + t1 = rn(s1); + } + } + /* Allocate a temporary if a register is used more than once, or if + * the value to shift is %RCX */ + if (r0 == r2 || r1 == r2 || r2 == _RCX_REGNO) { + s2 = jit_get_reg(jit_class_gpr); + t2 = rn(s2); + movr(t2, r2); + } + else + t2 = r2; + /* Allocate temporary if shift is also one of the outputs */ + if (r0 == r3 || r1 == r3) { + s3 = jit_get_reg(jit_class_gpr); + t3 = rn(s3); + movr(t3, r3); + } + else + t3 = r3; + /* Bits to shift left */ + if (sign) + rshi(t1, t2, __WORDSIZE - 1); + else + movi(t1, 0); + /* Shift in %RCX */ + /* Shift < 0 or > __WORDSIZE is undefined behavior and not tested */ + movr(_RCX_REGNO, t3); + /* Copy value to low register */ + movr(t0, t2); + /* SHRD shifts t0 right pulling extra bits in the left from t1 */ + /* SHRD */ + rex(0, WIDE, t1, _NOREG, t0); + ic(0xf); + ic(0xad); + mrm(0x03, r7(t1), r7(t0)); + /* Must swap results if shift value is __WORDSIZE */ + alui(X86_CMP, t3, __WORDSIZE); + over = jes(_jit->pc.w); + /* Already zero or sign extended if shift value is zero */ + alui(X86_CMP, t3, 0); + zero = jes(_jit->pc.w); + /* Calculate bits to shift left and fill high register */ + rsbi(_RCX_REGNO, _RCX_REGNO, __WORDSIZE); + lshr(t1, t2, _RCX_REGNO); + done = jmpsi(_jit->pc.w); + /* Swap registers if shift is __WORDSIZE */ + patch_at(over, _jit->pc.w); + xchgr(t0, t1); + /* If shift value is zero */ + patch_at(zero, _jit->pc.w); + patch_at(done, _jit->pc.w); + /* Release %RCX (if spilled) after branches */ + clear(_RCX_REGNO, _RCX); + if (t3 != r3) + jit_unget_reg(s3); + if (t2 != r2) + jit_unget_reg(s2); + if (t1 != r1) { + movr(r1, t1); + jit_unget_reg(s1); + } + if (t0 != r0) { + movr(r0, t0); + jit_unget_reg(s0); + } +} + +static void +_xrshi(jit_state_t *_jit, jit_bool_t sign, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0) +{ + if (i0 == 0) { + movr(r0, r2); + if (sign) + rshi(r1, r2, __WORDSIZE - 1); + else + movi(r1, 0); + } + else if (i0 == __WORDSIZE) { + movr(r1, r2); + if (sign) + rshi(r0, r2, __WORDSIZE - 1); + else + movi(r0, 0); + } + else { + assert((jit_uword_t)i0 <= __WORDSIZE); + lshi(r1, r2, __WORDSIZE - i0); + if (sign) + rshi(r0, r2, i0); + else + rshi_u(r0, r2, i0); + } +} + static void _unr(jit_state_t *_jit, jit_int32_t code, jit_int32_t r0) { @@ -2059,6 +2454,178 @@ _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) /* TZCNT has defined behavior for value zero */ } +static void +_rbitr(jit_state_t * _jit, jit_int32_t r0, jit_int32_t r1) +{ + jit_word_t loop; + jit_int32_t sav, set; + jit_int32_t r0_reg, t0, r1_reg, t1, t2, t3; + static const unsigned char swap_tab[256] = { + 0, 128, 64, 192, 32, 160, 96, 224, + 16, 144, 80, 208, 48, 176, 112, 240, + 8, 136, 72, 200, 40, 168, 104, 232, + 24, 152, 88, 216 ,56, 184, 120, 248, + 4, 132, 68, 196, 36, 164, 100, 228, + 20, 148, 84, 212, 52, 180, 116, 244, + 12, 140, 76, 204, 44, 172, 108, 236, + 28, 156, 92, 220, 60, 188, 124, 252, + 2, 130, 66, 194, 34, 162, 98, 226, + 18, 146, 82, 210, 50, 178, 114, 242, + 10, 138, 74, 202, 42, 170, 106, 234, + 26, 154, 90, 218, 58, 186, 122, 250, + 6, 134, 70, 198, 38, 166, 102, 230, + 22, 150, 86, 214, 54, 182, 118, 246, + 14, 142, 78, 206, 46, 174, 110, 238, + 30, 158, 94, 222, 62, 190, 126, 254, + 1, 129, 65, 193, 33, 161, 97, 225, + 17, 145, 81, 209, 49, 177, 113, 241, + 9, 137, 73, 201, 41, 169, 105, 233, + 25, 153, 89, 217, 57, 185, 121, 249, + 5, 133, 69, 197, 37, 165, 101, 229, + 21, 149, 85, 213, 53, 181, 117, 245, + 13, 141, 77, 205, 45, 173, 109, 237, + 29, 157, 93, 221, 61, 189, 125, 253, + 3, 131, 67, 195, 35, 163, 99, 227, + 19, 147, 83, 211, 51, 179, 115, 243, + 11, 139, 75, 203, 43, 171, 107, 235, + 27, 155, 91, 219, 59, 187, 123, 251, + 7, 135, 71, 199, 39, 167, 103, 231, + 23, 151, 87, 215, 55, 183, 119, 247, + 15, 143, 79, 207, 47, 175, 111, 239, + 31, 159, 95, 223, 63, 191, 127, 255 + }; + sav = set = 0; + isavset(_RCX_REGNO); + allocr(_RCX_REGNO, _RCX); + if (r0 == _RCX_REGNO) { + t0 = jit_get_reg(jit_class_gpr); + r0_reg = rn(t0); + } + else { + t0 = JIT_NOREG; + r0_reg = r0; + } + if (r1 == _RCX_REGNO || r0 == r1) { + t1 = jit_get_reg(jit_class_gpr); + r1_reg = rn(t1); + movr(r1_reg, r1); + } + else { + t1 = JIT_NOREG; + r1_reg = r1; + } + t2 = jit_get_reg(jit_class_gpr); + t3 = jit_get_reg(jit_class_gpr); +#if __WORDSIZE == 32 + /* Avoid condition that causes running out of registers */ + if (!reg8_p(r1_reg)) { + movi(rn(t2), 0xff); + andr(rn(t2), r1_reg, rn(t2)); + } + else +#endif + extr_uc(rn(t2), r1_reg); + movi(rn(t3), (jit_word_t)swap_tab); + ldxr_uc(r0_reg, rn(t3), rn(t2)); + movi(_RCX_REGNO, 8); + loop = _jit->pc.w; + rshr(rn(t2), r1_reg, _RCX_REGNO); + extr_uc(rn(t2), rn(t2)); + lshi(r0_reg, r0_reg, 8); + ldxr_uc(rn(t2), rn(t3), rn(t2)); + orr(r0_reg, r0_reg, rn(t2)); + addi(_RCX_REGNO, _RCX_REGNO, 8); + alui(X86_CMP, _RCX_REGNO, __WORDSIZE); + jls(loop); + clear(_RCX_REGNO, _RCX); + jit_unget_reg(t3); + jit_unget_reg(t2); + if (t1 != JIT_NOREG) + jit_unget_reg(t1); + if (t0 != JIT_NOREG) { + movr(r0, r0_reg); + jit_unget_reg(t0); + } +} + +static void +_popcntr(jit_state_t * _jit, jit_int32_t r0, jit_int32_t r1) +{ + if (jit_cpu.abm) { + ic(0xf3); + rex(0, WIDE, r0, _NOREG, r1); + ic(0x0f); + ic(0xb8); + mrm(0x3, r7(r0), r7(r1)); + } + else { + jit_word_t loop; + jit_int32_t sav, set; + jit_int32_t r0_reg, t0, r1_reg, t1, t2, t3; + static const unsigned char pop_tab[256] = { + 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8 + }; + sav = set = 0; + isavset(_RCX_REGNO); + allocr(_RCX_REGNO, _RCX); + if (r0 == _RCX_REGNO) { + t0 = jit_get_reg(jit_class_gpr); + r0_reg = rn(t0); + } + else { + t0 = JIT_NOREG; + r0_reg = r0; + } + if (r1 == _RCX_REGNO || r0 == r1) { + t1 = jit_get_reg(jit_class_gpr); + r1_reg = rn(t1); + movr(r1_reg, r1); + } + else { + t1 = JIT_NOREG; + r1_reg = r1; + } + t2 = jit_get_reg(jit_class_gpr); + t3 = jit_get_reg(jit_class_gpr); +#if __WORDSIZE == 32 + /* Avoid condition that causes running out of registers */ + if (!reg8_p(r1_reg)) { + movi(rn(t2), 0xff); + andr(rn(t2), r1_reg, rn(t2)); + } + else +#endif + extr_uc(rn(t2), r1_reg); + movi(rn(t3), (jit_word_t)pop_tab); + ldxr_uc(r0_reg, rn(t3), rn(t2)); + movi(_RCX_REGNO, 8); + loop = _jit->pc.w; + rshr(rn(t2), r1_reg, _RCX_REGNO); + extr_uc(rn(t2), rn(t2)); + ldxr_uc(rn(t2), rn(t3), rn(t2)); + addr(r0_reg, r0_reg, rn(t2)); + addi(_RCX_REGNO, _RCX_REGNO, 8); + alui(X86_CMP, _RCX_REGNO, __WORDSIZE); + jls(loop); + clear(_RCX_REGNO, _RCX); + jit_unget_reg(t3); + jit_unget_reg(t2); + if (t1 != JIT_NOREG) + jit_unget_reg(t1); + if (t0 != JIT_NOREG) { + movr(r0, r0_reg); + jit_unget_reg(t0); + } + } +} + static void _cr(jit_state_t *_jit, jit_int32_t code, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -2538,6 +3105,92 @@ _bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } #endif +static void +_extr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + else { + if (__WORDSIZE - (i0 + i1)) { + lshi(r0, r1, __WORDSIZE - (i0 + i1)); + rshi(r0, r0, __WORDSIZE - i1); + } + else + rshi(r0, r1, __WORDSIZE - i1); + } +} + +static void +_extr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0; + jit_word_t mask; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + /* Only cheaper in code size or number of instructions if i0 is not zero */ + /* Number of cpu cicles not tested */ + else if (i0 && jit_cpu.bmi2) { + mask = ((ONE << i1) - 1) << i0; + t0 = jit_get_reg(jit_class_gpr); + movi(rn(t0), mask); + /* PEXT */ + vex(r0, _NOREG, rn(t0), 2, WIDE, r1, 0, 2); + ic(0xf5); + mrm(0x03, r7(r0), r7(rn(t0))); + jit_unget_reg(t0); + } + else { + if (i0) + rshi_u(r0, r1, i0); + andi(r0, r0, (ONE << i1) - 1); + } +} + +static void +_depr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1) +{ + jit_word_t mask; + jit_int32_t t0, t1; + assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE); + if (i1 == __WORDSIZE) + movr(r0, r1); + /* Only cheaper in code size or number of instructions if i0 is not zero */ + /* Number of cpu cicles not tested */ + else if (i0 && jit_cpu.bmi2) { + mask = ((ONE << i1) - 1) << i0; + t0 = jit_get_reg(jit_class_gpr); + t1 = jit_get_reg(jit_class_gpr); + movi(rn(t0), mask); + movr(rn(t1), r0); + /* PDEP */ + vex(r0, _NOREG, rn(t0), 2, WIDE, r1, 0, 3); + ic(0xf5); + mrm(0x03, r7(r0), r7(rn(t0))); + andi(rn(t1), rn(t1), ~mask); + orr(r0, r0, rn(t1)); + jit_unget_reg(t1); + jit_unget_reg(t0); + } + else { + mask = (ONE << i1) - 1; + t0 = jit_get_reg(jit_class_gpr); + andi(rn(t0), r1, mask); + if (i0) { + lshi(rn(t0), rn(t0), i0); + mask <<= i0; + } + andi(r0, r0, ~mask); + orr(r0, r0, rn(t0)); + jit_unget_reg(t0); + } +} + static void _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -3395,7 +4048,7 @@ _jccs(jit_state_t *_jit, jit_int32_t code, jit_word_t i0) jit_word_t d; jit_word_t w; w = _jit->pc.w; - d = i0 - (w + 1); + d = i0 - (w + 2); ic(0x70 | code); ic(d); return (w); @@ -3913,6 +4566,9 @@ _jmpsi(jit_state_t *_jit, jit_uint8_t i0) ic(i0); return (w); } +#undef clear +#undef allocr +#undef savset static void _prolog(jit_state_t *_jit, jit_node_t *node) diff --git a/deps/lightning/lib/jit_x86-sse.c b/deps/lightning/lib/jit_x86-sse.c index c3ac895e..930efedb 100644 --- a/deps/lightning/lib/jit_x86-sse.c +++ b/deps/lightning/lib/jit_x86-sse.c @@ -63,7 +63,8 @@ # define sser(c,r0,r1) _sser(_jit,c,r0,r1) static void _sser(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define ssexr(p,c,r0,r1) _ssexr(_jit,p,c,r0,r1) -static void _ssexr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +static void _ssexr(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define ssexi(c,r0,m,i) _ssexi(_jit,c,r0,m,i) static void _ssexi(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define addssr(r0, r1) ssexr(0xf3, X86_SSE_ADD, r0, r1) @@ -93,13 +94,15 @@ static void _ssexi(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) # define ucomisdr(r0,r1) ssexr(0x66,X86_SSE_UCOMI,r0,r1) # define xorpsr(r0,r1) sser(X86_SSE_XOR,r0,r1) # define xorpdr(r0,r1) ssexr(0x66,X86_SSE_XOR,r0,r1) -# define movdlxr(r0,r1) ssexr(0x66, X86_SSE_X2G,r0,r1) +# define movdxr(r0,r1) ssexr(0x66, X86_SSE_X2G,r0,r1) +# define movdrx(r0,r1) ssexr(0x66, X86_SSE_G2X,r0,r1) +# define movqxr(r0,r1) sselxr(0x66, X86_SSE_X2G,r0,r1) +# define movqrx(r0,r1) sselxr(0x66, X86_SSE_G2X,r0,r1) # define pcmpeqlr(r0, r1) ssexr(0x66, X86_SSE_EQD, r0, r1) # define psrl(r0, i0) ssexi(0x72, r0, 0x02, i0) # define psrq(r0, i0) ssexi(0x73, r0, 0x02, i0) # define psll(r0, i0) ssexi(0x72, r0, 0x06, i0) # define pslq(r0, i0) ssexi(0x73, r0, 0x06, i0) -# define movdqxr(r0,r1) sselxr(0x66,X86_SSE_X2G,r0,r1) # if __X64 && !__X64_32 # define sselxr(p,c,r0,r1) _sselxr(_jit,p,c,r0,r1) static void @@ -163,6 +166,30 @@ static void _sse_negr_f(jit_state_t*,jit_int32_t,jit_int32_t); static void _sse_negr_d(jit_state_t*,jit_int32_t,jit_int32_t); # define sse_sqrtr_f(r0, r1) ssexr(0xf3, X86_SSE_SQRT, r0, r1) # define sse_sqrtr_d(r0, r1) ssexr(0xf2, X86_SSE_SQRT, r0, r1) +# define sse_fmar_f(r0, r1, r2, r3) _sse_fmar_f(_jit, r0, r1, r2, r3) +static void _sse_fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fmar_d(r0, r1, r2, r3) _sse_fmar_d(_jit, r0, r1, r2, r3) +static void _sse_fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fmsr_f(r0, r1, r2, r3) _sse_fmsr_f(_jit, r0, r1, r2, r3) +static void _sse_fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fmsr_d(r0, r1, r2, r3) _sse_fmsr_d(_jit, r0, r1, r2, r3) +static void _sse_fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fnmar_f(r0, r1, r2, r3) _sse_fnmar_f(_jit, r0, r1, r2, r3) +static void _sse_fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fnmar_d(r0, r1, r2, r3) _sse_fnmar_d(_jit, r0, r1, r2, r3) +static void _sse_fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fnmsr_f(r0, r1, r2, r3) _sse_fnmsr_f(_jit, r0, r1, r2, r3) +static void _sse_fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define sse_fnmsr_d(r0, r1, r2, r3) _sse_fnmsr_d(_jit, r0, r1, r2, r3) +static void _sse_fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define ssecmpf(code, r0, r1, r2) _ssecmp(_jit, 0, code, r0, r1, r2) # define ssecmpd(code, r0, r1, r2) _ssecmp(_jit, 1, code, r0, r1, r2) static void @@ -172,6 +199,10 @@ _ssecmp(jit_state_t*, jit_bool_t, jit_int32_t, static void _sse_movr_f(jit_state_t*, jit_int32_t, jit_int32_t); #define sse_movi_f(r0,i0) _sse_movi_f(_jit,r0,i0) static void _sse_movi_f(jit_state_t*, jit_int32_t, jit_float32_t*); +# define sse_movr_w_f(r0,r1) movdxr(r0, r1) +# define sse_movr_f_w(r0,r1) movdrx(r1, r0) +#define sse_movi_w_f(r0, i0) _sse_movi_w_f(_jit, r0, i0) +static void _sse_movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define sse_lti_f(r0, r1, i0) _sse_lti_f(_jit, r0, r1, i0) static void _sse_lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); # define sse_ltr_f(r0, r1, r2) ssecmpf(X86_CC_A, r0, r1, r2) @@ -227,6 +258,10 @@ static void _sse_ldi_f(jit_state_t*, jit_int32_t, jit_word_t); static void _sse_ldxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define sse_ldxi_f(r0, r1, i0) _sse_ldxi_f(_jit, r0, r1, i0) static void _sse_ldxi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define sse_unldr_x(r0, r1, i0) _sse_unldr_x(_jit, r0, r1, i0) +static void _sse_unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define sse_unldi_x(r0, i0, i1) _sse_unldi_x(_jit, r0, i0, i1) +static void _sse_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define sse_str_f(r0, r1) movssrm(r1, 0, r0, _NOREG, _SCL1) # define sse_sti_f(i0, r0) _sse_sti_f(_jit, i0, r0) static void _sse_sti_f(jit_state_t*, jit_word_t,jit_int32_t); @@ -234,6 +269,10 @@ static void _sse_sti_f(jit_state_t*, jit_word_t,jit_int32_t); static void _sse_stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define sse_stxi_f(i0, r0, r1) _sse_stxi_f(_jit, i0, r0, r1) static void _sse_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define sse_unstr_x(r0, r1, i0) _sse_unstr_x(_jit, r0, r1, i0) +static void _sse_unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define sse_unsti_x(i0, r0, i1) _sse_unsti_x(_jit, i0, r0, i1) +static void _sse_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define sse_bltr_f(i0, r0, r1) _sse_bltr_f(_jit, i0, r0, r1) static jit_word_t _sse_bltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); # define sse_blti_f(i0, r0, i1) _sse_blti_f(_jit, i0, r0, i1) @@ -308,6 +347,19 @@ _sse_bunordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*); static void _sse_movr_d(jit_state_t*, jit_int32_t, jit_int32_t); #define sse_movi_d(r0,i0) _sse_movi_d(_jit,r0,i0) static void _sse_movi_d(jit_state_t*, jit_int32_t, jit_float64_t*); +# if __X32 || __X64_32 +# define sse_movr_ww_d(r0, r1, r2) _sse_movr_ww_d(_jit, r0, r1, r2) +static void _sse_movr_ww_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); +# define sse_movr_d_ww(r0, r1, r2) _sse_movr_d_ww(_jit, r0, r1, r2) +static void _sse_movr_d_ww(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); +# define sse_movi_ww_d(r0, i0, i1) _sse_movi_ww_d(_jit, r0, i0, i1) +static void _sse_movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# else +# define sse_movr_w_d(r0, r1) movqxr(r0, r1) +# define sse_movr_d_w(r0, r1) movqrx(r1, r0) +# define sse_movi_w_d(r0, i0) _sse_movi_w_d(_jit, r0, i0) +static void _sse_movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); +# endif # define sse_ltr_d(r0, r1, r2) ssecmpd(X86_CC_A, r0, r1, r2) # define sse_lti_d(r0, r1, i0) _sse_lti_d(_jit, r0, r1, i0) static void _sse_lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); @@ -722,12 +774,12 @@ _sse_negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) imovi(rn(ireg), 0x80000000); if (r0 == r1) { freg = jit_get_reg(jit_class_fpr|jit_class_xpr); - movdlxr(rn(freg), rn(ireg)); + movdxr(rn(freg), rn(ireg)); xorpsr(r0, rn(freg)); jit_unget_reg(freg); } else { - movdlxr(r0, rn(ireg)); + movdxr(r0, rn(ireg)); xorpsr(r0, r1); } jit_unget_reg(ireg); @@ -741,19 +793,333 @@ _sse_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) imovi(rn(ireg), 0x80000000); if (r0 == r1) { freg = jit_get_reg(jit_class_fpr|jit_class_xpr); - movdlxr(rn(freg), rn(ireg)); + movdxr(rn(freg), rn(ireg)); pslq(rn(freg), 32); xorpdr(r0, rn(freg)); jit_unget_reg(freg); } else { - movdlxr(r0, rn(ireg)); + movdxr(r0, rn(ireg)); pslq(r0, 32); xorpdr(r0, r1); } jit_unget_reg(ireg); } +/* r1 = (r1 * r3) + r2 */ +#define vfmadd132ss(r1, r2, r3) _vfmadd132sx(_jit, 0, r1, r2, r3) +#define vfmadd132sd(r1, r2, r3) _vfmadd132sx(_jit, 1, r1, r2, r3) +static void +_vfmadd132sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMADD132SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0x99); + mrm(0x03, r7(r1), r7(r3)); +} + +/* r1 = (r1 * r3) - r2 */ +#define vfmsub132ss(r1, r2, r3) _vfmsub132sx(_jit, 0, r1, r2, r3) +#define vfmsub132sd(r1, r2, r3) _vfmsub132sx(_jit, 1, r1, r2, r3) +static void +_vfmsub132sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMSUB132SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0x9b); + mrm(0x03, r7(r1), r7(r3)); +} + +/* r1 = (r1 * r2) + r3 */ +#define vfmadd213ss(r1, r2, r3) _vfmadd213sx(_jit, 0, r1, r2, r3) +#define vfmadd213sd(r1, r2, r3) _vfmadd213sx(_jit, 1, r1, r2, r3) +static void +_vfmadd213sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMADD132SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0xa9); + mrm(0x03, r7(r1), r7(r3)); +} + +/* r1 = (r1 * r2) - r3 */ +#define vfmsub213ss(r1, r2, r3) _vfmsub213sx(_jit, 0, r1, r2, r3) +#define vfmsub213sd(r1, r2, r3) _vfmsub213sx(_jit, 1, r1, r2, r3) +static void +_vfmsub213sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMSUB132SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0xab); + mrm(0x03, r7(r1), r7(r3)); +} + +/* r1 = (r2 * r3) + r1 */ +#define vfmadd231ss(r1, r2, r3) _vfmadd231sx(_jit, 0, r1, r2, r3) +#define vfmadd231sd(r1, r2, r3) _vfmadd231sx(_jit, 1, r1, r2, r3) +static void +_vfmadd231sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMADD231SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0xb9); + mrm(0x03, r7(r1), r7(r3)); +} + +/* r1 = (r2 * r3) - r1 */ +#define vfmsub231ss(r1, r2, r3) _vfmsub231sx(_jit, 0, r1, r2, r3) +#define vfmsub231sd(r1, r2, r3) _vfmsub231sx(_jit, 1, r1, r2, r3) +static void +_vfmsub231sx(jit_state_t *_jit, jit_bool_t dbl, + jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + /* VFMSUB231SD */ + vex(r1, _NOREG, r3, 2, !!dbl, r2, 0, 1); + ic(0xbb); + mrm(0x03, r7(r1), r7(r3)); +} + +static void +_sse_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_movr_f(r0, r1); + vfmadd213ss(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_movr_f(rn(t0), r1); + vfmadd213ss(rn(t0), r2, r3); + sse_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + sse_mulr_f(r0, r1, r2); + sse_addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_mulr_f(rn(t0), r1, r2); + sse_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_sse_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_movr_d(r0, r1); + vfmadd213sd(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_movr_d(rn(t0), r1); + vfmadd213sd(rn(t0), r2, r3); + sse_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + sse_mulr_d(r0, r1, r2); + sse_addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_mulr_d(rn(t0), r1, r2); + sse_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_sse_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_movr_f(r0, r1); + vfmsub213ss(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_movr_f(rn(t0), r1); + vfmsub213ss(rn(t0), r2, r3); + sse_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + sse_mulr_f(r0, r1, r2); + sse_subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_mulr_f(rn(t0), r1, r2); + sse_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_sse_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_movr_d(r0, r1); + vfmsub213sd(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_movr_d(rn(t0), r1); + vfmsub213sd(rn(t0), r2, r3); + sse_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + if (r0 != r3) { + sse_mulr_d(r0, r1, r2); + sse_subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_mulr_d(rn(t0), r1, r2); + sse_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } + } +} + +static void +_sse_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_negr_f(r0, r1); + vfmsub213ss(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_f(rn(t0), r1); + vfmsub213ss(rn(t0), r2, r3); + sse_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_f(rn(t0), r1); + sse_mulr_f(rn(t0), rn(t0), r2); + sse_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_sse_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_negr_d(r0, r1); + vfmsub213sd(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_d(rn(t0), r1); + vfmsub213sd(rn(t0), r2, r3); + sse_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_d(rn(t0), r1); + sse_mulr_d(rn(t0), rn(t0), r2); + sse_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_sse_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_negr_f(r0, r1); + vfmadd213ss(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_f(rn(t0), r1); + vfmadd213ss(rn(t0), r2, r3); + sse_movr_f(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_f(rn(t0), r1); + sse_mulr_f(rn(t0), rn(t0), r2); + sse_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_sse_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (jit_cpu.fma) { + if (r0 != r2 && r0 != r3) { + sse_negr_d(r0, r1); + vfmadd213sd(r0, r2, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_d(rn(t0), r1); + vfmadd213sd(rn(t0), r2, r3); + sse_movr_d(r0, rn(t0)); + jit_unget_reg(t0); + } + } + else { + t0 = jit_get_reg(jit_class_fpr|jit_class_xpr); + sse_negr_d(rn(t0), r1); + sse_mulr_d(rn(t0), rn(t0), r2); + sse_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + static void _ssecmp(jit_state_t *_jit, jit_bool_t d, jit_int32_t code, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) @@ -817,12 +1183,22 @@ _sse_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) else { reg = jit_get_reg(jit_class_gpr); movi(rn(reg), data.i); - movdlxr(r0, rn(reg)); + movdxr(r0, rn(reg)); jit_unget_reg(reg); } } } +static void +_sse_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movdxr(r0, rn(reg)); + jit_unget_reg(reg); +} + fopi(lt) fopi(le) @@ -975,6 +1351,26 @@ _sse_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_sse_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + sse_ldr_f(r0, r1); + else + sse_ldr_d(r0, r1); +} + +static void +_sse_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + sse_ldi_f(r0, i0); + else + sse_ldi_d(r0, i0); +} + static void _sse_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) { @@ -1028,6 +1424,26 @@ _sse_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_sse_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + sse_str_f(r0, r1); + else + sse_str_d(r0, r1); +} + +static void +_sse_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + sse_sti_f(i0, r0); + else + sse_sti_d(i0, r0); +} + static jit_word_t _sse_bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) { @@ -1313,7 +1729,7 @@ _sse_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) reg = jit_get_reg(jit_class_gpr); #if __X64 && !__X64_32 movi(rn(reg), data.w); - movdqxr(r0, rn(reg)); + movqxr(r0, rn(reg)); jit_unget_reg(reg); #else CHECK_CVT_OFFSET(); @@ -1328,6 +1744,52 @@ _sse_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) } } +#if __X32 || __X64_32 +static void +_sse_movr_ww_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CHECK_CVT_OFFSET(); + stxi_i(CVT_OFFSET, _RBP_REGNO, r1); + stxi_i(CVT_OFFSET + 4, _RBP_REGNO, r2); + sse_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_sse_movr_d_ww(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CHECK_CVT_OFFSET(); + sse_stxi_d(CVT_OFFSET, _RBP_REGNO, r2); + ldxi_i(r0, _RBP_REGNO, CVT_OFFSET); + ldxi_i(r1, _RBP_REGNO, CVT_OFFSET + 4); +} + +static void +_sse_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t reg; + CHECK_CVT_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg)); + movi(rn(reg), i1); + stxi_i(CVT_OFFSET + 4, _RBP_REGNO, rn(reg)); + sse_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); + jit_unget_reg(reg); +} +#else +static void +_sse_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + movqxr(r0, rn(reg)); + jit_unget_reg(reg); +} +#endif + static void _sse_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) { diff --git a/deps/lightning/lib/jit_x86-sz.c b/deps/lightning/lib/jit_x86-sz.c index 5c4515a7..99bb6255 100644 --- a/deps/lightning/lib/jit_x86-sz.c +++ b/deps/lightning/lib/jit_x86-sz.c @@ -1,9 +1,9 @@ #if __X32 -#define JIT_INSTR_MAX 42 +#define JIT_INSTR_MAX 63 0, /* data */ 0, /* live */ - 11, /* align */ + 3, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -88,7 +88,9 @@ 16, /* rshr_u */ 5, /* rshi_u */ 4, /* negr */ + 5, /* negi */ 4, /* comr */ + 5, /* comi */ 15, /* ltr */ 16, /* lti */ 15, /* ltr_u */ @@ -116,17 +118,29 @@ 9, /* casr */ 13, /* casi */ 11, /* extr_c */ + 5, /* exti_c */ 11, /* extr_uc */ + 5, /* exti_uc */ 3, /* extr_s */ + 5, /* exti_s */ 3, /* extr_us */ + 5, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 7, /* bswapr_us */ + 5, /* bswapi_us */ 4, /* bswapr_ui */ + 5, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 7, /* htonr_us */ + 5, /* htoni_us */ 4, /* htonr_ui */ + 5, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 3, /* ldr_c */ 7, /* ldi_c */ 3, /* ldr_uc */ @@ -254,93 +268,96 @@ 0, /* retval_i */ 0, /* retval_ui */ 0, /* retval_l */ - 23, /* epilog */ + 24, /* epilog */ 0, /* arg_f */ 0, /* getarg_f */ 0, /* putargr_f */ 0, /* putargi_f */ 8, /* addr_f */ - 17, /* addi_f */ + 19, /* addi_f */ 12, /* subr_f */ - 17, /* subi_f */ + 19, /* subi_f */ 21, /* rsbi_f */ 8, /* mulr_f */ - 17, /* muli_f */ + 19, /* muli_f */ 12, /* divr_f */ - 17, /* divi_f */ + 19, /* divi_f */ 12, /* negr_f */ + 0, /* negi_f */ 12, /* absr_f */ - 4, /* sqrtr_f */ - 12, /* ltr_f */ + 0, /* absi_f */ + 6, /* sqrtr_f */ + 0, /* sqrti_f */ + 13, /* ltr_f */ 27, /* lti_f */ - 12, /* ler_f */ + 13, /* ler_f */ 27, /* lei_f */ - 14, /* eqr_f */ + 15, /* eqr_f */ 29, /* eqi_f */ - 12, /* ger_f */ + 13, /* ger_f */ 27, /* gei_f */ - 12, /* gtr_f */ + 13, /* gtr_f */ 27, /* gti_f */ - 17, /* ner_f */ + 18, /* ner_f */ 32, /* nei_f */ - 12, /* unltr_f */ + 13, /* unltr_f */ 27, /* unlti_f */ - 12, /* unler_f */ + 13, /* unler_f */ 27, /* unlei_f */ - 12, /* uneqr_f */ + 13, /* uneqr_f */ 27, /* uneqi_f */ - 12, /* unger_f */ + 13, /* unger_f */ 27, /* ungei_f */ - 12, /* ungtr_f */ + 13, /* ungtr_f */ 27, /* ungti_f */ - 12, /* ltgtr_f */ + 13, /* ltgtr_f */ 27, /* ltgti_f */ - 12, /* ordr_f */ + 13, /* ordr_f */ 27, /* ordi_f */ - 12, /* unordr_f */ + 13, /* unordr_f */ 27, /* unordi_f */ - 4, /* truncr_f_i */ + 8, /* truncr_f_i */ 0, /* truncr_f_l */ - 4, /* extr_f */ + 8, /* extr_f */ 4, /* extr_d_f */ 10, /* movr_f */ - 15, /* movi_f */ + 25, /* movi_f */ 4, /* ldr_f */ 8, /* ldi_f */ 5, /* ldxr_f */ 8, /* ldxi_f */ - 4, /* str_f */ - 8, /* sti_f */ - 5, /* stxr_f */ + 6, /* str_f */ + 10, /* sti_f */ + 7, /* stxr_f */ 8, /* stxi_f */ - 9, /* bltr_f */ - 18, /* blti_f */ - 9, /* bler_f */ - 18, /* blei_f */ - 11, /* beqr_f */ - 20, /* beqi_f */ - 9, /* bger_f */ - 18, /* bgei_f */ - 9, /* bgtr_f */ - 18, /* bgti_f */ - 12, /* bner_f */ - 21, /* bnei_f */ - 9, /* bunltr_f */ - 18, /* bunlti_f */ - 9, /* bunler_f */ - 18, /* bunlei_f */ - 9, /* buneqr_f */ - 18, /* buneqi_f */ - 9, /* bunger_f */ - 18, /* bungei_f */ - 9, /* bungtr_f */ - 18, /* bungti_f */ - 9, /* bltgtr_f */ - 18, /* bltgti_f */ - 9, /* bordr_f */ - 18, /* bordi_f */ - 9, /* bunordr_f */ - 18, /* bunordi_f */ + 10, /* bltr_f */ + 23, /* blti_f */ + 10, /* bler_f */ + 23, /* blei_f */ + 12, /* beqr_f */ + 25, /* beqi_f */ + 10, /* bger_f */ + 23, /* bgei_f */ + 10, /* bgtr_f */ + 23, /* bgti_f */ + 13, /* bner_f */ + 26, /* bnei_f */ + 10, /* bunltr_f */ + 23, /* bunlti_f */ + 10, /* bunler_f */ + 23, /* bunlei_f */ + 10, /* buneqr_f */ + 23, /* buneqi_f */ + 10, /* bunger_f */ + 23, /* bungei_f */ + 10, /* bungtr_f */ + 23, /* bungti_f */ + 10, /* bltgtr_f */ + 23, /* bltgti_f */ + 10, /* bordr_f */ + 21, /* bordi_f */ + 10, /* bunordr_f */ + 23, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -360,8 +377,11 @@ 12, /* divr_d */ 26, /* divi_d */ 18, /* negr_d */ + 0, /* negi_d */ 13, /* absr_d */ - 4, /* sqrtr_d */ + 0, /* absi_d */ + 6, /* sqrtr_d */ + 0, /* sqrti_d */ 13, /* ltr_d */ 37, /* lti_d */ 13, /* ler_d */ @@ -390,9 +410,9 @@ 37, /* ordi_d */ 13, /* unordr_d */ 37, /* unordi_d */ - 4, /* truncr_d_i */ + 8, /* truncr_d_i */ 0, /* truncr_d_l */ - 4, /* extr_d */ + 8, /* extr_d */ 4, /* extr_f_d */ 10, /* movr_d */ 33, /* movi_d */ @@ -400,9 +420,9 @@ 8, /* ldi_d */ 5, /* ldxr_d */ 8, /* ldxi_d */ - 4, /* str_d */ - 8, /* sti_d */ - 5, /* stxr_d */ + 6, /* str_d */ + 10, /* sti_d */ + 7, /* stxr_d */ 8, /* stxi_d */ 10, /* bltr_d */ 28, /* blti_d */ @@ -437,19 +457,78 @@ 0, /* retr_d */ 0, /* reti_d */ 10, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 8, /* movr_w_f */ + 13, /* movi_w_f */ + 11, /* movr_ww_d */ + 18, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 10, /* movr_f_w */ + 5, /* movi_f_w */ + 13, /* movr_d_ww */ + 7, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 21, /* clo */ - 17, /* clz */ - 15, /* cto */ - 11, /* ctz */ + 21, /* clor */ + 5, /* cloi */ + 17, /* clzr */ + 5, /* clzi */ + 15, /* ctor */ + 5, /* ctoi */ + 11, /* ctzr */ + 5, /* ctzi */ + 61, /* rbitr */ + 5, /* rbiti */ + 58, /* popcntr */ + 5, /* popcnti */ + 16, /* lrotr */ + 5, /* lroti */ + 16, /* rrotr */ + 5, /* rroti */ + 10, /* extr */ + 5, /* exti */ + 11, /* extr_u */ + 5, /* exti_u */ + 22, /* depr */ + 24, /* depi */ + 63, /* qlshr */ + 12, /* qlshi */ + 60, /* qlshr_u */ + 12, /* qlshi_u */ + 59, /* qrshr */ + 12, /* qrshi */ + 56, /* qrshr_u */ + 12, /* qrshi_u */ + 14, /* unldr */ + 19, /* unldi */ + 14, /* unldr_u */ + 19, /* unldi_u */ + 11, /* unstr */ + 18, /* unsti */ + 4, /* unldr_x */ + 8, /* unldi_x */ + 6, /* unstr_x */ + 10, /* unsti_x */ + 13, /* fmar_f */ + 0, /* fmai_f */ + 13, /* fmsr_f */ + 0, /* fmsi_f */ + 13, /* fmar_d */ + 0, /* fmai_d */ + 13, /* fmsr_d */ + 0, /* fmsi_d */ + 21, /* fnmar_f */ + 0, /* fnmai_f */ + 21, /* fnmsr_f */ + 0, /* fnmsi_f */ + 27, /* fnmar_d */ + 0, /* fnmai_d */ + 27, /* fnmsr_d */ + 0, /* fnmsi_d */ + 18, /* hmulr */ + 23, /* hmuli */ + 18, /* hmulr_u */ + 23, /* hmuli_u */ #endif /* __X32 */ #if __X64 @@ -457,7 +536,7 @@ #define JIT_INSTR_MAX 130 0, /* data */ 0, /* live */ - 27, /* align */ + 19, /* align */ 0, /* save */ 0, /* load */ 4, /* skip */ @@ -494,7 +573,7 @@ 0, /* putargi_ui */ 0, /* putargr_l */ 0, /* putargi_l */ - 7, /* va_start */ + 4, /* va_start */ 7, /* va_arg */ 9, /* va_arg_d */ 0, /* va_end */ @@ -522,9 +601,9 @@ 23, /* divr_u */ 30, /* divi_u */ 25, /* qdivr */ - 32, /* qdivi */ + 29, /* qdivi */ 26, /* qdivr_u */ - 33, /* qdivi_u */ + 30, /* qdivi_u */ 22, /* remr */ 29, /* remi */ 23, /* remr_u */ @@ -542,7 +621,9 @@ 9, /* rshr_u */ 7, /* rshi_u */ 6, /* negr */ + 7, /* negi */ 6, /* comr */ + 7, /* comi */ 13, /* ltr */ 14, /* lti */ 13, /* ltr_u */ @@ -568,33 +649,45 @@ 7, /* movnr */ 7, /* movzr */ 11, /* casr */ - 21, /* casi */ + 16, /* casi */ 7, /* extr_c */ + 7, /* exti_c */ 7, /* extr_uc */ + 5, /* exti_uc */ 4, /* extr_s */ + 7, /* exti_s */ 4, /* extr_us */ + 5, /* exti_us */ 3, /* extr_i */ + 10, /* exti_i */ 3, /* extr_ui */ + 5, /* exti_ui */ 9, /* bswapr_us */ + 5, /* bswapi_us */ 6, /* bswapr_ui */ + 5, /* bswapi_ui */ 6, /* bswapr_ul */ + 10, /* bswapi_ul */ 9, /* htonr_us */ + 5, /* htoni_us */ 6, /* htonr_ui */ + 5, /* htoni_ui */ 6, /* htonr_ul */ + 10, /* htoni_ul */ 4, /* ldr_c */ - 14, /* ldi_c */ + 9, /* ldi_c */ 4, /* ldr_uc */ - 14, /* ldi_uc */ + 9, /* ldi_uc */ 4, /* ldr_s */ - 14, /* ldi_s */ + 9, /* ldi_s */ 4, /* ldr_us */ - 14, /* ldi_us */ + 9, /* ldi_us */ 3, /* ldr_i */ - 13, /* ldi_i */ + 8, /* ldi_i */ 3, /* ldr_ui */ - 13, /* ldi_ui */ + 7, /* ldi_ui */ 3, /* ldr_l */ - 13, /* ldi_l */ + 7, /* ldi_l */ 5, /* ldxr_c */ 8, /* ldxi_c */ 5, /* ldxr_uc */ @@ -610,13 +703,13 @@ 4, /* ldxr_l */ 7, /* ldxi_l */ 6, /* str_c */ - 16, /* sti_c */ + 11, /* sti_c */ 4, /* str_s */ - 14, /* sti_s */ + 9, /* sti_s */ 3, /* str_i */ - 13, /* sti_i */ + 8, /* sti_i */ 3, /* str_l */ - 13, /* sti_l */ + 8, /* sti_l */ 7, /* stxr_c */ 7, /* stxi_c */ 5, /* stxr_s */ @@ -717,84 +810,87 @@ 19, /* addi_f */ 15, /* subr_f */ 19, /* subi_f */ - 26, /* rsbi_f */ + 23, /* rsbi_f */ 10, /* mulr_f */ 19, /* muli_f */ 15, /* divr_f */ 19, /* divi_f */ 14, /* negr_f */ + 0, /* negi_f */ 15, /* absr_f */ + 0, /* absi_f */ 5, /* sqrtr_f */ + 0, /* sqrti_f */ 16, /* ltr_f */ - 30, /* lti_f */ + 27, /* lti_f */ 16, /* ler_f */ - 30, /* lei_f */ + 27, /* lei_f */ 18, /* eqr_f */ - 32, /* eqi_f */ + 29, /* eqi_f */ 16, /* ger_f */ - 30, /* gei_f */ + 27, /* gei_f */ 16, /* gtr_f */ - 30, /* gti_f */ + 27, /* gti_f */ 20, /* ner_f */ - 34, /* nei_f */ + 31, /* nei_f */ 16, /* unltr_f */ - 30, /* unlti_f */ + 27, /* unlti_f */ 16, /* unler_f */ - 30, /* unlei_f */ + 27, /* unlei_f */ 16, /* uneqr_f */ - 30, /* uneqi_f */ + 27, /* uneqi_f */ 16, /* unger_f */ - 30, /* ungei_f */ + 27, /* ungei_f */ 16, /* ungtr_f */ - 30, /* ungti_f */ + 27, /* ungti_f */ 16, /* ltgtr_f */ - 30, /* ltgti_f */ + 27, /* ltgti_f */ 16, /* ordr_f */ - 30, /* ordi_f */ + 27, /* ordi_f */ 16, /* unordr_f */ - 30, /* unordi_f */ + 27, /* unordi_f */ 5, /* truncr_f_i */ 5, /* truncr_f_l */ 5, /* extr_f */ 5, /* extr_d_f */ 5, /* movr_f */ - 18, /* movi_f */ + 15, /* movi_f */ 5, /* ldr_f */ - 15, /* ldi_f */ + 10, /* ldi_f */ 6, /* ldxr_f */ 8, /* ldxi_f */ 5, /* str_f */ - 15, /* sti_f */ + 10, /* sti_f */ 6, /* stxr_f */ 9, /* stxi_f */ 10, /* bltr_f */ 19, /* blti_f */ 10, /* bler_f */ - 23, /* blei_f */ + 20, /* blei_f */ 12, /* beqr_f */ - 27, /* beqi_f */ + 26, /* beqi_f */ 10, /* bger_f */ - 24, /* bgei_f */ + 21, /* bgei_f */ 10, /* bgtr_f */ - 24, /* bgti_f */ + 21, /* bgti_f */ 13, /* bner_f */ - 27, /* bnei_f */ + 24, /* bnei_f */ 10, /* bunltr_f */ - 24, /* bunlti_f */ + 21, /* bunlti_f */ 10, /* bunler_f */ - 24, /* bunlei_f */ + 21, /* bunlei_f */ 10, /* buneqr_f */ - 24, /* buneqi_f */ + 21, /* buneqi_f */ 10, /* bunger_f */ - 24, /* bungei_f */ + 21, /* bungei_f */ 10, /* bungtr_f */ - 24, /* bungti_f */ + 21, /* bungti_f */ 10, /* bltgtr_f */ - 24, /* bltgti_f */ + 21, /* bltgti_f */ 10, /* bordr_f */ - 24, /* bordi_f */ + 21, /* bordi_f */ 10, /* bunordr_f */ - 24, /* bunordi_f */ + 21, /* bunordi_f */ 0, /* pushargr_f */ 0, /* pushargi_f */ 0, /* retr_f */ @@ -814,8 +910,11 @@ 15, /* divr_d */ 25, /* divi_d */ 21, /* negr_d */ + 0, /* negi_d */ 16, /* absr_d */ + 0, /* absi_d */ 5, /* sqrtr_d */ + 0, /* sqrti_d */ 17, /* ltr_d */ 32, /* lti_d */ 17, /* ler_d */ @@ -849,13 +948,13 @@ 5, /* extr_d */ 5, /* extr_f_d */ 5, /* movr_d */ - 29, /* movi_d */ + 15, /* movi_d */ 5, /* ldr_d */ - 15, /* ldi_d */ + 10, /* ldi_d */ 6, /* ldxr_d */ 8, /* ldxi_d */ 5, /* str_d */ - 15, /* sti_d */ + 10, /* sti_d */ 6, /* stxr_d */ 9, /* stxi_d */ 11, /* bltr_d */ @@ -891,19 +990,78 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 5, /* movr_w_f */ + 10, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 5, /* movr_w_d */ + 15, /* movi_w_d */ + 5, /* movr_f_w */ + 6, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 27, /* clo */ - 21, /* clz */ - 20, /* cto */ - 14, /* ctz */ + 5, /* movr_d_w */ + 10, /* movi_d_w */ + 27, /* clor */ + 5, /* cloi */ + 21, /* clzr */ + 5, /* clzi */ + 20, /* ctor */ + 5, /* ctoi */ + 14, /* ctzr */ + 5, /* ctzi */ + 61, /* rbitr */ + 10, /* rbiti */ + 57, /* popcntr */ + 5, /* popcnti */ + 9, /* lrotr */ + 7, /* lroti */ + 9, /* rrotr */ + 7, /* rroti */ + 12, /* extr */ + 7, /* exti */ + 20, /* extr_u */ + 5, /* exti_u */ + 37, /* depr */ + 30, /* depi */ + 58, /* qlshr */ + 15, /* qlshi */ + 54, /* qlshr_u */ + 15, /* qlshi_u */ + 53, /* qrshr */ + 15, /* qrshi */ + 49, /* qrshr_u */ + 15, /* qrshi_u */ + 21, /* unldr */ + 26, /* unldi */ + 21, /* unldr_u */ + 25, /* unldi_u */ + 26, /* unstr */ + 38, /* unsti */ + 5, /* unldr_x */ + 10, /* unldi_x */ + 5, /* unstr_x */ + 10, /* unsti_x */ + 12, /* fmar_f */ + 0, /* fmai_f */ + 20, /* fmsr_f */ + 0, /* fmsi_f */ + 12, /* fmar_d */ + 0, /* fmai_d */ + 20, /* fmsr_d */ + 0, /* fmsi_d */ + 28, /* fnmar_f */ + 0, /* fnmai_f */ + 24, /* fnmsr_f */ + 0, /* fnmsi_f */ + 34, /* fnmar_d */ + 0, /* fnmai_d */ + 30, /* fnmsr_d */ + 0, /* fnmsi_d */ + 17, /* hmulr */ + 27, /* hmuli */ + 17, /* hmulr_u */ + 27, /* hmuli_u */ #else # if __X64_32 @@ -995,7 +1153,9 @@ 9, /* rshr_u */ 7, /* rshi_u */ 6, /* negr */ + 5, /* negi */ 6, /* comr */ + 5, /* comi */ 13, /* ltr */ 14, /* lti */ 13, /* ltr_u */ @@ -1023,27 +1183,39 @@ 11, /* casr */ 16, /* casi */ 7, /* extr_c */ + 5, /* exti_c */ 7, /* extr_uc */ + 5, /* exti_uc */ 4, /* extr_s */ + 5, /* exti_s */ 4, /* extr_us */ + 5, /* exti_us */ 0, /* extr_i */ + 0, /* exti_i */ 0, /* extr_ui */ + 0, /* exti_ui */ 9, /* bswapr_us */ + 5, /* bswapi_us */ 6, /* bswapr_ui */ + 5, /* bswapi_ui */ 0, /* bswapr_ul */ + 0, /* bswapi_ul */ 9, /* htonr_us */ + 5, /* htoni_us */ 6, /* htonr_ui */ + 5, /* htoni_ui */ 0, /* htonr_ul */ + 0, /* htoni_ul */ 5, /* ldr_c */ - 9, /* ldi_c */ + 10, /* ldi_c */ 5, /* ldr_uc */ - 9, /* ldi_uc */ + 10, /* ldi_uc */ 5, /* ldr_s */ - 9, /* ldi_s */ + 10, /* ldi_s */ 5, /* ldr_us */ - 9, /* ldi_us */ + 10, /* ldi_us */ 4, /* ldr_i */ - 8, /* ldi_i */ + 9, /* ldi_i */ 0, /* ldr_ui */ 0, /* ldi_ui */ 0, /* ldr_l */ @@ -1057,7 +1229,7 @@ 9, /* ldxr_us */ 7, /* ldxi_us */ 8, /* ldxr_i */ - 7, /* ldxi_i */ + 6, /* ldxi_i */ 0, /* ldxr_ui */ 0, /* ldxi_ui */ 0, /* ldxr_l */ @@ -1065,9 +1237,9 @@ 7, /* str_c */ 11, /* sti_c */ 5, /* str_s */ - 9, /* sti_s */ + 10, /* sti_s */ 4, /* str_i */ - 8, /* sti_i */ + 9, /* sti_i */ 0, /* str_l */ 0, /* sti_l */ 11, /* stxr_c */ @@ -1176,8 +1348,11 @@ 15, /* divr_f */ 20, /* divi_f */ 15, /* negr_f */ + 0, /* negi_f */ 15, /* absr_f */ + 0, /* absi_f */ 5, /* sqrtr_f */ + 0, /* sqrti_f */ 15, /* ltr_f */ 26, /* lti_f */ 15, /* ler_f */ @@ -1217,7 +1392,7 @@ 10, /* ldxr_f */ 9, /* ldxi_f */ 6, /* str_f */ - 10, /* sti_f */ + 11, /* sti_f */ 10, /* stxr_f */ 9, /* stxi_f */ 10, /* bltr_f */ @@ -1267,8 +1442,11 @@ 15, /* divr_d */ 29, /* divi_d */ 22, /* negr_d */ + 0, /* negi_d */ 16, /* absr_d */ + 0, /* absi_d */ 5, /* sqrtr_d */ + 0, /* sqrti_d */ 16, /* ltr_d */ 39, /* lti_d */ 16, /* ler_d */ @@ -1302,13 +1480,13 @@ 5, /* extr_d */ 5, /* extr_f_d */ 5, /* movr_d */ - 23, /* movi_d */ + 28, /* movi_d */ 6, /* ldr_d */ 10, /* ldi_d */ 10, /* ldxr_d */ 9, /* ldxi_d */ 6, /* str_d */ - 10, /* sti_d */ + 11, /* sti_d */ 10, /* stxr_d */ 9, /* stxi_d */ 11, /* bltr_d */ @@ -1316,7 +1494,7 @@ 11, /* bler_d */ 30, /* blei_d */ 13, /* beqr_d */ - 36, /* beqi_d */ + 41, /* beqi_d */ 11, /* bger_d */ 30, /* bgei_d */ 11, /* bgtr_d */ @@ -1344,19 +1522,78 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ - 0, /* movr_ww_d */ + 5, /* movr_w_f */ + 10, /* movi_w_f */ + 14, /* movr_ww_d */ + 19, /* movi_ww_d */ 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ - 0, /* movr_d_ww */ - 0, /* movi_d_ww */ + 0, /* movi_w_d */ + 5, /* movr_f_w */ + 6, /* movi_f_w */ + 14, /* movr_d_ww */ + 9, /* movi_d_ww */ 0, /* movr_d_w */ 0, /* movi_d_w */ - 11, /* clo */ - 5, /* clz */ - 11, /* cto */ - 5, /* ctz */ + 11, /* clor */ + 5, /* cloi */ + 5, /* clzr */ + 5, /* clzi */ + 11, /* ctor */ + 5, /* ctoi */ + 5, /* ctzr */ + 5, /* ctzi */ + 64, /* rbitr */ + 5, /* rbiti */ + 5, /* popcntr */ + 5, /* popcnti */ + 9, /* lrotr */ + 7, /* lroti */ + 9, /* rrotr */ + 7, /* rroti */ + 12, /* extr */ + 5, /* exti */ + 11, /* extr_u */ + 5, /* exti_u */ + 24, /* depr */ + 27, /* depi */ + 56, /* qlshr */ + 15, /* qlshi */ + 52, /* qlshr_u */ + 15, /* qlshi_u */ + 51, /* qrshr */ + 15, /* qrshi */ + 47, /* qrshr_u */ + 15, /* qrshi_u */ + 19, /* unldr */ + 24, /* unldi */ + 19, /* unldr_u */ + 24, /* unldi_u */ + 18, /* unstr */ + 27, /* unsti */ + 5, /* unldr_x */ + 10, /* unldi_x */ + 5, /* unstr_x */ + 10, /* unsti_x */ + 15, /* fmar_f */ + 0, /* fmai_f */ + 15, /* fmsr_f */ + 0, /* fmsi_f */ + 15, /* fmar_d */ + 0, /* fmai_d */ + 15, /* fmsr_d */ + 0, /* fmsi_d */ + 24, /* fnmar_f */ + 0, /* fnmai_f */ + 24, /* fnmsr_f */ + 0, /* fnmsi_f */ + 31, /* fnmar_d */ + 0, /* fnmai_d */ + 31, /* fnmsr_d */ + 0, /* fnmsi_d */ + 15, /* hmulr */ + 21, /* hmuli */ + 15, /* hmulr_u */ + 21, /* hmuli_u */ #else #define JIT_INSTR_MAX 112 @@ -1427,9 +1664,9 @@ 23, /* divr_u */ 30, /* divi_u */ 25, /* qdivr */ - 32, /* qdivi */ + 29, /* qdivi */ 26, /* qdivr_u */ - 33, /* qdivi_u */ + 30, /* qdivi_u */ 22, /* remr */ 29, /* remi */ 23, /* remr_u */ @@ -1447,7 +1684,9 @@ 9, /* rshr_u */ 7, /* rshi_u */ 6, /* negr */ + 7, /* negi */ 6, /* comr */ + 7, /* comi */ 13, /* ltr */ 14, /* lti */ 13, /* ltr_u */ @@ -1475,17 +1714,29 @@ 11, /* casr */ 16, /* casi */ 4, /* extr_c */ + 7, /* exti_c */ 4, /* extr_uc */ + 5, /* exti_uc */ 4, /* extr_s */ + 7, /* exti_s */ 4, /* extr_us */ + 5, /* exti_us */ 3, /* extr_i */ + 10, /* exti_i */ 3, /* extr_ui */ + 5, /* exti_ui */ 9, /* bswapr_us */ + 5, /* bswapi_us */ 6, /* bswapr_ui */ + 5, /* bswapi_ui */ 6, /* bswapr_ul */ + 10, /* bswapi_ul */ 9, /* htonr_us */ + 5, /* htoni_us */ 6, /* htonr_ui */ + 5, /* htoni_ui */ 6, /* htonr_ul */ + 10, /* htoni_ul */ 5, /* ldr_c */ 9, /* ldi_c */ 5, /* ldr_uc */ @@ -1622,42 +1873,45 @@ 20, /* addi_f */ 15, /* subr_f */ 20, /* subi_f */ - 30, /* rsbi_f */ + 27, /* rsbi_f */ 10, /* mulr_f */ 20, /* muli_f */ 15, /* divr_f */ 20, /* divi_f */ 15, /* negr_f */ + 0, /* negi_f */ 15, /* absr_f */ + 0, /* absi_f */ 5, /* sqrtr_f */ + 0, /* sqrti_f */ 11, /* ltr_f */ - 26, /* lti_f */ + 23, /* lti_f */ 11, /* ler_f */ - 26, /* lei_f */ + 23, /* lei_f */ 13, /* eqr_f */ - 28, /* eqi_f */ + 25, /* eqi_f */ 11, /* ger_f */ - 26, /* gei_f */ + 23, /* gei_f */ 11, /* gtr_f */ - 26, /* gti_f */ + 23, /* gti_f */ 16, /* ner_f */ - 31, /* nei_f */ + 28, /* nei_f */ 11, /* unltr_f */ - 26, /* unlti_f */ + 23, /* unlti_f */ 11, /* unler_f */ - 26, /* unlei_f */ + 23, /* unlei_f */ 11, /* uneqr_f */ - 26, /* uneqi_f */ + 23, /* uneqi_f */ 11, /* unger_f */ - 26, /* ungei_f */ + 23, /* ungei_f */ 11, /* ungtr_f */ - 26, /* ungti_f */ + 23, /* ungti_f */ 11, /* ltgtr_f */ - 26, /* ltgti_f */ + 23, /* ltgti_f */ 11, /* ordr_f */ - 26, /* ordi_f */ + 23, /* ordi_f */ 11, /* unordr_f */ - 26, /* unordi_f */ + 23, /* unordi_f */ 5, /* truncr_f_i */ 5, /* truncr_f_l */ 5, /* extr_f */ @@ -1677,7 +1931,7 @@ 10, /* bler_f */ 22, /* blei_f */ 12, /* beqr_f */ - 22, /* beqi_f */ + 27, /* beqi_f */ 10, /* bger_f */ 22, /* bgei_f */ 10, /* bgtr_f */ @@ -1685,13 +1939,13 @@ 13, /* bner_f */ 25, /* bnei_f */ 10, /* bunltr_f */ - 23, /* bunlti_f */ + 22, /* bunlti_f */ 10, /* bunler_f */ - 23, /* bunlei_f */ + 22, /* bunlei_f */ 10, /* buneqr_f */ - 23, /* buneqi_f */ + 22, /* buneqi_f */ 10, /* bunger_f */ - 23, /* bungei_f */ + 22, /* bungei_f */ 10, /* bungtr_f */ 22, /* bungti_f */ 10, /* bltgtr_f */ @@ -1719,8 +1973,11 @@ 15, /* divr_d */ 25, /* divi_d */ 22, /* negr_d */ + 0, /* negi_d */ 16, /* absr_d */ + 0, /* absi_d */ 5, /* sqrtr_d */ + 0, /* sqrti_d */ 12, /* ltr_d */ 27, /* lti_d */ 12, /* ler_d */ @@ -1796,19 +2053,78 @@ 0, /* retr_d */ 0, /* reti_d */ 0, /* retval_d */ - 0, /* movr_w_f */ + 5, /* movr_w_f */ + 10, /* movi_w_f */ 0, /* movr_ww_d */ - 0, /* movr_w_d */ - 0, /* movr_f_w */ - 0, /* movi_f_w */ + 0, /* movi_ww_d */ + 5, /* movr_w_d */ + 15, /* movi_w_d */ + 5, /* movr_f_w */ + 6, /* movi_f_w */ 0, /* movr_d_ww */ 0, /* movi_d_ww */ - 0, /* movr_d_w */ - 0, /* movi_d_w */ - 11, /* clo */ - 5, /* clz */ - 11, /* cto */ - 5, /* ctz */ + 5, /* movr_d_w */ + 10, /* movi_d_w */ + 11, /* clor */ + 5, /* cloi */ + 5, /* clzr */ + 5, /* clzi */ + 11, /* ctor */ + 5, /* ctoi */ + 5, /* ctzr */ + 5, /* ctzi */ + 56, /* rbitr */ + 10, /* rbiti */ + 5, /* popcntr */ + 5, /* popcnti */ + 9, /* lrotr */ + 7, /* lroti */ + 9, /* rrotr */ + 7, /* rroti */ + 12, /* extr */ + 7, /* exti */ + 15, /* extr_u */ + 5, /* exti_u */ + 34, /* depr */ + 27, /* depi */ + 58, /* qlshr */ + 15, /* qlshi */ + 54, /* qlshr_u */ + 15, /* qlshi_u */ + 53, /* qrshr */ + 15, /* qrshi */ + 49, /* qrshr_u */ + 15, /* qrshi_u */ + 21, /* unldr */ + 27, /* unldi */ + 21, /* unldr_u */ + 26, /* unldi_u */ + 24, /* unstr */ + 36, /* unsti */ + 5, /* unldr_x */ + 10, /* unldi_x */ + 5, /* unstr_x */ + 10, /* unsti_x */ + 15, /* fmar_f */ + 0, /* fmai_f */ + 15, /* fmsr_f */ + 0, /* fmsi_f */ + 15, /* fmar_d */ + 0, /* fmai_d */ + 15, /* fmsr_d */ + 0, /* fmsi_d */ + 24, /* fnmar_f */ + 0, /* fnmai_f */ + 24, /* fnmsr_f */ + 0, /* fnmsi_f */ + 31, /* fnmar_d */ + 0, /* fnmai_d */ + 31, /* fnmsr_d */ + 0, /* fnmsi_d */ + 17, /* hmulr */ + 27, /* hmuli */ + 17, /* hmulr_u */ + 27, /* hmuli_u */ #endif /* __CYGWIN__ || _WIN32 */ # endif /* __X64_32 */ #endif /* __X64 */ diff --git a/deps/lightning/lib/jit_x86-x87.c b/deps/lightning/lib/jit_x86-x87.c index 3de0214e..61040dab 100644 --- a/deps/lightning/lib/jit_x86-x87.c +++ b/deps/lightning/lib/jit_x86-x87.c @@ -120,6 +120,30 @@ static void _x87_negr_d(jit_state_t*, jit_int32_t, jit_int32_t); # define x87_sqrtr_f(r0, r1) _x87_sqrtr_d(_jit, r0, r1) # define x87_sqrtr_d(r0, r1) _x87_sqrtr_d(_jit, r0, r1) static void _x87_sqrtr_d(jit_state_t*, jit_int32_t, jit_int32_t); +# define x87_fmar_f(r0, r1, r2, r3) _x87_fmar_f(_jit, r0, r1, r2, r3) +static void _x87_fmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fmar_d(r0, r1, r2, r3) _x87_fmar_d(_jit, r0, r1, r2, r3) +static void _x87_fmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fmsr_f(r0, r1, r2, r3) _x87_fmsr_f(_jit, r0, r1, r2, r3) +static void _x87_fmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fmsr_d(r0, r1, r2, r3) _x87_fmsr_d(_jit, r0, r1, r2, r3) +static void _x87_fmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fnmar_f(r0, r1, r2, r3) _x87_fnmar_f(_jit, r0, r1, r2, r3) +static void _x87_fnmar_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fnmar_d(r0, r1, r2, r3) _x87_fnmar_d(_jit, r0, r1, r2, r3) +static void _x87_fnmar_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fnmsr_f(r0, r1, r2, r3) _x87_fnmsr_f(_jit, r0, r1, r2, r3) +static void _x87_fnmsr_f(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); +# define x87_fnmsr_d(r0, r1, r2, r3) _x87_fnmsr_d(_jit, r0, r1, r2, r3) +static void _x87_fnmsr_d(jit_state_t*, + jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t); # define x87_truncr_f_i(r0, r1) _x87_truncr_d_i(_jit, r0, r1) # define x87_truncr_d_i(r0, r1) _x87_truncr_d_i(_jit, r0, r1) static void _x87_truncr_d_i(jit_state_t*, jit_int32_t, jit_int32_t); @@ -147,6 +171,12 @@ static jit_word_t _x87jcc2(jit_state_t*, jit_int32_t, jit_word_t, jit_int32_t, jit_int32_t); #define x87_movi_f(r0,i0) _x87_movi_f(_jit,r0,i0) static void _x87_movi_f(jit_state_t*, jit_int32_t, jit_float32_t*); +#define x87_movr_w_f(r0,r1) _x87_movr_w_f(_jit,r0,r1) +static void _x87_movr_w_f(jit_state_t*, jit_int32_t, jit_int32_t); +#define x87_movr_f_w(r0,r1) _x87_movr_f_w(_jit,r0,r1) +static void _x87_movr_f_w(jit_state_t*, jit_int32_t, jit_int32_t); +#define x87_movi_w_f(r0, i0) _x87_movi_w_f(_jit, r0, i0) +static void _x87_movi_w_f(jit_state_t*, jit_int32_t, jit_word_t); # define x87_ldr_f(r0, r1) _x87_ldr_f(_jit, r0, r1) static void _x87_ldr_f(jit_state_t*, jit_int32_t, jit_int32_t); # define x87_ldi_f(r0, i0) _x87_ldi_f(_jit, r0, i0) @@ -155,6 +185,10 @@ static void _x87_ldi_f(jit_state_t*, jit_int32_t, jit_word_t); static void _x87_ldxr_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t); # define x87_ldxi_f(r0, r1, i0) _x87_ldxi_f(_jit, r0, r1, i0) static void _x87_ldxi_f(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define x87_unldr_x(r0, r1, i0) _x87_unldr_x(_jit, r0, r1, i0) +static void _x87_unldr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +# define x87_unldi_x(r0, i0, i1) _x87_unldi_x(_jit, r0, i0, i1) +static void _x87_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); # define x87_str_f(r0, r1) _x87_str_f(_jit, r0, r1) static void _x87_str_f(jit_state_t*,jit_int32_t,jit_int32_t); # define x87_sti_f(i0, r0) _x87_sti_f(_jit, i0, r0) @@ -163,6 +197,10 @@ static void _x87_sti_f(jit_state_t*,jit_word_t, jit_int32_t); static void _x87_stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t); # define x87_stxi_f(i0, r0, r1) _x87_stxi_f(_jit, i0, r0, r1) static void _x87_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t); +#define x87_unstr_x(r0, r1, i0) _x87_unstr_x(_jit, r0, r1, i0) +static void _x87_unstr_x(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define x87_unsti_x(i0, r0, i1) _x87_unsti_x(_jit, i0, r0, i1) +static void _x87_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); # define x87_ltr_f(r0, r1, r2) x87cmp(X86_CC_A, r0, r2, r1) # define x87_lti_f(r0, r1, i0) _x87_lti_f(_jit, r0, r1, i0) static void _x87_lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*); @@ -255,6 +293,21 @@ static void _x87_unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*); static void _x87_movr_d(jit_state_t*, jit_int32_t, jit_int32_t); #define x87_movi_d(r0,i0) _x87_movi_d(_jit,r0,i0) static void _x87_movi_d(jit_state_t*, jit_int32_t, jit_float64_t*); +#if __X32 || __X64_32 +# define x87_movr_ww_d(r0,r1,r2) _x87_movr_ww_d(_jit,r0,r1,r2) +static void _x87_movr_ww_d(jit_state_t*, jit_int32_t, jit_int32_t,jit_int32_t); +# define x87_movr_d_ww(r0,r1,r2) _x87_movr_d_ww(_jit,r0,r1,r2) +static void _x87_movr_d_ww(jit_state_t*, jit_int32_t, jit_int32_t,jit_int32_t); +# define x87_movi_ww_d(r0, i0, i1) _x87_movi_ww_d(_jit, r0, i0, i1) +static void _x87_movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +#else +# define x87_movr_w_d(r0,r1) _x87_movr_w_d(_jit,r0,r1) +static void _x87_movr_w_d(jit_state_t*, jit_int32_t, jit_int32_t); +# define x87_movr_d_w(r0,r1) _x87_movr_d_w(_jit,r0,r1) +static void _x87_movr_d_w(jit_state_t*, jit_int32_t, jit_int32_t); +#define x87_movi_w_d(r0, i0) _x87_movi_w_d(_jit, r0, i0) +static void _x87_movi_w_d(jit_state_t*, jit_int32_t, jit_word_t); +#endif # define x87_ldr_d(r0, r1) _x87_ldr_d(_jit, r0, r1) static void _x87_ldr_d(jit_state_t*, jit_int32_t, jit_int32_t); # define x87_ldi_d(r0, i0) _x87_ldi_d(_jit, r0, i0) @@ -659,6 +712,126 @@ _x87_sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } } +static void +_x87_fmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + x87_mulr_f(r0, r1, r2); + x87_addr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + assert(jit_x87_reg_p(t0)); + x87_mulr_f(rn(t0), r1, r2); + x87_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_x87_fmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + x87_mulr_d(r0, r1, r2); + x87_addr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + assert(jit_x87_reg_p(t0)); + x87_mulr_d(rn(t0), r1, r2); + x87_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_x87_fmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + x87_mulr_f(r0, r1, r2); + x87_subr_f(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + assert(jit_x87_reg_p(t0)); + x87_mulr_f(rn(t0), r1, r2); + x87_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_x87_fmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + if (r0 != r3) { + x87_mulr_d(r0, r1, r2); + x87_subr_d(r0, r0, r3); + } + else { + t0 = jit_get_reg(jit_class_fpr); + assert(jit_x87_reg_p(t0)); + x87_mulr_d(rn(t0), r1, r2); + x87_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); + } +} + +static void +_x87_fnmar_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + x87_negr_f(rn(t0), r1); + x87_mulr_f(rn(t0), rn(t0), r2); + x87_subr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_x87_fnmar_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + x87_negr_d(rn(t0), r1); + x87_mulr_d(rn(t0), rn(t0), r2); + x87_subr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_x87_fnmsr_f(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + x87_negr_f(rn(t0), r1); + x87_mulr_f(rn(t0), rn(t0), r2); + x87_addr_f(r0, rn(t0), r3); + jit_unget_reg(t0); +} + +static void +_x87_fnmsr_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3) +{ + jit_int32_t t0; + t0 = jit_get_reg(jit_class_fpr); + x87_negr_d(rn(t0), r1); + x87_mulr_d(rn(t0), rn(t0), r2); + x87_addr_d(r0, rn(t0), r3); + jit_unget_reg(t0); +} + static void _x87_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -862,6 +1035,34 @@ _x87_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0) fstpr(r0 + 1); } +static void +_x87_movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + CHECK_CVT_OFFSET(); + stxi_i(CVT_OFFSET, _RBP_REGNO, r1); + x87_ldxi_f(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_x87_movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + CHECK_CVT_OFFSET(); + x87_stxi_f(CVT_OFFSET, _RBP_REGNO, r1); + ldxi_i(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_x87_movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + CHECK_CVT_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg)); + jit_unget_reg(reg); + x87_ldxi_f(r0, _RBP_REGNO, CVT_OFFSET); +} + static void _x87_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -921,6 +1122,26 @@ _x87_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) } } +static void +_x87_unldr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + x87_ldr_f(r0, r1); + else + x87_ldr_d(r0, r1); +} + +static void +_x87_unldi_x(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + x87_ldi_f(r0, i0); + else + x87_ldi_d(r0, i0); +} + static void _x87_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -996,6 +1217,26 @@ _x87_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1) } } +static void +_x87_unstr_x(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + x87_str_f(r0, r1); + else + x87_str_d(r0, r1); +} + +static void +_x87_unsti_x(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + x87_sti_f(i0, r0); + else + x87_sti_d(i0, r0); +} + static void _x87_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) { @@ -1061,6 +1302,71 @@ _x87_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0) fstpr(r0 + 1); } +#if __X32 || __X64_32 +static void +_x87_movr_ww_d(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CHECK_CVT_OFFSET(); + stxi_i(CVT_OFFSET, _RBP_REGNO, r1); + stxi_i(CVT_OFFSET + 4, _RBP_REGNO, r2); + x87_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_x87_movr_d_ww(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) +{ + CHECK_CVT_OFFSET(); + x87_stxi_d(CVT_OFFSET, _RBP_REGNO, r2); + ldxi_i(r0, _RBP_REGNO, CVT_OFFSET); + ldxi_i(r1, _RBP_REGNO, CVT_OFFSET + 4); +} + +static void +_x87_movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t reg; + CHECK_CVT_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg)); + movi(rn(reg), i1); + stxi_i(CVT_OFFSET + 4, _RBP_REGNO, rn(reg)); + jit_unget_reg(reg); + x87_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); +} +#else + +static void +_x87_movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + CHECK_CVT_OFFSET(); + stxi_l(CVT_OFFSET, _RBP_REGNO, r1); + x87_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_x87_movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) +{ + CHECK_CVT_OFFSET(); + x87_stxi_d(CVT_OFFSET, _RBP_REGNO, r1); + ldxi_l(r0, _RBP_REGNO, CVT_OFFSET); +} + +static void +_x87_movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t reg; + CHECK_CVT_OFFSET(); + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + stxi(CVT_OFFSET, _RBP_REGNO, rn(reg)); + jit_unget_reg(reg); + x87_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET); +} +#endif + dopi(lt) dopi(le) diff --git a/deps/lightning/lib/jit_x86.c b/deps/lightning/lib/jit_x86.c index b4094572..dd4fccd8 100644 --- a/deps/lightning/lib/jit_x86.c +++ b/deps/lightning/lib/jit_x86.c @@ -449,7 +449,8 @@ jit_get_cpu(void) : "=a" (eax), "=b" (ebx.cpuid), "=c" (ecx), "=d" (edx) : "a" (7), "c" (0)); #endif - jit_cpu.adx = ebx.bits.adx; + jit_cpu.adx = ebx.bits.adx; + jit_cpu.bmi2 = ebx.bits.bmi2; /* query %eax = 0x80000001 function */ @@ -464,6 +465,7 @@ jit_get_cpu(void) : "0" (0x80000001)); jit_cpu.lahf = !!(ecx.cpuid & 1); jit_cpu.abm = !!(ecx.cpuid & 32); + jit_cpu.fma4 = !!(ecx.cpuid & (1 << 16)); #endif } @@ -1555,6 +1557,27 @@ _emit_code(jit_state_t *_jit) name##r##type(rn(node->u.q.l), rn(node->u.q.h), \ rn(node->v.w), rn(node->w.w)); \ break +#define case_rqr(name, type) \ + case jit_code_##name##r##type: \ + if (jit_x87_reg_p(node->u.w) && \ + jit_x87_reg_p(node->v.q.l) && \ + jit_x87_reg_p(node->v.q.h) && \ + jit_x87_reg_p(node->w.w)) \ + x87_##name##r##type(rn(node->u.w), \ + rn(node->v.q.l), \ + rn(node->v.q.h), \ + rn(node->w.w)); \ + else { \ + assert(jit_sse_reg_p(node->u.w) && \ + jit_sse_reg_p(node->v.q.l) && \ + jit_sse_reg_p(node->v.q.h) && \ + jit_sse_reg_p(node->w.w)); \ + sse_##name##r##type(rn(node->u.w), \ + rn(node->v.q.l), \ + rn(node->v.q.h), \ + rn(node->w.w)); \ + } \ + break; #define case_frr(name, type) \ case jit_code_##name##r##type: \ if (jit_x87_reg_p(node->u.w)) \ @@ -1775,6 +1798,10 @@ _emit_code(jit_state_t *_jit) case_rrw(rsb,); case_rrr(mul,); case_rrw(mul,); + case_rrr(hmul,); + case_rrw(hmul,); + case_rrr(hmul, _u); + case_rrw(hmul, _u); case_rrrr(qmul,); case_rrrw(qmul,); case_rrrr(qmul, _u); @@ -1799,16 +1826,30 @@ _emit_code(jit_state_t *_jit) case_rrw(xor,); case_rrr(lsh,); case_rrw(lsh,); + case_rrrr(qlsh,); + case_rrrw(qlsh,); + case_rrrr(qlsh, _u); + case_rrrw(qlsh, _u); case_rrr(rsh,); case_rrw(rsh,); + case_rrrr(qrsh,); + case_rrrw(qrsh,); case_rrr(rsh, _u); case_rrw(rsh, _u); + case_rrrr(qrsh, _u); + case_rrrw(qrsh, _u); + case_rrr(lrot,); + case_rrw(lrot,); + case_rrr(rrot,); + case_rrw(rrot,); case_rr(neg,); case_rr(com,); case_rr(clo,); case_rr(clz,); case_rr(cto,); case_rr(ctz,); + case_rr(rbit,); + case_rr(popcnt,); case_rrr(lt,); case_rrw(lt,); case_rrr(lt, _u); @@ -1874,6 +1915,18 @@ _emit_code(jit_state_t *_jit) #if __X64 && !__X64_32 case_rr(bswap, _ul); #endif + case jit_code_extr: + extr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_extr_u: + extr_u(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depr: + depr(rn(node->u.w), rn(node->v.w), node->w.q.l, node->w.q.h); + break; + case jit_code_depi: + depi(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; case_rr(ext, _c); case_rr(ext, _uc); case_rr(ext, _s); @@ -1920,6 +1973,18 @@ _emit_code(jit_state_t *_jit) case_rrr(ldx, _l); case_rrw(ldx, _l); #endif + case jit_code_unldr: + unldr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi: + unldi(rn(node->u.w), node->v.w, node->w.w); + break; + case jit_code_unldr_u: + unldr_u(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_u: + unldi_u(rn(node->u.w), node->v.w, node->w.w); + break; case_rr(st, _c); case_wr(st, _c); case_rr(st, _s); @@ -1940,6 +2005,12 @@ _emit_code(jit_state_t *_jit) case_rrr(stx, _l); case_wrr(stx, _l); #endif + case jit_code_unstr: + unstr(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti: + unsti(node->u.w, rn(node->v.w), node->w.w); + break; case_brr(blt,); case_brw(blt,); case_brr(blt, _u); @@ -1992,6 +2063,10 @@ _emit_code(jit_state_t *_jit) case_ff(abs, _f); case_ff(neg, _f); case_ff(sqrt, _f); + case_rqr(fma, _f); + case_rqr(fms, _f); + case_rqr(fnma, _f); + case_rqr(fnms, _f); case_fr(ext, _f); case_fr(ext, _d_f); case_rff(lt, _f); @@ -2047,10 +2122,34 @@ _emit_code(jit_state_t *_jit) case_fw(ld, _f); case_frr(ldx, _f); case_frw(ldx, _f); + case jit_code_unldr_x: + if (jit_x87_reg_p(node->u.w)) + x87_unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + else + sse_unldr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unldi_x: + if (jit_x87_reg_p(node->u.w)) + x87_unldi_x(rn(node->u.w), node->v.w, node->w.w); + else + sse_unldi_x(rn(node->u.w), node->v.w, node->w.w); + break; case_rf(st, _f); case_wf(st, _f); case_rrf(stx, _f); case_wrf(stx, _f); + case jit_code_unstr_x: + if (jit_x87_reg_p(node->v.w)) + x87_unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + else + sse_unstr_x(rn(node->u.w), rn(node->v.w), node->w.w); + break; + case jit_code_unsti_x: + if (jit_x87_reg_p(node->v.w)) + x87_unsti_x(node->u.w, rn(node->v.w), node->w.w); + else + sse_unsti_x(node->u.w, rn(node->v.w), node->w.w); + break; case_bff(lt, _f); case_bfw(lt, _f, 32); case_bff(le, _f); @@ -2091,6 +2190,10 @@ _emit_code(jit_state_t *_jit) case_ff(abs, _d); case_ff(neg, _d); case_ff(sqrt, _d); + case_rqr(fma, _d); + case_rqr(fms, _d); + case_rqr(fnma, _d); + case_rqr(fnms, _d); case_fr(ext, _d); case_fr(ext, _f_d); case_rff(lt, _d); @@ -2295,6 +2398,76 @@ _emit_code(jit_state_t *_jit) epilog(node); _jitc->function = NULL; break; + case jit_code_movr_w_f: + if (jit_sse_reg_p(node->u.w)) + sse_movr_w_f(rn(node->u.w), rn(node->v.w)); + else + x87_movr_w_f(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_f_w: + if (jit_sse_reg_p(node->v.w)) + sse_movr_f_w(rn(node->u.w), rn(node->v.w)); + else + x87_movr_f_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_f_w: + assert(node->flag & jit_flag_data); + movi_f_w(rn(node->u.w), *(jit_float32_t *)node->v.n->u.w); + break; + case jit_code_movi_w_f: + if (jit_sse_reg_p(node->u.w)) + sse_movi_w_f(rn(node->u.w), node->v.w); + else + x87_movi_w_f(rn(node->u.w), node->v.w); + break; +# if __X32 || __X64_32 + case jit_code_movr_ww_d: + if (jit_sse_reg_p(node->u.w)) + sse_movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + else + x87_movr_ww_d(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movr_d_ww: + if (jit_sse_reg_p(node->w.w)) + sse_movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + else + x87_movr_d_ww(rn(node->u.w), rn(node->v.w), rn(node->w.w)); + break; + case jit_code_movi_d_ww: + assert(node->flag & jit_flag_data); + movi_d_ww(rn(node->u.w), rn(node->v.w), + *(jit_float64_t *)node->w.n->u.w); + break; + case jit_code_movi_ww_d: + if (jit_sse_reg_p(node->u.w)) + sse_movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + else + x87_movi_ww_d(rn(node->u.w), node->v.w, node->w.w); + break; +# else + case jit_code_movr_w_d: + if (jit_sse_reg_p(node->u.w)) + sse_movr_w_d(rn(node->u.w), rn(node->v.w)); + else + x87_movr_w_d(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movr_d_w: + if (jit_sse_reg_p(node->v.w)) + sse_movr_d_w(rn(node->u.w), rn(node->v.w)); + else + x87_movr_d_w(rn(node->u.w), rn(node->v.w)); + break; + case jit_code_movi_d_w: + assert(node->flag & jit_flag_data); + movi_d_w(rn(node->u.w), *(jit_float64_t *)node->v.n->u.w); + break; + case jit_code_movi_w_d: + if (jit_sse_reg_p(node->u.w)) + sse_movi_w_d(rn(node->u.w), node->v.w); + else + x87_movi_w_d(rn(node->u.w), node->v.w); + break; +# endif case jit_code_va_start: vastart(rn(node->u.w)); break; @@ -2363,6 +2536,13 @@ _emit_code(jit_state_t *_jit) #endif case jit_code_prepare: case jit_code_finishr: case jit_code_finishi: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: case jit_code_negi_d: + case jit_code_absi_d: case jit_code_sqrti_d: + case jit_code_fmai_f: case jit_code_fmsi_f: + case jit_code_fmai_d: case jit_code_fmsi_d: + case jit_code_fnmai_f: case jit_code_fnmsi_f: + case jit_code_fnmai_d: case jit_code_fnmsi_d: break; case jit_code_retval_f: #if __X32 @@ -2384,6 +2564,74 @@ _emit_code(jit_state_t *_jit) fstpr(rn(node->u.w) + 1); #endif break; + case jit_code_negi: + negi(rn(node->u.w), node->v.w); + break; + case jit_code_comi: + comi(rn(node->u.w), node->v.w); + break; + case jit_code_exti_c: + exti_c(rn(node->u.w), node->v.w); + break; + case jit_code_exti_uc: + exti_uc(rn(node->u.w), node->v.w); + break; + case jit_code_exti_s: + exti_s(rn(node->u.w), node->v.w); + break; + case jit_code_exti_us: + exti_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_us: + bswapi_us(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ui: + bswapi_ui(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_us: + htoni_us(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ui: + htoni_ui(rn(node->u.w), node->v.w); + break; +#if __X64 && !__X64_32 + case jit_code_exti_i: + exti_i(rn(node->u.w), node->v.w); + break; + case jit_code_exti_ui: + exti_ui(rn(node->u.w), node->v.w); + break; + case jit_code_bswapi_ul: + bswapi_ul(rn(node->u.w), node->v.w); + break; + case jit_code_htoni_ul: + htoni_ul(rn(node->u.w), node->v.w); + break; +#endif + case jit_code_cloi: + cloi(rn(node->u.w), node->v.w); + break; + case jit_code_clzi: + clzi(rn(node->u.w), node->v.w); + break; + case jit_code_ctoi: + ctoi(rn(node->u.w), node->v.w); + break; + case jit_code_ctzi: + ctzi(rn(node->u.w), node->v.w); + break; + case jit_code_rbiti: + rbiti(rn(node->u.w), node->v.w); + break; + case jit_code_popcnti: + popcnti(rn(node->u.w), node->v.w); + break; + case jit_code_exti: + exti(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; + case jit_code_exti_u: + exti_u(rn(node->u.w), node->v.w, node->w.q.l, node->w.q.h); + break; default: abort(); } diff --git a/deps/lightning/lib/lightning.c b/deps/lightning/lib/lightning.c index b0b0ef72..25a6078a 100644 --- a/deps/lightning/lib/lightning.c +++ b/deps/lightning/lib/lightning.c @@ -1171,6 +1171,21 @@ _jit_new_node_qww(jit_state_t *_jit, jit_code_t code, return (link_node(node)); } +jit_node_t * +_jit_new_node_wqw(jit_state_t *_jit, jit_code_t code, + jit_word_t u, jit_int32_t l, + jit_int32_t h, jit_word_t w) +{ + jit_node_t *node = new_node(code); + assert(!_jitc->realize); + assert(l != h); + node->u.w = u; + node->v.q.l = l; + node->v.q.h = h; + node->w.w = w; + return (link_node(node)); +} + jit_node_t * _jit_new_node_wwq(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v, @@ -1197,6 +1212,21 @@ _jit_new_node_wwf(jit_state_t *_jit, jit_code_t code, return (link_node(node)); } +jit_node_t * +_jit_new_node_wqf(jit_state_t *_jit, jit_code_t code, + jit_word_t u, jit_int32_t l, + jit_int32_t h, jit_float32_t w) +{ + jit_node_t *node = new_node(code); + assert(!_jitc->realize); + assert(l != h); + node->u.w = u; + node->v.q.l = l; + node->v.q.h = h; + node->w.f = w; + return (link_node(node)); +} + jit_node_t * _jit_new_node_wwd(jit_state_t *_jit, jit_code_t code, jit_word_t u, jit_word_t v, jit_float64_t w) @@ -1209,6 +1239,21 @@ _jit_new_node_wwd(jit_state_t *_jit, jit_code_t code, return (link_node(node)); } +jit_node_t * +_jit_new_node_wqd(jit_state_t *_jit, jit_code_t code, + jit_word_t u, jit_int32_t l, + jit_int32_t h, jit_float64_t w) +{ + jit_node_t *node = new_node(code); + assert(!_jitc->realize); + assert(l != h); + node->u.w = u; + node->v.q.l = l; + node->v.q.h = h; + node->w.d = w; + return (link_node(node)); +} + jit_node_t * _jit_new_node_pww(jit_state_t *_jit, jit_code_t code, jit_pointer_t u, jit_word_t v, jit_word_t w) @@ -1443,12 +1488,34 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) case jit_code_ldi_s: case jit_code_ldi_us: case jit_code_ldi_i: case jit_code_ldi_ui: case jit_code_ldi_l: case jit_code_ldi_f: case jit_code_ldi_d: + case jit_code_negi: case jit_code_comi: + case jit_code_exti_c: case jit_code_exti_uc: + case jit_code_exti_s: case jit_code_exti_us: + case jit_code_exti_i: case jit_code_exti_ui: + case jit_code_bswapi_us:case jit_code_bswapi_ui: + case jit_code_bswapi_ul: + case jit_code_htoni_us: case jit_code_htoni_ui: + case jit_code_htoni_ul: + case jit_code_cloi: case jit_code_clzi: + case jit_code_ctoi: case jit_code_ctzi: + case jit_code_rbiti: case jit_code_popcnti: + case jit_code_movi_w_f: case jit_code_movi_w_d: mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int; break; + case jit_code_unldi: case jit_code_unldi_u: case jit_code_unldi_x: + mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int|jit_cc_a2_int; + break; + case jit_code_movi_ww_d: + mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int|jit_cc_a2_int; + break; case jit_code_movi_f: case jit_code_movi_f_w: + case jit_code_negi_f: case jit_code_absi_f: + case jit_code_sqrti_f: mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_flt; break; case jit_code_movi_d: case jit_code_movi_d_w: + case jit_code_negi_d: case jit_code_absi_d: + case jit_code_sqrti_d: mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_dbl; break; case jit_code_movi_d_ww: @@ -1469,7 +1536,7 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) case jit_code_extr_f: case jit_code_extr_d_f: case jit_code_ldr_f: case jit_code_negr_d: case jit_code_absr_d: case jit_code_sqrtr_d: case jit_code_movr_d: case jit_code_extr_d: case jit_code_extr_f_d: - case jit_code_ldr_d: + case jit_code_ldr_d: case jit_code_rbitr: case jit_code_popcntr: case jit_code_clor: case jit_code_clzr: case jit_code_ctor: case jit_code_ctzr: case jit_code_movr_w_f: case jit_code_movr_f_w: @@ -1484,20 +1551,25 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) case jit_code_addi: case jit_code_addxi: case jit_code_addci: case jit_code_subi: case jit_code_subxi: case jit_code_subci: case jit_code_rsbi: - case jit_code_muli: case jit_code_divi: case jit_code_divi_u: + case jit_code_muli: case jit_code_hmuli: case jit_code_hmuli_u: + case jit_code_divi: case jit_code_divi_u: case jit_code_remi: case jit_code_remi_u: case jit_code_andi: case jit_code_ori: case jit_code_xori: case jit_code_lshi: - case jit_code_rshi: case jit_code_rshi_u: case jit_code_lti: + case jit_code_rshi: case jit_code_rshi_u: case jit_code_lroti: + case jit_code_rroti: case jit_code_lti: case jit_code_lti_u: case jit_code_lei: case jit_code_lei_u: case jit_code_eqi: case jit_code_gei: case jit_code_gei_u: case jit_code_gti: case jit_code_gti_u: case jit_code_nei: case jit_code_ldxi_c: case jit_code_ldxi_uc: case jit_code_ldxi_s: case jit_code_ldxi_us: case jit_code_ldxi_i: case jit_code_ldxi_ui: case jit_code_ldxi_l: case jit_code_ldxi_f: case jit_code_ldxi_d: + case jit_code_unldr: case jit_code_unldr_u: case jit_code_unldr_x: mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg|jit_cc_a2_int; break; case jit_code_qmuli: case jit_code_qmuli_u: case jit_code_qdivi: case jit_code_qdivi_u: + case jit_code_qlshi: case jit_code_qlshi_u: + case jit_code_qrshi: case jit_code_qrshi_u: mask = jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_chg| jit_cc_a1_reg|jit_cc_a2_int; break; @@ -1521,10 +1593,12 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) break; case jit_code_addr: case jit_code_addxr: case jit_code_addcr: case jit_code_subr: case jit_code_subxr: case jit_code_subcr: - case jit_code_mulr: case jit_code_divr: case jit_code_divr_u: + case jit_code_mulr: case jit_code_hmulr: case jit_code_hmulr_u: + case jit_code_divr: case jit_code_divr_u: case jit_code_remr: case jit_code_remr_u: case jit_code_andr: case jit_code_orr: case jit_code_xorr: case jit_code_lshr: - case jit_code_rshr: case jit_code_rshr_u: case jit_code_ltr: + case jit_code_rshr: case jit_code_rshr_u: case jit_code_lrotr: + case jit_code_rrotr: case jit_code_ltr: case jit_code_ltr_u: case jit_code_ler: case jit_code_ler_u: case jit_code_eqr: case jit_code_ger: case jit_code_ger_u: case jit_code_gtr: case jit_code_gtr_u: case jit_code_ner: @@ -1548,6 +1622,8 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) break; case jit_code_qmulr: case jit_code_qmulr_u: case jit_code_qdivr: case jit_code_qdivr_u: + case jit_code_qlshr: case jit_code_qlshr_u: + case jit_code_qrshr: case jit_code_qrshr_u: mask = jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_chg| jit_cc_a1_reg|jit_cc_a2_reg; break; @@ -1555,6 +1631,9 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) case jit_code_sti_l: case jit_code_sti_f: case jit_code_sti_d: mask = jit_cc_a0_int|jit_cc_a1_reg; break; + case jit_code_unsti: case jit_code_unsti_x: + mask = jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_int; + break; case jit_code_blti: case jit_code_blti_u: case jit_code_blei: case jit_code_blei_u: case jit_code_beqi: case jit_code_bgei: case jit_code_bgei_u: case jit_code_bgti: case jit_code_bgti_u: @@ -1581,6 +1660,9 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) case jit_code_str_l: case jit_code_str_f: case jit_code_str_d: mask = jit_cc_a0_reg|jit_cc_a1_reg; break; + case jit_code_unstr: case jit_code_unstr_x: + mask = jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int; + break; case jit_code_stxi_c: case jit_code_stxi_s: case jit_code_stxi_i: case jit_code_stxi_l: case jit_code_stxi_f: case jit_code_stxi_d: mask = jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_reg; @@ -1626,6 +1708,29 @@ _jit_classify(jit_state_t *_jit, jit_code_t code) mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int| jit_cc_a2_reg|jit_cc_a2_rlh; break; + case jit_code_extr: case jit_code_extr_u: case jit_code_depr: + mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_reg|jit_cc_a2_rlh; + break; + case jit_code_exti: case jit_code_exti_u: case jit_code_depi: + mask = jit_cc_a0_reg|jit_cc_a0_chg|jit_cc_a1_int|jit_cc_a2_rlh; + break; + case jit_code_fmar_f: case jit_code_fmar_d: + case jit_code_fmsr_f: case jit_code_fmsr_d: + case jit_code_fnmar_f: case jit_code_fnmar_d: + case jit_code_fnmsr_f: case jit_code_fnmsr_d: + mask = jit_cc_a0_reg|jit_cc_a0_chg| + jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_reg; + break; + case jit_code_fmai_f: case jit_code_fmsi_f: + case jit_code_fnmai_f: case jit_code_fnmsi_f: + mask = jit_cc_a0_reg|jit_cc_a0_chg| + jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_flt; + break; + case jit_code_fmai_d: case jit_code_fmsi_d: + case jit_code_fnmai_d: case jit_code_fnmsi_d: + mask = jit_cc_a0_reg|jit_cc_a0_chg| + jit_cc_a1_reg|jit_cc_a1_rlh|jit_cc_a2_dbl; + break; default: abort(); } @@ -1848,10 +1953,6 @@ _jit_optimize(jit_state_t *_jit) do_setup(); do_follow(1); - patch_registers(); - if (simplify()) - todo = 1; - jit_regset_set_ui(®mask, 0); for (offset = 0; offset < _jitc->reglen; offset++) { if ((jit_class(_rvs[offset].spec) & (jit_class_gpr|jit_class_fpr)) && @@ -1890,6 +1991,10 @@ _jit_optimize(jit_state_t *_jit) } } + patch_registers(); + if (simplify()) + todo = 1; + for (node = _jitc->head; node; node = node->next) { mask = jit_classify(node->code); if (mask & jit_cc_a0_reg) @@ -2056,13 +2161,22 @@ _jit_reglive(jit_state_t *_jit, jit_node_t *node) } } } - if ((value & jit_cc_a1_reg) && !(node->v.w & jit_regno_patch)) { - if (value & jit_cc_a1_chg) { - jit_regset_clrbit(&_jitc->reglive, node->v.w); - jit_regset_setbit(&_jitc->regmask, node->v.w); + if (value & jit_cc_a1_reg) { + if (value & jit_cc_a1_rlh) { + /* Assume registers are not changed */ + if (!(node->v.q.l & jit_regno_patch)) + jit_regset_setbit(&_jitc->reglive, node->v.q.l); + if (!(node->v.q.h & jit_regno_patch)) + jit_regset_setbit(&_jitc->reglive, node->v.q.h); + } + else if (!(node->v.w & jit_regno_patch)) { + if (value & jit_cc_a1_chg) { + jit_regset_clrbit(&_jitc->reglive, node->v.w); + jit_regset_setbit(&_jitc->regmask, node->v.w); + } + else + jit_regset_setbit(&_jitc->reglive, node->v.w); } - else - jit_regset_setbit(&_jitc->reglive, node->v.w); } if (value & jit_cc_a2_reg) { if (value & jit_cc_a2_rlh) { @@ -2110,8 +2224,14 @@ _jit_regarg_set(jit_state_t *_jit, jit_node_t *node, jit_int32_t value) else jit_regset_setbit(&_jitc->regarg, jit_regno(node->u.w)); } - if (value & jit_cc_a1_reg) - jit_regset_setbit(&_jitc->regarg, jit_regno(node->v.w)); + if (value & jit_cc_a1_reg) { + if (value & jit_cc_a1_rlh) { + jit_regset_setbit(&_jitc->regarg, jit_regno(node->v.q.l)); + jit_regset_setbit(&_jitc->regarg, jit_regno(node->v.q.h)); + } + else + jit_regset_setbit(&_jitc->regarg, jit_regno(node->v.w)); + } if (value & jit_cc_a2_reg) { if (value & jit_cc_a2_rlh) { jit_regset_setbit(&_jitc->regarg, jit_regno(node->w.q.l)); @@ -2149,8 +2269,14 @@ _jit_regarg_clr(jit_state_t *_jit, jit_node_t *node, jit_int32_t value) else jit_regset_clrbit(&_jitc->regarg, jit_regno(node->u.w)); } - if (value & jit_cc_a1_reg) - jit_regset_clrbit(&_jitc->regarg, jit_regno(node->v.w)); + if (value & jit_cc_a1_reg) { + if (value & jit_cc_a1_rlh) { + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->v.q.l)); + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->v.q.h)); + } + else + jit_regset_clrbit(&_jitc->regarg, jit_regno(node->v.w)); + } if (value & jit_cc_a2_reg) { if (value & jit_cc_a2_rlh) { jit_regset_clrbit(&_jitc->regarg, jit_regno(node->w.q.l)); @@ -2429,12 +2555,12 @@ _jit_emit(jit_state_t *_jit) assert(result == 0); } if (!_jit->user_code) { - _jit->code.protected = _jit->pc.uc - _jit->code.ptr; + _jit->code.protect = _jit->pc.uc - _jit->code.ptr; # if __riscv && __WORDSIZE == 64 /* FIXME should start adding consts at a page boundary */ - _jit->code.protected -= _jitc->consts.hash.count * sizeof(jit_word_t); + _jit->code.protect -= _jitc->consts.hash.count * sizeof(jit_word_t); # endif - result = mprotect(_jit->code.ptr, _jit->code.protected, PROT_READ | PROT_EXEC); + result = mprotect(_jit->code.ptr, _jit->code.protect, PROT_READ | PROT_EXEC); assert(result == 0); } #endif /* HAVE_MMAP */ @@ -2452,7 +2578,7 @@ _jit_protect(jit_state_t *_jit) #else int result; if (_jit->user_code) return; - result = mprotect (_jit->code.ptr, _jit->code.protected, PROT_READ | PROT_EXEC); + result = mprotect (_jit->code.ptr, _jit->code.protect, PROT_READ | PROT_EXEC); assert (result == 0); #endif } @@ -2465,7 +2591,7 @@ _jit_unprotect(jit_state_t *_jit) #else int result; if (_jit->user_code) return; - result = mprotect (_jit->code.ptr, _jit->code.protected, PROT_READ | PROT_WRITE); + result = mprotect (_jit->code.ptr, _jit->code.protect, PROT_READ | PROT_WRITE); assert (result == 0); #endif } @@ -2535,21 +2661,51 @@ _jit_setup(jit_state_t *_jit, jit_block_t *block) /* Check argument registers in reverse order to properly * handle registers that are both, argument and result */ value = jit_classify(node->code); - if ((value & jit_cc_a2_reg) && - !(node->w.w & jit_regno_patch) && - jit_regset_tstbit(&block->regmask, node->w.w)) { + if (value & jit_cc_a2_reg) { live = !(value & jit_cc_a2_chg); - jit_regset_clrbit(&block->regmask, node->w.w); - if (live) - jit_regset_setbit(&block->reglive, node->w.w); + if (value & jit_cc_a2_rlh) { + /* Assume will not modify a pair in second argument */ + assert(live); + if (!(node->w.q.l & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->w.q.l)) { + jit_regset_clrbit(&block->regmask, node->w.q.l); + } + if (!(node->w.q.h & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->w.q.h)) { + jit_regset_clrbit(&block->regmask, node->w.q.h); + } + } + else { + if (!(node->w.w & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->w.w)) { + jit_regset_clrbit(&block->regmask, node->w.w); + if (live) + jit_regset_setbit(&block->reglive, node->w.w); + } + } } - if ((value & jit_cc_a1_reg) && - !(node->v.w & jit_regno_patch) && - jit_regset_tstbit(&block->regmask, node->v.w)) { + if (value & jit_cc_a1_reg) { live = !(value & jit_cc_a1_chg); - jit_regset_clrbit(&block->regmask, node->v.w); - if (live) - jit_regset_setbit(&block->reglive, node->v.w); + if (value & jit_cc_a1_rlh) { + /* Assume will not modify a pair in second argument */ + assert(live); + if (!(node->v.q.l & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->v.q.l)) { + jit_regset_clrbit(&block->regmask, node->v.q.l); + } + if (!(node->v.q.h & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->v.q.h)) { + jit_regset_clrbit(&block->regmask, node->v.q.h); + } + } + else { + if (!(node->v.w & jit_regno_patch) && + jit_regset_tstbit(&block->regmask, node->v.w)) { + jit_regset_clrbit(&block->regmask, node->v.w); + if (live) + jit_regset_setbit(&block->reglive, node->v.w); + } + } } if (value & jit_cc_a0_reg) { live = !(value & jit_cc_a0_chg); @@ -2654,23 +2810,34 @@ _jit_follow(jit_state_t *_jit, jit_block_t *block) } } else { - if (value & jit_cc_a2_reg) { - if (!(node->w.w & jit_regno_patch)) { - if (jit_regset_tstbit(®mask, node->w.w)) { - jit_regset_clrbit(®mask, node->w.w); - if (!(value & jit_cc_a2_chg)) - jit_regset_setbit(®live, node->w.w); - } + if (!(node->w.w & jit_regno_patch)) { + if (jit_regset_tstbit(®mask, node->w.w)) { + jit_regset_clrbit(®mask, node->w.w); + if (!(value & jit_cc_a2_chg)) + jit_regset_setbit(®live, node->w.w); } } } } if (value & jit_cc_a1_reg) { - if (!(node->v.w & jit_regno_patch)) { - if (jit_regset_tstbit(®mask, node->v.w)) { - jit_regset_clrbit(®mask, node->v.w); - if (!(value & jit_cc_a1_chg)) - jit_regset_setbit(®live, node->v.w); + if (value & jit_cc_a1_rlh) { + if (!(node->v.q.l & jit_regno_patch)) { + /* Assume register is not changed */ + if (jit_regset_tstbit(®mask, node->v.q.l)) + jit_regset_clrbit(®mask, node->v.q.l); + } + if (!(node->v.q.h & jit_regno_patch)) { + if (jit_regset_tstbit(®mask, node->v.q.h)) + jit_regset_clrbit(®mask, node->v.q.h); + } + } + else { + if (!(node->v.w & jit_regno_patch)) { + if (jit_regset_tstbit(®mask, node->v.w)) { + jit_regset_clrbit(®mask, node->v.w); + if (!(value & jit_cc_a1_chg)) + jit_regset_setbit(®live, node->v.w); + } } } } @@ -2830,11 +2997,24 @@ _jit_update(jit_state_t *_jit, jit_node_t *node, } } if (value & jit_cc_a1_reg) { - if (!(node->v.w & jit_regno_patch)) { - if (jit_regset_tstbit(mask, node->v.w)) { - jit_regset_clrbit(mask, node->v.w); - if (!(value & jit_cc_a1_chg)) - jit_regset_setbit(live, node->v.w); + if (value & jit_cc_a1_rlh) { + if (!(node->v.q.l & jit_regno_patch)) { + /* Assume register is not changed */ + if (jit_regset_tstbit(mask, node->v.q.l)) + jit_regset_clrbit(mask, node->v.q.l); + } + if (!(node->v.q.h & jit_regno_patch)) { + if (jit_regset_tstbit(mask, node->v.q.h)) + jit_regset_clrbit(mask, node->v.q.h); + } + } + else { + if (!(node->v.w & jit_regno_patch)) { + if (jit_regset_tstbit(mask, node->v.w)) { + jit_regset_clrbit(mask, node->v.w); + if (!(value & jit_cc_a1_chg)) + jit_regset_setbit(live, node->v.w); + } } } } @@ -3407,11 +3587,21 @@ _simplify_movr(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, { jit_int32_t regno; jit_int32_t right; + jit_int32_t spec; jit_value_t *value; regno = jit_regno(node->u.w); right = jit_regno(node->v.w); value = _jitc->values + regno; + + spec = jit_class(_rvs[regno].spec); + if (!(spec & (jit_class_gpr | jit_class_fpr))) { + /* reserved register */ + value->kind = 0; + ++_jitc->gen[regno]; + return (0); + } + if ((value->kind == jit_kind_register && jit_regno(value->base.q.l) == right && value->base.q.h == _jitc->gen[right]) || @@ -3449,12 +3639,18 @@ _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node, ++_jitc->gen[regno]; return (0); } + spec = jit_class(_rvs[regno].spec); + if (!(spec & (jit_class_gpr | jit_class_fpr))) { + /* reserved register */ + value->kind = 0; + ++_jitc->gen[regno]; + return (0); + } if (value->kind == kind) { if (memcmp(&node->v.w, &value->base.w, size) == 0) { del_node(prev, node); return (1); } - spec = jit_class(_rvs[regno].spec); if (kind == jit_kind_word) spec &= jit_class_gpr; else @@ -3715,9 +3911,24 @@ _simplify(jit_state_t *_jit) } } if (info & jit_cc_a1_chg) { - regno = jit_regno(node->v.w); - _jitc->values[regno].kind = 0; - ++_jitc->gen[regno]; +#if 0 + /* Assume registers are not changed */ + if (info & jit_cc_a1_rlh) { + regno = jit_regno(node->v.q.l); + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; + regno = jit_regno(node->v.q.h); + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; + } + else { +#endif + regno = jit_regno(node->v.w); + _jitc->values[regno].kind = 0; + ++_jitc->gen[regno]; +#if 0 + } +#endif } if (info & jit_cc_a2_chg) { #if 0 @@ -3750,33 +3961,51 @@ _register_change_p(jit_state_t *_jit, jit_node_t *node, jit_node_t *link, jit_int32_t regno) { jit_int32_t value; + jit_bool_t use, change; for (; node != link; node = node->next) { switch (node->code) { case jit_code_label: case jit_code_prolog: - /* lack of extra information so cannot say it is undefined */ - return (jit_reg_change); + /* lack of extra information so assume it is live */ + return (jit_reg_static); case jit_code_callr: case jit_code_calli: if (!(jit_class(_rvs[regno].spec) & jit_class_sav)) return (jit_reg_undef); break; default: value = jit_classify(node->code); + use = change = 0; + if (value & jit_cc_a0_rlh) { + if (node->u.q.l == regno || node->u.q.h == regno) { + if (value & jit_cc_a0_chg) + change = 1; + use = !change; + } + } + else if ((value & jit_cc_a0_reg) && node->u.w == regno) { + if (value & jit_cc_a0_chg) + change = 1; + use = !change; + } + if (!use && + (value & jit_cc_a1_reg) && node->v.w == regno) { + if (value & jit_cc_a1_chg) + change = 1; + use = !change; + } + if (!use && + (value & jit_cc_a2_reg) && node->w.w == regno) { + if (value & jit_cc_a2_chg) + change = 1; + use = !change; + } /* lack of extra information */ - if (value & (jit_cc_a0_jmp|jit_cc_a0_cnd)) - return (jit_reg_change); - else if ((value & (jit_cc_a0_reg|jit_cc_a0_chg)) == - (jit_cc_a0_reg|jit_cc_a0_chg) && - (((value & jit_cc_a0_rlh) && - (node->u.q.l == regno || node->u.q.h == regno)) || - (!(value & jit_cc_a0_rlh) && - node->u.w == regno))) - return (jit_reg_change); - else if ((value & jit_cc_a1_reg) && node->v.w == regno && - (value & jit_cc_a1_chg)) - return (jit_reg_change); - else if ((value & jit_cc_a2_reg) && node->w.w == regno && - (value & jit_cc_a2_chg)) + if (!use && (value & (jit_cc_a0_jmp|jit_cc_a0_cnd)) && + /* In case of indirect branches, always consider + * callee save registers as live. */ + !(jit_class(_rvs[regno].spec) & jit_class_sav)) + change = 1; + if (!use && change) return (jit_reg_change); } } @@ -3941,8 +4170,18 @@ _patch_register(jit_state_t *_jit, jit_node_t *node, jit_node_t *link, node->u.w = patch; } } - if ((value & jit_cc_a1_reg) && node->v.w == regno) - node->v.w = patch; + if (value & jit_cc_a1_reg) { + if (value & jit_cc_a1_rlh) { + if (node->v.q.l == regno) + node->v.q.l = patch; + if (node->v.q.h == regno) + node->v.q.h = patch; + } + else { + if (node->v.w == regno) + node->v.w = patch; + } + } if (value & jit_cc_a2_reg) { if (value & jit_cc_a2_rlh) { if (node->w.q.l == regno) @@ -3983,6 +4222,93 @@ static maybe_unused void generic_bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1); #endif +#define depi(r0, i0, i1, i2) _depi(_jit, r0, i0, i1, i2) +static void _depi(jit_state_t*,jit_int32_t, jit_word_t, jit_word_t, jit_word_t); +#define negi(r0, i0) _negi(_jit, r0, i0) +static void _negi(jit_state_t*, jit_int32_t, jit_word_t); +#define comi(r0, i0) _comi(_jit, r0, i0) +static void _comi(jit_state_t*, jit_int32_t, jit_word_t); +#define exti_c(r0, i0) _exti_c(_jit, r0, i0) +static void _exti_c(jit_state_t*, jit_int32_t, jit_word_t); +#define exti_uc(r0, i0) _exti_uc(_jit, r0, i0) +static void _exti_uc(jit_state_t*, jit_int32_t, jit_word_t); +#define exti_s(r0, i0) _exti_s(_jit, r0, i0) +static void _exti_s(jit_state_t*, jit_int32_t, jit_word_t); +#define exti_us(r0, i0) _exti_us(_jit, r0, i0) +static void _exti_us(jit_state_t*, jit_int32_t, jit_word_t); +#if __WORDSIZE == 64 +#define exti_i(r0, i0) _exti_i(_jit, r0, i0) +static void _exti_i(jit_state_t*, jit_int32_t, jit_word_t); +#define exti_ui(r0, i0) _exti_ui(_jit, r0, i0) +static void _exti_ui(jit_state_t*, jit_int32_t, jit_word_t); +#endif +#define bswapi_us(r0, i0) _bswapi_us(_jit, r0, i0) +static void _bswapi_us(jit_state_t*, jit_int32_t, jit_word_t); +#define bswapi_ui(r0, i0) _bswapi_ui(_jit, r0, i0) +static void _bswapi_ui(jit_state_t*, jit_int32_t, jit_word_t); +#if __WORDSIZE == 64 +# define bswapi_ul(r0, i0) _bswapi_ul(_jit, r0, i0) +static void _bswapi_ul(jit_state_t*, jit_int32_t, jit_word_t); +#endif +#define htoni_us(r0, i0) _htoni_us(_jit, r0, i0) +static void _htoni_us(jit_state_t*, jit_int32_t, jit_word_t); +#define htoni_ui(r0, i0) _htoni_ui(_jit, r0, i0) +static void _htoni_ui(jit_state_t*, jit_int32_t, jit_word_t); +#if __WORDSIZE == 64 +# define htoni_ul(r0, i0) _htoni_ul(_jit, r0, i0) +static void _htoni_ul(jit_state_t*, jit_int32_t, jit_word_t); +#endif +# define movi_f_w(r0, i0) _movi_f_w(_jit, r0, i0) +static void _movi_f_w(jit_state_t*, jit_int32_t, jit_float32_t); +#if __WORDSIZE == 32 +# define movi_d_ww(r0, r1, i0) _movi_d_ww(_jit, r0, r1, i0) +static void _movi_d_ww(jit_state_t*, jit_int32_t, jit_int32_t, jit_float64_t); +#else +# define movi_d_w(r0, i0) _movi_d_w(_jit, r0, i0) +static void _movi_d_w(jit_state_t*, jit_int32_t, jit_float64_t); +#endif +#define cloi(r0, i0) _cloi(_jit, r0, i0) +static void _cloi(jit_state_t*, jit_int32_t, jit_word_t); +#define clzi(r0, i0) _clzi(_jit, r0, i0) +static void _clzi(jit_state_t*, jit_int32_t, jit_word_t); +#define ctoi(r0, i0) _ctoi(_jit, r0, i0) +static void _ctoi(jit_state_t*, jit_int32_t, jit_word_t); +#define ctzi(r0, i0) _ctzi(_jit, r0, i0) +static void _ctzi(jit_state_t*, jit_int32_t, jit_word_t); +#define rbiti(r0, i0) _rbiti(_jit, r0, i0) +static void _rbiti(jit_state_t*, jit_int32_t, jit_word_t); +#define popcnti(r0, i0) _popcnti(_jit, r0, i0) +static void _popcnti(jit_state_t*, jit_int32_t, jit_word_t); +#define exti(r0, i0, i1, i2) _exti(_jit, r0, i0, i1, i2) +static void _exti(jit_state_t*,jit_int32_t, jit_word_t, jit_word_t, jit_word_t); +#define exti_u(r0, i0, i1, i2) _exti_u(_jit, r0, i0, i1, i2) +static void _exti_u(jit_state_t*, + jit_int32_t, jit_word_t, jit_word_t, jit_word_t); +#define generic_unldr(r0, r1, i0) _generic_unldr(_jit, r0, r1, i0) +static void _generic_unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define generic_unldi(r0, i0, i1) _generic_unldi(_jit, r0, i0, i1) +static void _generic_unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +#define generic_unldr_u(r0, r1, i0) _generic_unldr_u(_jit, r0, r1, i0) +static void _generic_unldr_u(jit_state_t*, + jit_int32_t, jit_int32_t, jit_word_t); +#define generic_unldi_u(r0, i0, i1) _generic_unldi_u(_jit, r0, i0, i1) +static void _generic_unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +#define generic_unstr(r0, r1, i0) _generic_unstr(_jit, r0, r1, i0) +static void _generic_unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t); +#define generic_unsti(i0, r0, i1) _generic_unsti(_jit, i0, r0, i1) +static void _generic_unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); +#if !defined(__i386__) && !defined(__x86_64__) +# define generic_unldr_x(r0, r1, i0) _generic_unldr_x(_jit, r0, r1, i0) +static void _generic_unldr_x(jit_state_t*, + jit_int32_t, jit_int32_t, jit_word_t); +# define generic_unldi_x(r0, i0, i1) _generic_unldi_x(_jit, r0, i0, i1) +static void _generic_unldi_x(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t); +# define generic_unstr_x(r0, r1, i0) _generic_unstr_x(_jit, r0, r1, i0) +static void _generic_unstr_x(jit_state_t*, + jit_int32_t, jit_int32_t, jit_word_t); +# define generic_unsti_x(i0, r0, i1) _generic_unsti_x(_jit, i0, r0, i1) +static void _generic_unsti_x(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t); +#endif #define patch_alist(revert) _patch_alist(_jit, revert) static maybe_unused void _patch_alist(jit_state_t *_jit, jit_bool_t revert); @@ -4056,6 +4382,1067 @@ generic_bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1) } #endif +static void +_depi(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1, jit_word_t i2) +{ + jit_int32_t reg; + reg = jit_get_reg(jit_class_gpr); + movi(rn(reg), i0); + depr(r0, rn(reg), i1, i2); + jit_unget_reg(reg); +} + +static void +_negi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, -i0); +} + +static void +_comi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, ~i0); +} + +static void +_exti_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_int8_t)i0); +} + +static void +_exti_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_uint8_t)i0); +} + +static void +_exti_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_int16_t)i0); +} + +static void +_exti_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_uint16_t)i0); +} + +#if __WORDSIZE == 64 +static void +_exti_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_int32_t)i0); +} + +static void +_exti_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + movi(r0, (jit_uint32_t)i0); +} +#endif + +static void +_bswapi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + union { + jit_uint16_t us; + jit_uint8_t v[2]; + } l, h; + l.us = i0; + h.v[0] = l.v[1]; + h.v[1] = l.v[0]; + movi(r0, h.us); +} + +static void +_bswapi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + union { + jit_uint32_t ui; + jit_uint8_t v[4]; + } l, h; + l.ui = i0; + h.v[0] = l.v[3]; + h.v[1] = l.v[2]; + h.v[2] = l.v[1]; + h.v[3] = l.v[0]; + movi(r0, h.ui); +} + +#if __WORDSIZE == 64 +static void +_bswapi_ul(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + union { + jit_uint64_t ul; + jit_uint8_t v[8]; + } l, h; + l.ul = i0; + h.v[0] = l.v[7]; + h.v[1] = l.v[6]; + h.v[2] = l.v[5]; + h.v[3] = l.v[4]; + h.v[4] = l.v[3]; + h.v[5] = l.v[2]; + h.v[6] = l.v[1]; + h.v[7] = l.v[0]; + movi(r0, h.ul); +} +#endif + +static void +_htoni_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +#if __BYTE_ORDER == __LITTLE_ENDIAN + bswapi_us(r0, i0); +#else + exti_us(r0, i0); +#endif +} + +static void +_htoni_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +#if __BYTE_ORDER == __LITTLE_ENDIAN + bswapi_ui(r0, i0); +#else +# if __WORDSIZE == 32 + movi(r0, i0); +# else + exti_ui(r0, i0); +# endif +#endif +} + +#if __WORDSIZE == 64 +static void +_htoni_ul(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +# if __BYTE_ORDER == __LITTLE_ENDIAN + bswapi_ul(r0, i0); +# else + movi(r0, i0); +# endif +} +#endif + +static void +_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0) +{ + union { + jit_int32_t i; + jit_float32_t f; + } data; + data.f = i0; +#if defined(__ia64__) + /* Should be used only in this case (with out0 == 120) */ + if (r0 >= 120) + r0 = _jitc->rout + (r0 - 120); +#endif + movi(r0, data.i); +} + +#if __WORDSIZE == 32 +static void +_movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0) +{ + union { + jit_int32_t i[2]; + jit_float64_t d; + } data; + data.d = i0; + /* Mips does not change byte order of double values */ +# if __BYTE_ORDER == __LITTLE_ENDIAN || defined(__mips__) + movi(r0, data.i[0]); + movi(r1, data.i[1]); +# else + movi(r1, data.i[0]); + movi(r0, data.i[1]); +# endif +} + +#else +static void +_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0) +{ + union { + jit_int64_t l; + jit_float64_t d; + } data; + data.d = i0; +# if defined(__ia64__) + /* Should be used only in this case (with out0 == 120) */ + if (r0 >= 120) + r0 = _jitc->rout + (r0 - 120); +# endif + movi(r0, data.l); +} +#endif + + void +_jit_negi_f(jit_state_t *_jit, jit_fpr_t u, jit_float32_t v) +{ + jit_inc_synth_wf(negi_f, u, v); + jit_movi_f(u, v); + jit_negr_f(u, u); + jit_dec_synth(); +} + +void +_jit_absi_f(jit_state_t *_jit, jit_fpr_t u, jit_float32_t v) +{ + jit_inc_synth_wf(absi_f, u, v); + jit_movi_f(u, v); + jit_absr_f(u, u); + jit_dec_synth(); +} + +void +_jit_sqrti_f(jit_state_t *_jit, jit_fpr_t u, jit_float32_t v) +{ + jit_inc_synth_wf(sqrti_f, u, v); + jit_movi_f(u, v); + jit_sqrtr_f(u, u); + jit_dec_synth(); +} + +void +_jit_fmai_f(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float32_t x) +{ + jit_int32_t y; + jit_inc_synth_wqf(fmai_f, u, v, w, x); + if (u != v && u != w) { + jit_movi_f(u, x); + jit_fmar_f(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_f(y, x); + jit_fmar_f(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fmsi_f(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float32_t x) +{ + jit_int32_t y; + jit_inc_synth_wqf(fmai_f, u, v, w, x); + if (u != v && u != w) { + jit_movi_f(u, x); + jit_fmsr_f(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_f(y, x); + jit_fmsr_f(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fnmai_f(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float32_t x) +{ + jit_int32_t y; + jit_inc_synth_wqf(fmai_f, u, v, w, x); + if (u != v && u != w) { + jit_movi_f(u, x); + jit_fnmar_f(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_f(y, x); + jit_fnmar_f(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fnmsi_f(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float32_t x) +{ + jit_int32_t y; + jit_inc_synth_wqf(fmai_f, u, v, w, x); + if (u != v && u != w) { + jit_movi_f(u, x); + jit_fnmsr_f(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_f(y, x); + jit_fnmsr_f(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_negi_d(jit_state_t *_jit, jit_fpr_t u, jit_float64_t v) +{ + jit_inc_synth_wd(negi_d, u, v); + jit_movi_d(u, v); + jit_negr_d(u, u); + jit_dec_synth(); +} + +void +_jit_absi_d(jit_state_t *_jit, jit_fpr_t u, jit_float64_t v) +{ + jit_inc_synth_wd(absi_d, u, v); + jit_movi_d(u, v); + jit_absr_d(u, u); + jit_dec_synth(); +} + +void +_jit_sqrti_d(jit_state_t *_jit, jit_fpr_t u, jit_float64_t v) +{ + jit_inc_synth_wd(sqrti_d, u, v); + jit_movi_d(u, v); + jit_sqrtr_d(u, u); + jit_dec_synth(); +} + +void +_jit_fmai_d(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float64_t x) +{ + jit_int32_t y; + jit_inc_synth_wqd(fmai_d, u, v, w, x); + if (u != v && u != w) { + jit_movi_d(u, x); + jit_fmar_d(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_d(y, x); + jit_fmar_d(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fmsi_d(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float64_t x) +{ + jit_int32_t y; + jit_inc_synth_wqd(fmai_d, u, v, w, x); + if (u != v && u != w) { + jit_movi_d(u, x); + jit_fmsr_d(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_d(y, x); + jit_fmsr_d(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fnmai_d(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float64_t x) +{ + jit_int32_t y; + jit_inc_synth_wqd(fmai_d, u, v, w, x); + if (u != v && u != w) { + jit_movi_d(u, x); + jit_fnmar_d(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_d(y, x); + jit_fnmar_d(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +void +_jit_fnmsi_d(jit_state_t *_jit, + jit_fpr_t u, jit_fpr_t v, jit_fpr_t w, jit_float64_t x) +{ + jit_int32_t y; + jit_inc_synth_wqd(fmai_d, u, v, w, x); + if (u != v && u != w) { + jit_movi_d(u, x); + jit_fnmsr_d(u, v, w, u); + } + else { + y = jit_get_reg(jit_class_fpr); + jit_movi_d(y, x); + jit_fnmsr_d(u, v, w, y); + jit_unget_reg(y); + } + jit_dec_synth(); +} + +static void +_cloi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + clzi(r0, ~i0); +} + +static void +_clzi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +#if __WORDSIZE == 64 && _WIN32 + movi(r0, (i0) ? __builtin_clzll(i0) : __WORDSIZE); +#else + movi(r0, (i0) ? __builtin_clzl(i0) : __WORDSIZE); +#endif +} + +static void +_ctoi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + ctzi(r0, ~i0); +} + +static void +_ctzi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +#if __WORDSIZE == 64 && _WIN32 + movi(r0, (i0) ? __builtin_ctzll(i0) : __WORDSIZE); +#else + movi(r0, (i0) ? __builtin_ctzl(i0) : __WORDSIZE); +#endif +} + +static void +_rbiti(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ + jit_int32_t i; + union { + jit_uword_t w; + jit_uint8_t v[__WORDSIZE >> 3]; + } u, v; + static const unsigned char swap_tab[256] = { + 0, 128, 64, 192, 32, 160, 96, 224, + 16, 144, 80, 208, 48, 176, 112, 240, + 8, 136, 72, 200, 40, 168, 104, 232, + 24, 152, 88, 216 ,56, 184, 120, 248, + 4, 132, 68, 196, 36, 164, 100, 228, + 20, 148, 84, 212, 52, 180, 116, 244, + 12, 140, 76, 204, 44, 172, 108, 236, + 28, 156, 92, 220, 60, 188, 124, 252, + 2, 130, 66, 194, 34, 162, 98, 226, + 18, 146, 82, 210, 50, 178, 114, 242, + 10, 138, 74, 202, 42, 170, 106, 234, + 26, 154, 90, 218, 58, 186, 122, 250, + 6, 134, 70, 198, 38, 166, 102, 230, + 22, 150, 86, 214, 54, 182, 118, 246, + 14, 142, 78, 206, 46, 174, 110, 238, + 30, 158, 94, 222, 62, 190, 126, 254, + 1, 129, 65, 193, 33, 161, 97, 225, + 17, 145, 81, 209, 49, 177, 113, 241, + 9, 137, 73, 201, 41, 169, 105, 233, + 25, 153, 89, 217, 57, 185, 121, 249, + 5, 133, 69, 197, 37, 165, 101, 229, + 21, 149, 85, 213, 53, 181, 117, 245, + 13, 141, 77, 205, 45, 173, 109, 237, + 29, 157, 93, 221, 61, 189, 125, 253, + 3, 131, 67, 195, 35, 163, 99, 227, + 19, 147, 83, 211, 51, 179, 115, 243, + 11, 139, 75, 203, 43, 171, 107, 235, + 27, 155, 91, 219, 59, 187, 123, 251, + 7, 135, 71, 199, 39, 167, 103, 231, + 23, 151, 87, 215, 55, 183, 119, 247, + 15, 143, 79, 207, 47, 175, 111, 239, + 31, 159, 95, 223, 63, 191, 127, 255 + }; + u.w = i0; + for (i = 0; i < sizeof(jit_word_t); ++i) + v.v[i] = swap_tab[u.v[sizeof(jit_word_t) - i - 1]]; + movi(r0, v.w); +} + +static void +_popcnti(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) +{ +#if __WORDSIZE == 64 && _WIN32 + movi(r0, (i0) ? __builtin_popcountll(i0) : __WORDSIZE); +#else + movi(r0, (i0) ? __builtin_popcountl(i0) : __WORDSIZE); +#endif +} + +static void _exti(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1, jit_word_t i2) +{ +#if __BYTE_ORDER == __BIG_ENDIAN + i1 = __WORDSIZE - (i1 + i2); +#endif + i0 <<= __WORDSIZE - (i1 + i2); + i0 >>= __WORDSIZE - i2; + movi(r0, i0); +} + +static void _exti_u(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1, jit_word_t i2) +{ + jit_word_t t; +#if __BYTE_ORDER == __BIG_ENDIAN + i1 = __WORDSIZE - (i1 + i2); +#endif + if (i1) + i0 >>= __WORDSIZE - i2; +#if __WORDSIZE == 64 && !_WIN32 + i0 &= (1L << i2) - 1; +#else + i0 &= (1LL << i2) - 1; +#endif + movi(r0, i0); +} + +static void +_generic_unldr(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 & (i0 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r1); + } + switch (i0) { + case 1: + ldr_c(r0, r1); + break; + case 2: + ldr_s(r0, r1); + break; + case 3: +#if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r2); + ldxi_c(r2, r2, 2); + lshi(r2, r2, 16); +#else + ldr_c(r0, r2); + lshi(r0, r0, 16); + ldxi_us(r2, r2, 1); +#endif + break; +#if __WORDSIZE == 32 + default: + ldr_i(r0, r1); + break; +#else + case 4: + ldr_i(r0, r1); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_c(r2, r2, 4); + lshi(r2, r2, 32); +# else + ldr_i(r0, r2); + lshi(r0, r0, 8); + ldxi_uc(r2, r2, 4); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_s(r2, r2, 4); + lshi(r2, r2, 32); +# else + ldr_i(r0, r2); + lshi(r0, r0, 16); + ldxi_us(r2, r2, 4); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_i(r2, r2, 4); + lshi(r2, r2, 40); + rshi(r2, r2, 8); +# else + ldr_i(r0, r2); + lshi(r0, r0, 24); + ldxi_ui(r2, r2, 4); + rshi(r2, r2, 8); +# endif + break; + default: + ldr_l(r0, r1); + break; +#endif + } + if (i0 & (i0 - 1)) { + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +static void +_generic_unldi(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + assert(i1 >= 1 && i1 <= sizeof(jit_word_t)); + if (i1 & (i1 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + } + switch (i1) { + case 1: + ldi_c(r0, i0); + break; + case 2: + ldi_s(r0, i0); + break; + case 3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i0); + ldi_c(r2, i0 + 2); + lshi(r2, r2, 16); +# else + ldi_c(r0, i0); + lshi(r0, r0, 16); + ldi_us(r2, i0 + 1); +# endif + break; +# if __WORDSIZE == 32 + default: + ldi_i(r0, i0); + break; +# else + case 4: + ldi_i(r0, i0); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_c(r2, i0 + 4); + lshi(r2, r2, 32); +# else + ldi_i(r0, i0); + lshi(r0, r0, 8); + ldi_uc(r2, i0 + 4); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_s(r2, i0 + 4); + lshi(r2, r2, 32); +# else + ldi_i(r0, i0); + lshi(r0, r0, 16); + ldi_us(r2, i0 + 4); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_i(r2, i0 + 4); + lshi(r2, r2, 40); + rshi(r2, r2, 8); +# else + ldi_i(r0, i0); + lshi(r0, r0, 24); + ldi_ui(r2, i0 + 4); + rshi(r2, r2, 8); +# endif + break; + default: + ldi_l(r0, i0); + break; +# endif + } + if (i1 & (i1 - 1)) { + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +static void +_generic_unldr_u(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_int32_t t0, r2; + assert(i0 >= 1 && i0 <= sizeof(jit_word_t)); + if (i0 & (i0 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + movr(r2, r1); + } + switch (i0) { + case 1: + ldr_uc(r0, r1); + break; + case 2: + ldr_us(r0, r1); + break; + case 3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_us(r0, r2); + ldxi_uc(r2, r2, 2); + lshi(r2, r2, 16); +# else + ldr_uc(r0, r2); + lshi(r0, r0, 16); + ldxi_us(r2, r2, 1); +# endif + break; +# if __WORDSIZE == 32 + default: + ldr_i(r0, r1); + break; +# else + case 4: + ldr_ui(r0, r1); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_uc(r2, r2, 4); + lshi(r2, r2, 32); +# else + ldr_ui(r0, r2); + lshi(r0, r0, 8); + ldxi_uc(r2, r2, 4); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_us(r2, r2, 4); + lshi(r2, r2, 32); +# else + ldr_ui(r0, r2); + lshi(r0, r0, 16); + ldxi_us(r2, r2, 4); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldr_ui(r0, r2); + ldxi_ui(r2, r2, 4); + lshi(r2, r2, 40); + rshi_u(r2, r2, 8); +# else + ldr_ui(r0, r2); + lshi(r0, r0, 24); + ldxi_ui(r2, r2, 4); + rshi(r2, r2, 8); +# endif + break; + default: + ldr_l(r0, r1); + break; +# endif + } + if (i0 & (i0 - 1)) { + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +static void +_generic_unldi_u(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + jit_int32_t t0, r2; + assert(i1 >= 1 && i1 <= sizeof(jit_word_t)); + if (i1 & (i1 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + } + switch (i1) { + case 1: + ldi_uc(r0, i0); + break; + case 2: + ldi_us(r0, i0); + break; + case 3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_us(r0, i0); + ldi_uc(r2, i0 + 2); + lshi(r2, r2, 16); +# else + ldi_uc(r0, i0); + lshi(r0, r0, 16); + ldi_us(r2, i0 + 1); +# endif + break; +# if __WORDSIZE == 32 + default: + ldi_i(r0, i0); + break; +# else + case 4: + ldi_ui(r0, i0); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_uc(r2, i0 + 4); + lshi(r2, r2, 32); +# else + ldi_ui(r0, i0); + lshi(r0, r0, 8); + ldi_uc(r2, i0 + 4); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_us(r2, i0 + 4); + lshi(r2, r2, 32); +# else + ldi_ui(r0, i0); + lshi(r0, r0, 16); + ldi_us(r2, i0 + 4); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + ldi_ui(r0, i0); + ldi_ui(r2, i0 + 4); + lshi(r2, r2, 40); + rshi_u(r2, r2, 8); +# else + ldi_ui(r0, i0); + lshi(r0, r0, 24); + ldi_ui(r2, i0 + 4); + rshi(r2, r2, 8); +# endif + break; + default: + ldi_l(r0, i0); + break; +# endif + } + if (i1 & (i1 - 1)) { + orr(r0, r0, r2); + jit_unget_reg(t0); + } +} + +static void +_generic_unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + jit_word_t t0, r2; + assert(i0 > 0 && i0 <= sizeof(jit_word_t)); + if (i0 & (i0 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + } + switch (i0) { + case 1: + str_c(r0, r1); + break; + case 2: + str_s(r0, r1); + break; + case 3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_s(r0, r1); + rshi(r2, r1, 16); + stxi_c(2, r0, r2); +# else + stxi_c(2, r0, r1); + rshi(r2, r1, 8); + str_s(r0, r2); +# endif + break; +# if __WORDSIZE == 32 + default: + str_i(r0, r1); + break; +# else + case 4: + str_i(r0, r1); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r0, r1); + rshi(r2, r1, 32); + stxi_c(4, r0, r2); +# else + stxi_c(4, r0, r1); + rshi(r2, r1, 8); + str_i(r0, r2); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r0, r1); + rshi(r2, r1, 32); + stxi_s(4, r0, r2); +# else + stxi_s(4, r0, r1); + rshi(r2, r1, 16); + str_i(r0, r2); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + str_i(r0, r1); + rshi(r2, r1, 32); + stxi_s(4, r0, r2); + rshi(r2, r2, 16); + stxi_c(6, r0, r2); +# else + stxi_c(6, r0, r1); + rshi(r2, r1, 8); + stxi_s(4, r0, r2); + rshi(r2, r2, 16); + str_i(r0, r2); +# endif + break; + default: + str_l(r0, r1); + break; +# endif + } + if (i0 & (i0 - 1)) + jit_unget_reg(t0); +} + +static void +_generic_unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + jit_word_t t0, r2; + assert(i1 > 0 && i1 <= sizeof(jit_word_t)); + if (i1 & (i1 - 1)) { + t0 = jit_get_reg(jit_class_gpr); + r2 = rn(t0); + } + switch (i1) { + case 1: + sti_c(i0, r0); + break; + case 2: + sti_s(i0, r0); + break; + case 3: +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_s(i0, r0); + rshi(r2, r0, 16); + sti_c(2 + i0, r2); +# else + sti_c(2 + i0, r0); + rshi(r2, r0, 8); + sti_s(i0, r2); +# endif + break; +# if __WORDSIZE == 32 + default: + sti_i(i0, r0); + break; +# else + case 4: + sti_i(i0, r0); + break; + case 5: +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i0, r0); + rshi(r2, r0, 32); + sti_c(4 + i0, r2); +# else + stxi_c(4, i0, r0); + rshi(r2, r0, 8); + sti_i(i0, r2); +# endif + break; + case 6: +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i0, r0); + rshi(r2, r0, 32); + sti_s(4 + i0, r2); +# else + sti_s(4 + i0, r0); + rshi(r2, r0, 16); + sti_i(i0, r2); +# endif + break; + case 7: +# if __BYTE_ORDER == __LITTLE_ENDIAN + sti_i(i0, r0); + rshi(r2, r0, 32); + sti_s(4 + i0, r2); + rshi(r2, r2, 16); + sti_c(6 + i0, r2); +# else + sti_c(6 + i0, r0); + rshi(r2, r0, 8); + sti_s(4 + i0, r2); + rshi(r2, r2, 16); + sti_i(i0, r2); +# endif + break; + default: + sti_l(i0, r0); + break; +# endif + } + if (i1 & (i1 - 1)) + jit_unget_reg(t0); +} + +#if !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) +static void +_generic_unldr_x(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + ldr_f(r0, r1); + else + ldr_d(r0, r1); +} + +static void +_generic_unldi_x(jit_state_t *_jit, + jit_int32_t r0, jit_word_t i0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + ldi_f(r0, i0); + else + ldi_d(r0, i0); +} + +static void +_generic_unstr_x(jit_state_t *_jit, + jit_int32_t r0, jit_int32_t r1, jit_word_t i0) +{ + assert(i0 == 4 || i0 == 8); + if (i0 == 4) + str_f(r0, r1); + else + str_d(r0, r1); +} + +static void +_generic_unsti_x(jit_state_t *_jit, + jit_word_t i0, jit_int32_t r0, jit_word_t i1) +{ + assert(i1 == 4 || i1 == 8); + if (i1 == 4) + sti_f(i0, r0); + else + sti_d(i0, r0); +} +#endif + #if defined(stack_framesize) static maybe_unused void _patch_alist(jit_state_t *_jit, jit_bool_t revert) diff --git a/deps/lightning/size.c b/deps/lightning/size.c index 1f31ed60..855e7bce 100644 --- a/deps/lightning/size.c +++ b/deps/lightning/size.c @@ -40,9 +40,14 @@ main(int argc, char *argv[]) fclose(fp); max = 0; - for (offset = 0; offset < jit_code_last_code; offset++) + for (offset = 0; offset < jit_code_last_code; offset++) { +#if defined(__ia64__) + if (_szs[offset] > 16) + _szs[offset] = _szs[offset] / 3 + 16 & -16; +#endif if (max < _szs[offset]) max = _szs[offset]; + } if ((fp = fopen(JIT_SIZE_PATH, "w")) == NULL) exit(-1); -- 2.39.5