[PATCH v5 00/24] target/m68k: fpu improvements

[PATCH v5 00/24] target/m68k: fpu improvements

[Richard Henderson]

v3: https://lore.kernel.org/qemu-devel/20240909172823.649837-1-richard.henderson@linaro.org/
v4: https://lore.kernel.org/qemu-devel/20250224171444.440135-1-richard.henderson@linaro.org/

Changes for v5:
  - Rebase from February.  :-/
  - Use ldl_be_p in m68k_fpu_gdb_set_reg (phil).

Patches needing review:
  03-target-m68k-Keep-FPSR-up-to-date.patch
  05-target-m68k-Update-FPSR-for-FMOVECR.patch
  09-target-m68k-Use-OS_UNSIZED-in-LEA-PEA-JMP.patch
  10-target-m68k-Move-pre-dec-post-inc-to-gen_lea_mode.patch
  11-target-m68k-Split-gen_ea_mode-for-load-store.patch
  21-target-m68k-Implement-packed-decimal-real-loads-a.patch


r~


Richard Henderson (24):
  target/m68k: Add FPSR exception bit defines
  target/m68k: Restore fp rounding mode on vm load
  target/m68k: Keep FPSR up-to-date
  target/m68k: Update FPSR.EXC
  target/m68k: Update FPSR for FMOVECR
  target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL
  target/m68k: Merge gen_ea into SRC_EA and DEST_EA
  target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode
  target/m68k: Use OS_UNSIZED in LEA, PEA, JMP
  target/m68k: Move pre-dec/post-inc to gen_lea_mode
  target/m68k: Split gen_ea_mode for load/store
  target/m68k: Remove env argument to gen_lea_indexed
  target/m68k: Remove env argument to gen_lea_mode
  target/m68k: Remove env argument to gen_load_mode
  target/m68k: Remove env argument to gen_store_mode
  target/m68k: Remove env argument to gen_ea_mode_fp
  target/m68k: Split gen_ea_mode_fp for load/store
  target/m68k: Move gen_addr_fault into gen_{load,store}_mode_fp
  target/m68k: Merge gen_load_fp, gen_load_mode_fp
  target/m68k: Merge gen_store_fp, gen_store_mode_fp
  target/m68k: Implement packed decimal real loads and stores
  tests/tcg/m68k: Add packed decimal tests
  target/m68k: Make vmstate variables static
  target/m68k: Implement FPIAR

 target/m68k/cpu.h                |   27 +-
 target/m68k/helper.h             |    5 +-
 target/m68k/cpu.c                |   38 +-
 target/m68k/fpu_helper.c         |  330 +-
 target/m68k/gen-floatx80-pow10.c |   33 +
 target/m68k/helper.c             |   18 +-
 target/m68k/translate.c          |  789 +++--
 tests/tcg/m68k/packeddecimal-1.c |   41 +
 tests/tcg/m68k/packeddecimal-2.c |   46 +
 target/m68k/floatx80-pow10.c.inc | 4935 ++++++++++++++++++++++++++++++
 tests/tcg/m68k/Makefile.target   |    4 +-
 11 files changed, 5746 insertions(+), 520 deletions(-)
 create mode 100644 target/m68k/gen-floatx80-pow10.c
 create mode 100644 tests/tcg/m68k/packeddecimal-1.c
 create mode 100644 tests/tcg/m68k/packeddecimal-2.c
 create mode 100644 target/m68k/floatx80-pow10.c.inc

-- 
2.43.0

[PATCH v5 01/24] target/m68k: Add FPSR exception bit defines

[Richard Henderson]

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.h        | 21 +++++++++++++++++++++
 target/m68k/fpu_helper.c | 22 +++++++++++-----------
 2 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index d9db6a486a..035034772b 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -442,6 +442,27 @@ typedef enum {
 #define FPSR_QT_MASK  0x00ff0000
 #define FPSR_QT_SHIFT 16
 
+/* Exception Status Byte */
+
+#define FPSR_EXC_MASK     0xff00
+#define FPSR_EXC_INEX1    0x0100
+#define FPSR_EXC_INEX2    0x0200
+#define FPSR_EXC_DZ       0x0400
+#define FPSR_EXC_UNFL     0x0800
+#define FPSR_EXC_OVFL     0x1000
+#define FPSR_EXC_OPERR    0x2000
+#define FPSR_EXC_SNAN     0x4000
+#define FPSR_EXC_BSUN     0x8000
+
+/* Accrued Exception Byte */
+
+#define FPSR_AEXC_MASK    0xf8
+#define FPSR_AEXC_INEX    0x08
+#define FPSR_AEXP_DZ      0x10
+#define FPSR_AEXP_UNFL    0x20
+#define FPSR_AEXP_OVFL    0x40
+#define FPSR_AEXP_IOP     0x80
+
 /* Floating-Point Control Register */
 /* Rounding mode */
 #define FPCR_RND_MASK   0x0030
diff --git a/target/m68k/fpu_helper.c b/target/m68k/fpu_helper.c
index 56012863c8..3e35c20be3 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -169,19 +169,19 @@ static int cpu_m68k_exceptbits_from_host(int host_bits)
     int target_bits = 0;
 
     if (host_bits & float_flag_invalid) {
-        target_bits |= 0x80;
+        target_bits |= FPSR_AEXP_IOP;
     }
     if (host_bits & float_flag_overflow) {
-        target_bits |= 0x40;
+        target_bits |= FPSR_AEXP_OVFL;
     }
     if (host_bits & (float_flag_underflow | float_flag_output_denormal_flushed)) {
-        target_bits |= 0x20;
+        target_bits |= FPSR_AEXP_UNFL;
     }
     if (host_bits & float_flag_divbyzero) {
-        target_bits |= 0x10;
+        target_bits |= FPSR_AEXP_DZ;
     }
     if (host_bits & float_flag_inexact) {
-        target_bits |= 0x08;
+        target_bits |= FPSR_AEXC_INEX;
     }
     return target_bits;
 }
@@ -191,19 +191,19 @@ static int cpu_m68k_exceptbits_to_host(int target_bits)
 {
     int host_bits = 0;
 
-    if (target_bits & 0x80) {
+    if (target_bits & FPSR_AEXP_IOP) {
         host_bits |= float_flag_invalid;
     }
-    if (target_bits & 0x40) {
+    if (target_bits & FPSR_AEXP_OVFL) {
         host_bits |= float_flag_overflow;
     }
-    if (target_bits & 0x20) {
+    if (target_bits & FPSR_AEXP_UNFL) {
         host_bits |= float_flag_underflow;
     }
-    if (target_bits & 0x10) {
+    if (target_bits & FPSR_AEXP_DZ) {
         host_bits |= float_flag_divbyzero;
     }
-    if (target_bits & 0x08) {
+    if (target_bits & FPSR_AEXC_INEX) {
         host_bits |= float_flag_inexact;
     }
     return host_bits;
@@ -213,7 +213,7 @@ uint32_t cpu_m68k_get_fpsr(CPUM68KState *env)
 {
     int host_flags = get_float_exception_flags(&env->fp_status);
     int target_flags = cpu_m68k_exceptbits_from_host(host_flags);
-    int except = (env->fpsr & ~(0xf8)) | target_flags;
+    int except = (env->fpsr & ~FPSR_AEXC_MASK) | target_flags;
     return except;
 }
 
-- 
2.43.0

[PATCH v5 02/24] target/m68k: Restore fp rounding mode on vm load

[Richard Henderson]

Call cpu_m68k_set_fpcr to make sure softfloat internals
are up-to-date with the restored FPCR.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index c5196a612e..724138b302 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -480,6 +480,7 @@ static int fpu_post_load(void *opaque, int version)
 {
     M68kCPU *s = opaque;
 
+    cpu_m68k_set_fpcr(&s->env, s->env.fpcr);
     cpu_m68k_set_fpsr(&s->env, s->env.fpsr);
     return 0;
 }
-- 
2.43.0

[PATCH v5 03/24] target/m68k: Keep FPSR up-to-date

[Richard Henderson]

Proper support for m68k exceptions will require testing the FPCR vs
the FPSR for every instruction.  As a step, do not keep FPSR bits in
fp_status, but copy them back to the FPSR in every instruction.

Since most of the FPSR must be updated on every insn, handle this
from the existing helper_ftst and helper_fcmp functions.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.h        |  2 -
 target/m68k/helper.h     |  2 -
 target/m68k/cpu.c        | 10 -----
 target/m68k/fpu_helper.c | 94 +++++++++++-----------------------------
 target/m68k/helper.c     |  4 +-
 target/m68k/translate.c  |  4 +-
 6 files changed, 30 insertions(+), 86 deletions(-)

diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index 035034772b..0630eb26c2 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -201,8 +201,6 @@ void cpu_m68k_set_ccr(CPUM68KState *env, uint32_t);
 void cpu_m68k_set_sr(CPUM68KState *env, uint32_t);
 void cpu_m68k_restore_fp_status(CPUM68KState *env);
 void cpu_m68k_set_fpcr(CPUM68KState *env, uint32_t val);
-uint32_t cpu_m68k_get_fpsr(CPUM68KState *env);
-void cpu_m68k_set_fpsr(CPUM68KState *env, uint32_t val);
 
 /*
  * Instead of computing the condition codes after each m68k instruction,
diff --git a/target/m68k/helper.h b/target/m68k/helper.h
index 95aa5e53bb..2bbe0dc032 100644
--- a/target/m68k/helper.h
+++ b/target/m68k/helper.h
@@ -54,8 +54,6 @@ DEF_HELPER_4(fsdiv, void, env, fp, fp, fp)
 DEF_HELPER_4(fddiv, void, env, fp, fp, fp)
 DEF_HELPER_4(fsgldiv, void, env, fp, fp, fp)
 DEF_HELPER_FLAGS_3(fcmp, TCG_CALL_NO_RWG, void, env, fp, fp)
-DEF_HELPER_2(set_fpsr, void, env, i32)
-DEF_HELPER_1(get_fpsr, i32, env)
 DEF_HELPER_FLAGS_2(set_fpcr, TCG_CALL_NO_RWG, void, env, i32)
 DEF_HELPER_FLAGS_2(ftst, TCG_CALL_NO_RWG, void, env, fp)
 DEF_HELPER_3(fconst, void, env, fp, i32)
diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index 724138b302..e898156403 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -468,20 +468,11 @@ static const VMStateDescription vmstate_freg = {
     }
 };
 
-static int fpu_pre_save(void *opaque)
-{
-    M68kCPU *s = opaque;
-
-    s->env.fpsr = cpu_m68k_get_fpsr(&s->env);
-    return 0;
-}
-
 static int fpu_post_load(void *opaque, int version)
 {
     M68kCPU *s = opaque;
 
     cpu_m68k_set_fpcr(&s->env, s->env.fpcr);
-    cpu_m68k_set_fpsr(&s->env, s->env.fpsr);
     return 0;
 }
 
@@ -490,7 +481,6 @@ const VMStateDescription vmmstate_fpu = {
     .version_id = 1,
     .minimum_version_id = 1,
     .needed = fpu_needed,
-    .pre_save = fpu_pre_save,
     .post_load = fpu_post_load,
     .fields = (const VMStateField[]) {
         VMSTATE_UINT32(env.fpcr, M68kCPU),
diff --git a/target/m68k/fpu_helper.c b/target/m68k/fpu_helper.c
index 3e35c20be3..195281f118 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -163,76 +163,34 @@ void HELPER(set_fpcr)(CPUM68KState *env, uint32_t val)
     cpu_m68k_set_fpcr(env, val);
 }
 
-/* Convert host exception flags to cpu_m68k form.  */
-static int cpu_m68k_exceptbits_from_host(int host_bits)
+static void update_fpsr(CPUM68KState *env, int cc)
 {
-    int target_bits = 0;
+    uint32_t fpsr = env->fpsr;
+    int flags = get_float_exception_flags(&env->fp_status);
 
-    if (host_bits & float_flag_invalid) {
-        target_bits |= FPSR_AEXP_IOP;
-    }
-    if (host_bits & float_flag_overflow) {
-        target_bits |= FPSR_AEXP_OVFL;
-    }
-    if (host_bits & (float_flag_underflow | float_flag_output_denormal_flushed)) {
-        target_bits |= FPSR_AEXP_UNFL;
-    }
-    if (host_bits & float_flag_divbyzero) {
-        target_bits |= FPSR_AEXP_DZ;
-    }
-    if (host_bits & float_flag_inexact) {
-        target_bits |= FPSR_AEXC_INEX;
-    }
-    return target_bits;
-}
+    fpsr &= ~FPSR_CC_MASK;
+    fpsr |= cc;
 
-/* Convert cpu_m68k exception flags to target form.  */
-static int cpu_m68k_exceptbits_to_host(int target_bits)
-{
-    int host_bits = 0;
+    if (flags) {
+        set_float_exception_flags(0, &env->fp_status);
 
-    if (target_bits & FPSR_AEXP_IOP) {
-        host_bits |= float_flag_invalid;
+        if (flags & float_flag_invalid) {
+            fpsr |= FPSR_AEXP_IOP;
+        }
+        if (flags & float_flag_overflow) {
+            fpsr |= FPSR_AEXP_OVFL;
+        }
+        if (flags & (float_flag_underflow | float_flag_output_denormal_flushed)) {
+            fpsr |= FPSR_AEXP_UNFL;
+        }
+        if (flags & float_flag_divbyzero) {
+            fpsr |= FPSR_AEXP_DZ;
+        }
+        if (flags & float_flag_inexact) {
+            fpsr |= FPSR_AEXC_INEX;
+        }
     }
-    if (target_bits & FPSR_AEXP_OVFL) {
-        host_bits |= float_flag_overflow;
-    }
-    if (target_bits & FPSR_AEXP_UNFL) {
-        host_bits |= float_flag_underflow;
-    }
-    if (target_bits & FPSR_AEXP_DZ) {
-        host_bits |= float_flag_divbyzero;
-    }
-    if (target_bits & FPSR_AEXC_INEX) {
-        host_bits |= float_flag_inexact;
-    }
-    return host_bits;
-}
-
-uint32_t cpu_m68k_get_fpsr(CPUM68KState *env)
-{
-    int host_flags = get_float_exception_flags(&env->fp_status);
-    int target_flags = cpu_m68k_exceptbits_from_host(host_flags);
-    int except = (env->fpsr & ~FPSR_AEXC_MASK) | target_flags;
-    return except;
-}
-
-uint32_t HELPER(get_fpsr)(CPUM68KState *env)
-{
-    return cpu_m68k_get_fpsr(env);
-}
-
-void cpu_m68k_set_fpsr(CPUM68KState *env, uint32_t val)
-{
-    env->fpsr = val;
-
-    int host_flags = cpu_m68k_exceptbits_to_host((int) env->fpsr);
-    set_float_exception_flags(host_flags, &env->fp_status);
-}
-
-void HELPER(set_fpsr)(CPUM68KState *env, uint32_t val)
-{
-    cpu_m68k_set_fpsr(env, val);
+    env->fpsr = fpsr;
 }
 
 #define PREC_BEGIN(prec)                                        \
@@ -441,12 +399,12 @@ void HELPER(fcmp)(CPUM68KState *env, FPReg *val0, FPReg *val1)
     FloatRelation float_compare;
 
     float_compare = floatx80_compare(val1->d, val0->d, &env->fp_status);
-    env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | float_comp_to_cc(float_compare);
+    update_fpsr(env, float_comp_to_cc(float_compare));
 }
 
 void HELPER(ftst)(CPUM68KState *env, FPReg *val)
 {
-    uint32_t cc = 0;
+    int cc = 0;
 
     if (floatx80_is_neg(val->d)) {
         cc |= FPSR_CC_N;
@@ -459,7 +417,7 @@ void HELPER(ftst)(CPUM68KState *env, FPReg *val)
     } else if (floatx80_is_zero(val->d)) {
         cc |= FPSR_CC_Z;
     }
-    env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | cc;
+    update_fpsr(env, cc);
 }
 
 void HELPER(fconst)(CPUM68KState *env, FPReg *val, uint32_t offset)
diff --git a/target/m68k/helper.c b/target/m68k/helper.c
index 15f110fa7a..b50ef6dec3 100644
--- a/target/m68k/helper.c
+++ b/target/m68k/helper.c
@@ -92,7 +92,7 @@ static int m68k_fpu_gdb_get_reg(CPUState *cs, GByteArray *mem_buf, int n)
     case 8: /* fpcontrol */
         return gdb_get_reg32(mem_buf, env->fpcr);
     case 9: /* fpstatus */
-        return gdb_get_reg32(mem_buf, cpu_m68k_get_fpsr(env));
+        return gdb_get_reg32(mem_buf, env->fpsr);
     case 10: /* fpiar, not implemented */
         return gdb_get_reg32(mem_buf, 0);
     }
@@ -114,7 +114,7 @@ static int m68k_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
         cpu_m68k_set_fpcr(env, ldl_be_p(mem_buf));
         return 4;
     case 9: /* fpstatus */
-        cpu_m68k_set_fpsr(env, ldl_be_p(mem_buf));
+        env->fpsr = ldl_be_p(mem_buf);
         return 4;
     case 10: /* fpiar, not implemented */
         return 4;
diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 97afceb129..340d72bc4f 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -4733,7 +4733,7 @@ static void gen_load_fcr(DisasContext *s, TCGv res, int reg)
         tcg_gen_movi_i32(res, 0);
         break;
     case M68K_FPSR:
-        gen_helper_get_fpsr(res, tcg_env);
+        tcg_gen_ld_i32(res, tcg_env, offsetof(CPUM68KState, fpsr));
         break;
     case M68K_FPCR:
         tcg_gen_ld_i32(res, tcg_env, offsetof(CPUM68KState, fpcr));
@@ -4747,7 +4747,7 @@ static void gen_store_fcr(DisasContext *s, TCGv val, int reg)
     case M68K_FPIAR:
         break;
     case M68K_FPSR:
-        gen_helper_set_fpsr(tcg_env, val);
+        tcg_gen_st_i32(val, tcg_env, offsetof(CPUM68KState, fpsr));
         break;
     case M68K_FPCR:
         gen_helper_set_fpcr(tcg_env, val);
-- 
2.43.0

[PATCH v5 04/24] target/m68k: Update FPSR.EXC

[Richard Henderson]

So far we've only been updating the AEXC byte.
Update the EXC byte as well.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/fpu_helper.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/target/m68k/fpu_helper.c b/target/m68k/fpu_helper.c
index 195281f118..deae94b0ee 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -168,26 +168,28 @@ static void update_fpsr(CPUM68KState *env, int cc)
     uint32_t fpsr = env->fpsr;
     int flags = get_float_exception_flags(&env->fp_status);
 
-    fpsr &= ~FPSR_CC_MASK;
+    fpsr &= ~(FPSR_CC_MASK | FPSR_EXC_MASK);
     fpsr |= cc;
 
     if (flags) {
         set_float_exception_flags(0, &env->fp_status);
 
-        if (flags & float_flag_invalid) {
-            fpsr |= FPSR_AEXP_IOP;
+        if (flags & float_flag_invalid_snan) {
+            fpsr |= FPSR_EXC_SNAN | FPSR_AEXP_IOP;
+        } else if (flags & float_flag_invalid) {
+            fpsr |= FPSR_EXC_OPERR | FPSR_AEXP_IOP;
         }
         if (flags & float_flag_overflow) {
-            fpsr |= FPSR_AEXP_OVFL;
+            fpsr |= FPSR_EXC_OVFL | FPSR_AEXP_OVFL;
         }
         if (flags & (float_flag_underflow | float_flag_output_denormal_flushed)) {
-            fpsr |= FPSR_AEXP_UNFL;
+            fpsr |= FPSR_EXC_UNFL | FPSR_AEXP_UNFL;
         }
         if (flags & float_flag_divbyzero) {
-            fpsr |= FPSR_AEXP_DZ;
+            fpsr |= FPSR_EXC_DZ | FPSR_AEXP_DZ;
         }
         if (flags & float_flag_inexact) {
-            fpsr |= FPSR_AEXC_INEX;
+            fpsr |= FPSR_EXC_INEX2 | FPSR_AEXC_INEX;
         }
     }
     env->fpsr = fpsr;
-- 
2.43.0

[PATCH v5 05/24] target/m68k: Update FPSR for FMOVECR

[Richard Henderson]

This instruction sets CC and EXC bits just like any other.
So far we do not properly emulate inexact for the various
rom entries, but we can certainly update CC correctly.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/fpu_helper.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/target/m68k/fpu_helper.c b/target/m68k/fpu_helper.c
index deae94b0ee..e63fd3ec11 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -425,6 +425,7 @@ void HELPER(ftst)(CPUM68KState *env, FPReg *val)
 void HELPER(fconst)(CPUM68KState *env, FPReg *val, uint32_t offset)
 {
     val->d = fpu_rom[offset];
+    HELPER(ftst)(env, val);
 }
 
 typedef int (*float_access)(CPUM68KState *env, uint32_t addr, FPReg *fp,
-- 
2.43.0

[PATCH v5 06/24] target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL

[Richard Henderson]

Set for 68020 and 68030, but does nothing so far.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.h | 2 ++
 target/m68k/cpu.c | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index 0630eb26c2..8adb1c6515 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -574,6 +574,8 @@ enum m68k_features {
     M68K_FEATURE_MOVEFROMSR_PRIV,
     /* Exception frame with format+vector (from 68010) */
     M68K_FEATURE_EXCEPTION_FORMAT_VEC,
+    /* FPU supports packed decimal real format */
+    M68K_FEATURE_FPU_PACKED_DECIMAL,
 };
 
 static inline bool m68k_feature(CPUM68KState *env, int feature)
diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index e898156403..866d32fc9f 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -260,6 +260,7 @@ static void m68020_cpu_initfn(Object *obj)
     m68k_set_feature(env, M68K_FEATURE_MSP);
     m68k_set_feature(env, M68K_FEATURE_UNALIGNED_DATA);
     m68k_set_feature(env, M68K_FEATURE_TRAPCC);
+    m68k_set_feature(env, M68K_FEATURE_FPU_PACKED_DECIMAL);
 }
 
 /*
@@ -302,6 +303,7 @@ static void m68040_cpu_initfn(Object *obj)
 
     m68030_cpu_initfn(obj);
     m68k_unset_feature(env, M68K_FEATURE_M68030);
+    m68k_unset_feature(env, M68K_FEATURE_FPU_PACKED_DECIMAL);
     m68k_set_feature(env, M68K_FEATURE_M68040);
 }
 
-- 
2.43.0

[PATCH v5 07/24] target/m68k: Merge gen_ea into SRC_EA and DEST_EA

[Richard Henderson]

This will enable further cleanups further down the call chain.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 340d72bc4f..b9633e06da 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -897,14 +897,6 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
     return NULL_QREG;
 }
 
-static TCGv gen_ea(CPUM68KState *env, DisasContext *s, uint16_t insn,
-                   int opsize, TCGv val, TCGv *addrp, ea_what what, int index)
-{
-    int mode = extract32(insn, 3, 3);
-    int reg0 = REG(insn, 0);
-    return gen_ea_mode(env, s, mode, reg0, opsize, val, addrp, what, index);
-}
-
 static TCGv_ptr gen_fp_ptr(int freg)
 {
     TCGv_ptr fp = tcg_temp_new_ptr();
@@ -1368,18 +1360,22 @@ static void gen_exit_tb(DisasContext *s)
     s->base.is_jmp = DISAS_EXIT;
 }
 
-#define SRC_EA(env, result, opsize, op_sign, addrp) do {                \
-        result = gen_ea(env, s, insn, opsize, NULL_QREG, addrp,         \
-                        op_sign ? EA_LOADS : EA_LOADU, IS_USER(s));     \
+#define SRC_EA(env, result, opsize, op_sign, addrp)                     \
+    do {                                                                \
+        result = gen_ea_mode(env, s, extract32(insn, 3, 3),             \
+                             REG(insn, 0), opsize, NULL_QREG, addrp,    \
+                             op_sign ? EA_LOADS : EA_LOADU, IS_USER(s)); \
         if (IS_NULL_QREG(result)) {                                     \
             gen_addr_fault(s);                                          \
             return;                                                     \
         }                                                               \
     } while (0)
 
-#define DEST_EA(env, insn, opsize, val, addrp) do {                     \
-        TCGv ea_result = gen_ea(env, s, insn, opsize, val, addrp,       \
-                                EA_STORE, IS_USER(s));                  \
+#define DEST_EA(env, insn, opsize, val, addrp)                          \
+    do {                                                                \
+        TCGv ea_result = gen_ea_mode(env, s, extract32(insn, 3, 3),     \
+                                     REG(insn, 0), opsize, val, addrp,  \
+                                     EA_STORE, IS_USER(s));             \
         if (IS_NULL_QREG(ea_result)) {                                  \
             gen_addr_fault(s);                                          \
             return;                                                     \
-- 
2.43.0

[PATCH v5 08/24] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode

[Richard Henderson]

The mode argument is extracted from 3 bits, and all cases are covered.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index b9633e06da..f87eff3b10 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -768,8 +768,7 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
         tcg_gen_movi_i32(tmp, offset);
         return tmp;
     }
-    /* Should never happen.  */
-    return NULL_QREG;
+    g_assert_not_reached();
 }
 
 static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
@@ -893,8 +892,7 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
             return NULL_QREG;
         }
     }
-    /* Should never happen.  */
-    return NULL_QREG;
+    g_assert_not_reached();
 }
 
 static TCGv_ptr gen_fp_ptr(int freg)
-- 
2.43.0

[PATCH v5 09/24] target/m68k: Use OS_UNSIZED in LEA, PEA, JMP

[Richard Henderson]

For LEA and PEA, while the manual says "size = (long)", it also says
that the pre-decrement and post-increment addressing modes are illegal.
For JMP, the manual says "unsized".  OS_UNSIZED is the way to signal
gen_lea_mode to reject those addressing modes.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index f87eff3b10..b6d46c3bdb 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -2561,7 +2561,7 @@ DISAS_INSN(lea)
     TCGv tmp;
 
     reg = AREG(insn, 9);
-    tmp = gen_lea(env, s, insn, OS_LONG);
+    tmp = gen_lea(env, s, insn, OS_UNSIZED);
     if (IS_NULL_QREG(tmp)) {
         gen_addr_fault(s);
         return;
@@ -2658,7 +2658,7 @@ DISAS_INSN(pea)
 {
     TCGv tmp;
 
-    tmp = gen_lea(env, s, insn, OS_LONG);
+    tmp = gen_lea(env, s, insn, OS_UNSIZED);
     if (IS_NULL_QREG(tmp)) {
         gen_addr_fault(s);
         return;
@@ -2909,7 +2909,7 @@ DISAS_INSN(jump)
      * Load the target address first to ensure correct exception
      * behavior.
      */
-    tmp = gen_lea(env, s, insn, OS_LONG);
+    tmp = gen_lea(env, s, insn, OS_UNSIZED);
     if (IS_NULL_QREG(tmp)) {
         gen_addr_fault(s);
         return;
-- 
2.43.0

[PATCH v5 10/24] target/m68k: Move pre-dec/post-inc to gen_lea_mode

[Richard Henderson]

Move autoinc down the call chain so that it happens in one place,
more or less.  This unifies code from gen_ea_mode and gen_ea_mode_fp,
as well as the by-hand autoinc from CAS, TAS, MOVES, and MAC.
In FMOVE_FCR and FMOVEM, use delay_set_areg to update the value
to be stored at the end of the insn.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 264 +++++++++++++++-------------------------
 1 file changed, 95 insertions(+), 169 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index b6d46c3bdb..593ff9ba2d 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -699,15 +699,23 @@ static void gen_partset_reg(int opsize, TCGv reg, TCGv val)
     }
 }
 
+static int addr_inc_size(DisasContext *s, int reg0, int opsize)
+{
+    if (reg0 == 7
+        && opsize == OS_BYTE
+        && m68k_feature(s->env, M68K_FEATURE_M68K)) {
+        return 2;
+    }
+    return opsize_bytes(opsize);
+}
+
 /*
- * Generate code for an "effective address".  Does not adjust the base
- * register for autoincrement addressing modes.
+ * Generate code for an "effective address".
  */
 static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
                          int mode, int reg0, int opsize)
 {
-    TCGv reg;
-    TCGv tmp;
+    TCGv reg, addr, tmp;
     uint16_t ext;
     uint32_t offset;
 
@@ -715,34 +723,37 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
     case 0: /* Data register direct.  */
     case 1: /* Address register direct.  */
         return NULL_QREG;
+    case 2: /* Indirect register */
+        reg = get_areg(s, reg0);
+        addr = tcg_temp_new();
+        tcg_gen_mov_i32(addr, reg);
+        return addr;
     case 3: /* Indirect postincrement.  */
         if (opsize == OS_UNSIZED) {
             return NULL_QREG;
         }
-        /* fallthru */
-    case 2: /* Indirect register */
+        reg = get_areg(s, reg0);
+        addr = tcg_temp_new();
+        tcg_gen_mov_i32(addr, get_areg(s, reg0));
         tmp = tcg_temp_new();
-        tcg_gen_mov_i32(tmp, get_areg(s, reg0));
-        return tmp;
+        tcg_gen_addi_i32(tmp, reg, addr_inc_size(s, reg0, opsize));
+        delay_set_areg(s, reg0, tmp, true);
+        return addr;
     case 4: /* Indirect predecrememnt.  */
         if (opsize == OS_UNSIZED) {
             return NULL_QREG;
         }
         reg = get_areg(s, reg0);
-        tmp = tcg_temp_new();
-        if (reg0 == 7 && opsize == OS_BYTE &&
-            m68k_feature(s->env, M68K_FEATURE_M68K)) {
-            tcg_gen_subi_i32(tmp, reg, 2);
-        } else {
-            tcg_gen_subi_i32(tmp, reg, opsize_bytes(opsize));
-        }
-        return tmp;
+        addr = tcg_temp_new();
+        tcg_gen_subi_i32(addr, reg, addr_inc_size(s, reg0, opsize));
+        delay_set_areg(s, reg0, addr, false);
+        return addr;
     case 5: /* Indirect displacement.  */
         reg = get_areg(s, reg0);
-        tmp = tcg_temp_new();
+        addr = tcg_temp_new();
         ext = read_im16(env, s);
-        tcg_gen_addi_i32(tmp, reg, (int16_t)ext);
-        return tmp;
+        tcg_gen_addi_i32(addr, reg, (int16_t)ext);
+        return addr;
     case 6: /* Indirect index + displacement.  */
         reg = get_areg(s, reg0);
         return gen_lea_indexed(env, s, reg);
@@ -788,7 +799,7 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
                         int opsize, TCGv val, TCGv *addrp, ea_what what,
                         int index)
 {
-    TCGv reg, tmp, result;
+    TCGv reg, ret, addr = NULL;
     int32_t offset;
 
     switch (mode) {
@@ -796,76 +807,25 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
         reg = cpu_dregs[reg0];
         if (what == EA_STORE) {
             gen_partset_reg(opsize, reg, val);
-            return store_dummy;
+            ret = store_dummy;
         } else {
-            return gen_extend(s, reg, opsize, what == EA_LOADS);
+            ret = gen_extend(s, reg, opsize, what == EA_LOADS);
         }
+        break;
+
     case 1: /* Address register direct.  */
         reg = get_areg(s, reg0);
         if (what == EA_STORE) {
             tcg_gen_mov_i32(reg, val);
-            return store_dummy;
+            ret = store_dummy;
         } else {
-            return gen_extend(s, reg, opsize, what == EA_LOADS);
+            ret = gen_extend(s, reg, opsize, what == EA_LOADS);
         }
-    case 2: /* Indirect register */
-        reg = get_areg(s, reg0);
-        return gen_ldst(s, opsize, reg, val, what, index);
-    case 3: /* Indirect postincrement.  */
-        reg = get_areg(s, reg0);
-        result = gen_ldst(s, opsize, reg, val, what, index);
-        if (what == EA_STORE || !addrp) {
-            tmp = tcg_temp_new();
-            if (reg0 == 7 && opsize == OS_BYTE &&
-                m68k_feature(s->env, M68K_FEATURE_M68K)) {
-                tcg_gen_addi_i32(tmp, reg, 2);
-            } else {
-                tcg_gen_addi_i32(tmp, reg, opsize_bytes(opsize));
-            }
-            delay_set_areg(s, reg0, tmp, true);
-        }
-        return result;
-    case 4: /* Indirect predecrememnt.  */
-        if (addrp && what == EA_STORE) {
-            tmp = *addrp;
-        } else {
-            tmp = gen_lea_mode(env, s, mode, reg0, opsize);
-            if (IS_NULL_QREG(tmp)) {
-                return tmp;
-            }
-            if (addrp) {
-                *addrp = tmp;
-            }
-        }
-        result = gen_ldst(s, opsize, tmp, val, what, index);
-        if (what == EA_STORE || !addrp) {
-            delay_set_areg(s, reg0, tmp, false);
-        }
-        return result;
-    case 5: /* Indirect displacement.  */
-    case 6: /* Indirect index + displacement.  */
-    do_indirect:
-        if (addrp && what == EA_STORE) {
-            tmp = *addrp;
-        } else {
-            tmp = gen_lea_mode(env, s, mode, reg0, opsize);
-            if (IS_NULL_QREG(tmp)) {
-                return tmp;
-            }
-            if (addrp) {
-                *addrp = tmp;
-            }
-        }
-        return gen_ldst(s, opsize, tmp, val, what, index);
+        break;
+
     case 7: /* Other */
-        switch (reg0) {
-        case 0: /* Absolute short.  */
-        case 1: /* Absolute long.  */
-        case 2: /* pc displacement  */
-        case 3: /* pc index+displacement.  */
-            goto do_indirect;
-        case 4: /* Immediate.  */
-            /* Sign extend values for consistency.  */
+        if (reg0 == 4 && what != EA_STORE) {
+            /* Immediate: sign extend values for consistency.  */
             switch (opsize) {
             case OS_BYTE:
                 if (what == EA_LOADS) {
@@ -887,12 +847,37 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
             default:
                 g_assert_not_reached();
             }
-            return tcg_constant_i32(offset);
-        default:
-            return NULL_QREG;
+            ret = tcg_constant_i32(offset);
+            break;
         }
+        /* fall through */
+
+    case 2: /* Indirect register */
+    case 3: /* Indirect postincrement.  */
+    case 4: /* Indirect predecrememnt.  */
+    case 5: /* Indirect displacement.  */
+    case 6: /* Indirect index + displacement.  */
+        if (what == EA_STORE && addrp && *addrp) {
+            addr = *addrp;
+        } else {
+            addr = gen_lea_mode(env, s, mode, reg0, opsize);
+            if (IS_NULL_QREG(addr)) {
+                ret = addr;
+                addr = NULL;
+                break;
+            }
+        }
+        ret = gen_ldst(s, opsize, addr, val, what, index);
+        break;
+
+    default:
+        g_assert_not_reached();
     }
-    g_assert_not_reached();
+
+    if (addrp) {
+        *addrp = addr;
+    }
+    return ret;
 }
 
 static TCGv_ptr gen_fp_ptr(int freg)
@@ -1069,43 +1054,9 @@ static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
         return 0;
     case 1: /* Address register direct.  */
         return -1;
-    case 2: /* Indirect register */
-        addr = get_areg(s, reg0);
-        gen_ldst_fp(s, opsize, addr, fp, what, index);
-        return 0;
-    case 3: /* Indirect postincrement.  */
-        addr = cpu_aregs[reg0];
-        gen_ldst_fp(s, opsize, addr, fp, what, index);
-        tcg_gen_addi_i32(addr, addr, opsize_bytes(opsize));
-        return 0;
-    case 4: /* Indirect predecrememnt.  */
-        addr = gen_lea_mode(env, s, mode, reg0, opsize);
-        if (IS_NULL_QREG(addr)) {
-            return -1;
-        }
-        gen_ldst_fp(s, opsize, addr, fp, what, index);
-        tcg_gen_mov_i32(cpu_aregs[reg0], addr);
-        return 0;
-    case 5: /* Indirect displacement.  */
-    case 6: /* Indirect index + displacement.  */
-    do_indirect:
-        addr = gen_lea_mode(env, s, mode, reg0, opsize);
-        if (IS_NULL_QREG(addr)) {
-            return -1;
-        }
-        gen_ldst_fp(s, opsize, addr, fp, what, index);
-        return 0;
+
     case 7: /* Other */
-        switch (reg0) {
-        case 0: /* Absolute short.  */
-        case 1: /* Absolute long.  */
-        case 2: /* pc displacement  */
-        case 3: /* pc index+displacement.  */
-            goto do_indirect;
-        case 4: /* Immediate.  */
-            if (what == EA_STORE) {
-                return -1;
-            }
+        if (reg0 == 4 && what != EA_STORE) {
             switch (opsize) {
             case OS_BYTE:
                 tmp = tcg_constant_i32((int8_t)read_im8(env, s));
@@ -1148,11 +1099,22 @@ static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
                 g_assert_not_reached();
             }
             return 0;
-        default:
+        }
+        /* fall through */
+
+    case 2: /* Indirect register */
+    case 3: /* Indirect postincrement.  */
+    case 4: /* Indirect predecrememnt.  */
+    case 5: /* Indirect displacement.  */
+    case 6: /* Indirect index + displacement.  */
+        addr = gen_lea_mode(env, s, mode, reg0, opsize);
+        if (IS_NULL_QREG(addr)) {
             return -1;
         }
+        gen_ldst_fp(s, opsize, addr, fp, what, index);
+        return 0;
     }
-    return -1;
+    g_assert_not_reached();
 }
 
 static int gen_ea_fp(CPUM68KState *env, DisasContext *s, uint16_t insn,
@@ -1360,8 +1322,12 @@ static void gen_exit_tb(DisasContext *s)
 
 #define SRC_EA(env, result, opsize, op_sign, addrp)                     \
     do {                                                                \
+        TCGv *addrp_ = (addrp);                                         \
+        if (addrp_) {                                                   \
+            *addrp_ = NULL;                                             \
+        }                                                               \
         result = gen_ea_mode(env, s, extract32(insn, 3, 3),             \
-                             REG(insn, 0), opsize, NULL_QREG, addrp,    \
+                             REG(insn, 0), opsize, NULL_QREG, addrp_,   \
                              op_sign ? EA_LOADS : EA_LOADU, IS_USER(s)); \
         if (IS_NULL_QREG(result)) {                                     \
             gen_addr_fault(s);                                          \
@@ -1730,7 +1696,7 @@ DISAS_INSN(abcd_reg)
 
 DISAS_INSN(abcd_mem)
 {
-    TCGv src, dest, addr;
+    TCGv src, dest, addr = NULL;
 
     gen_flush_flags(s); /* !Z is sticky */
 
@@ -1767,7 +1733,7 @@ DISAS_INSN(sbcd_reg)
 
 DISAS_INSN(sbcd_mem)
 {
-    TCGv src, dest, addr;
+    TCGv src, dest, addr = NULL;
 
     gen_flush_flags(s); /* !Z is sticky */
 
@@ -2356,15 +2322,6 @@ DISAS_INSN(cas)
     /* update flags before setting cmp to load */
     gen_update_cc_cmp(s, load, cmp, opsize);
     gen_partset_reg(opsize, DREG(ext, 0), load);
-
-    switch (extract32(insn, 3, 3)) {
-    case 3: /* Indirect postincrement.  */
-        tcg_gen_addi_i32(AREG(insn, 0), addr, opsize_bytes(opsize));
-        break;
-    case 4: /* Indirect predecrememnt.  */
-        tcg_gen_mov_i32(AREG(insn, 0), addr);
-        break;
-    }
 }
 
 DISAS_INSN(cas2w)
@@ -2728,15 +2685,6 @@ DISAS_INSN(tas)
         tcg_gen_atomic_fetch_or_tl(src1, addr, tcg_constant_tl(0x80),
                                    IS_USER(s), MO_SB);
         gen_logic_cc(s, src1, OS_BYTE);
-
-        switch (mode) {
-        case 3: /* Indirect postincrement.  */
-            tcg_gen_addi_i32(AREG(insn, 0), addr, 1);
-            break;
-        case 4: /* Indirect predecrememnt.  */
-            tcg_gen_mov_i32(AREG(insn, 0), addr);
-            break;
-        }
     }
 }
 
@@ -4453,17 +4401,6 @@ DISAS_INSN(moves)
             gen_partset_reg(opsize, reg, tmp);
         }
     }
-    switch (extract32(insn, 3, 3)) {
-    case 3: /* Indirect postincrement.  */
-        tcg_gen_addi_i32(AREG(insn, 0), addr,
-                         REG(insn, 0) == 7 && opsize == OS_BYTE
-                         ? 2
-                         : opsize_bytes(opsize));
-        break;
-    case 4: /* Indirect predecrememnt.  */
-        tcg_gen_mov_i32(AREG(insn, 0), addr);
-        break;
-    }
 }
 
 DISAS_INSN(move_to_sr)
@@ -4846,7 +4783,7 @@ static void gen_op_fmove_fcr(CPUM68KState *env, DisasContext *s,
                 }
             }
        }
-       tcg_gen_mov_i32(AREG(insn, 0), addr);
+       delay_set_areg(s, REG(insn, 0), addr, true);
     } else {
         for (i = 0; i < 3; i++, mask >>= 1) {
             if (mask & 1) {
@@ -4861,7 +4798,7 @@ static void gen_op_fmove_fcr(CPUM68KState *env, DisasContext *s,
             }
         }
         if (mode == 3) {
-            tcg_gen_mov_i32(AREG(insn, 0), addr);
+            delay_set_areg(s, REG(insn, 0), addr, true);
         }
     }
 }
@@ -4922,7 +4859,7 @@ static void gen_op_fmovem(CPUM68KState *env, DisasContext *s,
         }
     }
     if ((insn & 070) == 030 || (insn & 070) == 040) {
-        tcg_gen_mov_i32(AREG(insn, 0), tmp);
+        delay_set_areg(s, REG(insn, 0), tmp, true);
     }
 }
 
@@ -5572,17 +5509,6 @@ DISAS_INSN(mac)
         TCGv rw;
         rw = (insn & 0x40) ? AREG(insn, 9) : DREG(insn, 9);
         tcg_gen_mov_i32(rw, loadval);
-        /*
-         * FIXME: Should address writeback happen with the masked or
-         * unmasked value?
-         */
-        switch ((insn >> 3) & 7) {
-        case 3: /* Post-increment.  */
-            tcg_gen_addi_i32(AREG(insn, 0), addr, 4);
-            break;
-        case 4: /* Pre-decrement.  */
-            tcg_gen_mov_i32(AREG(insn, 0), addr);
-        }
     }
 }
 
-- 
2.43.0

[PATCH v5 11/24] target/m68k: Split gen_ea_mode for load/store

[Richard Henderson]

Replace with gen_load_mode and gen_store_mode.
Return bool for success from gen_store_mode,
which makes store_dummy unused.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 155 ++++++++++++++++++++--------------------
 1 file changed, 76 insertions(+), 79 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 593ff9ba2d..0abdb1673a 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -60,8 +60,6 @@ static TCGv_i64 cpu_macc[4];
 
 static TCGv NULL_QREG;
 #define IS_NULL_QREG(t) (t == NULL_QREG)
-/* Used to distinguish stores from bad addressing modes.  */
-static TCGv store_dummy;
 
 void m68k_tcg_init(void)
 {
@@ -105,7 +103,6 @@ void m68k_tcg_init(void)
     }
 
     NULL_QREG = tcg_global_mem_new(tcg_env, -4, "NULL");
-    store_dummy = tcg_global_mem_new(tcg_env, -8, "NULL");
 }
 
 /* internal defines */
@@ -339,21 +336,6 @@ typedef enum {
     EA_LOADS
 } ea_what;
 
-/*
- * Generate an unsigned load if VAL is 0 a signed load if val is -1,
- * otherwise generate a store.
- */
-static TCGv gen_ldst(DisasContext *s, int opsize, TCGv addr, TCGv val,
-                     ea_what what, int index)
-{
-    if (what == EA_STORE) {
-        gen_store(s, opsize, addr, val, index);
-        return store_dummy;
-    } else {
-        return gen_load(s, opsize, addr, what == EA_LOADS, index);
-    }
-}
-
 /* Read a 16-bit immediate constant */
 static inline uint16_t read_im16(CPUM68KState *env, DisasContext *s)
 {
@@ -795,9 +777,9 @@ static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
  * a write otherwise it is a read (0 == sign extend, -1 == zero extend).
  * ADDRP is non-null for readwrite operands.
  */
-static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
-                        int opsize, TCGv val, TCGv *addrp, ea_what what,
-                        int index)
+static TCGv gen_load_mode(CPUM68KState *env, DisasContext *s,
+                          int mode, int reg0, int opsize, TCGv *addrp,
+                          int sign, int index)
 {
     TCGv reg, ret, addr = NULL;
     int32_t offset;
@@ -805,40 +787,28 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
     switch (mode) {
     case 0: /* Data register direct.  */
         reg = cpu_dregs[reg0];
-        if (what == EA_STORE) {
-            gen_partset_reg(opsize, reg, val);
-            ret = store_dummy;
-        } else {
-            ret = gen_extend(s, reg, opsize, what == EA_LOADS);
-        }
+        ret = gen_extend(s, reg, opsize, sign);
         break;
 
     case 1: /* Address register direct.  */
         reg = get_areg(s, reg0);
-        if (what == EA_STORE) {
-            tcg_gen_mov_i32(reg, val);
-            ret = store_dummy;
-        } else {
-            ret = gen_extend(s, reg, opsize, what == EA_LOADS);
-        }
+        ret = gen_extend(s, reg, opsize, sign);
         break;
 
     case 7: /* Other */
-        if (reg0 == 4 && what != EA_STORE) {
+        if (reg0 == 4) {
             /* Immediate: sign extend values for consistency.  */
             switch (opsize) {
             case OS_BYTE:
-                if (what == EA_LOADS) {
-                    offset = (int8_t)read_im8(env, s);
-                } else {
-                    offset = read_im8(env, s);
+                offset = read_im8(env, s);
+                if (sign) {
+                    offset = (int8_t)offset;
                 }
                 break;
             case OS_WORD:
-                if (what == EA_LOADS) {
-                    offset = (int16_t)read_im16(env, s);
-                } else {
-                    offset = read_im16(env, s);
+                offset = read_im16(env, s);
+                if (sign) {
+                    offset = (int16_t)offset;
                 }
                 break;
             case OS_LONG:
@@ -857,17 +827,13 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
     case 4: /* Indirect predecrememnt.  */
     case 5: /* Indirect displacement.  */
     case 6: /* Indirect index + displacement.  */
-        if (what == EA_STORE && addrp && *addrp) {
-            addr = *addrp;
-        } else {
-            addr = gen_lea_mode(env, s, mode, reg0, opsize);
-            if (IS_NULL_QREG(addr)) {
-                ret = addr;
-                addr = NULL;
-                break;
-            }
+        addr = gen_lea_mode(env, s, mode, reg0, opsize);
+        if (IS_NULL_QREG(addr)) {
+            ret = addr;
+            addr = NULL;
+            break;
         }
-        ret = gen_ldst(s, opsize, addr, val, what, index);
+        ret = gen_load(s, opsize, addr, sign, index);
         break;
 
     default:
@@ -880,6 +846,43 @@ static TCGv gen_ea_mode(CPUM68KState *env, DisasContext *s, int mode, int reg0,
     return ret;
 }
 
+static bool gen_store_mode(CPUM68KState *env, DisasContext *s,
+                           int mode, int reg0, int opsize,
+                           TCGv val, TCGv addr, int index)
+{
+    TCGv reg;
+
+    switch (mode) {
+    case 0: /* Data register direct.  */
+        reg = cpu_dregs[reg0];
+        gen_partset_reg(opsize, reg, val);
+        return true;
+
+    case 1: /* Address register direct.  */
+        reg = get_areg(s, reg0);
+        tcg_gen_mov_i32(reg, val);
+        return true;
+
+    case 2: /* Indirect register */
+    case 3: /* Indirect postincrement.  */
+    case 4: /* Indirect predecrememnt.  */
+    case 5: /* Indirect displacement.  */
+    case 6: /* Indirect index + displacement.  */
+    case 7: /* Other */
+        if (!addr) {
+            addr = gen_lea_mode(env, s, mode, reg0, opsize);
+            if (IS_NULL_QREG(addr)) {
+                return false;
+            }
+        }
+        gen_store(s, opsize, addr, val, index);
+        return true;
+
+    default:
+        g_assert_not_reached();
+    }
+}
+
 static TCGv_ptr gen_fp_ptr(int freg)
 {
     TCGv_ptr fp = tcg_temp_new_ptr();
@@ -1322,13 +1325,9 @@ static void gen_exit_tb(DisasContext *s)
 
 #define SRC_EA(env, result, opsize, op_sign, addrp)                     \
     do {                                                                \
-        TCGv *addrp_ = (addrp);                                         \
-        if (addrp_) {                                                   \
-            *addrp_ = NULL;                                             \
-        }                                                               \
-        result = gen_ea_mode(env, s, extract32(insn, 3, 3),             \
-                             REG(insn, 0), opsize, NULL_QREG, addrp_,   \
-                             op_sign ? EA_LOADS : EA_LOADU, IS_USER(s)); \
+        result = gen_load_mode(env, s, extract32(insn, 3, 3),           \
+                               REG(insn, 0), opsize, addrp,             \
+                               op_sign, IS_USER(s));                    \
         if (IS_NULL_QREG(result)) {                                     \
             gen_addr_fault(s);                                          \
             return;                                                     \
@@ -1337,10 +1336,10 @@ static void gen_exit_tb(DisasContext *s)
 
 #define DEST_EA(env, insn, opsize, val, addrp)                          \
     do {                                                                \
-        TCGv ea_result = gen_ea_mode(env, s, extract32(insn, 3, 3),     \
-                                     REG(insn, 0), opsize, val, addrp,  \
-                                     EA_STORE, IS_USER(s));             \
-        if (IS_NULL_QREG(ea_result)) {                                  \
+        TCGv *addrp_ = (addrp);                                         \
+        if (!gen_store_mode(env, s, extract32(insn, 3, 3),              \
+                            REG(insn, 0), opsize, val,                  \
+                            addrp_ ? *addrp_ : NULL, IS_USER(s))) {     \
             gen_addr_fault(s);                                          \
             return;                                                     \
         }                                                               \
@@ -1702,15 +1701,14 @@ DISAS_INSN(abcd_mem)
 
     /* Indirect pre-decrement load (mode 4) */
 
-    src = gen_ea_mode(env, s, 4, REG(insn, 0), OS_BYTE,
-                      NULL_QREG, NULL, EA_LOADU, IS_USER(s));
-    dest = gen_ea_mode(env, s, 4, REG(insn, 9), OS_BYTE,
-                       NULL_QREG, &addr, EA_LOADU, IS_USER(s));
+    src = gen_load_mode(env, s, 4, REG(insn, 0), OS_BYTE,
+                        NULL, false, IS_USER(s));
+    dest = gen_load_mode(env, s, 4, REG(insn, 9), OS_BYTE,
+                         &addr, false, IS_USER(s));
 
     bcd_add(dest, src);
 
-    gen_ea_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, &addr,
-                EA_STORE, IS_USER(s));
+    gen_store_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
 
     bcd_flags(dest);
 }
@@ -1739,15 +1737,14 @@ DISAS_INSN(sbcd_mem)
 
     /* Indirect pre-decrement load (mode 4) */
 
-    src = gen_ea_mode(env, s, 4, REG(insn, 0), OS_BYTE,
-                      NULL_QREG, NULL, EA_LOADU, IS_USER(s));
-    dest = gen_ea_mode(env, s, 4, REG(insn, 9), OS_BYTE,
-                       NULL_QREG, &addr, EA_LOADU, IS_USER(s));
+    src = gen_load_mode(env, s, 4, REG(insn, 0), OS_BYTE,
+                        NULL, false, IS_USER(s));
+    dest = gen_load_mode(env, s, 4, REG(insn, 9), OS_BYTE,
+                         &addr, false, IS_USER(s));
 
     bcd_sub(dest, src);
 
-    gen_ea_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, &addr,
-                EA_STORE, IS_USER(s));
+    gen_store_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
 
     bcd_flags(dest);
 }
@@ -3124,11 +3121,11 @@ DISAS_INSN(cmpm)
     TCGv src, dst;
 
     /* Post-increment load (mode 3) from Ay.  */
-    src = gen_ea_mode(env, s, 3, REG(insn, 0), opsize,
-                      NULL_QREG, NULL, EA_LOADS, IS_USER(s));
+    src = gen_load_mode(env, s, 3, REG(insn, 0), opsize,
+                        NULL, true, IS_USER(s));
     /* Post-increment load (mode 3) from Ax.  */
-    dst = gen_ea_mode(env, s, 3, REG(insn, 9), opsize,
-                      NULL_QREG, NULL, EA_LOADS, IS_USER(s));
+    dst = gen_load_mode(env, s, 3, REG(insn, 9), opsize,
+                        NULL, true, IS_USER(s));
 
     gen_update_cc_cmp(s, dst, src, opsize);
 }
-- 
2.43.0

[PATCH v5 12/24] target/m68k: Remove env argument to gen_lea_indexed

[Richard Henderson]

Use the env pointer in DisasContext.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 0abdb1673a..532b050ffa 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -392,7 +392,7 @@ static TCGv gen_addr_index(DisasContext *s, uint16_t ext, TCGv tmp)
  * Handle a base + index + displacement effective address.
  * A NULL_QREG base means pc-relative.
  */
-static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base)
+static TCGv gen_lea_indexed(DisasContext *s, TCGv base)
 {
     uint32_t offset;
     uint16_t ext;
@@ -401,7 +401,7 @@ static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base)
     uint32_t bd, od;
 
     offset = s->pc;
-    ext = read_im16(env, s);
+    ext = read_im16(s->env, s);
 
     if ((ext & 0x800) == 0 && !m68k_feature(s->env, M68K_FEATURE_WORD_INDEX))
         return NULL_QREG;
@@ -419,9 +419,9 @@ static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base)
         if ((ext & 0x30) > 0x10) {
             /* base displacement */
             if ((ext & 0x30) == 0x20) {
-                bd = (int16_t)read_im16(env, s);
+                bd = (int16_t)read_im16(s->env, s);
             } else {
-                bd = read_im32(env, s);
+                bd = read_im32(s->env, s);
             }
         } else {
             bd = 0;
@@ -467,9 +467,9 @@ static TCGv gen_lea_indexed(CPUM68KState *env, DisasContext *s, TCGv base)
             if ((ext & 3) > 1) {
                 /* outer displacement */
                 if ((ext & 3) == 2) {
-                    od = (int16_t)read_im16(env, s);
+                    od = (int16_t)read_im16(s->env, s);
                 } else {
-                    od = read_im32(env, s);
+                    od = read_im32(s->env, s);
                 }
             } else {
                 od = 0;
@@ -738,7 +738,7 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
         return addr;
     case 6: /* Indirect index + displacement.  */
         reg = get_areg(s, reg0);
-        return gen_lea_indexed(env, s, reg);
+        return gen_lea_indexed(s, reg);
     case 7: /* Other */
         switch (reg0) {
         case 0: /* Absolute short.  */
@@ -752,7 +752,7 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
             offset += (int16_t)read_im16(env, s);
             break;
         case 3: /* pc index+displacement.  */
-            return gen_lea_indexed(env, s, NULL_QREG);
+            return gen_lea_indexed(s, NULL_QREG);
         case 4: /* Immediate.  */
         default:
             return NULL_QREG;
-- 
2.43.0

[PATCH v5 13/24] target/m68k: Remove env argument to gen_lea_mode

[Richard Henderson]

Use the env pointer in DisasContext.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 532b050ffa..e0482bdbec 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -694,8 +694,7 @@ static int addr_inc_size(DisasContext *s, int reg0, int opsize)
 /*
  * Generate code for an "effective address".
  */
-static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
-                         int mode, int reg0, int opsize)
+static TCGv gen_lea_mode(DisasContext *s, int mode, int reg0, int opsize)
 {
     TCGv reg, addr, tmp;
     uint16_t ext;
@@ -733,7 +732,7 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
     case 5: /* Indirect displacement.  */
         reg = get_areg(s, reg0);
         addr = tcg_temp_new();
-        ext = read_im16(env, s);
+        ext = read_im16(s->env, s);
         tcg_gen_addi_i32(addr, reg, (int16_t)ext);
         return addr;
     case 6: /* Indirect index + displacement.  */
@@ -742,14 +741,14 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
     case 7: /* Other */
         switch (reg0) {
         case 0: /* Absolute short.  */
-            offset = (int16_t)read_im16(env, s);
+            offset = (int16_t)read_im16(s->env, s);
             break;
         case 1: /* Absolute long.  */
-            offset = read_im32(env, s);
+            offset = read_im32(s->env, s);
             break;
         case 2: /* pc displacement  */
             offset = s->pc;
-            offset += (int16_t)read_im16(env, s);
+            offset += (int16_t)read_im16(s->env, s);
             break;
         case 3: /* pc index+displacement.  */
             return gen_lea_indexed(s, NULL_QREG);
@@ -769,7 +768,7 @@ static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
-    return gen_lea_mode(env, s, mode, reg0, opsize);
+    return gen_lea_mode(s, mode, reg0, opsize);
 }
 
 /*
@@ -827,7 +826,7 @@ static TCGv gen_load_mode(CPUM68KState *env, DisasContext *s,
     case 4: /* Indirect predecrememnt.  */
     case 5: /* Indirect displacement.  */
     case 6: /* Indirect index + displacement.  */
-        addr = gen_lea_mode(env, s, mode, reg0, opsize);
+        addr = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(addr)) {
             ret = addr;
             addr = NULL;
@@ -870,7 +869,7 @@ static bool gen_store_mode(CPUM68KState *env, DisasContext *s,
     case 6: /* Indirect index + displacement.  */
     case 7: /* Other */
         if (!addr) {
-            addr = gen_lea_mode(env, s, mode, reg0, opsize);
+            addr = gen_lea_mode(s, mode, reg0, opsize);
             if (IS_NULL_QREG(addr)) {
                 return false;
             }
@@ -1110,7 +1109,7 @@ static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
     case 4: /* Indirect predecrememnt.  */
     case 5: /* Indirect displacement.  */
     case 6: /* Indirect index + displacement.  */
-        addr = gen_lea_mode(env, s, mode, reg0, opsize);
+        addr = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(addr)) {
             return -1;
         }
@@ -1931,7 +1930,7 @@ DISAS_INSN(movem)
         break;
 
     default:
-        tmp = gen_lea_mode(env, s, mode, reg0, opsize);
+        tmp = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(tmp)) {
             goto do_addr_fault;
         }
@@ -2673,7 +2672,7 @@ DISAS_INSN(tas)
     } else {
         TCGv src1, addr;
 
-        addr = gen_lea_mode(env, s, mode, reg0, OS_BYTE);
+        addr = gen_lea_mode(s, mode, reg0, OS_BYTE);
         if (IS_NULL_QREG(addr)) {
             gen_addr_fault(s);
             return;
-- 
2.43.0

[PATCH v5 14/24] target/m68k: Remove env argument to gen_load_mode

[Richard Henderson]

Use the env pointer in DisasContext.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 31 ++++++++++++-------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index e0482bdbec..ac48329674 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -776,9 +776,8 @@ static TCGv gen_lea(CPUM68KState *env, DisasContext *s, uint16_t insn,
  * a write otherwise it is a read (0 == sign extend, -1 == zero extend).
  * ADDRP is non-null for readwrite operands.
  */
-static TCGv gen_load_mode(CPUM68KState *env, DisasContext *s,
-                          int mode, int reg0, int opsize, TCGv *addrp,
-                          int sign, int index)
+static TCGv gen_load_mode(DisasContext *s, int mode, int reg0, int opsize,
+                          TCGv *addrp, int sign, int index)
 {
     TCGv reg, ret, addr = NULL;
     int32_t offset;
@@ -799,19 +798,19 @@ static TCGv gen_load_mode(CPUM68KState *env, DisasContext *s,
             /* Immediate: sign extend values for consistency.  */
             switch (opsize) {
             case OS_BYTE:
-                offset = read_im8(env, s);
+                offset = read_im8(s->env, s);
                 if (sign) {
                     offset = (int8_t)offset;
                 }
                 break;
             case OS_WORD:
-                offset = read_im16(env, s);
+                offset = read_im16(s->env, s);
                 if (sign) {
                     offset = (int16_t)offset;
                 }
                 break;
             case OS_LONG:
-                offset = read_im32(env, s);
+                offset = read_im32(s->env, s);
                 break;
             default:
                 g_assert_not_reached();
@@ -1324,7 +1323,7 @@ static void gen_exit_tb(DisasContext *s)
 
 #define SRC_EA(env, result, opsize, op_sign, addrp)                     \
     do {                                                                \
-        result = gen_load_mode(env, s, extract32(insn, 3, 3),           \
+        result = gen_load_mode(s, extract32(insn, 3, 3),                \
                                REG(insn, 0), opsize, addrp,             \
                                op_sign, IS_USER(s));                    \
         if (IS_NULL_QREG(result)) {                                     \
@@ -1700,10 +1699,8 @@ DISAS_INSN(abcd_mem)
 
     /* Indirect pre-decrement load (mode 4) */
 
-    src = gen_load_mode(env, s, 4, REG(insn, 0), OS_BYTE,
-                        NULL, false, IS_USER(s));
-    dest = gen_load_mode(env, s, 4, REG(insn, 9), OS_BYTE,
-                         &addr, false, IS_USER(s));
+    src = gen_load_mode(s, 4, REG(insn, 0), OS_BYTE, NULL, false, IS_USER(s));
+    dest = gen_load_mode(s, 4, REG(insn, 9), OS_BYTE, &addr, false, IS_USER(s));
 
     bcd_add(dest, src);
 
@@ -1736,10 +1733,8 @@ DISAS_INSN(sbcd_mem)
 
     /* Indirect pre-decrement load (mode 4) */
 
-    src = gen_load_mode(env, s, 4, REG(insn, 0), OS_BYTE,
-                        NULL, false, IS_USER(s));
-    dest = gen_load_mode(env, s, 4, REG(insn, 9), OS_BYTE,
-                         &addr, false, IS_USER(s));
+    src = gen_load_mode(s, 4, REG(insn, 0), OS_BYTE, NULL, false, IS_USER(s));
+    dest = gen_load_mode(s, 4, REG(insn, 9), OS_BYTE, &addr, false, IS_USER(s));
 
     bcd_sub(dest, src);
 
@@ -3120,11 +3115,9 @@ DISAS_INSN(cmpm)
     TCGv src, dst;
 
     /* Post-increment load (mode 3) from Ay.  */
-    src = gen_load_mode(env, s, 3, REG(insn, 0), opsize,
-                        NULL, true, IS_USER(s));
+    src = gen_load_mode(s, 3, REG(insn, 0), opsize, NULL, true, IS_USER(s));
     /* Post-increment load (mode 3) from Ax.  */
-    dst = gen_load_mode(env, s, 3, REG(insn, 9), opsize,
-                        NULL, true, IS_USER(s));
+    dst = gen_load_mode(s, 3, REG(insn, 9), opsize, NULL, true, IS_USER(s));
 
     gen_update_cc_cmp(s, dst, src, opsize);
 }
-- 
2.43.0

[PATCH v5 15/24] target/m68k: Remove env argument to gen_store_mode

[Richard Henderson]

Use the env pointer in DisasContext.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index ac48329674..dba415acf1 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -844,8 +844,7 @@ static TCGv gen_load_mode(DisasContext *s, int mode, int reg0, int opsize,
     return ret;
 }
 
-static bool gen_store_mode(CPUM68KState *env, DisasContext *s,
-                           int mode, int reg0, int opsize,
+static bool gen_store_mode(DisasContext *s, int mode, int reg0, int opsize,
                            TCGv val, TCGv addr, int index)
 {
     TCGv reg;
@@ -1335,7 +1334,7 @@ static void gen_exit_tb(DisasContext *s)
 #define DEST_EA(env, insn, opsize, val, addrp)                          \
     do {                                                                \
         TCGv *addrp_ = (addrp);                                         \
-        if (!gen_store_mode(env, s, extract32(insn, 3, 3),              \
+        if (!gen_store_mode(s, extract32(insn, 3, 3),                   \
                             REG(insn, 0), opsize, val,                  \
                             addrp_ ? *addrp_ : NULL, IS_USER(s))) {     \
             gen_addr_fault(s);                                          \
@@ -1704,7 +1703,7 @@ DISAS_INSN(abcd_mem)
 
     bcd_add(dest, src);
 
-    gen_store_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
+    gen_store_mode(s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
 
     bcd_flags(dest);
 }
@@ -1738,7 +1737,7 @@ DISAS_INSN(sbcd_mem)
 
     bcd_sub(dest, src);
 
-    gen_store_mode(env, s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
+    gen_store_mode(s, 4, REG(insn, 9), OS_BYTE, dest, addr, IS_USER(s));
 
     bcd_flags(dest);
 }
-- 
2.43.0

[PATCH v5 16/24] target/m68k: Remove env argument to gen_ea_mode_fp

[Richard Henderson]

Use the env pointer in DisasContext.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index dba415acf1..2694620375 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -1012,9 +1012,8 @@ static void gen_ldst_fp(DisasContext *s, int opsize, TCGv addr,
     }
 }
 
-static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
-                          int reg0, int opsize, TCGv_ptr fp, ea_what what,
-                          int index)
+static int gen_ea_mode_fp(DisasContext *s, int mode, int reg0, int opsize,
+                          TCGv_ptr fp, ea_what what, int index)
 {
     TCGv reg, addr, tmp;
     TCGv_i64 t64;
@@ -1059,23 +1058,23 @@ static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
         if (reg0 == 4 && what != EA_STORE) {
             switch (opsize) {
             case OS_BYTE:
-                tmp = tcg_constant_i32((int8_t)read_im8(env, s));
+                tmp = tcg_constant_i32((int8_t)read_im8(s->env, s));
                 gen_helper_exts32(tcg_env, fp, tmp);
                 break;
             case OS_WORD:
-                tmp = tcg_constant_i32((int16_t)read_im16(env, s));
+                tmp = tcg_constant_i32((int16_t)read_im16(s->env, s));
                 gen_helper_exts32(tcg_env, fp, tmp);
                 break;
             case OS_LONG:
-                tmp = tcg_constant_i32(read_im32(env, s));
+                tmp = tcg_constant_i32(read_im32(s->env, s));
                 gen_helper_exts32(tcg_env, fp, tmp);
                 break;
             case OS_SINGLE:
-                tmp = tcg_constant_i32(read_im32(env, s));
+                tmp = tcg_constant_i32(read_im32(s->env, s));
                 gen_helper_extf32(tcg_env, fp, tmp);
                 break;
             case OS_DOUBLE:
-                t64 = tcg_constant_i64(read_im64(env, s));
+                t64 = tcg_constant_i64(read_im64(s->env, s));
                 gen_helper_extf64(tcg_env, fp, t64);
                 break;
             case OS_EXTENDED:
@@ -1083,9 +1082,9 @@ static int gen_ea_mode_fp(CPUM68KState *env, DisasContext *s, int mode,
                     gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
                     break;
                 }
-                tmp = tcg_constant_i32(read_im32(env, s) >> 16);
+                tmp = tcg_constant_i32(read_im32(s->env, s) >> 16);
                 tcg_gen_st16_i32(tmp, fp, offsetof(FPReg, l.upper));
-                t64 = tcg_constant_i64(read_im64(env, s));
+                t64 = tcg_constant_i64(read_im64(s->env, s));
                 tcg_gen_st_i64(t64, fp, offsetof(FPReg, l.lower));
                 break;
             case OS_PACKED:
@@ -1122,7 +1121,7 @@ static int gen_ea_fp(CPUM68KState *env, DisasContext *s, uint16_t insn,
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
-    return gen_ea_mode_fp(env, s, mode, reg0, opsize, fp, what, index);
+    return gen_ea_mode_fp(s, mode, reg0, opsize, fp, what, index);
 }
 
 typedef struct {
-- 
2.43.0

[PATCH v5 17/24] target/m68k: Split gen_ea_mode_fp for load/store

[Richard Henderson]

Replace with gen_load_mode_fp and gen_store_mode_fp.
Return bool for success from the new functions.
Remove gen_ldst_fp and ea_what as unused.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 125 +++++++++++++++++++++-------------------
 1 file changed, 65 insertions(+), 60 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 2694620375..a6afde7f49 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -330,12 +330,6 @@ static inline void gen_store(DisasContext *s, int opsize, TCGv addr, TCGv val,
     }
 }
 
-typedef enum {
-    EA_STORE,
-    EA_LOADU,
-    EA_LOADS
-} ea_what;
-
 /* Read a 16-bit immediate constant */
 static inline uint16_t read_im16(CPUM68KState *env, DisasContext *s)
 {
@@ -1002,60 +996,38 @@ static void gen_store_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp,
     }
 }
 
-static void gen_ldst_fp(DisasContext *s, int opsize, TCGv addr,
-                        TCGv_ptr fp, ea_what what, int index)
-{
-    if (what == EA_STORE) {
-        gen_store_fp(s, opsize, addr, fp, index);
-    } else {
-        gen_load_fp(s, opsize, addr, fp, index);
-    }
-}
-
-static int gen_ea_mode_fp(DisasContext *s, int mode, int reg0, int opsize,
-                          TCGv_ptr fp, ea_what what, int index)
+static bool gen_load_mode_fp(DisasContext *s, uint16_t insn, int opsize,
+                             TCGv_ptr fp, int index)
 {
+    int mode = extract32(insn, 3, 3);
+    int reg0 = REG(insn, 0);
     TCGv reg, addr, tmp;
     TCGv_i64 t64;
 
     switch (mode) {
     case 0: /* Data register direct.  */
         reg = cpu_dregs[reg0];
-        if (what == EA_STORE) {
-            switch (opsize) {
-            case OS_BYTE:
-            case OS_WORD:
-            case OS_LONG:
-                gen_helper_reds32(reg, tcg_env, fp);
-                break;
-            case OS_SINGLE:
-                gen_helper_redf32(reg, tcg_env, fp);
-                break;
-            default:
-                g_assert_not_reached();
-            }
-        } else {
-            tmp = tcg_temp_new();
-            switch (opsize) {
-            case OS_BYTE:
-            case OS_WORD:
-            case OS_LONG:
-                tcg_gen_ext_i32(tmp, reg, opsize | MO_SIGN);
-                gen_helper_exts32(tcg_env, fp, tmp);
-                break;
-            case OS_SINGLE:
-                gen_helper_extf32(tcg_env, fp, reg);
-                break;
-            default:
-                g_assert_not_reached();
-            }
+        tmp = tcg_temp_new();
+        switch (opsize) {
+        case OS_BYTE:
+        case OS_WORD:
+        case OS_LONG:
+            tcg_gen_ext_i32(tmp, reg, opsize | MO_SIGN);
+            gen_helper_exts32(tcg_env, fp, tmp);
+            break;
+        case OS_SINGLE:
+            gen_helper_extf32(tcg_env, fp, reg);
+            break;
+        default:
+            g_assert_not_reached();
         }
-        return 0;
+        return true;
+
     case 1: /* Address register direct.  */
-        return -1;
+        return false;
 
     case 7: /* Other */
-        if (reg0 == 4 && what != EA_STORE) {
+        if (reg0 == 4) {
             switch (opsize) {
             case OS_BYTE:
                 tmp = tcg_constant_i32((int8_t)read_im8(s->env, s));
@@ -1097,7 +1069,7 @@ static int gen_ea_mode_fp(DisasContext *s, int mode, int reg0, int opsize,
             default:
                 g_assert_not_reached();
             }
-            return 0;
+            return true;
         }
         /* fall through */
 
@@ -1108,20 +1080,55 @@ static int gen_ea_mode_fp(DisasContext *s, int mode, int reg0, int opsize,
     case 6: /* Indirect index + displacement.  */
         addr = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(addr)) {
-            return -1;
+            return false;
         }
-        gen_ldst_fp(s, opsize, addr, fp, what, index);
-        return 0;
+        gen_load_fp(s, opsize, addr, fp, index);
+        return true;
     }
     g_assert_not_reached();
 }
 
-static int gen_ea_fp(CPUM68KState *env, DisasContext *s, uint16_t insn,
-                       int opsize, TCGv_ptr fp, ea_what what, int index)
+static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
+                              TCGv_ptr fp, int index)
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
-    return gen_ea_mode_fp(s, mode, reg0, opsize, fp, what, index);
+    TCGv reg, addr;
+
+    switch (mode) {
+    case 0: /* Data register direct.  */
+        reg = cpu_dregs[reg0];
+        switch (opsize) {
+        case OS_BYTE:
+        case OS_WORD:
+        case OS_LONG:
+            gen_helper_reds32(reg, tcg_env, fp);
+            break;
+        case OS_SINGLE:
+            gen_helper_redf32(reg, tcg_env, fp);
+            break;
+        default:
+            g_assert_not_reached();
+        }
+        return true;
+
+    case 1: /* Address register direct.  */
+        return false;
+
+    case 2: /* Indirect register */
+    case 3: /* Indirect postincrement.  */
+    case 4: /* Indirect predecrememnt.  */
+    case 5: /* Indirect displacement.  */
+    case 6: /* Indirect index + displacement.  */
+    case 7: /* Other */
+        addr = gen_lea_mode(s, mode, reg0, opsize);
+        if (IS_NULL_QREG(addr)) {
+            return false;
+        }
+        gen_store_fp(s, opsize, addr, fp, index);
+        return true;
+    }
+    g_assert_not_reached();
 }
 
 typedef struct {
@@ -4880,8 +4887,7 @@ DISAS_INSN(fpu)
     case 3: /* fmove out */
         cpu_src = gen_fp_ptr(REG(ext, 7));
         opsize = ext_opsize(ext, 10);
-        if (gen_ea_fp(env, s, insn, opsize, cpu_src,
-                      EA_STORE, IS_USER(s)) == -1) {
+        if (!gen_store_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
             gen_addr_fault(s);
         }
         gen_helper_ftst(tcg_env, cpu_src);
@@ -4902,8 +4908,7 @@ DISAS_INSN(fpu)
         /* Source effective address.  */
         opsize = ext_opsize(ext, 10);
         cpu_src = gen_fp_result_ptr();
-        if (gen_ea_fp(env, s, insn, opsize, cpu_src,
-                      EA_LOADS, IS_USER(s)) == -1) {
+        if (!gen_load_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
             gen_addr_fault(s);
             return;
         }
-- 
2.43.0

[PATCH v5 18/24] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp

[Richard Henderson]

Move the exception to be raised into the helpers.
This in preparation for raising other exceptions,
and still wanting to return failure.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index a6afde7f49..642e80857c 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -1024,6 +1024,7 @@ static bool gen_load_mode_fp(DisasContext *s, uint16_t insn, int opsize,
         return true;
 
     case 1: /* Address register direct.  */
+        gen_addr_fault(s);
         return false;
 
     case 7: /* Other */
@@ -1080,6 +1081,7 @@ static bool gen_load_mode_fp(DisasContext *s, uint16_t insn, int opsize,
     case 6: /* Indirect index + displacement.  */
         addr = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(addr)) {
+            gen_addr_fault(s);
             return false;
         }
         gen_load_fp(s, opsize, addr, fp, index);
@@ -1113,6 +1115,7 @@ static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
         return true;
 
     case 1: /* Address register direct.  */
+        gen_addr_fault(s);
         return false;
 
     case 2: /* Indirect register */
@@ -1123,6 +1126,7 @@ static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
     case 7: /* Other */
         addr = gen_lea_mode(s, mode, reg0, opsize);
         if (IS_NULL_QREG(addr)) {
+            gen_addr_fault(s);
             return false;
         }
         gen_store_fp(s, opsize, addr, fp, index);
@@ -4887,10 +4891,9 @@ DISAS_INSN(fpu)
     case 3: /* fmove out */
         cpu_src = gen_fp_ptr(REG(ext, 7));
         opsize = ext_opsize(ext, 10);
-        if (!gen_store_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
-            gen_addr_fault(s);
+        if (gen_store_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
+            gen_helper_ftst(tcg_env, cpu_src);
         }
-        gen_helper_ftst(tcg_env, cpu_src);
         return;
     case 4: /* fmove to control register.  */
     case 5: /* fmove from control register.  */
@@ -4909,7 +4912,6 @@ DISAS_INSN(fpu)
         opsize = ext_opsize(ext, 10);
         cpu_src = gen_fp_result_ptr();
         if (!gen_load_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
-            gen_addr_fault(s);
             return;
         }
     } else {
-- 
2.43.0

[PATCH v5 19/24] target/m68k: Merge gen_load_fp, gen_load_mode_fp

[Richard Henderson]

This enables the exceptions raised by the actual load
to be reflected as a failure.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 104 ++++++++++++++++++++--------------------
 1 file changed, 51 insertions(+), 53 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 642e80857c..711f1477c8 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -902,53 +902,6 @@ static void gen_fp_move(TCGv_ptr dest, TCGv_ptr src)
     tcg_gen_st_i64(t64, dest, offsetof(FPReg, l.lower));
 }
 
-static void gen_load_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp,
-                        int index)
-{
-    TCGv tmp;
-    TCGv_i64 t64;
-
-    t64 = tcg_temp_new_i64();
-    tmp = tcg_temp_new();
-    switch (opsize) {
-    case OS_BYTE:
-    case OS_WORD:
-    case OS_LONG:
-        tcg_gen_qemu_ld_tl(tmp, addr, index, opsize | MO_SIGN | MO_TE);
-        gen_helper_exts32(tcg_env, fp, tmp);
-        break;
-    case OS_SINGLE:
-        tcg_gen_qemu_ld_tl(tmp, addr, index, MO_TEUL);
-        gen_helper_extf32(tcg_env, fp, tmp);
-        break;
-    case OS_DOUBLE:
-        tcg_gen_qemu_ld_i64(t64, addr, index, MO_TEUQ);
-        gen_helper_extf64(tcg_env, fp, t64);
-        break;
-    case OS_EXTENDED:
-        if (m68k_feature(s->env, M68K_FEATURE_CF_FPU)) {
-            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-            break;
-        }
-        tcg_gen_qemu_ld_i32(tmp, addr, index, MO_TEUL);
-        tcg_gen_shri_i32(tmp, tmp, 16);
-        tcg_gen_st16_i32(tmp, fp, offsetof(FPReg, l.upper));
-        tcg_gen_addi_i32(tmp, addr, 4);
-        tcg_gen_qemu_ld_i64(t64, tmp, index, MO_TEUQ);
-        tcg_gen_st_i64(t64, fp, offsetof(FPReg, l.lower));
-        break;
-    case OS_PACKED:
-        /*
-         * unimplemented data type on 68040/ColdFire
-         * FIXME if needed for another FPU
-         */
-        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-        break;
-    default:
-        g_assert_not_reached();
-    }
-}
-
 static void gen_store_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp,
                          int index)
 {
@@ -996,8 +949,8 @@ static void gen_store_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp,
     }
 }
 
-static bool gen_load_mode_fp(DisasContext *s, uint16_t insn, int opsize,
-                             TCGv_ptr fp, int index)
+static bool gen_load_fp(DisasContext *s, uint16_t insn, int opsize,
+                        TCGv_ptr fp, int index)
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
@@ -1084,10 +1037,55 @@ static bool gen_load_mode_fp(DisasContext *s, uint16_t insn, int opsize,
             gen_addr_fault(s);
             return false;
         }
-        gen_load_fp(s, opsize, addr, fp, index);
-        return true;
+        break;
+
+    default:
+        g_assert_not_reached();
     }
-    g_assert_not_reached();
+
+    switch (opsize) {
+    case OS_BYTE:
+    case OS_WORD:
+    case OS_LONG:
+        tmp = tcg_temp_new();
+        tcg_gen_qemu_ld_tl(tmp, addr, index, opsize | MO_SIGN | MO_TE);
+        gen_helper_exts32(tcg_env, fp, tmp);
+        break;
+    case OS_SINGLE:
+        tmp = tcg_temp_new();
+        tcg_gen_qemu_ld_tl(tmp, addr, index, MO_TEUL);
+        gen_helper_extf32(tcg_env, fp, tmp);
+        break;
+    case OS_DOUBLE:
+        t64 = tcg_temp_new_i64();
+        tcg_gen_qemu_ld_i64(t64, addr, index, MO_TEUQ);
+        gen_helper_extf64(tcg_env, fp, t64);
+        break;
+    case OS_EXTENDED:
+        if (m68k_feature(s->env, M68K_FEATURE_CF_FPU)) {
+            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+            return false;
+        }
+        tmp = tcg_temp_new();
+        t64 = tcg_temp_new_i64();
+        tcg_gen_qemu_ld_i32(tmp, addr, index, MO_TEUL);
+        tcg_gen_addi_i32(addr, addr, 4);
+        tcg_gen_qemu_ld_i64(t64, addr, index, MO_TEUQ);
+        tcg_gen_shri_i32(tmp, tmp, 16);
+        tcg_gen_st16_i32(tmp, fp, offsetof(FPReg, l.upper));
+        tcg_gen_st_i64(t64, fp, offsetof(FPReg, l.lower));
+        break;
+    case OS_PACKED:
+        /*
+         * unimplemented data type on 68040/ColdFire
+         * FIXME if needed for another FPU
+         */
+        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+        return false;
+    default:
+        g_assert_not_reached();
+    }
+    return true;
 }
 
 static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
@@ -4911,7 +4909,7 @@ DISAS_INSN(fpu)
         /* Source effective address.  */
         opsize = ext_opsize(ext, 10);
         cpu_src = gen_fp_result_ptr();
-        if (!gen_load_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
+        if (!gen_load_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
             return;
         }
     } else {
-- 
2.43.0

[PATCH v5 20/24] target/m68k: Merge gen_store_fp, gen_store_mode_fp

[Richard Henderson]

This enables the exceptions raised by the actual store
to be reflected as a failure.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/translate.c | 107 ++++++++++++++++++++--------------------
 1 file changed, 53 insertions(+), 54 deletions(-)

diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 711f1477c8..af5b20989c 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -902,53 +902,6 @@ static void gen_fp_move(TCGv_ptr dest, TCGv_ptr src)
     tcg_gen_st_i64(t64, dest, offsetof(FPReg, l.lower));
 }
 
-static void gen_store_fp(DisasContext *s, int opsize, TCGv addr, TCGv_ptr fp,
-                         int index)
-{
-    TCGv tmp;
-    TCGv_i64 t64;
-
-    t64 = tcg_temp_new_i64();
-    tmp = tcg_temp_new();
-    switch (opsize) {
-    case OS_BYTE:
-    case OS_WORD:
-    case OS_LONG:
-        gen_helper_reds32(tmp, tcg_env, fp);
-        tcg_gen_qemu_st_tl(tmp, addr, index, opsize | MO_TE);
-        break;
-    case OS_SINGLE:
-        gen_helper_redf32(tmp, tcg_env, fp);
-        tcg_gen_qemu_st_tl(tmp, addr, index, MO_TEUL);
-        break;
-    case OS_DOUBLE:
-        gen_helper_redf64(t64, tcg_env, fp);
-        tcg_gen_qemu_st_i64(t64, addr, index, MO_TEUQ);
-        break;
-    case OS_EXTENDED:
-        if (m68k_feature(s->env, M68K_FEATURE_CF_FPU)) {
-            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-            break;
-        }
-        tcg_gen_ld16u_i32(tmp, fp, offsetof(FPReg, l.upper));
-        tcg_gen_shli_i32(tmp, tmp, 16);
-        tcg_gen_qemu_st_i32(tmp, addr, index, MO_TEUL);
-        tcg_gen_addi_i32(tmp, addr, 4);
-        tcg_gen_ld_i64(t64, fp, offsetof(FPReg, l.lower));
-        tcg_gen_qemu_st_i64(t64, tmp, index, MO_TEUQ);
-        break;
-    case OS_PACKED:
-        /*
-         * unimplemented data type on 68040/ColdFire
-         * FIXME if needed for another FPU
-         */
-        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-        break;
-    default:
-        g_assert_not_reached();
-    }
-}
-
 static bool gen_load_fp(DisasContext *s, uint16_t insn, int opsize,
                         TCGv_ptr fp, int index)
 {
@@ -1088,12 +1041,13 @@ static bool gen_load_fp(DisasContext *s, uint16_t insn, int opsize,
     return true;
 }
 
-static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
-                              TCGv_ptr fp, int index)
+static bool gen_store_fp(DisasContext *s, uint16_t insn, int opsize,
+                         TCGv_ptr fp, int index)
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
-    TCGv reg, addr;
+    TCGv reg, addr, tmp;
+    TCGv_i64 t64;
 
     switch (mode) {
     case 0: /* Data register direct.  */
@@ -1127,10 +1081,55 @@ static bool gen_store_mode_fp(DisasContext *s, uint16_t insn, int opsize,
             gen_addr_fault(s);
             return false;
         }
-        gen_store_fp(s, opsize, addr, fp, index);
-        return true;
+        break;
+
+    default:
+        g_assert_not_reached();
     }
-    g_assert_not_reached();
+
+    switch (opsize) {
+    case OS_BYTE:
+    case OS_WORD:
+    case OS_LONG:
+        tmp = tcg_temp_new();
+        gen_helper_reds32(tmp, tcg_env, fp);
+        tcg_gen_qemu_st_tl(tmp, addr, index, opsize | MO_TE);
+        break;
+    case OS_SINGLE:
+        tmp = tcg_temp_new();
+        gen_helper_redf32(tmp, tcg_env, fp);
+        tcg_gen_qemu_st_tl(tmp, addr, index, MO_TEUL);
+        break;
+    case OS_DOUBLE:
+        t64 = tcg_temp_new_i64();
+        gen_helper_redf64(t64, tcg_env, fp);
+        tcg_gen_qemu_st_i64(t64, addr, index, MO_TEUQ);
+        break;
+    case OS_EXTENDED:
+        if (m68k_feature(s->env, M68K_FEATURE_CF_FPU)) {
+            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+            return false;
+        }
+        tmp = tcg_temp_new();
+        t64 = tcg_temp_new_i64();
+        tcg_gen_ld16u_i32(tmp, fp, offsetof(FPReg, l.upper));
+        tcg_gen_shli_i32(tmp, tmp, 16);
+        tcg_gen_qemu_st_i32(tmp, addr, index, MO_TEUL);
+        tcg_gen_addi_i32(addr, addr, 4);
+        tcg_gen_ld_i64(t64, fp, offsetof(FPReg, l.lower));
+        tcg_gen_qemu_st_i64(t64, addr, index, MO_TEUQ);
+        break;
+    case OS_PACKED:
+        /*
+         * unimplemented data type on 68040/ColdFire
+         * FIXME if needed for another FPU
+         */
+        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+        return false;
+    default:
+        g_assert_not_reached();
+    }
+    return true;
 }
 
 typedef struct {
@@ -4889,7 +4888,7 @@ DISAS_INSN(fpu)
     case 3: /* fmove out */
         cpu_src = gen_fp_ptr(REG(ext, 7));
         opsize = ext_opsize(ext, 10);
-        if (gen_store_mode_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
+        if (gen_store_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
             gen_helper_ftst(tcg_env, cpu_src);
         }
         return;
-- 
2.43.0

[PATCH v5 21/24] target/m68k: Implement packed decimal real loads and stores

[Richard Henderson]

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2488
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.h                |    1 +
 target/m68k/helper.h             |    3 +
 target/m68k/fpu_helper.c         |  237 ++
 target/m68k/gen-floatx80-pow10.c |   33 +
 target/m68k/translate.c          |   55 +-
 target/m68k/floatx80-pow10.c.inc | 4935 ++++++++++++++++++++++++++++++
 6 files changed, 5246 insertions(+), 18 deletions(-)
 create mode 100644 target/m68k/gen-floatx80-pow10.c
 create mode 100644 target/m68k/floatx80-pow10.c.inc

diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index 8adb1c6515..8c23d772e4 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -108,6 +108,7 @@ typedef struct CPUArchState {
     FPReg fp_result;
     uint32_t fpcr;
     uint32_t fpsr;
+    bool fpsr_inex1;  /* live only with an in-flight decimal operand */
     float_status fp_status;
 
     uint64_t mactmp;
diff --git a/target/m68k/helper.h b/target/m68k/helper.h
index 2bbe0dc032..b3d9d78f80 100644
--- a/target/m68k/helper.h
+++ b/target/m68k/helper.h
@@ -124,6 +124,9 @@ DEF_HELPER_FLAGS_4(bfffo_mem, TCG_CALL_NO_WG, i64, env, i32, s32, i32)
 DEF_HELPER_3(chk, void, env, s32, s32)
 DEF_HELPER_4(chk2, void, env, s32, s32, s32)
 
+DEF_HELPER_FLAGS_3(load_pdr_to_fx80, TCG_CALL_NO_RWG, void, env, fp, tl)
+DEF_HELPER_FLAGS_4(store_fx80_to_pdr, TCG_CALL_NO_RWG, void, env, tl, fp, int)
+
 #if !defined(CONFIG_USER_ONLY)
 DEF_HELPER_3(ptest, void, env, i32, i32)
 DEF_HELPER_3(pflush, void, env, i32, i32)
diff --git a/target/m68k/fpu_helper.c b/target/m68k/fpu_helper.c
index e63fd3ec11..9381a51786 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -192,6 +192,13 @@ static void update_fpsr(CPUM68KState *env, int cc)
             fpsr |= FPSR_EXC_INEX2 | FPSR_AEXC_INEX;
         }
     }
+
+    /* Incorporate packed decimal real inexact conversion. */
+    if (env->fpsr_inex1) {
+        env->fpsr_inex1 = false;
+        fpsr |= FPSR_EXC_INEX1 | FPSR_AEXC_INEX;
+    }
+
     env->fpsr = fpsr;
 }
 
@@ -708,3 +715,233 @@ void HELPER(fcosh)(CPUM68KState *env, FPReg *res, FPReg *val)
 {
     res->d = floatx80_cosh(val->d, &env->fp_status);
 }
+
+static const floatx80 floatx80_pow10[] = {
+#include "floatx80-pow10.c.inc"
+};
+
+static floatx80 floatx80_scale10i(floatx80 x, int e, float_status *status)
+{
+    if (e == 0) {
+        return x;
+    }
+    if (e < 0) {
+        e = -e;
+        assert(e < ARRAY_SIZE(floatx80_pow10));
+        return floatx80_div(x, floatx80_pow10[e], status);
+    } else if (e < ARRAY_SIZE(floatx80_pow10)) {
+        return floatx80_mul(x, floatx80_pow10[e], status);
+    } else {
+        /*
+         * Because of denormals, we may need to scale up more than
+         * is possible with one multiplication.  Do the best we can.
+         */
+        int e0 = ARRAY_SIZE(floatx80_pow10) - 1;
+        int e1 = e - e0;
+        x = floatx80_mul(x, floatx80_pow10[e0], status);
+        return floatx80_mul(x, floatx80_pow10[e1], status);
+    }
+}
+
+void HELPER(load_pdr_to_fx80)(CPUM68KState *env, FPReg *res, target_ulong addr)
+{
+    float_status status;
+    uint64_t lo;
+    uint32_t hi;
+    int64_t mant;
+    int exp;
+    floatx80 t;
+
+    hi = cpu_ldl_be_data_ra(env, addr, GETPC());
+    lo = cpu_ldq_be_data_ra(env, addr + 4, GETPC());
+
+    if (unlikely((hi & 0x7fff0000) == 0x7fff0000)) {
+        /* NaN or Inf */
+        res->l.lower = lo;
+        res->l.upper = hi >> 16;
+        return;
+    }
+
+    /* Initialize mant with the integer digit. */
+    mant = hi & 0xf;
+    if (!mant && !lo) {
+        /* +/- 0, regardless of exponent. */
+        res->l.lower = 0;
+        res->l.upper = (hi >> 16) & 0x8000;
+        return;
+    }
+
+    /*
+     * Accumulate the 16 decimal fraction digits into mant.
+     * With 17 decimal digits, the maximum value is 10**17 - 1,
+     * which is less than 2**57.
+     */
+    for (int i = 60; i >= 0; i -= 4) {
+        /*
+         * From 1.6.6 Data Format and Type Summary:
+         * The fpu does not detect non-decimal digits in any of the exponent,
+         * integer, or fraction digits.  These non-decimal digits are converted
+         * in the same manner as decimal digits; the result is probably useless
+         * although it is repeatable.
+         */
+        mant = mant * 10 + ((lo >> i) & 0xf);
+    }
+
+    /* Apply the mantissa sign. */
+    if (hi & 0x80000000) {
+        mant = -mant;
+    }
+
+    /* Convert the 3 digit decimal exponent to binary. */
+    exp = ((hi >> 24) & 0xf)
+        + ((hi >> 20) & 0xf) * 10
+        + ((hi >> 16) & 0xf) * 100;
+
+    /* Apply the exponent sign. */
+    if (hi & 0x40000000) {
+        exp = -exp;
+    }
+
+    /*
+     * Our representation of mant is integral, whereas the decimal point
+     * belongs between the integer and fractional components.
+     * Adjust the exponent to compensate.
+     */
+    exp -= 16;
+
+    status = env->fp_status;
+    set_floatx80_rounding_precision(floatx80_precision_x, &status);
+    set_float_exception_flags(0, &status);
+
+    /* Convert mantissa and apply exponent. */
+    t = int64_to_floatx80(mant, &status),
+    res->d = floatx80_scale10i(t, exp, &status);
+
+    /*
+     * The only exception bit that is relevant is inexact.
+     * All of the rest will be collected from the result.
+     */
+    env->fpsr_inex1 = get_float_exception_flags(&status) & float_flag_inexact;
+}
+
+#define KFACTOR_MIN  1
+#define KFACTOR_MAX  17
+
+void HELPER(store_fx80_to_pdr)(CPUM68KState *env, target_ulong addr,
+                               FPReg *srcp, int kfactor)
+{
+    /* 10**0 through 10**17 */
+    static const int64_t i64_pow10[KFACTOR_MAX + 1] = {
+        1ll,
+        10ll,
+        100ll,
+        1000ll,
+        10000ll,
+        100000ll,
+        1000000ll,
+        10000000ll,
+        100000000ll,
+        1000000000ll,
+        10000000000ll,
+        100000000000ll,
+        1000000000000ll,
+        10000000000000ll,
+        100000000000000ll,
+        1000000000000000ll,
+        10000000000000000ll,
+        100000000000000000ll,
+    };
+
+    float_status status;
+    floatx80 x = srcp->d;
+    int len, exp2, exp10;
+    uint64_t res_lo;
+    uint32_t res_hi;
+    int64_t y;
+
+    res_lo = x.low;
+    exp2 = x.high & 0x7fff;
+    if (unlikely(exp2 == 0x7fff)) {
+        /* NaN and Inf */
+        res_hi = (uint32_t)x.high << 16;
+        goto done;
+    }
+
+    /* Copy the sign bit to the output, and then x = abs(x). */
+    res_hi = (x.high & 0x8000u) << 16;
+    x.high &= 0x7fff;
+
+    if (exp2 == 0) {
+        if (res_lo == 0) {
+            /* +/- 0 */
+            goto done;
+        }
+        /* denormal */
+        exp2 = -0x3fff - clz64(res_lo);
+    } else {
+        exp2 -= 0x3fff;
+    }
+
+    status = env->fp_status;
+    set_floatx80_rounding_precision(floatx80_precision_x, &status);
+
+    /*
+     * Begin with an approximation of log2(x) via the base 2 exponent.
+     * Scale, such that the value is integral in the number of digits
+     * we wish to extract.
+     */
+    exp10 = (exp2 * 30102) / 100000;
+    while (1) {
+        floatx80 t;
+
+        /* kfactor controls the number of output digits */
+        if (kfactor <= 0) {
+            /* kfactor is number of digits right of the decimal point. */
+            len = exp10 - kfactor;
+        } else {
+            /* kfactor is number of significant digits */
+            len = kfactor;
+        }
+        len = MIN(MAX(len, KFACTOR_MIN), KFACTOR_MAX);
+
+        /*
+         * Scale, so that we have the requested number of digits
+         * left of the decimal point.  Convert to integer, which
+         * handles the rounding (and may force adjustment of exp10).
+         */
+        set_float_exception_flags(0, &status);
+        t = floatx80_scale10i(x, len - 1 - exp10, &status);
+        y = floatx80_to_int64(t, &status);
+        if (y < i64_pow10[len - 1]) {
+            exp10--;
+        } else if (y < i64_pow10[len]) {
+            break;
+        } else {
+            exp10++;
+        }
+    }
+
+    /* The only exception bit that is relevant is inexact. */
+    env->fpsr_inex1 = get_float_exception_flags(&status) & float_flag_inexact;
+
+    /* Output the mantissa. */
+    res_hi |= y / i64_pow10[len - 1];
+    res_lo = 0;
+    for (int i = 1; i < len; ++i) {
+        int64_t d = (y / i64_pow10[len - 1 - i]) % 10;
+        res_lo |= d << (64 - i * 4);
+    }
+
+    /* Output the exponent. */
+    if (exp10 < 0) {
+        res_hi |= 0x40000000;
+        exp10 = -exp10;
+    }
+    for (int i = 24; exp10; i -= 4, exp10 /= 10) {
+        res_hi |= (exp10 % 10) << i;
+    }
+
+ done:
+    cpu_stl_be_data_ra(env, addr, res_hi, GETPC());
+    cpu_stq_be_data_ra(env, addr + 4, res_lo, GETPC());
+}
diff --git a/target/m68k/gen-floatx80-pow10.c b/target/m68k/gen-floatx80-pow10.c
new file mode 100644
index 0000000000..903677ee2c
--- /dev/null
+++ b/target/m68k/gen-floatx80-pow10.c
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * Generator for floatx80-pow10.c.inc, using glibc's multi-precision
+ * integer arithmetic in stdio for correct rounding.
+ * Only works on x86 host, so not integrated into the build process.
+ */
+
+#include <stdio.h>
+#include <float.h>
+
+int main()
+{
+    printf("/* Automatically generated by gen-floatx80-pow10.c"
+           " - do not modify. */\n\n");
+
+    for (int i = 0; i <= LDBL_MAX_10_EXP; ++i) {
+        char buf[32];
+        union {
+            long double d;
+            struct {
+                unsigned l;
+                unsigned m;
+                unsigned short h;
+            } i;
+        } u = { };
+
+        snprintf(buf, sizeof(buf), "1e%d", i);
+        sscanf(buf, "%Le", &u.d);
+        printf("/* %4d */ make_floatx80_init(0x%04x, 0x%08x%08x),\n",
+               i, u.i.h, u.i.m, u.i.l);
+    }
+    return 0;
+}
diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index af5b20989c..44c1b3c0cf 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -648,6 +648,7 @@ static inline int ext_opsize(int ext, int pos)
     case 4: return OS_WORD;
     case 5: return OS_DOUBLE;
     case 6: return OS_BYTE;
+    case 7: return OS_PACKED; /* store, dynamic k-factor */
     default:
         g_assert_not_reached();
     }
@@ -967,11 +968,13 @@ static bool gen_load_fp(DisasContext *s, uint16_t insn, int opsize,
                 tcg_gen_st_i64(t64, fp, offsetof(FPReg, l.lower));
                 break;
             case OS_PACKED:
-                /*
-                 * unimplemented data type on 68040/ColdFire
-                 * FIXME if needed for another FPU
-                 */
-                gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+                if (!m68k_feature(s->env, M68K_FEATURE_FPU_PACKED_DECIMAL)) {
+                    gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+                    break;
+                }
+                tmp = tcg_constant_tl(s->pc);
+                s->pc += 12;
+                gen_helper_load_pdr_to_fx80(tcg_env, fp, tmp);
                 break;
             default:
                 g_assert_not_reached();
@@ -1029,20 +1032,20 @@ static bool gen_load_fp(DisasContext *s, uint16_t insn, int opsize,
         tcg_gen_st_i64(t64, fp, offsetof(FPReg, l.lower));
         break;
     case OS_PACKED:
-        /*
-         * unimplemented data type on 68040/ColdFire
-         * FIXME if needed for another FPU
-         */
-        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-        return false;
+        if (!m68k_feature(s->env, M68K_FEATURE_FPU_PACKED_DECIMAL)) {
+            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+            return false;
+        }
+        gen_helper_load_pdr_to_fx80(tcg_env, fp, addr);
+        break;
     default:
         g_assert_not_reached();
     }
     return true;
 }
 
-static bool gen_store_fp(DisasContext *s, uint16_t insn, int opsize,
-                         TCGv_ptr fp, int index)
+static bool gen_store_fp(DisasContext *s, uint16_t insn, uint16_t ext,
+                         int opsize, TCGv_ptr fp, int index)
 {
     int mode = extract32(insn, 3, 3);
     int reg0 = REG(insn, 0);
@@ -1120,12 +1123,27 @@ static bool gen_store_fp(DisasContext *s, uint16_t insn, int opsize,
         tcg_gen_qemu_st_i64(t64, addr, index, MO_TEUQ);
         break;
     case OS_PACKED:
+        if (!m68k_feature(s->env, M68K_FEATURE_FPU_PACKED_DECIMAL)) {
+            gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
+            return false;
+        }
         /*
-         * unimplemented data type on 68040/ColdFire
-         * FIXME if needed for another FPU
+         * For stores we must recover k-factor, either from an
+         * immediate or the low 7 bits of a D register.
          */
-        gen_exception(s, s->base.pc_next, EXCP_FP_UNIMP);
-        return false;
+        switch ((ext >> 10) & 7) {
+        case 3:
+            tmp = tcg_constant_i32(sextract32(ext, 0, 7));
+            break;
+        case 7:
+            tmp = tcg_temp_new();
+            tcg_gen_sextract_i32(tmp, DREG(ext, 4), 0, 7);
+            break;
+        default:
+            g_assert_not_reached();
+        }
+        gen_helper_store_fx80_to_pdr(tcg_env, addr, fp, tmp);
+        break;
     default:
         g_assert_not_reached();
     }
@@ -4870,6 +4888,7 @@ DISAS_INSN(fpu)
     TCGv_ptr cpu_src, cpu_dest;
 
     ext = read_im16(env, s);
+
     opmode = ext & 0x7f;
     switch ((ext >> 13) & 7) {
     case 0:
@@ -4888,7 +4907,7 @@ DISAS_INSN(fpu)
     case 3: /* fmove out */
         cpu_src = gen_fp_ptr(REG(ext, 7));
         opsize = ext_opsize(ext, 10);
-        if (gen_store_fp(s, insn, opsize, cpu_src, IS_USER(s))) {
+        if (gen_store_fp(s, insn, ext, opsize, cpu_src, IS_USER(s))) {
             gen_helper_ftst(tcg_env, cpu_src);
         }
         return;
diff --git a/target/m68k/floatx80-pow10.c.inc b/target/m68k/floatx80-pow10.c.inc
new file mode 100644
index 0000000000..dfc2a62288
--- /dev/null
+++ b/target/m68k/floatx80-pow10.c.inc
@@ -0,0 +1,4935 @@
+/* Automatically generated by gen-floatx80-pow10.c - do not modify. */
+
+/*    0 */ make_floatx80_init(0x3fff, 0x8000000000000000),
+/*    1 */ make_floatx80_init(0x4002, 0xa000000000000000),
+/*    2 */ make_floatx80_init(0x4005, 0xc800000000000000),
+/*    3 */ make_floatx80_init(0x4008, 0xfa00000000000000),
+/*    4 */ make_floatx80_init(0x400c, 0x9c40000000000000),
+/*    5 */ make_floatx80_init(0x400f, 0xc350000000000000),
+/*    6 */ make_floatx80_init(0x4012, 0xf424000000000000),
+/*    7 */ make_floatx80_init(0x4016, 0x9896800000000000),
+/*    8 */ make_floatx80_init(0x4019, 0xbebc200000000000),
+/*    9 */ make_floatx80_init(0x401c, 0xee6b280000000000),
+/*   10 */ make_floatx80_init(0x4020, 0x9502f90000000000),
+/*   11 */ make_floatx80_init(0x4023, 0xba43b74000000000),
+/*   12 */ make_floatx80_init(0x4026, 0xe8d4a51000000000),
+/*   13 */ make_floatx80_init(0x402a, 0x9184e72a00000000),
+/*   14 */ make_floatx80_init(0x402d, 0xb5e620f480000000),
+/*   15 */ make_floatx80_init(0x4030, 0xe35fa931a0000000),
+/*   16 */ make_floatx80_init(0x4034, 0x8e1bc9bf04000000),
+/*   17 */ make_floatx80_init(0x4037, 0xb1a2bc2ec5000000),
+/*   18 */ make_floatx80_init(0x403a, 0xde0b6b3a76400000),
+/*   19 */ make_floatx80_init(0x403e, 0x8ac7230489e80000),
+/*   20 */ make_floatx80_init(0x4041, 0xad78ebc5ac620000),
+/*   21 */ make_floatx80_init(0x4044, 0xd8d726b7177a8000),
+/*   22 */ make_floatx80_init(0x4048, 0x878678326eac9000),
+/*   23 */ make_floatx80_init(0x404b, 0xa968163f0a57b400),
+/*   24 */ make_floatx80_init(0x404e, 0xd3c21bcecceda100),
+/*   25 */ make_floatx80_init(0x4052, 0x84595161401484a0),
+/*   26 */ make_floatx80_init(0x4055, 0xa56fa5b99019a5c8),
+/*   27 */ make_floatx80_init(0x4058, 0xcecb8f27f4200f3a),
+/*   28 */ make_floatx80_init(0x405c, 0x813f3978f8940984),
+/*   29 */ make_floatx80_init(0x405f, 0xa18f07d736b90be5),
+/*   30 */ make_floatx80_init(0x4062, 0xc9f2c9cd04674edf),
+/*   31 */ make_floatx80_init(0x4065, 0xfc6f7c4045812296),
+/*   32 */ make_floatx80_init(0x4069, 0x9dc5ada82b70b59e),
+/*   33 */ make_floatx80_init(0x406c, 0xc5371912364ce305),
+/*   34 */ make_floatx80_init(0x406f, 0xf684df56c3e01bc7),
+/*   35 */ make_floatx80_init(0x4073, 0x9a130b963a6c115c),
+/*   36 */ make_floatx80_init(0x4076, 0xc097ce7bc90715b3),
+/*   37 */ make_floatx80_init(0x4079, 0xf0bdc21abb48db20),
+/*   38 */ make_floatx80_init(0x407d, 0x96769950b50d88f4),
+/*   39 */ make_floatx80_init(0x4080, 0xbc143fa4e250eb31),
+/*   40 */ make_floatx80_init(0x4083, 0xeb194f8e1ae525fd),
+/*   41 */ make_floatx80_init(0x4087, 0x92efd1b8d0cf37be),
+/*   42 */ make_floatx80_init(0x408a, 0xb7abc627050305ae),
+/*   43 */ make_floatx80_init(0x408d, 0xe596b7b0c643c719),
+/*   44 */ make_floatx80_init(0x4091, 0x8f7e32ce7bea5c70),
+/*   45 */ make_floatx80_init(0x4094, 0xb35dbf821ae4f38c),
+/*   46 */ make_floatx80_init(0x4097, 0xe0352f62a19e306f),
+/*   47 */ make_floatx80_init(0x409b, 0x8c213d9da502de45),
+/*   48 */ make_floatx80_init(0x409e, 0xaf298d050e4395d7),
+/*   49 */ make_floatx80_init(0x40a1, 0xdaf3f04651d47b4c),
+/*   50 */ make_floatx80_init(0x40a5, 0x88d8762bf324cd10),
+/*   51 */ make_floatx80_init(0x40a8, 0xab0e93b6efee0054),
+/*   52 */ make_floatx80_init(0x40ab, 0xd5d238a4abe98068),
+/*   53 */ make_floatx80_init(0x40af, 0x85a36366eb71f041),
+/*   54 */ make_floatx80_init(0x40b2, 0xa70c3c40a64e6c52),
+/*   55 */ make_floatx80_init(0x40b5, 0xd0cf4b50cfe20766),
+/*   56 */ make_floatx80_init(0x40b9, 0x82818f1281ed44a0),
+/*   57 */ make_floatx80_init(0x40bc, 0xa321f2d7226895c8),
+/*   58 */ make_floatx80_init(0x40bf, 0xcbea6f8ceb02bb3a),
+/*   59 */ make_floatx80_init(0x40c2, 0xfee50b7025c36a08),
+/*   60 */ make_floatx80_init(0x40c6, 0x9f4f2726179a2245),
+/*   61 */ make_floatx80_init(0x40c9, 0xc722f0ef9d80aad6),
+/*   62 */ make_floatx80_init(0x40cc, 0xf8ebad2b84e0d58c),
+/*   63 */ make_floatx80_init(0x40d0, 0x9b934c3b330c8577),
+/*   64 */ make_floatx80_init(0x40d3, 0xc2781f49ffcfa6d5),
+/*   65 */ make_floatx80_init(0x40d6, 0xf316271c7fc3908b),
+/*   66 */ make_floatx80_init(0x40da, 0x97edd871cfda3a57),
+/*   67 */ make_floatx80_init(0x40dd, 0xbde94e8e43d0c8ec),
+/*   68 */ make_floatx80_init(0x40e0, 0xed63a231d4c4fb27),
+/*   69 */ make_floatx80_init(0x40e4, 0x945e455f24fb1cf9),
+/*   70 */ make_floatx80_init(0x40e7, 0xb975d6b6ee39e437),
+/*   71 */ make_floatx80_init(0x40ea, 0xe7d34c64a9c85d44),
+/*   72 */ make_floatx80_init(0x40ee, 0x90e40fbeea1d3a4b),
+/*   73 */ make_floatx80_init(0x40f1, 0xb51d13aea4a488dd),
+/*   74 */ make_floatx80_init(0x40f4, 0xe264589a4dcdab15),
+/*   75 */ make_floatx80_init(0x40f8, 0x8d7eb76070a08aed),
+/*   76 */ make_floatx80_init(0x40fb, 0xb0de65388cc8ada8),
+/*   77 */ make_floatx80_init(0x40fe, 0xdd15fe86affad912),
+/*   78 */ make_floatx80_init(0x4102, 0x8a2dbf142dfcc7ab),
+/*   79 */ make_floatx80_init(0x4105, 0xacb92ed9397bf996),
+/*   80 */ make_floatx80_init(0x4108, 0xd7e77a8f87daf7fc),
+/*   81 */ make_floatx80_init(0x410c, 0x86f0ac99b4e8dafd),
+/*   82 */ make_floatx80_init(0x410f, 0xa8acd7c0222311bd),
+/*   83 */ make_floatx80_init(0x4112, 0xd2d80db02aabd62c),
+/*   84 */ make_floatx80_init(0x4116, 0x83c7088e1aab65db),
+/*   85 */ make_floatx80_init(0x4119, 0xa4b8cab1a1563f52),
+/*   86 */ make_floatx80_init(0x411c, 0xcde6fd5e09abcf27),
+/*   87 */ make_floatx80_init(0x4120, 0x80b05e5ac60b6178),
+/*   88 */ make_floatx80_init(0x4123, 0xa0dc75f1778e39d6),
+/*   89 */ make_floatx80_init(0x4126, 0xc913936dd571c84c),
+/*   90 */ make_floatx80_init(0x4129, 0xfb5878494ace3a5f),
+/*   91 */ make_floatx80_init(0x412d, 0x9d174b2dcec0e47b),
+/*   92 */ make_floatx80_init(0x4130, 0xc45d1df942711d9a),
+/*   93 */ make_floatx80_init(0x4133, 0xf5746577930d6501),
+/*   94 */ make_floatx80_init(0x4137, 0x9968bf6abbe85f20),
+/*   95 */ make_floatx80_init(0x413a, 0xbfc2ef456ae276e9),
+/*   96 */ make_floatx80_init(0x413d, 0xefb3ab16c59b14a3),
+/*   97 */ make_floatx80_init(0x4141, 0x95d04aee3b80ece6),
+/*   98 */ make_floatx80_init(0x4144, 0xbb445da9ca61281f),
+/*   99 */ make_floatx80_init(0x4147, 0xea1575143cf97227),
+/*  100 */ make_floatx80_init(0x414b, 0x924d692ca61be758),
+/*  101 */ make_floatx80_init(0x414e, 0xb6e0c377cfa2e12e),
+/*  102 */ make_floatx80_init(0x4151, 0xe498f455c38b997a),
+/*  103 */ make_floatx80_init(0x4155, 0x8edf98b59a373fec),
+/*  104 */ make_floatx80_init(0x4158, 0xb2977ee300c50fe7),
+/*  105 */ make_floatx80_init(0x415b, 0xdf3d5e9bc0f653e1),
+/*  106 */ make_floatx80_init(0x415f, 0x8b865b215899f46d),
+/*  107 */ make_floatx80_init(0x4162, 0xae67f1e9aec07188),
+/*  108 */ make_floatx80_init(0x4165, 0xda01ee641a708dea),
+/*  109 */ make_floatx80_init(0x4169, 0x884134fe908658b2),
+/*  110 */ make_floatx80_init(0x416c, 0xaa51823e34a7eedf),
+/*  111 */ make_floatx80_init(0x416f, 0xd4e5e2cdc1d1ea96),
+/*  112 */ make_floatx80_init(0x4173, 0x850fadc09923329e),
+/*  113 */ make_floatx80_init(0x4176, 0xa6539930bf6bff46),
+/*  114 */ make_floatx80_init(0x4179, 0xcfe87f7cef46ff17),
+/*  115 */ make_floatx80_init(0x417d, 0x81f14fae158c5f6e),
+/*  116 */ make_floatx80_init(0x4180, 0xa26da3999aef774a),
+/*  117 */ make_floatx80_init(0x4183, 0xcb090c8001ab551c),
+/*  118 */ make_floatx80_init(0x4186, 0xfdcb4fa002162a63),
+/*  119 */ make_floatx80_init(0x418a, 0x9e9f11c4014dda7e),
+/*  120 */ make_floatx80_init(0x418d, 0xc646d63501a1511e),
+/*  121 */ make_floatx80_init(0x4190, 0xf7d88bc24209a565),
+/*  122 */ make_floatx80_init(0x4194, 0x9ae757596946075f),
+/*  123 */ make_floatx80_init(0x4197, 0xc1a12d2fc3978937),
+/*  124 */ make_floatx80_init(0x419a, 0xf209787bb47d6b85),
+/*  125 */ make_floatx80_init(0x419e, 0x9745eb4d50ce6333),
+/*  126 */ make_floatx80_init(0x41a1, 0xbd176620a501fc00),
+/*  127 */ make_floatx80_init(0x41a4, 0xec5d3fa8ce427b00),
+/*  128 */ make_floatx80_init(0x41a8, 0x93ba47c980e98ce0),
+/*  129 */ make_floatx80_init(0x41ab, 0xb8a8d9bbe123f018),
+/*  130 */ make_floatx80_init(0x41ae, 0xe6d3102ad96cec1e),
+/*  131 */ make_floatx80_init(0x41b2, 0x9043ea1ac7e41393),
+/*  132 */ make_floatx80_init(0x41b5, 0xb454e4a179dd1877),
+/*  133 */ make_floatx80_init(0x41b8, 0xe16a1dc9d8545e95),
+/*  134 */ make_floatx80_init(0x41bc, 0x8ce2529e2734bb1d),
+/*  135 */ make_floatx80_init(0x41bf, 0xb01ae745b101e9e4),
+/*  136 */ make_floatx80_init(0x41c2, 0xdc21a1171d42645d),
+/*  137 */ make_floatx80_init(0x41c6, 0x899504ae72497eba),
+/*  138 */ make_floatx80_init(0x41c9, 0xabfa45da0edbde69),
+/*  139 */ make_floatx80_init(0x41cc, 0xd6f8d7509292d603),
+/*  140 */ make_floatx80_init(0x41d0, 0x865b86925b9bc5c2),
+/*  141 */ make_floatx80_init(0x41d3, 0xa7f26836f282b733),
+/*  142 */ make_floatx80_init(0x41d6, 0xd1ef0244af2364ff),
+/*  143 */ make_floatx80_init(0x41da, 0x8335616aed761f1f),
+/*  144 */ make_floatx80_init(0x41dd, 0xa402b9c5a8d3a6e7),
+/*  145 */ make_floatx80_init(0x41e0, 0xcd036837130890a1),
+/*  146 */ make_floatx80_init(0x41e4, 0x802221226be55a65),
+/*  147 */ make_floatx80_init(0x41e7, 0xa02aa96b06deb0fe),
+/*  148 */ make_floatx80_init(0x41ea, 0xc83553c5c8965d3d),
+/*  149 */ make_floatx80_init(0x41ed, 0xfa42a8b73abbf48d),
+/*  150 */ make_floatx80_init(0x41f1, 0x9c69a97284b578d8),
+/*  151 */ make_floatx80_init(0x41f4, 0xc38413cf25e2d70e),
+/*  152 */ make_floatx80_init(0x41f7, 0xf46518c2ef5b8cd1),
+/*  153 */ make_floatx80_init(0x41fb, 0x98bf2f79d5993803),
+/*  154 */ make_floatx80_init(0x41fe, 0xbeeefb584aff8604),
+/*  155 */ make_floatx80_init(0x4201, 0xeeaaba2e5dbf6785),
+/*  156 */ make_floatx80_init(0x4205, 0x952ab45cfa97a0b3),
+/*  157 */ make_floatx80_init(0x4208, 0xba756174393d88e0),
+/*  158 */ make_floatx80_init(0x420b, 0xe912b9d1478ceb17),
+/*  159 */ make_floatx80_init(0x420f, 0x91abb422ccb812ef),
+/*  160 */ make_floatx80_init(0x4212, 0xb616a12b7fe617aa),
+/*  161 */ make_floatx80_init(0x4215, 0xe39c49765fdf9d95),
+/*  162 */ make_floatx80_init(0x4219, 0x8e41ade9fbebc27d),
+/*  163 */ make_floatx80_init(0x421c, 0xb1d219647ae6b31c),
+/*  164 */ make_floatx80_init(0x421f, 0xde469fbd99a05fe3),
+/*  165 */ make_floatx80_init(0x4223, 0x8aec23d680043bee),
+/*  166 */ make_floatx80_init(0x4226, 0xada72ccc20054aea),
+/*  167 */ make_floatx80_init(0x4229, 0xd910f7ff28069da4),
+/*  168 */ make_floatx80_init(0x422d, 0x87aa9aff79042287),
+/*  169 */ make_floatx80_init(0x4230, 0xa99541bf57452b28),
+/*  170 */ make_floatx80_init(0x4233, 0xd3fa922f2d1675f2),
+/*  171 */ make_floatx80_init(0x4237, 0x847c9b5d7c2e09b7),
+/*  172 */ make_floatx80_init(0x423a, 0xa59bc234db398c25),
+/*  173 */ make_floatx80_init(0x423d, 0xcf02b2c21207ef2f),
+/*  174 */ make_floatx80_init(0x4241, 0x8161afb94b44f57d),
+/*  175 */ make_floatx80_init(0x4244, 0xa1ba1ba79e1632dc),
+/*  176 */ make_floatx80_init(0x4247, 0xca28a291859bbf93),
+/*  177 */ make_floatx80_init(0x424a, 0xfcb2cb35e702af78),
+/*  178 */ make_floatx80_init(0x424e, 0x9defbf01b061adab),
+/*  179 */ make_floatx80_init(0x4251, 0xc56baec21c7a1916),
+/*  180 */ make_floatx80_init(0x4254, 0xf6c69a72a3989f5c),
+/*  181 */ make_floatx80_init(0x4258, 0x9a3c2087a63f6399),
+/*  182 */ make_floatx80_init(0x425b, 0xc0cb28a98fcf3c80),
+/*  183 */ make_floatx80_init(0x425e, 0xf0fdf2d3f3c30b9f),
+/*  184 */ make_floatx80_init(0x4262, 0x969eb7c47859e744),
+/*  185 */ make_floatx80_init(0x4265, 0xbc4665b596706115),
+/*  186 */ make_floatx80_init(0x4268, 0xeb57ff22fc0c795a),
+/*  187 */ make_floatx80_init(0x426c, 0x9316ff75dd87cbd8),
+/*  188 */ make_floatx80_init(0x426f, 0xb7dcbf5354e9bece),
+/*  189 */ make_floatx80_init(0x4272, 0xe5d3ef282a242e82),
+/*  190 */ make_floatx80_init(0x4276, 0x8fa475791a569d11),
+/*  191 */ make_floatx80_init(0x4279, 0xb38d92d760ec4455),
+/*  192 */ make_floatx80_init(0x427c, 0xe070f78d3927556b),
+/*  193 */ make_floatx80_init(0x4280, 0x8c469ab843b89563),
+/*  194 */ make_floatx80_init(0x4283, 0xaf58416654a6babb),
+/*  195 */ make_floatx80_init(0x4286, 0xdb2e51bfe9d0696a),
+/*  196 */ make_floatx80_init(0x428a, 0x88fcf317f22241e2),
+/*  197 */ make_floatx80_init(0x428d, 0xab3c2fddeeaad25b),
+/*  198 */ make_floatx80_init(0x4290, 0xd60b3bd56a5586f2),
+/*  199 */ make_floatx80_init(0x4294, 0x85c7056562757457),
+/*  200 */ make_floatx80_init(0x4297, 0xa738c6bebb12d16d),
+/*  201 */ make_floatx80_init(0x429a, 0xd106f86e69d785c8),
+/*  202 */ make_floatx80_init(0x429e, 0x82a45b450226b39d),
+/*  203 */ make_floatx80_init(0x42a1, 0xa34d721642b06084),
+/*  204 */ make_floatx80_init(0x42a4, 0xcc20ce9bd35c78a5),
+/*  205 */ make_floatx80_init(0x42a7, 0xff290242c83396ce),
+/*  206 */ make_floatx80_init(0x42ab, 0x9f79a169bd203e41),
+/*  207 */ make_floatx80_init(0x42ae, 0xc75809c42c684dd1),
+/*  208 */ make_floatx80_init(0x42b1, 0xf92e0c3537826146),
+/*  209 */ make_floatx80_init(0x42b5, 0x9bbcc7a142b17ccc),
+/*  210 */ make_floatx80_init(0x42b8, 0xc2abf989935ddbfe),
+/*  211 */ make_floatx80_init(0x42bb, 0xf356f7ebf83552fe),
+/*  212 */ make_floatx80_init(0x42bf, 0x98165af37b2153df),
+/*  213 */ make_floatx80_init(0x42c2, 0xbe1bf1b059e9a8d6),
+/*  214 */ make_floatx80_init(0x42c5, 0xeda2ee1c7064130c),
+/*  215 */ make_floatx80_init(0x42c9, 0x9485d4d1c63e8be8),
+/*  216 */ make_floatx80_init(0x42cc, 0xb9a74a0637ce2ee1),
+/*  217 */ make_floatx80_init(0x42cf, 0xe8111c87c5c1ba9a),
+/*  218 */ make_floatx80_init(0x42d3, 0x910ab1d4db9914a0),
+/*  219 */ make_floatx80_init(0x42d6, 0xb54d5e4a127f59c8),
+/*  220 */ make_floatx80_init(0x42d9, 0xe2a0b5dc971f303a),
+/*  221 */ make_floatx80_init(0x42dd, 0x8da471a9de737e24),
+/*  222 */ make_floatx80_init(0x42e0, 0xb10d8e1456105dad),
+/*  223 */ make_floatx80_init(0x42e3, 0xdd50f1996b947519),
+/*  224 */ make_floatx80_init(0x42e7, 0x8a5296ffe33cc930),
+/*  225 */ make_floatx80_init(0x42ea, 0xace73cbfdc0bfb7b),
+/*  226 */ make_floatx80_init(0x42ed, 0xd8210befd30efa5a),
+/*  227 */ make_floatx80_init(0x42f1, 0x8714a775e3e95c78),
+/*  228 */ make_floatx80_init(0x42f4, 0xa8d9d1535ce3b396),
+/*  229 */ make_floatx80_init(0x42f7, 0xd31045a8341ca07c),
+/*  230 */ make_floatx80_init(0x42fb, 0x83ea2b892091e44e),
+/*  231 */ make_floatx80_init(0x42fe, 0xa4e4b66b68b65d61),
+/*  232 */ make_floatx80_init(0x4301, 0xce1de40642e3f4b9),
+/*  233 */ make_floatx80_init(0x4305, 0x80d2ae83e9ce78f4),
+/*  234 */ make_floatx80_init(0x4308, 0xa1075a24e4421731),
+/*  235 */ make_floatx80_init(0x430b, 0xc94930ae1d529cfd),
+/*  236 */ make_floatx80_init(0x430e, 0xfb9b7cd9a4a7443c),
+/*  237 */ make_floatx80_init(0x4312, 0x9d412e0806e88aa6),
+/*  238 */ make_floatx80_init(0x4315, 0xc491798a08a2ad4f),
+/*  239 */ make_floatx80_init(0x4318, 0xf5b5d7ec8acb58a3),
+/*  240 */ make_floatx80_init(0x431c, 0x9991a6f3d6bf1766),
+/*  241 */ make_floatx80_init(0x431f, 0xbff610b0cc6edd3f),
+/*  242 */ make_floatx80_init(0x4322, 0xeff394dcff8a948f),
+/*  243 */ make_floatx80_init(0x4326, 0x95f83d0a1fb69cd9),
+/*  244 */ make_floatx80_init(0x4329, 0xbb764c4ca7a44410),
+/*  245 */ make_floatx80_init(0x432c, 0xea53df5fd18d5514),
+/*  246 */ make_floatx80_init(0x4330, 0x92746b9be2f8552c),
+/*  247 */ make_floatx80_init(0x4333, 0xb7118682dbb66a77),
+/*  248 */ make_floatx80_init(0x4336, 0xe4d5e82392a40515),
+/*  249 */ make_floatx80_init(0x433a, 0x8f05b1163ba6832d),
+/*  250 */ make_floatx80_init(0x433d, 0xb2c71d5bca9023f8),
+/*  251 */ make_floatx80_init(0x4340, 0xdf78e4b2bd342cf7),
+/*  252 */ make_floatx80_init(0x4344, 0x8bab8eefb6409c1a),
+/*  253 */ make_floatx80_init(0x4347, 0xae9672aba3d0c321),
+/*  254 */ make_floatx80_init(0x434a, 0xda3c0f568cc4f3e9),
+/*  255 */ make_floatx80_init(0x434e, 0x8865899617fb1871),
+/*  256 */ make_floatx80_init(0x4351, 0xaa7eebfb9df9de8e),
+/*  257 */ make_floatx80_init(0x4354, 0xd51ea6fa85785631),
+/*  258 */ make_floatx80_init(0x4358, 0x8533285c936b35df),
+/*  259 */ make_floatx80_init(0x435b, 0xa67ff273b8460357),
+/*  260 */ make_floatx80_init(0x435e, 0xd01fef10a657842c),
+/*  261 */ make_floatx80_init(0x4362, 0x8213f56a67f6b29c),
+/*  262 */ make_floatx80_init(0x4365, 0xa298f2c501f45f43),
+/*  263 */ make_floatx80_init(0x4368, 0xcb3f2f7642717713),
+/*  264 */ make_floatx80_init(0x436b, 0xfe0efb53d30dd4d8),
+/*  265 */ make_floatx80_init(0x436f, 0x9ec95d1463e8a507),
+/*  266 */ make_floatx80_init(0x4372, 0xc67bb4597ce2ce49),
+/*  267 */ make_floatx80_init(0x4375, 0xf81aa16fdc1b81db),
+/*  268 */ make_floatx80_init(0x4379, 0x9b10a4e5e9913129),
+/*  269 */ make_floatx80_init(0x437c, 0xc1d4ce1f63f57d73),
+/*  270 */ make_floatx80_init(0x437f, 0xf24a01a73cf2dcd0),
+/*  271 */ make_floatx80_init(0x4383, 0x976e41088617ca02),
+/*  272 */ make_floatx80_init(0x4386, 0xbd49d14aa79dbc82),
+/*  273 */ make_floatx80_init(0x4389, 0xec9c459d51852ba3),
+/*  274 */ make_floatx80_init(0x438d, 0x93e1ab8252f33b46),
+/*  275 */ make_floatx80_init(0x4390, 0xb8da1662e7b00a17),
+/*  276 */ make_floatx80_init(0x4393, 0xe7109bfba19c0c9d),
+/*  277 */ make_floatx80_init(0x4397, 0x906a617d450187e2),
+/*  278 */ make_floatx80_init(0x439a, 0xb484f9dc9641e9db),
+/*  279 */ make_floatx80_init(0x439d, 0xe1a63853bbd26451),
+/*  280 */ make_floatx80_init(0x43a1, 0x8d07e33455637eb3),
+/*  281 */ make_floatx80_init(0x43a4, 0xb049dc016abc5e60),
+/*  282 */ make_floatx80_init(0x43a7, 0xdc5c5301c56b75f7),
+/*  283 */ make_floatx80_init(0x43ab, 0x89b9b3e11b6329bb),
+/*  284 */ make_floatx80_init(0x43ae, 0xac2820d9623bf429),
+/*  285 */ make_floatx80_init(0x43b1, 0xd732290fbacaf134),
+/*  286 */ make_floatx80_init(0x43b5, 0x867f59a9d4bed6c0),
+/*  287 */ make_floatx80_init(0x43b8, 0xa81f301449ee8c70),
+/*  288 */ make_floatx80_init(0x43bb, 0xd226fc195c6a2f8c),
+/*  289 */ make_floatx80_init(0x43bf, 0x83585d8fd9c25db8),
+/*  290 */ make_floatx80_init(0x43c2, 0xa42e74f3d032f526),
+/*  291 */ make_floatx80_init(0x43c5, 0xcd3a1230c43fb26f),
+/*  292 */ make_floatx80_init(0x43c9, 0x80444b5e7aa7cf85),
+/*  293 */ make_floatx80_init(0x43cc, 0xa0555e361951c367),
+/*  294 */ make_floatx80_init(0x43cf, 0xc86ab5c39fa63441),
+/*  295 */ make_floatx80_init(0x43d2, 0xfa856334878fc151),
+/*  296 */ make_floatx80_init(0x43d6, 0x9c935e00d4b9d8d2),
+/*  297 */ make_floatx80_init(0x43d9, 0xc3b8358109e84f07),
+/*  298 */ make_floatx80_init(0x43dc, 0xf4a642e14c6262c9),
+/*  299 */ make_floatx80_init(0x43e0, 0x98e7e9cccfbd7dbe),
+/*  300 */ make_floatx80_init(0x43e3, 0xbf21e44003acdd2d),
+/*  301 */ make_floatx80_init(0x43e6, 0xeeea5d5004981478),
+/*  302 */ make_floatx80_init(0x43ea, 0x95527a5202df0ccb),
+/*  303 */ make_floatx80_init(0x43ed, 0xbaa718e68396cffe),
+/*  304 */ make_floatx80_init(0x43f0, 0xe950df20247c83fd),
+/*  305 */ make_floatx80_init(0x43f4, 0x91d28b7416cdd27e),
+/*  306 */ make_floatx80_init(0x43f7, 0xb6472e511c81471e),
+/*  307 */ make_floatx80_init(0x43fa, 0xe3d8f9e563a198e5),
+/*  308 */ make_floatx80_init(0x43fe, 0x8e679c2f5e44ff8f),
+/*  309 */ make_floatx80_init(0x4401, 0xb201833b35d63f73),
+/*  310 */ make_floatx80_init(0x4404, 0xde81e40a034bcf50),
+/*  311 */ make_floatx80_init(0x4408, 0x8b112e86420f6192),
+/*  312 */ make_floatx80_init(0x440b, 0xadd57a27d29339f6),
+/*  313 */ make_floatx80_init(0x440e, 0xd94ad8b1c7380874),
+/*  314 */ make_floatx80_init(0x4412, 0x87cec76f1c830549),
+/*  315 */ make_floatx80_init(0x4415, 0xa9c2794ae3a3c69b),
+/*  316 */ make_floatx80_init(0x4418, 0xd433179d9c8cb841),
+/*  317 */ make_floatx80_init(0x441c, 0x849feec281d7f329),
+/*  318 */ make_floatx80_init(0x441f, 0xa5c7ea73224deff3),
+/*  319 */ make_floatx80_init(0x4422, 0xcf39e50feae16bf0),
+/*  320 */ make_floatx80_init(0x4426, 0x81842f29f2cce376),
+/*  321 */ make_floatx80_init(0x4429, 0xa1e53af46f801c53),
+/*  322 */ make_floatx80_init(0x442c, 0xca5e89b18b602368),
+/*  323 */ make_floatx80_init(0x442f, 0xfcf62c1dee382c42),
+/*  324 */ make_floatx80_init(0x4433, 0x9e19db92b4e31ba9),
+/*  325 */ make_floatx80_init(0x4436, 0xc5a05277621be294),
+/*  326 */ make_floatx80_init(0x4439, 0xf70867153aa2db39),
+/*  327 */ make_floatx80_init(0x443d, 0x9a65406d44a5c903),
+/*  328 */ make_floatx80_init(0x4440, 0xc0fe908895cf3b44),
+/*  329 */ make_floatx80_init(0x4443, 0xf13e34aabb430a15),
+/*  330 */ make_floatx80_init(0x4447, 0x96c6e0eab509e64d),
+/*  331 */ make_floatx80_init(0x444a, 0xbc789925624c5fe1),
+/*  332 */ make_floatx80_init(0x444d, 0xeb96bf6ebadf77d9),
+/*  333 */ make_floatx80_init(0x4451, 0x933e37a534cbaae8),
+/*  334 */ make_floatx80_init(0x4454, 0xb80dc58e81fe95a1),
+/*  335 */ make_floatx80_init(0x4457, 0xe61136f2227e3b0a),
+/*  336 */ make_floatx80_init(0x445b, 0x8fcac257558ee4e6),
+/*  337 */ make_floatx80_init(0x445e, 0xb3bd72ed2af29e20),
+/*  338 */ make_floatx80_init(0x4461, 0xe0accfa875af45a8),
+/*  339 */ make_floatx80_init(0x4465, 0x8c6c01c9498d8b89),
+/*  340 */ make_floatx80_init(0x4468, 0xaf87023b9bf0ee6b),
+/*  341 */ make_floatx80_init(0x446b, 0xdb68c2ca82ed2a06),
+/*  342 */ make_floatx80_init(0x446f, 0x892179be91d43a44),
+/*  343 */ make_floatx80_init(0x4472, 0xab69d82e364948d4),
+/*  344 */ make_floatx80_init(0x4475, 0xd6444e39c3db9b0a),
+/*  345 */ make_floatx80_init(0x4479, 0x85eab0e41a6940e6),
+/*  346 */ make_floatx80_init(0x447c, 0xa7655d1d2103911f),
+/*  347 */ make_floatx80_init(0x447f, 0xd13eb46469447567),
+/*  348 */ make_floatx80_init(0x4483, 0x82c730bec1cac961),
+/*  349 */ make_floatx80_init(0x4486, 0xa378fcee723d7bb9),
+/*  350 */ make_floatx80_init(0x4489, 0xcc573c2a0eccdaa7),
+/*  351 */ make_floatx80_init(0x448c, 0xff6d0b3492801151),
+/*  352 */ make_floatx80_init(0x4490, 0x9fa42700db900ad2),
+/*  353 */ make_floatx80_init(0x4493, 0xc78d30c112740d87),
+/*  354 */ make_floatx80_init(0x4496, 0xf9707cf1571110e9),
+/*  355 */ make_floatx80_init(0x449a, 0x9be64e16d66aaa91),
+/*  356 */ make_floatx80_init(0x449d, 0xc2dfe19c8c055536),
+/*  357 */ make_floatx80_init(0x44a0, 0xf397da03af06aa83),
+/*  358 */ make_floatx80_init(0x44a4, 0x983ee8424d642a92),
+/*  359 */ make_floatx80_init(0x44a7, 0xbe4ea252e0bd3537),
+/*  360 */ make_floatx80_init(0x44aa, 0xede24ae798ec8284),
+/*  361 */ make_floatx80_init(0x44ae, 0x94ad6ed0bf93d193),
+/*  362 */ make_floatx80_init(0x44b1, 0xb9d8ca84ef78c5f7),
+/*  363 */ make_floatx80_init(0x44b4, 0xe84efd262b56f775),
+/*  364 */ make_floatx80_init(0x44b8, 0x91315e37db165aa9),
+/*  365 */ make_floatx80_init(0x44bb, 0xb57db5c5d1dbf153),
+/*  366 */ make_floatx80_init(0x44be, 0xe2dd23374652eda8),
+/*  367 */ make_floatx80_init(0x44c2, 0x8dca36028bf3d489),
+/*  368 */ make_floatx80_init(0x44c5, 0xb13cc3832ef0c9ac),
+/*  369 */ make_floatx80_init(0x44c8, 0xdd8bf463faacfc16),
+/*  370 */ make_floatx80_init(0x44cc, 0x8a7778be7cac1d8e),
+/*  371 */ make_floatx80_init(0x44cf, 0xad1556ee1bd724f1),
+/*  372 */ make_floatx80_init(0x44d2, 0xd85aaca9a2ccee2e),
+/*  373 */ make_floatx80_init(0x44d6, 0x8738abea05c014dd),
+/*  374 */ make_floatx80_init(0x44d9, 0xa906d6e487301a14),
+/*  375 */ make_floatx80_init(0x44dc, 0xd3488c9da8fc2099),
+/*  376 */ make_floatx80_init(0x44e0, 0x840d57e2899d945f),
+/*  377 */ make_floatx80_init(0x44e3, 0xa510addb2c04f977),
+/*  378 */ make_floatx80_init(0x44e6, 0xce54d951f70637d5),
+/*  379 */ make_floatx80_init(0x44ea, 0x80f507d33a63e2e5),
+/*  380 */ make_floatx80_init(0x44ed, 0xa13249c808fcdb9f),
+/*  381 */ make_floatx80_init(0x44f0, 0xc97edc3a0b3c1286),
+/*  382 */ make_floatx80_init(0x44f3, 0xfbde93488e0b1728),
+/*  383 */ make_floatx80_init(0x44f7, 0x9d6b1c0d58c6ee79),
+/*  384 */ make_floatx80_init(0x44fa, 0xc4c5e310aef8aa17),
+/*  385 */ make_floatx80_init(0x44fd, 0xf5f75bd4dab6d49d),
+/*  386 */ make_floatx80_init(0x4501, 0x99ba996508b244e2),
+/*  387 */ make_floatx80_init(0x4504, 0xc0293fbe4aded61b),
+/*  388 */ make_floatx80_init(0x4507, 0xf0338faddd968ba1),
+/*  389 */ make_floatx80_init(0x450b, 0x962039ccaa7e1745),
+/*  390 */ make_floatx80_init(0x450e, 0xbba8483fd51d9d16),
+/*  391 */ make_floatx80_init(0x4511, 0xea925a4fca65045b),
+/*  392 */ make_floatx80_init(0x4515, 0x929b7871de7f22b9),
+/*  393 */ make_floatx80_init(0x4518, 0xb742568e561eeb67),
+/*  394 */ make_floatx80_init(0x451b, 0xe512ec31eba6a641),
+/*  395 */ make_floatx80_init(0x451f, 0x8f2bd39f334827e9),
+/*  396 */ make_floatx80_init(0x4522, 0xb2f6c887001a31e3),
+/*  397 */ make_floatx80_init(0x4525, 0xdfb47aa8c020be5c),
+/*  398 */ make_floatx80_init(0x4529, 0x8bd0cca9781476f9),
+/*  399 */ make_floatx80_init(0x452c, 0xaec4ffd3d61994b8),
+/*  400 */ make_floatx80_init(0x452f, 0xda763fc8cb9ff9e6),
+/*  401 */ make_floatx80_init(0x4533, 0x8889e7dd7f43fc2f),
+/*  402 */ make_floatx80_init(0x4536, 0xaaac61d4df14fb3b),
+/*  403 */ make_floatx80_init(0x4539, 0xd5577a4a16da3a0a),
+/*  404 */ make_floatx80_init(0x453d, 0x8556ac6e4e486446),
+/*  405 */ make_floatx80_init(0x4540, 0xa6ac5789e1da7d58),
+/*  406 */ make_floatx80_init(0x4543, 0xd0576d6c5a511cae),
+/*  407 */ make_floatx80_init(0x4547, 0x8236a463b872b1ed),
+/*  408 */ make_floatx80_init(0x454a, 0xa2c44d7ca68f5e68),
+/*  409 */ make_floatx80_init(0x454d, 0xcb7560dbd0333602),
+/*  410 */ make_floatx80_init(0x4550, 0xfe52b912c4400382),
+/*  411 */ make_floatx80_init(0x4554, 0x9ef3b3abbaa80231),
+/*  412 */ make_floatx80_init(0x4557, 0xc6b0a096a95202be),
+/*  413 */ make_floatx80_init(0x455a, 0xf85cc8bc53a6836d),
+/*  414 */ make_floatx80_init(0x455e, 0x9b39fd75b4481224),
+/*  415 */ make_floatx80_init(0x4561, 0xc2087cd3215a16ad),
+/*  416 */ make_floatx80_init(0x4564, 0xf28a9c07e9b09c59),
+/*  417 */ make_floatx80_init(0x4568, 0x9796a184f20e61b7),
+/*  418 */ make_floatx80_init(0x456b, 0xbd7c49e62e91fa25),
+/*  419 */ make_floatx80_init(0x456e, 0xecdb5c5fba3678af),
+/*  420 */ make_floatx80_init(0x4572, 0x940919bbd4620b6d),
+/*  421 */ make_floatx80_init(0x4575, 0xb90b602ac97a8e48),
+/*  422 */ make_floatx80_init(0x4578, 0xe74e38357bd931db),
+/*  423 */ make_floatx80_init(0x457c, 0x9090e3216d67bf29),
+/*  424 */ make_floatx80_init(0x457f, 0xb4b51be9c8c1aef3),
+/*  425 */ make_floatx80_init(0x4582, 0xe1e262e43af21aaf),
+/*  426 */ make_floatx80_init(0x4586, 0x8d2d7dcea4d750ae),
+/*  427 */ make_floatx80_init(0x4589, 0xb078dd424e0d24d9),
+/*  428 */ make_floatx80_init(0x458c, 0xdc971492e1906e0f),
+/*  429 */ make_floatx80_init(0x4590, 0x89de6cdbccfa44ca),
+/*  430 */ make_floatx80_init(0x4593, 0xac560812c038d5fc),
+/*  431 */ make_floatx80_init(0x4596, 0xd76b8a1770470b7b),
+/*  432 */ make_floatx80_init(0x459a, 0x86a3364ea62c672d),
+/*  433 */ make_floatx80_init(0x459d, 0xa84c03e24fb780f8),
+/*  434 */ make_floatx80_init(0x45a0, 0xd25f04dae3a56136),
+/*  435 */ make_floatx80_init(0x45a4, 0x837b6308ce475cc2),
+/*  436 */ make_floatx80_init(0x45a7, 0xa45a3bcb01d933f2),
+/*  437 */ make_floatx80_init(0x45aa, 0xcd70cabdc24f80ef),
+/*  438 */ make_floatx80_init(0x45ae, 0x80667eb69971b095),
+/*  439 */ make_floatx80_init(0x45b1, 0xa0801e643fce1cbb),
+/*  440 */ make_floatx80_init(0x45b4, 0xc8a025fd4fc1a3e9),
+/*  441 */ make_floatx80_init(0x45b7, 0xfac82f7ca3b20ce4),
+/*  442 */ make_floatx80_init(0x45bb, 0x9cbd1dade64f480e),
+/*  443 */ make_floatx80_init(0x45be, 0xc3ec65195fe31a12),
+/*  444 */ make_floatx80_init(0x45c1, 0xf4e77e5fb7dbe096),
+/*  445 */ make_floatx80_init(0x45c5, 0x9910aefbd2e96c5e),
+/*  446 */ make_floatx80_init(0x45c8, 0xbf54dabac7a3c775),
+/*  447 */ make_floatx80_init(0x45cb, 0xef2a1169798cb953),
+/*  448 */ make_floatx80_init(0x45cf, 0x957a4ae1ebf7f3d4),
+/*  449 */ make_floatx80_init(0x45d2, 0xbad8dd9a66f5f0c9),
+/*  450 */ make_floatx80_init(0x45d5, 0xe98f150100b36cfb),
+/*  451 */ make_floatx80_init(0x45d9, 0x91f96d20a070241d),
+/*  452 */ make_floatx80_init(0x45dc, 0xb677c868c88c2d24),
+/*  453 */ make_floatx80_init(0x45df, 0xe415ba82faaf386d),
+/*  454 */ make_floatx80_init(0x45e3, 0x8e8d9491dcad8344),
+/*  455 */ make_floatx80_init(0x45e6, 0xb230f9b653d8e415),
+/*  456 */ make_floatx80_init(0x45e9, 0xdebd3823e8cf1d1a),
+/*  457 */ make_floatx80_init(0x45ed, 0x8b36431671817230),
+/*  458 */ make_floatx80_init(0x45f0, 0xae03d3dc0de1cebd),
+/*  459 */ make_floatx80_init(0x45f3, 0xd984c8d3115a426c),
+/*  460 */ make_floatx80_init(0x45f7, 0x87f2fd83ead86983),
+/*  461 */ make_floatx80_init(0x45fa, 0xa9efbce4e58e83e4),
+/*  462 */ make_floatx80_init(0x45fd, 0xd46bac1e1ef224dd),
+/*  463 */ make_floatx80_init(0x4601, 0x84c34b92d357570a),
+/*  464 */ make_floatx80_init(0x4604, 0xa5f41e77882d2ccd),
+/*  465 */ make_floatx80_init(0x4607, 0xcf7126156a387800),
+/*  466 */ make_floatx80_init(0x460b, 0x81a6b7cd62634b00),
+/*  467 */ make_floatx80_init(0x460e, 0xa21065c0bafc1dc0),
+/*  468 */ make_floatx80_init(0x4611, 0xca947f30e9bb2530),
+/*  469 */ make_floatx80_init(0x4614, 0xfd399efd2429ee7c),
+/*  470 */ make_floatx80_init(0x4618, 0x9e44035e369a350d),
+/*  471 */ make_floatx80_init(0x461b, 0xc5d50435c440c251),
+/*  472 */ make_floatx80_init(0x461e, 0xf74a45433550f2e5),
+/*  473 */ make_floatx80_init(0x4622, 0x9a8e6b4a015297cf),
+/*  474 */ make_floatx80_init(0x4625, 0xc132061c81a73dc3),
+/*  475 */ make_floatx80_init(0x4628, 0xf17e87a3a2110d34),
+/*  476 */ make_floatx80_init(0x462c, 0x96ef14c6454aa840),
+/*  477 */ make_floatx80_init(0x462f, 0xbcaad9f7d69d5250),
+/*  478 */ make_floatx80_init(0x4632, 0xebd59075cc44a6e4),
+/*  479 */ make_floatx80_init(0x4636, 0x93657a499faae84f),
+/*  480 */ make_floatx80_init(0x4639, 0xb83ed8dc0795a262),
+/*  481 */ make_floatx80_init(0x463c, 0xe64e8f13097b0afb),
+/*  482 */ make_floatx80_init(0x4640, 0x8ff1196be5ece6dd),
+/*  483 */ make_floatx80_init(0x4643, 0xb3ed5fc6df682094),
+/*  484 */ make_floatx80_init(0x4646, 0xe0e8b7b8974228b9),
+/*  485 */ make_floatx80_init(0x464a, 0x8c9172d35e895974),
+/*  486 */ make_floatx80_init(0x464d, 0xafb5cf88362bafd1),
+/*  487 */ make_floatx80_init(0x4650, 0xdba3436a43b69bc5),
+/*  488 */ make_floatx80_init(0x4654, 0x89460a226a52215b),
+/*  489 */ make_floatx80_init(0x4657, 0xab978cab04e6a9b2),
+/*  490 */ make_floatx80_init(0x465a, 0xd67d6fd5c620541e),
+/*  491 */ make_floatx80_init(0x465e, 0x860e65e59bd43493),
+/*  492 */ make_floatx80_init(0x4661, 0xa791ff5f02c941b8),
+/*  493 */ make_floatx80_init(0x4664, 0xd1767f36c37b9226),
+/*  494 */ make_floatx80_init(0x4668, 0x82ea0f823a2d3b57),
+/*  495 */ make_floatx80_init(0x466b, 0xa3a49362c8b88a2d),
+/*  496 */ make_floatx80_init(0x466e, 0xcc8db83b7ae6acb9),
+/*  497 */ make_floatx80_init(0x4671, 0xffb1264a59a057e7),
+/*  498 */ make_floatx80_init(0x4675, 0x9fceb7ee780436f0),
+/*  499 */ make_floatx80_init(0x4678, 0xc7c265ea160544ac),
+/*  500 */ make_floatx80_init(0x467b, 0xf9b2ff649b8695d7),
+/*  501 */ make_floatx80_init(0x467f, 0x9c0fdf9ee1341da7),
+/*  502 */ make_floatx80_init(0x4682, 0xc313d78699812510),
+/*  503 */ make_floatx80_init(0x4685, 0xf3d8cd683fe16e54),
+/*  504 */ make_floatx80_init(0x4689, 0x9867806127ece4f5),
+/*  505 */ make_floatx80_init(0x468c, 0xbe81607971e81e32),
+/*  506 */ make_floatx80_init(0x468f, 0xee21b897ce6225be),
+/*  507 */ make_floatx80_init(0x4693, 0x94d5135ee0fd5797),
+/*  508 */ make_floatx80_init(0x4696, 0xba0a5836993cad7d),
+/*  509 */ make_floatx80_init(0x4699, 0xe88cee443f8bd8dc),
+/*  510 */ make_floatx80_init(0x469d, 0x915814eaa7b76789),
+/*  511 */ make_floatx80_init(0x46a0, 0xb5ae1a2551a5416c),
+/*  512 */ make_floatx80_init(0x46a3, 0xe319a0aea60e91c7),
+/*  513 */ make_floatx80_init(0x46a7, 0x8df0046d27c91b1c),
+/*  514 */ make_floatx80_init(0x46aa, 0xb16c058871bb61e3),
+/*  515 */ make_floatx80_init(0x46ad, 0xddc706ea8e2a3a5c),
+/*  516 */ make_floatx80_init(0x46b1, 0x8a9c645298da647a),
+/*  517 */ make_floatx80_init(0x46b4, 0xad437d673f10fd98),
+/*  518 */ make_floatx80_init(0x46b7, 0xd8945cc10ed53cfe),
+/*  519 */ make_floatx80_init(0x46bb, 0x875cb9f8a945461f),
+/*  520 */ make_floatx80_init(0x46be, 0xa933e876d39697a6),
+/*  521 */ make_floatx80_init(0x46c1, 0xd380e294887c3d90),
+/*  522 */ make_floatx80_init(0x46c5, 0x84308d9cd54da67a),
+/*  523 */ make_floatx80_init(0x46c8, 0xa53cb1040aa11019),
+/*  524 */ make_floatx80_init(0x46cb, 0xce8bdd450d49541f),
+/*  525 */ make_floatx80_init(0x46cf, 0x81176a4b284dd493),
+/*  526 */ make_floatx80_init(0x46d2, 0xa15d44ddf26149b8),
+/*  527 */ make_floatx80_init(0x46d5, 0xc9b496156ef99c26),
+/*  528 */ make_floatx80_init(0x46d8, 0xfc21bb9acab8032f),
+/*  529 */ make_floatx80_init(0x46dc, 0x9d951540beb301fe),
+/*  530 */ make_floatx80_init(0x46df, 0xc4fa5a90ee5fc27d),
+/*  531 */ make_floatx80_init(0x46e2, 0xf638f13529f7b31c),
+/*  532 */ make_floatx80_init(0x46e6, 0x99e396c13a3acff2),
+/*  533 */ make_floatx80_init(0x46e9, 0xc05c7c7188c983ee),
+/*  534 */ make_floatx80_init(0x46ec, 0xf0739b8deafbe4ea),
+/*  535 */ make_floatx80_init(0x46f0, 0x96484138b2dd6f12),
+/*  536 */ make_floatx80_init(0x46f3, 0xbbda5186df94cad7),
+/*  537 */ make_floatx80_init(0x46f6, 0xead0e5e89779fd8c),
+/*  538 */ make_floatx80_init(0x46fa, 0x92c28fb15eac3e78),
+/*  539 */ make_floatx80_init(0x46fd, 0xb773339db6574e16),
+/*  540 */ make_floatx80_init(0x4700, 0xe550008523ed219b),
+/*  541 */ make_floatx80_init(0x4704, 0x8f52005336743501),
+/*  542 */ make_floatx80_init(0x4707, 0xb326806804114241),
+/*  543 */ make_floatx80_init(0x470a, 0xdff02082051592d1),
+/*  544 */ make_floatx80_init(0x470e, 0x8bf61451432d7bc3),
+/*  545 */ make_floatx80_init(0x4711, 0xaef3996593f8dab3),
+/*  546 */ make_floatx80_init(0x4714, 0xdab07fbef8f71160),
+/*  547 */ make_floatx80_init(0x4718, 0x88ae4fd75b9a6adc),
+/*  548 */ make_floatx80_init(0x471b, 0xaad9e3cd32810593),
+/*  549 */ make_floatx80_init(0x471e, 0xd5905cc07f2146f8),
+/*  550 */ make_floatx80_init(0x4722, 0x857a39f84f74cc5b),
+/*  551 */ make_floatx80_init(0x4725, 0xa6d8c8766351ff72),
+/*  552 */ make_floatx80_init(0x4728, 0xd08efa93fc267f4e),
+/*  553 */ make_floatx80_init(0x472c, 0x82595c9c7d980f91),
+/*  554 */ make_floatx80_init(0x472f, 0xa2efb3c39cfe1375),
+/*  555 */ make_floatx80_init(0x4732, 0xcbaba0b4843d9852),
+/*  556 */ make_floatx80_init(0x4735, 0xfe9688e1a54cfe67),
+/*  557 */ make_floatx80_init(0x4739, 0x9f1e158d07501f00),
+/*  558 */ make_floatx80_init(0x473c, 0xc6e59af0492426c1),
+/*  559 */ make_floatx80_init(0x473f, 0xf89f01ac5b6d3071),
+/*  560 */ make_floatx80_init(0x4743, 0x9b63610bb9243e46),
+/*  561 */ make_floatx80_init(0x4746, 0xc23c394ea76d4dd8),
+/*  562 */ make_floatx80_init(0x4749, 0xf2cb47a25148a14e),
+/*  563 */ make_floatx80_init(0x474d, 0x97bf0cc572cd64d1),
+/*  564 */ make_floatx80_init(0x4750, 0xbdaecff6cf80be05),
+/*  565 */ make_floatx80_init(0x4753, 0xed1a83f48360ed86),
+/*  566 */ make_floatx80_init(0x4757, 0x94309278d21c9474),
+/*  567 */ make_floatx80_init(0x475a, 0xb93cb71706a3b991),
+/*  568 */ make_floatx80_init(0x475d, 0xe78be4dcc84ca7f5),
+/*  569 */ make_floatx80_init(0x4761, 0x90b76f09fd2fe8f9),
+/*  570 */ make_floatx80_init(0x4764, 0xb4e54acc7c7be337),
+/*  571 */ make_floatx80_init(0x4767, 0xe21e9d7f9b9adc05),
+/*  572 */ make_floatx80_init(0x476b, 0x8d53226fc140c983),
+/*  573 */ make_floatx80_init(0x476e, 0xb0a7eb0bb190fbe4),
+/*  574 */ make_floatx80_init(0x4771, 0xdcd1e5ce9df53add),
+/*  575 */ make_floatx80_init(0x4775, 0x8a032fa122b944ca),
+/*  576 */ make_floatx80_init(0x4778, 0xac83fb896b6795fd),
+/*  577 */ make_floatx80_init(0x477b, 0xd7a4fa6bc6417b7c),
+/*  578 */ make_floatx80_init(0x477f, 0x86c71c835be8ed2d),
+/*  579 */ make_floatx80_init(0x4782, 0xa878e3a432e32879),
+/*  580 */ make_floatx80_init(0x4785, 0xd2971c8d3f9bf297),
+/*  581 */ make_floatx80_init(0x4789, 0x839e71d847c1779e),
+/*  582 */ make_floatx80_init(0x478c, 0xa4860e4e59b1d586),
+/*  583 */ make_floatx80_init(0x478f, 0xcda791e1f01e4ae8),
+/*  584 */ make_floatx80_init(0x4793, 0x8088bb2d3612eed1),
+/*  585 */ make_floatx80_init(0x4796, 0xa0aae9f88397aa85),
+/*  586 */ make_floatx80_init(0x4799, 0xc8d5a476a47d9526),
+/*  587 */ make_floatx80_init(0x479c, 0xfb0b0d944d9cfa70),
+/*  588 */ make_floatx80_init(0x47a0, 0x9ce6e87cb0821c86),
+/*  589 */ make_floatx80_init(0x47a3, 0xc420a29bdca2a3a7),
+/*  590 */ make_floatx80_init(0x47a6, 0xf528cb42d3cb4c91),
+/*  591 */ make_floatx80_init(0x47aa, 0x99397f09c45f0fdb),
+/*  592 */ make_floatx80_init(0x47ad, 0xbf87decc3576d3d1),
+/*  593 */ make_floatx80_init(0x47b0, 0xef69d67f42d488c6),
+/*  594 */ make_floatx80_init(0x47b4, 0x95a2260f89c4d57c),
+/*  595 */ make_floatx80_init(0x47b7, 0xbb0aaf936c360ada),
+/*  596 */ make_floatx80_init(0x47ba, 0xe9cd5b7847438d91),
+/*  597 */ make_floatx80_init(0x47be, 0x9220592b2c8a387b),
+/*  598 */ make_floatx80_init(0x47c1, 0xb6a86f75f7acc699),
+/*  599 */ make_floatx80_init(0x47c4, 0xe4528b537597f840),
+/*  600 */ make_floatx80_init(0x47c8, 0x8eb39714297efb28),
+/*  601 */ make_floatx80_init(0x47cb, 0xb2607cd933deb9f2),
+/*  602 */ make_floatx80_init(0x47ce, 0xdef89c0f80d6686e),
+/*  603 */ make_floatx80_init(0x47d2, 0x8b5b6189b0860145),
+/*  604 */ make_floatx80_init(0x47d5, 0xae3239ec1ca78196),
+/*  605 */ make_floatx80_init(0x47d8, 0xd9bec86723d161fc),
+/*  606 */ make_floatx80_init(0x47dc, 0x88173d407662dd3d),
+/*  607 */ make_floatx80_init(0x47df, 0xaa1d0c9093fb948c),
+/*  608 */ make_floatx80_init(0x47e2, 0xd4a44fb4b8fa79b0),
+/*  609 */ make_floatx80_init(0x47e6, 0x84e6b1d0f39c8c0e),
+/*  610 */ make_floatx80_init(0x47e9, 0xa6205e453083af11),
+/*  611 */ make_floatx80_init(0x47ec, 0xcfa875d67ca49ad5),
+/*  612 */ make_floatx80_init(0x47f0, 0x81c949a60de6e0c5),
+/*  613 */ make_floatx80_init(0x47f3, 0xa23b9c0f916098f7),
+/*  614 */ make_floatx80_init(0x47f6, 0xcaca831375b8bf34),
+/*  615 */ make_floatx80_init(0x47f9, 0xfd7d23d85326ef02),
+/*  616 */ make_floatx80_init(0x47fd, 0x9e6e366733f85561),
+/*  617 */ make_floatx80_init(0x4800, 0xc609c40100f66ab9),
+/*  618 */ make_floatx80_init(0x4803, 0xf78c350141340568),
+/*  619 */ make_floatx80_init(0x4807, 0x9ab7a120c8c08361),
+/*  620 */ make_floatx80_init(0x480a, 0xc1658968faf0a439),
+/*  621 */ make_floatx80_init(0x480d, 0xf1beebc339accd47),
+/*  622 */ make_floatx80_init(0x4811, 0x9717535a040c004c),
+/*  623 */ make_floatx80_init(0x4814, 0xbcdd2830850f0060),
+/*  624 */ make_floatx80_init(0x4817, 0xec14723ca652c077),
+/*  625 */ make_floatx80_init(0x481b, 0x938cc765e7f3b84b),
+/*  626 */ make_floatx80_init(0x481e, 0xb86ff93f61f0a65d),
+/*  627 */ make_floatx80_init(0x4821, 0xe68bf78f3a6ccff5),
+/*  628 */ make_floatx80_init(0x4825, 0x90177ab9848401f9),
+/*  629 */ make_floatx80_init(0x4828, 0xb41d5967e5a50277),
+/*  630 */ make_floatx80_init(0x482b, 0xe124afc1df0e4315),
+/*  631 */ make_floatx80_init(0x482f, 0x8cb6edd92b68e9ed),
+/*  632 */ make_floatx80_init(0x4832, 0xafe4a94f76432468),
+/*  633 */ make_floatx80_init(0x4835, 0xdbddd3a353d3ed82),
+/*  634 */ make_floatx80_init(0x4839, 0x896aa44614647472),
+/*  635 */ make_floatx80_init(0x483c, 0xabc54d57997d918e),
+/*  636 */ make_floatx80_init(0x483f, 0xd6b6a0ad7fdcf5f1),
+/*  637 */ make_floatx80_init(0x4843, 0x8632246c6fea19b7),
+/*  638 */ make_floatx80_init(0x4846, 0xa7bead878be4a025),
+/*  639 */ make_floatx80_init(0x4849, 0xd1ae58e96eddc82e),
+/*  640 */ make_floatx80_init(0x484d, 0x830cf791e54a9d1d),
+/*  641 */ make_floatx80_init(0x4850, 0xa3d035765e9d4464),
+/*  642 */ make_floatx80_init(0x4853, 0xccc442d3f644957d),
+/*  643 */ make_floatx80_init(0x4856, 0xfff55388f3d5badc),
+/*  644 */ make_floatx80_init(0x485a, 0x9ff95435986594c9),
+/*  645 */ make_floatx80_init(0x485d, 0xc7f7a942fe7ef9fc),
+/*  646 */ make_floatx80_init(0x4860, 0xf9f59393be1eb87b),
+/*  647 */ make_floatx80_init(0x4864, 0x9c397c3c56d3334d),
+/*  648 */ make_floatx80_init(0x4867, 0xc347db4b6c880020),
+/*  649 */ make_floatx80_init(0x486a, 0xf419d21e47aa0028),
+/*  650 */ make_floatx80_init(0x486e, 0x98902352ecca4019),
+/*  651 */ make_floatx80_init(0x4871, 0xbeb42c27a7fcd01f),
+/*  652 */ make_floatx80_init(0x4874, 0xee61373191fc0427),
+/*  653 */ make_floatx80_init(0x4878, 0x94fcc27efb3d8298),
+/*  654 */ make_floatx80_init(0x487b, 0xba3bf31eba0ce33e),
+/*  655 */ make_floatx80_init(0x487e, 0xe8caefe668901c0e),
+/*  656 */ make_floatx80_init(0x4882, 0x917ed5f0015a1189),
+/*  657 */ make_floatx80_init(0x4885, 0xb5de8b6c01b095eb),
+/*  658 */ make_floatx80_init(0x4888, 0xe3562e47021cbb66),
+/*  659 */ make_floatx80_init(0x488c, 0x8e15dcec6151f520),
+/*  660 */ make_floatx80_init(0x488f, 0xb19b542779a67267),
+/*  661 */ make_floatx80_init(0x4892, 0xde02293158100f01),
+/*  662 */ make_floatx80_init(0x4896, 0x8ac159bed70a0961),
+/*  663 */ make_floatx80_init(0x4899, 0xad71b02e8ccc8bb9),
+/*  664 */ make_floatx80_init(0x489c, 0xd8ce1c3a2fffaea7),
+/*  665 */ make_floatx80_init(0x48a0, 0x8780d1a45dffcd29),
+/*  666 */ make_floatx80_init(0x48a3, 0xa961060d757fc073),
+/*  667 */ make_floatx80_init(0x48a6, 0xd3b94790d2dfb08f),
+/*  668 */ make_floatx80_init(0x48aa, 0x8453ccba83cbce5a),
+/*  669 */ make_floatx80_init(0x48ad, 0xa568bfe924bec1f0),
+/*  670 */ make_floatx80_init(0x48b0, 0xcec2efe36dee726c),
+/*  671 */ make_floatx80_init(0x48b4, 0x8139d5ee24b50783),
+/*  672 */ make_floatx80_init(0x48b7, 0xa1884b69ade24964),
+/*  673 */ make_floatx80_init(0x48ba, 0xc9ea5e44195adbbd),
+/*  674 */ make_floatx80_init(0x48bd, 0xfc64f5d51fb192ad),
+/*  675 */ make_floatx80_init(0x48c1, 0x9dbf19a533cefbac),
+/*  676 */ make_floatx80_init(0x48c4, 0xc52ee00e80c2ba97),
+/*  677 */ make_floatx80_init(0x48c7, 0xf67a981220f3693d),
+/*  678 */ make_floatx80_init(0x48cb, 0x9a0c9f0b549821c6),
+/*  679 */ make_floatx80_init(0x48ce, 0xc08fc6ce29be2a37),
+/*  680 */ make_floatx80_init(0x48d1, 0xf0b3b881b42db4c5),
+/*  681 */ make_floatx80_init(0x48d5, 0x96705351109c90fb),
+/*  682 */ make_floatx80_init(0x48d8, 0xbc0c682554c3b53a),
+/*  683 */ make_floatx80_init(0x48db, 0xeb0f822ea9f4a289),
+/*  684 */ make_floatx80_init(0x48df, 0x92e9b15d2a38e595),
+/*  685 */ make_floatx80_init(0x48e2, 0xb7a41db474c71efb),
+/*  686 */ make_floatx80_init(0x48e5, 0xe58d252191f8e6b9),
+/*  687 */ make_floatx80_init(0x48e9, 0x8f783734fb3b9034),
+/*  688 */ make_floatx80_init(0x48ec, 0xb35645023a0a7441),
+/*  689 */ make_floatx80_init(0x48ef, 0xe02bd642c88d1151),
+/*  690 */ make_floatx80_init(0x48f3, 0x8c1b65e9bd582ad3),
+/*  691 */ make_floatx80_init(0x48f6, 0xaf223f642cae3587),
+/*  692 */ make_floatx80_init(0x48f9, 0xdaeacf3d37d9c2e9),
+/*  693 */ make_floatx80_init(0x48fd, 0x88d2c18642e819d2),
+/*  694 */ make_floatx80_init(0x4900, 0xab0771e7d3a22046),
+/*  695 */ make_floatx80_init(0x4903, 0xd5c94e61c88aa858),
+/*  696 */ make_floatx80_init(0x4907, 0x859dd0fd1d56a937),
+/*  697 */ make_floatx80_init(0x490a, 0xa705453c64ac5385),
+/*  698 */ make_floatx80_init(0x490d, 0xd0c6968b7dd76866),
+/*  699 */ make_floatx80_init(0x4911, 0x827c1e172ea6a140),
+/*  700 */ make_floatx80_init(0x4914, 0xa31b259cfa50498f),
+/*  701 */ make_floatx80_init(0x4917, 0xcbe1ef0438e45bf3),
+/*  702 */ make_floatx80_init(0x491a, 0xfeda6ac5471d72f0),
+/*  703 */ make_floatx80_init(0x491e, 0x9f4882bb4c7267d6),
+/*  704 */ make_floatx80_init(0x4921, 0xc71aa36a1f8f01cc),
+/*  705 */ make_floatx80_init(0x4924, 0xf8e14c44a772c23f),
+/*  706 */ make_floatx80_init(0x4928, 0x9b8ccfaae8a7b967),
+/*  707 */ make_floatx80_init(0x492b, 0xc2700395a2d1a7c1),
+/*  708 */ make_floatx80_init(0x492e, 0xf30c047b0b8611b1),
+/*  709 */ make_floatx80_init(0x4932, 0x97e782cce733cb0f),
+/*  710 */ make_floatx80_init(0x4935, 0xbde163802100bdd2),
+/*  711 */ make_floatx80_init(0x4938, 0xed59bc602940ed47),
+/*  712 */ make_floatx80_init(0x493c, 0x945815bc19c8944c),
+/*  713 */ make_floatx80_init(0x493f, 0xb96e1b2b203ab95f),
+/*  714 */ make_floatx80_init(0x4942, 0xe7c9a1f5e84967b7),
+/*  715 */ make_floatx80_init(0x4946, 0x90de0539b12de0d3),
+/*  716 */ make_floatx80_init(0x4949, 0xb51586881d795907),
+/*  717 */ make_floatx80_init(0x494c, 0xe25ae82a24d7af49),
+/*  718 */ make_floatx80_init(0x4950, 0x8d78d11a5706cd8e),
+/*  719 */ make_floatx80_init(0x4953, 0xb0d70560ecc880f1),
+/*  720 */ make_floatx80_init(0x4956, 0xdd0cc6b927faa12d),
+/*  721 */ make_floatx80_init(0x495a, 0x8a27fc33b8fca4bc),
+/*  722 */ make_floatx80_init(0x495d, 0xacb1fb40a73bcdeb),
+/*  723 */ make_floatx80_init(0x4960, 0xd7de7a10d10ac166),
+/*  724 */ make_floatx80_init(0x4964, 0x86eb0c4a82a6b8e0),
+/*  725 */ make_floatx80_init(0x4967, 0xa8a5cf5d23506718),
+/*  726 */ make_floatx80_init(0x496a, 0xd2cf43346c2480de),
+/*  727 */ make_floatx80_init(0x496e, 0x83c18a00c396d08b),
+/*  728 */ make_floatx80_init(0x4971, 0xa4b1ec80f47c84ad),
+/*  729 */ make_floatx80_init(0x4974, 0xcdde67a1319ba5d9),
+/*  730 */ make_floatx80_init(0x4978, 0x80ab00c4bf0147a7),
+/*  731 */ make_floatx80_init(0x497b, 0xa0d5c0f5eec19991),
+/*  732 */ make_floatx80_init(0x497e, 0xc90b31336a71fff6),
+/*  733 */ make_floatx80_init(0x4981, 0xfb4dfd80450e7ff3),
+/*  734 */ make_floatx80_init(0x4985, 0x9d10be702b290ff8),
+/*  735 */ make_floatx80_init(0x4988, 0xc454ee0c35f353f6),
+/*  736 */ make_floatx80_init(0x498b, 0xf56a298f437028f3),
+/*  737 */ make_floatx80_init(0x498f, 0x996259f98a261998),
+/*  738 */ make_floatx80_init(0x4992, 0xbfbaf077ecaf9ffe),
+/*  739 */ make_floatx80_init(0x4995, 0xefa9ac95e7db87fd),
+/*  740 */ make_floatx80_init(0x4999, 0x95ca0bddb0e934fe),
+/*  741 */ make_floatx80_init(0x499c, 0xbb3c8ed51d23823e),
+/*  742 */ make_floatx80_init(0x499f, 0xea0bb28a646c62ce),
+/*  743 */ make_floatx80_init(0x49a3, 0x92474f967ec3bdc0),
+/*  744 */ make_floatx80_init(0x49a6, 0xb6d9237c1e74ad31),
+/*  745 */ make_floatx80_init(0x49a9, 0xe48f6c5b2611d87d),
+/*  746 */ make_floatx80_init(0x49ad, 0x8ed9a3b8f7cb274e),
+/*  747 */ make_floatx80_init(0x49b0, 0xb2900ca735bdf121),
+/*  748 */ make_floatx80_init(0x49b3, 0xdf340fd1032d6d6a),
+/*  749 */ make_floatx80_init(0x49b7, 0x8b8089e2a1fc6462),
+/*  750 */ make_floatx80_init(0x49ba, 0xae60ac5b4a7b7d7b),
+/*  751 */ make_floatx80_init(0x49bd, 0xd9f8d7721d1a5cd9),
+/*  752 */ make_floatx80_init(0x49c1, 0x883b86a752307a08),
+/*  753 */ make_floatx80_init(0x49c4, 0xaa4a685126bc988a),
+/*  754 */ make_floatx80_init(0x49c7, 0xd4dd0265706bbeac),
+/*  755 */ make_floatx80_init(0x49cb, 0x850a217f6643572c),
+/*  756 */ make_floatx80_init(0x49ce, 0xa64ca9df3fd42cf7),
+/*  757 */ make_floatx80_init(0x49d1, 0xcfdfd4570fc93834),
+/*  758 */ make_floatx80_init(0x49d5, 0x81ebe4b669ddc321),
+/*  759 */ make_floatx80_init(0x49d8, 0xa266dde4045533e9),
+/*  760 */ make_floatx80_init(0x49db, 0xcb00955d056a80e3),
+/*  761 */ make_floatx80_init(0x49de, 0xfdc0bab446c5211c),
+/*  762 */ make_floatx80_init(0x49e2, 0x9e9874b0ac3b34b1),
+/*  763 */ make_floatx80_init(0x49e5, 0xc63e91dcd74a01de),
+/*  764 */ make_floatx80_init(0x49e8, 0xf7ce36540d1c8255),
+/*  765 */ make_floatx80_init(0x49ec, 0x9ae0e1f48831d175),
+/*  766 */ make_floatx80_init(0x49ef, 0xc1991a71aa3e45d2),
+/*  767 */ make_floatx80_init(0x49f2, 0xf1ff610e14cdd747),
+/*  768 */ make_floatx80_init(0x49f6, 0x973f9ca8cd00a68c),
+/*  769 */ make_floatx80_init(0x49f9, 0xbd0f83d30040d030),
+/*  770 */ make_floatx80_init(0x49fc, 0xec5364c7c051043b),
+/*  771 */ make_floatx80_init(0x4a00, 0x93b41efcd832a2a5),
+/*  772 */ make_floatx80_init(0x4a03, 0xb8a126bc0e3f4b4e),
+/*  773 */ make_floatx80_init(0x4a06, 0xe6c9706b11cf1e22),
+/*  774 */ make_floatx80_init(0x4a0a, 0x903de642eb2172d5),
+/*  775 */ make_floatx80_init(0x4a0d, 0xb44d5fd3a5e9cf8b),
+/*  776 */ make_floatx80_init(0x4a10, 0xe160b7c88f64436d),
+/*  777 */ make_floatx80_init(0x4a14, 0x8cdc72dd599eaa24),
+/*  778 */ make_floatx80_init(0x4a17, 0xb0138f94b00654ad),
+/*  779 */ make_floatx80_init(0x4a1a, 0xdc187379dc07e9d9),
+/*  780 */ make_floatx80_init(0x4a1e, 0x898f482c2984f227),
+/*  781 */ make_floatx80_init(0x4a21, 0xabf31a3733e62eb1),
+/*  782 */ make_floatx80_init(0x4a24, 0xd6efe0c500dfba5e),
+/*  783 */ make_floatx80_init(0x4a28, 0x8655ec7b208bd47a),
+/*  784 */ make_floatx80_init(0x4a2b, 0xa7eb6799e8aec999),
+/*  785 */ make_floatx80_init(0x4a2e, 0xd1e6418062da7bff),
+/*  786 */ make_floatx80_init(0x4a32, 0x832fe8f03dc88d80),
+/*  787 */ make_floatx80_init(0x4a35, 0xa3fbe32c4d3ab0e0),
+/*  788 */ make_floatx80_init(0x4a38, 0xccfadbf760895d17),
+/*  789 */ make_floatx80_init(0x4a3c, 0x801cc97a9c55da2f),
+/*  790 */ make_floatx80_init(0x4a3f, 0xa023fbd9436b50ba),
+/*  791 */ make_floatx80_init(0x4a42, 0xc82cfacf944624e9),
+/*  792 */ make_floatx80_init(0x4a45, 0xfa3839837957ae23),
+/*  793 */ make_floatx80_init(0x4a49, 0x9c6323f22bd6ccd6),
+/*  794 */ make_floatx80_init(0x4a4c, 0xc37beceeb6cc800b),
+/*  795 */ make_floatx80_init(0x4a4f, 0xf45ae82a647fa00e),
+/*  796 */ make_floatx80_init(0x4a53, 0x98b8d11a7ecfc409),
+/*  797 */ make_floatx80_init(0x4a56, 0xbee705611e83b50b),
+/*  798 */ make_floatx80_init(0x4a59, 0xeea0c6b96624a24e),
+/*  799 */ make_floatx80_init(0x4a5d, 0x95247c33dfd6e571),
+/*  800 */ make_floatx80_init(0x4a60, 0xba6d9b40d7cc9ecd),
+/*  801 */ make_floatx80_init(0x4a63, 0xe90902110dbfc680),
+/*  802 */ make_floatx80_init(0x4a67, 0x91a5a14aa897dc10),
+/*  803 */ make_floatx80_init(0x4a6a, 0xb60f099d52bdd314),
+/*  804 */ make_floatx80_init(0x4a6d, 0xe392cc04a76d47d9),
+/*  805 */ make_floatx80_init(0x4a71, 0x8e3bbf82e8a44ce8),
+/*  806 */ make_floatx80_init(0x4a74, 0xb1caaf63a2cd6022),
+/*  807 */ make_floatx80_init(0x4a77, 0xde3d5b3c8b80b82a),
+/*  808 */ make_floatx80_init(0x4a7b, 0x8ae65905d730731a),
+/*  809 */ make_floatx80_init(0x4a7e, 0xad9fef474cfc8fe1),
+/*  810 */ make_floatx80_init(0x4a81, 0xd907eb19203bb3d9),
+/*  811 */ make_floatx80_init(0x4a85, 0x87a4f2efb4255068),
+/*  812 */ make_floatx80_init(0x4a88, 0xa98e2faba12ea482),
+/*  813 */ make_floatx80_init(0x4a8b, 0xd3f1bb96897a4da2),
+/*  814 */ make_floatx80_init(0x4a8f, 0x8477153e15ec7085),
+/*  815 */ make_floatx80_init(0x4a92, 0xa594da8d9b678ca7),
+/*  816 */ make_floatx80_init(0x4a95, 0xcefa113102416fd0),
+/*  817 */ make_floatx80_init(0x4a99, 0x815c4abea168e5e2),
+/*  818 */ make_floatx80_init(0x4a9c, 0xa1b35d6e49c31f5b),
+/*  819 */ make_floatx80_init(0x4a9f, 0xca2034c9dc33e731),
+/*  820 */ make_floatx80_init(0x4aa2, 0xfca841fc5340e0fe),
+/*  821 */ make_floatx80_init(0x4aa6, 0x9de9293db4088c9e),
+/*  822 */ make_floatx80_init(0x4aa9, 0xc563738d210aafc6),
+/*  823 */ make_floatx80_init(0x4aac, 0xf6bc5070694d5bb8),
+/*  824 */ make_floatx80_init(0x4ab0, 0x9a35b24641d05953),
+/*  825 */ make_floatx80_init(0x4ab3, 0xc0c31ed7d2446fa7),
+/*  826 */ make_floatx80_init(0x4ab6, 0xf0f3e68dc6d58b91),
+/*  827 */ make_floatx80_init(0x4aba, 0x969870189c45773b),
+/*  828 */ make_floatx80_init(0x4abd, 0xbc3e8c1ec356d50a),
+/*  829 */ make_floatx80_init(0x4ac0, 0xeb4e2f26742c8a4c),
+/*  830 */ make_floatx80_init(0x4ac4, 0x9310dd78089bd66f),
+/*  831 */ make_floatx80_init(0x4ac7, 0xb7d514d60ac2cc0b),
+/*  832 */ make_floatx80_init(0x4aca, 0xe5ca5a0b8d737f0e),
+/*  833 */ make_floatx80_init(0x4ace, 0x8f9e784738682f69),
+/*  834 */ make_floatx80_init(0x4ad1, 0xb386165906823b43),
+/*  835 */ make_floatx80_init(0x4ad4, 0xe0679bef4822ca14),
+/*  836 */ make_floatx80_init(0x4ad8, 0x8c40c1758d15be4c),
+/*  837 */ make_floatx80_init(0x4adb, 0xaf50f1d2f05b2ddf),
+/*  838 */ make_floatx80_init(0x4ade, 0xdb252e47ac71f957),
+/*  839 */ make_floatx80_init(0x4ae2, 0x88f73ceccbc73bd7),
+/*  840 */ make_floatx80_init(0x4ae5, 0xab350c27feb90acc),
+/*  841 */ make_floatx80_init(0x4ae8, 0xd6024f31fe674d7f),
+/*  842 */ make_floatx80_init(0x4aec, 0x85c1717f3f009070),
+/*  843 */ make_floatx80_init(0x4aef, 0xa731cddf0ec0b48b),
+/*  844 */ make_floatx80_init(0x4af2, 0xd0fe4156d270e1ae),
+/*  845 */ make_floatx80_init(0x4af6, 0x829ee8d643868d0d),
+/*  846 */ make_floatx80_init(0x4af9, 0xa346a30bd4683050),
+/*  847 */ make_floatx80_init(0x4afc, 0xcc184bcec9823c64),
+/*  848 */ make_floatx80_init(0x4aff, 0xff1e5ec27be2cb7d),
+/*  849 */ make_floatx80_init(0x4b03, 0x9f72fb398d6dbf2e),
+/*  850 */ make_floatx80_init(0x4b06, 0xc74fba07f0c92efa),
+/*  851 */ make_floatx80_init(0x4b09, 0xf923a889ecfb7ab8),
+/*  852 */ make_floatx80_init(0x4b0d, 0x9bb64956341d2cb3),
+/*  853 */ make_floatx80_init(0x4b10, 0xc2a3dbabc12477e0),
+/*  854 */ make_floatx80_init(0x4b13, 0xf34cd296b16d95d8),
+/*  855 */ make_floatx80_init(0x4b17, 0x9810039e2ee47da7),
+/*  856 */ make_floatx80_init(0x4b1a, 0xbe140485ba9d9d11),
+/*  857 */ make_floatx80_init(0x4b1d, 0xed9905a729450455),
+/*  858 */ make_floatx80_init(0x4b21, 0x947fa38879cb22b5),
+/*  859 */ make_floatx80_init(0x4b24, 0xb99f8c6a983deb62),
+/*  860 */ make_floatx80_init(0x4b27, 0xe8076f853e4d663b),
+/*  861 */ make_floatx80_init(0x4b2b, 0x9104a5b346f05fe5),
+/*  862 */ make_floatx80_init(0x4b2e, 0xb545cf2018ac77de),
+/*  863 */ make_floatx80_init(0x4b31, 0xe29742e81ed795d6),
+/*  864 */ make_floatx80_init(0x4b35, 0x8d9e89d11346bda5),
+/*  865 */ make_floatx80_init(0x4b38, 0xb1062c4558186d0f),
+/*  866 */ make_floatx80_init(0x4b3b, 0xdd47b756ae1e8853),
+/*  867 */ make_floatx80_init(0x4b3f, 0x8a4cd2962cd31534),
+/*  868 */ make_floatx80_init(0x4b42, 0xace0073bb807da81),
+/*  869 */ make_floatx80_init(0x4b45, 0xd818090aa609d121),
+/*  870 */ make_floatx80_init(0x4b49, 0x870f05a6a7c622b4),
+/*  871 */ make_floatx80_init(0x4b4c, 0xa8d2c71051b7ab62),
+/*  872 */ make_floatx80_init(0x4b4f, 0xd30778d46625963a),
+/*  873 */ make_floatx80_init(0x4b53, 0x83e4ab84bfd77de4),
+/*  874 */ make_floatx80_init(0x4b56, 0xa4ddd665efcd5d5d),
+/*  875 */ make_floatx80_init(0x4b59, 0xce154bff6bc0b4b5),
+/*  876 */ make_floatx80_init(0x4b5d, 0x80cd4f7fa35870f1),
+/*  877 */ make_floatx80_init(0x4b60, 0xa100a35f8c2e8d2d),
+/*  878 */ make_floatx80_init(0x4b63, 0xc940cc376f3a3078),
+/*  879 */ make_floatx80_init(0x4b66, 0xfb90ff454b08bc96),
+/*  880 */ make_floatx80_init(0x4b6a, 0x9d3a9f8b4ee575de),
+/*  881 */ make_floatx80_init(0x4b6d, 0xc489476e229ed355),
+/*  882 */ make_floatx80_init(0x4b70, 0xf5ab9949ab46882b),
+/*  883 */ make_floatx80_init(0x4b74, 0x998b3fce0b0c151b),
+/*  884 */ make_floatx80_init(0x4b77, 0xbfee0fc18dcf1a61),
+/*  885 */ make_floatx80_init(0x4b7a, 0xefe993b1f142e0fa),
+/*  886 */ make_floatx80_init(0x4b7e, 0x95f1fc4f36c9cc9c),
+/*  887 */ make_floatx80_init(0x4b81, 0xbb6e7b63047c3fc3),
+/*  888 */ make_floatx80_init(0x4b84, 0xea4a1a3bc59b4fb4),
+/*  889 */ make_floatx80_init(0x4b88, 0x926e50655b8111d0),
+/*  890 */ make_floatx80_init(0x4b8b, 0xb709e47eb2615645),
+/*  891 */ make_floatx80_init(0x4b8e, 0xe4cc5d9e5ef9abd6),
+/*  892 */ make_floatx80_init(0x4b92, 0x8effba82fb5c0b66),
+/*  893 */ make_floatx80_init(0x4b95, 0xb2bfa923ba330e3f),
+/*  894 */ make_floatx80_init(0x4b98, 0xdf6f936ca8bfd1cf),
+/*  895 */ make_floatx80_init(0x4b9c, 0x8ba5bc23e977e321),
+/*  896 */ make_floatx80_init(0x4b9f, 0xae8f2b2ce3d5dbea),
+/*  897 */ make_floatx80_init(0x4ba2, 0xda32f5f81ccb52e4),
+/*  898 */ make_floatx80_init(0x4ba6, 0x885fd9bb11ff13ce),
+/*  899 */ make_floatx80_init(0x4ba9, 0xaa77d029d67ed8c2),
+/*  900 */ make_floatx80_init(0x4bac, 0xd515c4344c1e8ef3),
+/*  901 */ make_floatx80_init(0x4bb0, 0x852d9aa0af931958),
+/*  902 */ make_floatx80_init(0x4bb3, 0xa6790148db77dfae),
+/*  903 */ make_floatx80_init(0x4bb6, 0xd017419b1255d799),
+/*  904 */ make_floatx80_init(0x4bba, 0x820e8900eb75a6c0),
+/*  905 */ make_floatx80_init(0x4bbd, 0xa2922b412653106f),
+/*  906 */ make_floatx80_init(0x4bc0, 0xcb36b6116fe7d48b),
+/*  907 */ make_floatx80_init(0x4bc3, 0xfe046395cbe1c9ae),
+/*  908 */ make_floatx80_init(0x4bc7, 0x9ec2be3d9f6d1e0d),
+/*  909 */ make_floatx80_init(0x4bca, 0xc6736dcd07486590),
+/*  910 */ make_floatx80_init(0x4bcd, 0xf8104940491a7ef4),
+/*  911 */ make_floatx80_init(0x4bd1, 0x9b0a2dc82db08f59),
+/*  912 */ make_floatx80_init(0x4bd4, 0xc1ccb93a391cb32f),
+/*  913 */ make_floatx80_init(0x4bd7, 0xf23fe788c763dffa),
+/*  914 */ make_floatx80_init(0x4bdb, 0x9767f0b57c9e6bfc),
+/*  915 */ make_floatx80_init(0x4bde, 0xbd41ece2dbc606fc),
+/*  916 */ make_floatx80_init(0x4be1, 0xec92681b92b788ba),
+/*  917 */ make_floatx80_init(0x4be5, 0x93db81113bb2b575),
+/*  918 */ make_floatx80_init(0x4be8, 0xb8d261558a9f62d2),
+/*  919 */ make_floatx80_init(0x4beb, 0xe706f9aaed473b86),
+/*  920 */ make_floatx80_init(0x4bef, 0x90645c0ad44c8534),
+/*  921 */ make_floatx80_init(0x4bf2, 0xb47d730d895fa681),
+/*  922 */ make_floatx80_init(0x4bf5, 0xe19ccfd0ebb79021),
+/*  923 */ make_floatx80_init(0x4bf9, 0x8d0201e29352ba15),
+/*  924 */ make_floatx80_init(0x4bfc, 0xb042825b3827689a),
+/*  925 */ make_floatx80_init(0x4bff, 0xdc5322f2063142c0),
+/*  926 */ make_floatx80_init(0x4c03, 0x89b3f5d743dec9b8),
+/*  927 */ make_floatx80_init(0x4c06, 0xac20f34d14d67c26),
+/*  928 */ make_floatx80_init(0x4c09, 0xd72930205a0c1b30),
+/*  929 */ make_floatx80_init(0x4c0d, 0x8679be14384790fe),
+/*  930 */ make_floatx80_init(0x4c10, 0xa8182d994659753d),
+/*  931 */ make_floatx80_init(0x4c13, 0xd21e38ff97efd28d),
+/*  932 */ make_floatx80_init(0x4c17, 0x8352e39fbef5e398),
+/*  933 */ make_floatx80_init(0x4c1a, 0xa4279c87aeb35c7e),
+/*  934 */ make_floatx80_init(0x4c1d, 0xcd3183a99a60339d),
+/*  935 */ make_floatx80_init(0x4c21, 0x803ef24a007c2042),
+/*  936 */ make_floatx80_init(0x4c24, 0xa04eaedc809b2853),
+/*  937 */ make_floatx80_init(0x4c27, 0xc8625a93a0c1f268),
+/*  938 */ make_floatx80_init(0x4c2a, 0xfa7af13888f26f01),
+/*  939 */ make_floatx80_init(0x4c2e, 0x9c8cd6c355978561),
+/*  940 */ make_floatx80_init(0x4c31, 0xc3b00c742afd66b9),
+/*  941 */ make_floatx80_init(0x4c34, 0xf49c0f9135bcc067),
+/*  942 */ make_floatx80_init(0x4c38, 0x98e189bac195f841),
+/*  943 */ make_floatx80_init(0x4c3b, 0xbf19ec2971fb7651),
+/*  944 */ make_floatx80_init(0x4c3e, 0xeee06733ce7a53e5),
+/*  945 */ make_floatx80_init(0x4c42, 0x954c4080610c746f),
+/*  946 */ make_floatx80_init(0x4c45, 0xba9f50a0794f918b),
+/*  947 */ make_floatx80_init(0x4c48, 0xe94724c897a375ee),
+/*  948 */ make_floatx80_init(0x4c4c, 0x91cc76fd5ec629b5),
+/*  949 */ make_floatx80_init(0x4c4f, 0xb63f94bcb677b422),
+/*  950 */ make_floatx80_init(0x4c52, 0xe3cf79ebe415a12a),
+/*  951 */ make_floatx80_init(0x4c56, 0x8e61ac336e8d84ba),
+/*  952 */ make_floatx80_init(0x4c59, 0xb1fa17404a30e5e9),
+/*  953 */ make_floatx80_init(0x4c5c, 0xde789d105cbd1f63),
+/*  954 */ make_floatx80_init(0x4c60, 0x8b0b622a39f6339e),
+/*  955 */ make_floatx80_init(0x4c63, 0xadce3ab4c873c085),
+/*  956 */ make_floatx80_init(0x4c66, 0xd941c961fa90b0a7),
+/*  957 */ make_floatx80_init(0x4c6a, 0x87c91ddd3c9a6e68),
+/*  958 */ make_floatx80_init(0x4c6d, 0xa9bb65548bc10a02),
+/*  959 */ make_floatx80_init(0x4c70, 0xd42a3ea9aeb14c83),
+/*  960 */ make_floatx80_init(0x4c74, 0x849a672a0d2ecfd2),
+/*  961 */ make_floatx80_init(0x4c77, 0xa5c100f4907a83c6),
+/*  962 */ make_floatx80_init(0x4c7a, 0xcf314131b49924b8),
+/*  963 */ make_floatx80_init(0x4c7e, 0x817ec8bf10dfb6f3),
+/*  964 */ make_floatx80_init(0x4c81, 0xa1de7aeed517a4b0),
+/*  965 */ make_floatx80_init(0x4c84, 0xca5619aa8a5d8ddb),
+/*  966 */ make_floatx80_init(0x4c87, 0xfceba0152cf4f152),
+/*  967 */ make_floatx80_init(0x4c8b, 0x9e13440d3c1916d3),
+/*  968 */ make_floatx80_init(0x4c8e, 0xc59815108b1f5c88),
+/*  969 */ make_floatx80_init(0x4c91, 0xf6fe1a54ade733aa),
+/*  970 */ make_floatx80_init(0x4c95, 0x9a5ed074ecb0804b),
+/*  971 */ make_floatx80_init(0x4c98, 0xc0f6849227dca05d),
+/*  972 */ make_floatx80_init(0x4c9b, 0xf13425b6b1d3c874),
+/*  973 */ make_floatx80_init(0x4c9f, 0x96c097922f245d49),
+/*  974 */ make_floatx80_init(0x4ca2, 0xbc70bd76baed749b),
+/*  975 */ make_floatx80_init(0x4ca5, 0xeb8cecd469a8d1c2),
+/*  976 */ make_floatx80_init(0x4ca9, 0x93381404c2098319),
+/*  977 */ make_floatx80_init(0x4cac, 0xb8061905f28be3df),
+/*  978 */ make_floatx80_init(0x4caf, 0xe6079f476f2edcd7),
+/*  979 */ make_floatx80_init(0x4cb3, 0x8fc4c38ca57d4a06),
+/*  980 */ make_floatx80_init(0x4cb6, 0xb3b5f46fcedc9c88),
+/*  981 */ make_floatx80_init(0x4cb9, 0xe0a3718bc293c3aa),
+/*  982 */ make_floatx80_init(0x4cbd, 0x8c6626f7599c5a4a),
+/*  983 */ make_floatx80_init(0x4cc0, 0xaf7fb0b5300370dd),
+/*  984 */ make_floatx80_init(0x4cc3, 0xdb5f9ce27c044d14),
+/*  985 */ make_floatx80_init(0x4cc7, 0x891bc20d8d82b02d),
+/*  986 */ make_floatx80_init(0x4cca, 0xab62b290f0e35c38),
+/*  987 */ make_floatx80_init(0x4ccd, 0xd63b5f352d1c3346),
+/*  988 */ make_floatx80_init(0x4cd1, 0x85e51b813c31a00c),
+/*  989 */ make_floatx80_init(0x4cd4, 0xa75e62618b3e080e),
+/*  990 */ make_floatx80_init(0x4cd7, 0xd135faf9ee0d8a12),
+/*  991 */ make_floatx80_init(0x4cdb, 0x82c1bcdc34c8764b),
+/*  992 */ make_floatx80_init(0x4cde, 0xa3722c1341fa93de),
+/*  993 */ make_floatx80_init(0x4ce1, 0xcc4eb718127938d6),
+/*  994 */ make_floatx80_init(0x4ce4, 0xff6264de1717870b),
+/*  995 */ make_floatx80_init(0x4ce8, 0x9f9d7f0ace6eb467),
+/*  996 */ make_floatx80_init(0x4ceb, 0xc784decd820a6181),
+/*  997 */ make_floatx80_init(0x4cee, 0xf9661680e28cf9e1),
+/*  998 */ make_floatx80_init(0x4cf2, 0x9bdfce108d981c2c),
+/*  999 */ make_floatx80_init(0x4cf5, 0xc2d7c194b0fe2338),
+/* 1000 */ make_floatx80_init(0x4cf8, 0xf38db1f9dd3dac05),
+/* 1001 */ make_floatx80_init(0x4cfc, 0x98388f3c2a468b83),
+/* 1002 */ make_floatx80_init(0x4cff, 0xbe46b30b34d82e64),
+/* 1003 */ make_floatx80_init(0x4d02, 0xedd85fce020e39fd),
+/* 1004 */ make_floatx80_init(0x4d06, 0x94a73be0c148e43e),
+/* 1005 */ make_floatx80_init(0x4d09, 0xb9d10ad8f19b1d4e),
+/* 1006 */ make_floatx80_init(0x4d0c, 0xe8454d8f2e01e4a1),
+/* 1007 */ make_floatx80_init(0x4d10, 0x912b50797cc12ee5),
+/* 1008 */ make_floatx80_init(0x4d13, 0xb5762497dbf17a9e),
+/* 1009 */ make_floatx80_init(0x4d16, 0xe2d3adbdd2edd946),
+/* 1010 */ make_floatx80_init(0x4d1a, 0x8dc44c96a3d4a7cc),
+/* 1011 */ make_floatx80_init(0x4d1d, 0xb1355fbc4cc9d1be),
+/* 1012 */ make_floatx80_init(0x4d20, 0xdd82b7ab5ffc462e),
+/* 1013 */ make_floatx80_init(0x4d24, 0x8a71b2cb1bfdabdd),
+/* 1014 */ make_floatx80_init(0x4d27, 0xad0e1f7de2fd16d4),
+/* 1015 */ make_floatx80_init(0x4d2a, 0xd851a75d5bbc5c89),
+/* 1016 */ make_floatx80_init(0x4d2e, 0x8733089a5955b9d6),
+/* 1017 */ make_floatx80_init(0x4d31, 0xa8ffcac0efab284b),
+/* 1018 */ make_floatx80_init(0x4d34, 0xd33fbd712b95f25e),
+/* 1019 */ make_floatx80_init(0x4d38, 0x8407d666bb3db77b),
+/* 1020 */ make_floatx80_init(0x4d3b, 0xa509cc006a0d2559),
+/* 1021 */ make_floatx80_init(0x4d3e, 0xce4c3f0084906eb0),
+/* 1022 */ make_floatx80_init(0x4d42, 0x80efa76052da452e),
+/* 1023 */ make_floatx80_init(0x4d45, 0xa12b91386790d679),
+/* 1024 */ make_floatx80_init(0x4d48, 0xc976758681750c17),
+/* 1025 */ make_floatx80_init(0x4d4b, 0xfbd412e821d24f1d),
+/* 1026 */ make_floatx80_init(0x4d4f, 0x9d648bd115237172),
+/* 1027 */ make_floatx80_init(0x4d52, 0xc4bdaec55a6c4dcf),
+/* 1028 */ make_floatx80_init(0x4d55, 0xf5ed1a76b1076143),
+/* 1029 */ make_floatx80_init(0x4d59, 0x99b4308a2ea49cca),
+/* 1030 */ make_floatx80_init(0x4d5c, 0xc0213cacba4dc3fc),
+/* 1031 */ make_floatx80_init(0x4d5f, 0xf0298bd7e8e134fb),
+/* 1032 */ make_floatx80_init(0x4d63, 0x9619f766f18cc11d),
+/* 1033 */ make_floatx80_init(0x4d66, 0xbba07540adeff164),
+/* 1034 */ make_floatx80_init(0x4d69, 0xea889290d96bedbd),
+/* 1035 */ make_floatx80_init(0x4d6d, 0x92955b9a87e37496),
+/* 1036 */ make_floatx80_init(0x4d70, 0xb73ab28129dc51bc),
+/* 1037 */ make_floatx80_init(0x4d73, 0xe5095f217453662b),
+/* 1038 */ make_floatx80_init(0x4d77, 0x8f25db74e8b41fdb),
+/* 1039 */ make_floatx80_init(0x4d7a, 0xb2ef525222e127d1),
+/* 1040 */ make_floatx80_init(0x4d7d, 0xdfab26e6ab9971c6),
+/* 1041 */ make_floatx80_init(0x4d81, 0x8bcaf8502b3fe71c),
+/* 1042 */ make_floatx80_init(0x4d84, 0xaebdb664360fe0e2),
+/* 1043 */ make_floatx80_init(0x4d87, 0xda6d23fd4393d91b),
+/* 1044 */ make_floatx80_init(0x4d8b, 0x8884367e4a3c67b1),
+/* 1045 */ make_floatx80_init(0x4d8e, 0xaaa5441ddccb819d),
+/* 1046 */ make_floatx80_init(0x4d91, 0xd54e952553fe6204),
+/* 1047 */ make_floatx80_init(0x4d95, 0x85511d37547efd43),
+/* 1048 */ make_floatx80_init(0x4d98, 0xa6a56485299ebc93),
+/* 1049 */ make_floatx80_init(0x4d9b, 0xd04ebda674066bb8),
+/* 1050 */ make_floatx80_init(0x4d9f, 0x8231368808840353),
+/* 1051 */ make_floatx80_init(0x4da2, 0xa2bd842a0aa50428),
+/* 1052 */ make_floatx80_init(0x4da5, 0xcb6ce5348d4e4532),
+/* 1053 */ make_floatx80_init(0x4da8, 0xfe481e81b0a1d67e),
+/* 1054 */ make_floatx80_init(0x4dac, 0x9eed13110e65260f),
+/* 1055 */ make_floatx80_init(0x4daf, 0xc6a857d551fe6f93),
+/* 1056 */ make_floatx80_init(0x4db2, 0xf8526dcaa67e0b78),
+/* 1057 */ make_floatx80_init(0x4db6, 0x9b33849ea80ec72b),
+/* 1058 */ make_floatx80_init(0x4db9, 0xc20065c6521278f5),
+/* 1059 */ make_floatx80_init(0x4dbc, 0xf2807f37e6971733),
+/* 1060 */ make_floatx80_init(0x4dc0, 0x97904f82f01e6e80),
+/* 1061 */ make_floatx80_init(0x4dc3, 0xbd746363ac260a20),
+/* 1062 */ make_floatx80_init(0x4dc6, 0xecd17c3c972f8ca8),
+/* 1063 */ make_floatx80_init(0x4dca, 0x9402eda5de7db7e9),
+/* 1064 */ make_floatx80_init(0x4dcd, 0xb903a90f561d25e3),
+/* 1065 */ make_floatx80_init(0x4dd0, 0xe74493532ba46f5c),
+/* 1066 */ make_floatx80_init(0x4dd4, 0x908adc13fb46c599),
+/* 1067 */ make_floatx80_init(0x4dd7, 0xb4ad9318fa187700),
+/* 1068 */ make_floatx80_init(0x4dda, 0xe1d8f7df389e94bf),
+/* 1069 */ make_floatx80_init(0x4dde, 0x8d279aeb83631cf8),
+/* 1070 */ make_floatx80_init(0x4de1, 0xb07181a6643be436),
+/* 1071 */ make_floatx80_init(0x4de4, 0xdc8de20ffd4add43),
+/* 1072 */ make_floatx80_init(0x4de8, 0x89d8ad49fe4eca4a),
+/* 1073 */ make_floatx80_init(0x4deb, 0xac4ed89c7de27cdc),
+/* 1074 */ make_floatx80_init(0x4dee, 0xd7628ec39d5b1c13),
+/* 1075 */ make_floatx80_init(0x4df2, 0x869d993a4258f18c),
+/* 1076 */ make_floatx80_init(0x4df5, 0xa844ff88d2ef2def),
+/* 1077 */ make_floatx80_init(0x4df8, 0xd2563f6b07aaf96b),
+/* 1078 */ make_floatx80_init(0x4dfc, 0x8375e7a2e4cadbe3),
+/* 1079 */ make_floatx80_init(0x4dff, 0xa453618b9dfd92dc),
+/* 1080 */ make_floatx80_init(0x4e02, 0xcd6839ee857cf792),
+/* 1081 */ make_floatx80_init(0x4e06, 0x80612435136e1abc),
+/* 1082 */ make_floatx80_init(0x4e09, 0xa0796d425849a16a),
+/* 1083 */ make_floatx80_init(0x4e0c, 0xc897c892ee5c09c5),
+/* 1084 */ make_floatx80_init(0x4e0f, 0xfabdbab7a9f30c36),
+/* 1085 */ make_floatx80_init(0x4e13, 0x9cb694b2ca37e7a2),
+/* 1086 */ make_floatx80_init(0x4e16, 0xc3e439df7cc5e18a),
+/* 1087 */ make_floatx80_init(0x4e19, 0xf4dd48575bf759ed),
+/* 1088 */ make_floatx80_init(0x4e1d, 0x990a4d36997a9834),
+/* 1089 */ make_floatx80_init(0x4e20, 0xbf4ce0843fd93e41),
+/* 1090 */ make_floatx80_init(0x4e23, 0xef2018a54fcf8dd1),
+/* 1091 */ make_floatx80_init(0x4e27, 0x95740f6751e1b8a3),
+/* 1092 */ make_floatx80_init(0x4e2a, 0xbad11341265a26cc),
+/* 1093 */ make_floatx80_init(0x4e2d, 0xe98558116ff0b07f),
+/* 1094 */ make_floatx80_init(0x4e31, 0x91f3570ae5f66e4f),
+/* 1095 */ make_floatx80_init(0x4e34, 0xb6702ccd9f7409e3),
+/* 1096 */ make_floatx80_init(0x4e37, 0xe40c380107510c5c),
+/* 1097 */ make_floatx80_init(0x4e3b, 0x8e87a300a492a7b9),
+/* 1098 */ make_floatx80_init(0x4e3e, 0xb2298bc0cdb751a8),
+/* 1099 */ make_floatx80_init(0x4e41, 0xdeb3eeb101252611),
+/* 1100 */ make_floatx80_init(0x4e45, 0x8b30752ea0b737cb),
+/* 1101 */ make_floatx80_init(0x4e48, 0xadfc927a48e505be),
+/* 1102 */ make_floatx80_init(0x4e4b, 0xd97bb718db1e472d),
+/* 1103 */ make_floatx80_init(0x4e4f, 0x87ed526f88f2ec7c),
+/* 1104 */ make_floatx80_init(0x4e52, 0xa9e8a70b6b2fa79b),
+/* 1105 */ make_floatx80_init(0x4e55, 0xd462d0ce45fb9182),
+/* 1106 */ make_floatx80_init(0x4e59, 0x84bdc280ebbd3af1),
+/* 1107 */ make_floatx80_init(0x4e5c, 0xa5ed332126ac89ae),
+/* 1108 */ make_floatx80_init(0x4e5f, 0xcf687fe97057ac19),
+/* 1109 */ make_floatx80_init(0x4e63, 0x81a14ff1e636cb90),
+/* 1110 */ make_floatx80_init(0x4e66, 0xa209a3ee5fc47e73),
+/* 1111 */ make_floatx80_init(0x4e69, 0xca8c0ce9f7b59e10),
+/* 1112 */ make_floatx80_init(0x4e6c, 0xfd2f102475a30594),
+/* 1113 */ make_floatx80_init(0x4e70, 0x9e3d6a16c985e37d),
+/* 1114 */ make_floatx80_init(0x4e73, 0xc5ccc49c7be75c5c),
+/* 1115 */ make_floatx80_init(0x4e76, 0xf73ff5c39ae13373),
+/* 1116 */ make_floatx80_init(0x4e7a, 0x9a87f99a40ccc028),
+/* 1117 */ make_floatx80_init(0x4e7d, 0xc129f800d0fff032),
+/* 1118 */ make_floatx80_init(0x4e80, 0xf1747601053fec3e),
+/* 1119 */ make_floatx80_init(0x4e84, 0x96e8c9c0a347f3a7),
+/* 1120 */ make_floatx80_init(0x4e87, 0xbca2fc30cc19f091),
+/* 1121 */ make_floatx80_init(0x4e8a, 0xebcbbb3cff206cb5),
+/* 1122 */ make_floatx80_init(0x4e8e, 0x935f55061f7443f1),
+/* 1123 */ make_floatx80_init(0x4e91, 0xb8372a47a75154ed),
+/* 1124 */ make_floatx80_init(0x4e94, 0xe644f4d99125aa29),
+/* 1125 */ make_floatx80_init(0x4e98, 0x8feb1907fab78a59),
+/* 1126 */ make_floatx80_init(0x4e9b, 0xb3e5df49f9656cf0),
+/* 1127 */ make_floatx80_init(0x4e9e, 0xe0df571c77bec82c),
+/* 1128 */ make_floatx80_init(0x4ea2, 0x8c8b9671cad73d1b),
+/* 1129 */ make_floatx80_init(0x4ea5, 0xafae7c0e3d8d0c62),
+/* 1130 */ make_floatx80_init(0x4ea8, 0xdb9a1b11ccf04f7b),
+/* 1131 */ make_floatx80_init(0x4eac, 0x894050eb201631ad),
+/* 1132 */ make_floatx80_init(0x4eaf, 0xab906525e81bbe18),
+/* 1133 */ make_floatx80_init(0x4eb2, 0xd6747e6f6222ad9e),
+/* 1134 */ make_floatx80_init(0x4eb6, 0x8608cf059d55ac83),
+/* 1135 */ make_floatx80_init(0x4eb9, 0xa78b02c704ab17a3),
+/* 1136 */ make_floatx80_init(0x4ebc, 0xd16dc378c5d5dd8c),
+/* 1137 */ make_floatx80_init(0x4ec0, 0x82e49a2b7ba5aa77),
+/* 1138 */ make_floatx80_init(0x4ec3, 0xa39dc0b65a8f1515),
+/* 1139 */ make_floatx80_init(0x4ec6, 0xcc8530e3f132da5b),
+/* 1140 */ make_floatx80_init(0x4ec9, 0xffa67d1ced7f90f1),
+/* 1141 */ make_floatx80_init(0x4ecd, 0x9fc80e32146fba97),
+/* 1142 */ make_floatx80_init(0x4ed0, 0xc7ba11be998ba93d),
+/* 1143 */ make_floatx80_init(0x4ed3, 0xf9a8962e3fee938c),
+/* 1144 */ make_floatx80_init(0x4ed7, 0x9c095ddce7f51c37),
+/* 1145 */ make_floatx80_init(0x4eda, 0xc30bb55421f26345),
+/* 1146 */ make_floatx80_init(0x4edd, 0xf3cea2a92a6efc16),
+/* 1147 */ make_floatx80_init(0x4ee1, 0x986125a9ba855d8e),
+/* 1148 */ make_floatx80_init(0x4ee4, 0xbe796f142926b4f2),
+/* 1149 */ make_floatx80_init(0x4ee7, 0xee17cad93370622e),
+/* 1150 */ make_floatx80_init(0x4eeb, 0x94cedec7c0263d5d),
+/* 1151 */ make_floatx80_init(0x4eee, 0xba029679b02fccb4),
+/* 1152 */ make_floatx80_init(0x4ef1, 0xe8833c181c3bbfe1),
+/* 1153 */ make_floatx80_init(0x4ef5, 0x9152058f11a557ed),
+/* 1154 */ make_floatx80_init(0x4ef8, 0xb5a686f2d60eade8),
+/* 1155 */ make_floatx80_init(0x4efb, 0xe31028af8b925962),
+/* 1156 */ make_floatx80_init(0x4eff, 0x8dea196db73b77dd),
+/* 1157 */ make_floatx80_init(0x4f02, 0xb1649fc9250a55d4),
+/* 1158 */ make_floatx80_init(0x4f05, 0xddbdc7bb6e4ceb49),
+/* 1159 */ make_floatx80_init(0x4f09, 0x8a969cd524f0130e),
+/* 1160 */ make_floatx80_init(0x4f0c, 0xad3c440a6e2c17d1),
+/* 1161 */ make_floatx80_init(0x4f0f, 0xd88b550d09b71dc6),
+/* 1162 */ make_floatx80_init(0x4f13, 0x875715282612729b),
+/* 1163 */ make_floatx80_init(0x4f16, 0xa92cda722f970f42),
+/* 1164 */ make_floatx80_init(0x4f19, 0xd378110ebb7cd313),
+/* 1165 */ make_floatx80_init(0x4f1d, 0x842b0aa9352e03ec),
+/* 1166 */ make_floatx80_init(0x4f20, 0xa535cd53827984e7),
+/* 1167 */ make_floatx80_init(0x4f23, 0xce8340a86317e621),
+/* 1168 */ make_floatx80_init(0x4f27, 0x811208693deeefd4),
+/* 1169 */ make_floatx80_init(0x4f2a, 0xa1568a838d6aabc9),
+/* 1170 */ make_floatx80_init(0x4f2d, 0xc9ac2d2470c556bc),
+/* 1171 */ make_floatx80_init(0x4f30, 0xfc17386d8cf6ac6b),
+/* 1172 */ make_floatx80_init(0x4f34, 0x9d8e8344781a2bc3),
+/* 1173 */ make_floatx80_init(0x4f37, 0xc4f224159620b6b3),
+/* 1174 */ make_floatx80_init(0x4f3a, 0xf62ead1afba8e460),
+/* 1175 */ make_floatx80_init(0x4f3e, 0x99dd2c30dd498ebc),
+/* 1176 */ make_floatx80_init(0x4f41, 0xc054773d149bf26b),
+/* 1177 */ make_floatx80_init(0x4f44, 0xf069950c59c2ef06),
+/* 1178 */ make_floatx80_init(0x4f48, 0x9641fd27b819d564),
+/* 1179 */ make_floatx80_init(0x4f4b, 0xbbd27c71a6204abd),
+/* 1180 */ make_floatx80_init(0x4f4e, 0xeac71b8e0fa85d6c),
+/* 1181 */ make_floatx80_init(0x4f52, 0x92bc7138c9c93a63),
+/* 1182 */ make_floatx80_init(0x4f55, 0xb76b8d86fc3b88fc),
+/* 1183 */ make_floatx80_init(0x4f58, 0xe54670e8bb4a6b3b),
+/* 1184 */ make_floatx80_init(0x4f5c, 0x8f4c0691750e8305),
+/* 1185 */ make_floatx80_init(0x4f5f, 0xb31f0835d25223c6),
+/* 1186 */ make_floatx80_init(0x4f62, 0xdfe6ca4346e6acb8),
+/* 1187 */ make_floatx80_init(0x4f66, 0x8bf03e6a0c502bf3),
+/* 1188 */ make_floatx80_init(0x4f69, 0xaeec4e048f6436f0),
+/* 1189 */ make_floatx80_init(0x4f6c, 0xdaa76185b33d44ac),
+/* 1190 */ make_floatx80_init(0x4f70, 0x88a89cf390064aeb),
+/* 1191 */ make_floatx80_init(0x4f73, 0xaad2c4307407dda6),
+/* 1192 */ make_floatx80_init(0x4f76, 0xd587753c9109d510),
+/* 1193 */ make_floatx80_init(0x4f7a, 0x8574a945daa6252a),
+/* 1194 */ make_floatx80_init(0x4f7d, 0xa6d1d397514fae74),
+/* 1195 */ make_floatx80_init(0x4f80, 0xd086487d25a39a11),
+/* 1196 */ make_floatx80_init(0x4f84, 0x8253ed4e3786404b),
+/* 1197 */ make_floatx80_init(0x4f87, 0xa2e8e8a1c567d05d),
+/* 1198 */ make_floatx80_init(0x4f8a, 0xcba322ca36c1c475),
+/* 1199 */ make_floatx80_init(0x4f8d, 0xfe8beb7cc4723592),
+/* 1200 */ make_floatx80_init(0x4f91, 0x9f17732dfac7617b),
+/* 1201 */ make_floatx80_init(0x4f94, 0xc6dd4ff9797939da),
+/* 1202 */ make_floatx80_init(0x4f97, 0xf894a3f7d7d78851),
+/* 1203 */ make_floatx80_init(0x4f9b, 0x9b5ce67ae6e6b532),
+/* 1204 */ make_floatx80_init(0x4f9e, 0xc2342019a0a0627f),
+/* 1205 */ make_floatx80_init(0x4fa1, 0xf2c1282008c87b1f),
+/* 1206 */ make_floatx80_init(0x4fa5, 0x97b8b914057d4cf3),
+/* 1207 */ make_floatx80_init(0x4fa8, 0xbda6e75906dca030),
+/* 1208 */ make_floatx80_init(0x4fab, 0xed10a12f4893c83c),
+/* 1209 */ make_floatx80_init(0x4faf, 0x942a64bd8d5c5d25),
+/* 1210 */ make_floatx80_init(0x4fb2, 0xb934fdecf0b3746f),
+/* 1211 */ make_floatx80_init(0x4fb5, 0xe7823d682ce0518b),
+/* 1212 */ make_floatx80_init(0x4fb9, 0x90b166611c0c32f7),
+/* 1213 */ make_floatx80_init(0x4fbc, 0xb4ddbff9630f3fb4),
+/* 1214 */ make_floatx80_init(0x4fbf, 0xe2152ff7bbd30fa1),
+/* 1215 */ make_floatx80_init(0x4fc3, 0x8d4d3dfad563e9c5),
+/* 1216 */ make_floatx80_init(0x4fc6, 0xb0a08d798abce436),
+/* 1217 */ make_floatx80_init(0x4fc9, 0xdcc8b0d7ed6c1d44),
+/* 1218 */ make_floatx80_init(0x4fcd, 0x89fd6e86f463924a),
+/* 1219 */ make_floatx80_init(0x4fd0, 0xac7cca28b17c76dd),
+/* 1220 */ make_floatx80_init(0x4fd3, 0xd79bfcb2dddb9494),
+/* 1221 */ make_floatx80_init(0x4fd7, 0x86c17defcaa93cdc),
+/* 1222 */ make_floatx80_init(0x4fda, 0xa871dd6bbd538c14),
+/* 1223 */ make_floatx80_init(0x4fdd, 0xd28e54c6aca86f18),
+/* 1224 */ make_floatx80_init(0x4fe1, 0x8398f4fc2be9456f),
+/* 1225 */ make_floatx80_init(0x4fe4, 0xa47f323b36e396cb),
+/* 1226 */ make_floatx80_init(0x4fe7, 0xcd9efeca049c7c7e),
+/* 1227 */ make_floatx80_init(0x4feb, 0x80835f3e42e1cdcf),
+/* 1228 */ make_floatx80_init(0x4fee, 0xa0a4370dd39a4142),
+/* 1229 */ make_floatx80_init(0x4ff1, 0xc8cd44d14880d193),
+/* 1230 */ make_floatx80_init(0x4ff4, 0xfb0096059aa105f8),
+/* 1231 */ make_floatx80_init(0x4ff8, 0x9ce05dc380a4a3bb),
+/* 1232 */ make_floatx80_init(0x4ffb, 0xc418753460cdcca9),
+/* 1233 */ make_floatx80_init(0x4ffe, 0xf51e928179013fd4),
+/* 1234 */ make_floatx80_init(0x5002, 0x99331b90eba0c7e4),
+/* 1235 */ make_floatx80_init(0x5005, 0xbf7fe2752688f9de),
+/* 1236 */ make_floatx80_init(0x5008, 0xef5fdb12702b3855),
+/* 1237 */ make_floatx80_init(0x500c, 0x959be8eb861b0335),
+/* 1238 */ make_floatx80_init(0x500f, 0xbb02e32667a1c402),
+/* 1239 */ make_floatx80_init(0x5012, 0xe9c39bf0018a3503),
+/* 1240 */ make_floatx80_init(0x5016, 0x921a417600f66122),
+/* 1241 */ make_floatx80_init(0x5019, 0xb6a0d1d38133f96a),
+/* 1242 */ make_floatx80_init(0x501c, 0xe44906486180f7c5),
+/* 1243 */ make_floatx80_init(0x5020, 0x8eada3ed3cf09adb),
+/* 1244 */ make_floatx80_init(0x5023, 0xb2590ce88c2cc192),
+/* 1245 */ make_floatx80_init(0x5026, 0xdeef5022af37f1f6),
+/* 1246 */ make_floatx80_init(0x502a, 0x8b559215ad82f73a),
+/* 1247 */ make_floatx80_init(0x502d, 0xae2af69b18e3b508),
+/* 1248 */ make_floatx80_init(0x5030, 0xd9b5b441df1ca24a),
+/* 1249 */ make_floatx80_init(0x5034, 0x881190a92b71e56f),
+/* 1250 */ make_floatx80_init(0x5037, 0xaa15f4d3764e5eca),
+/* 1251 */ make_floatx80_init(0x503a, 0xd49b720853e1f67d),
+/* 1252 */ make_floatx80_init(0x503e, 0x84e12745346d3a0e),
+/* 1253 */ make_floatx80_init(0x5041, 0xa619711681888891),
+/* 1254 */ make_floatx80_init(0x5044, 0xcf9fcd5c21eaaab6),
+/* 1255 */ make_floatx80_init(0x5048, 0x81c3e0599532aab2),
+/* 1256 */ make_floatx80_init(0x504b, 0xa234d86ffa7f555e),
+/* 1257 */ make_floatx80_init(0x504e, 0xcac20e8bf91f2ab6),
+/* 1258 */ make_floatx80_init(0x5051, 0xfd72922ef766f563),
+/* 1259 */ make_floatx80_init(0x5055, 0x9e679b5d5aa0595e),
+/* 1260 */ make_floatx80_init(0x5058, 0xc6018234b1486fb5),
+/* 1261 */ make_floatx80_init(0x505b, 0xf781e2c1dd9a8ba3),
+/* 1262 */ make_floatx80_init(0x505f, 0x9ab12db92a809746),
+/* 1263 */ make_floatx80_init(0x5062, 0xc15d79277520bd17),
+/* 1264 */ make_floatx80_init(0x5065, 0xf1b4d7715268ec5d),
+/* 1265 */ make_floatx80_init(0x5069, 0x971106a6d38193ba),
+/* 1266 */ make_floatx80_init(0x506c, 0xbcd548508861f8a8),
+/* 1267 */ make_floatx80_init(0x506f, 0xec0a9a64aa7a76d3),
+/* 1268 */ make_floatx80_init(0x5073, 0x9386a07eea8c8a44),
+/* 1269 */ make_floatx80_init(0x5076, 0xb868489ea52facd5),
+/* 1270 */ make_floatx80_init(0x5079, 0xe6825ac64e7b980a),
+/* 1271 */ make_floatx80_init(0x507d, 0x901178bbf10d3f06),
+/* 1272 */ make_floatx80_init(0x5080, 0xb415d6eaed508ec8),
+/* 1273 */ make_floatx80_init(0x5083, 0xe11b4ca5a8a4b279),
+/* 1274 */ make_floatx80_init(0x5087, 0x8cb10fe78966ef8c),
+/* 1275 */ make_floatx80_init(0x508a, 0xafdd53e16bc0ab6f),
+/* 1276 */ make_floatx80_init(0x508d, 0xdbd4a8d9c6b0d64b),
+/* 1277 */ make_floatx80_init(0x5091, 0x8964e9881c2e85ef),
+/* 1278 */ make_floatx80_init(0x5094, 0xabbe23ea233a276a),
+/* 1279 */ make_floatx80_init(0x5097, 0xd6adace4ac08b145),
+/* 1280 */ make_floatx80_init(0x509b, 0x862c8c0eeb856ecb),
+/* 1281 */ make_floatx80_init(0x509e, 0xa7b7af12a666ca7e),
+/* 1282 */ make_floatx80_init(0x50a1, 0xd1a59ad750007d1d),
+/* 1283 */ make_floatx80_init(0x50a5, 0x830780c692004e32),
+/* 1284 */ make_floatx80_init(0x50a8, 0xa3c960f8368061bf),
+/* 1285 */ make_floatx80_init(0x50ab, 0xccbbb93644207a2f),
+/* 1286 */ make_floatx80_init(0x50ae, 0xffeaa783d52898ba),
+/* 1287 */ make_floatx80_init(0x50b2, 0x9ff2a8b265395f74),
+/* 1288 */ make_floatx80_init(0x50b5, 0xc7ef52defe87b751),
+/* 1289 */ make_floatx80_init(0x50b8, 0xf9eb2796be29a526),
+/* 1290 */ make_floatx80_init(0x50bc, 0x9c32f8be36da0738),
+/* 1291 */ make_floatx80_init(0x50bf, 0xc33fb6edc4908906),
+/* 1292 */ make_floatx80_init(0x50c2, 0xf40fa4a935b4ab47),
+/* 1293 */ make_floatx80_init(0x50c6, 0x9889c6e9c190eb0c),
+/* 1294 */ make_floatx80_init(0x50c9, 0xbeac38a431f525cf),
+/* 1295 */ make_floatx80_init(0x50cc, 0xee5746cd3e726f43),
+/* 1296 */ make_floatx80_init(0x50d0, 0x94f68c404707858a),
+/* 1297 */ make_floatx80_init(0x50d3, 0xba342f5058c966ed),
+/* 1298 */ make_floatx80_init(0x50d6, 0xe8c13b246efbc0a8),
+/* 1299 */ make_floatx80_init(0x50da, 0x9178c4f6c55d5869),
+/* 1300 */ make_floatx80_init(0x50dd, 0xb5d6f63476b4ae83),
+/* 1301 */ make_floatx80_init(0x50e0, 0xe34cb3c19461da24),
+/* 1302 */ make_floatx80_init(0x50e4, 0x8e0ff058fcbd2856),
+/* 1303 */ make_floatx80_init(0x50e7, 0xb193ec6f3bec726c),
+/* 1304 */ make_floatx80_init(0x50ea, 0xddf8e78b0ae78f07),
+/* 1305 */ make_floatx80_init(0x50ee, 0x8abb90b6e6d0b964),
+/* 1306 */ make_floatx80_init(0x50f1, 0xad6a74e4a084e7bd),
+/* 1307 */ make_floatx80_init(0x50f4, 0xd8c5121dc8a621ad),
+/* 1308 */ make_floatx80_init(0x50f8, 0x877b2b529d67d50c),
+/* 1309 */ make_floatx80_init(0x50fb, 0xa959f62744c1ca4f),
+/* 1310 */ make_floatx80_init(0x50fe, 0xd3b073b115f23ce3),
+/* 1311 */ make_floatx80_init(0x5102, 0x844e484eadb7660e),
+/* 1312 */ make_floatx80_init(0x5105, 0xa561da6259253f91),
+/* 1313 */ make_floatx80_init(0x5108, 0xceba50faef6e8f75),
+/* 1314 */ make_floatx80_init(0x510c, 0x8134729cd5a519a9),
+/* 1315 */ make_floatx80_init(0x510f, 0xa1818f440b0e6014),
+/* 1316 */ make_floatx80_init(0x5112, 0xc9e1f3150dd1f819),
+/* 1317 */ make_floatx80_init(0x5115, 0xfc5a6fda5146761f),
+/* 1318 */ make_floatx80_init(0x5119, 0x9db885e872cc09d3),
+/* 1319 */ make_floatx80_init(0x511c, 0xc526a7628f7f0c48),
+/* 1320 */ make_floatx80_init(0x511f, 0xf670513b335ecf5a),
+/* 1321 */ make_floatx80_init(0x5123, 0x9a0632c5001b4198),
+/* 1322 */ make_floatx80_init(0x5126, 0xc087bf76402211fe),
+/* 1323 */ make_floatx80_init(0x5129, 0xf0a9af53d02a967e),
+/* 1324 */ make_floatx80_init(0x512d, 0x966a0d94621a9e0f),
+/* 1325 */ make_floatx80_init(0x5130, 0xbc0490f97aa14592),
+/* 1326 */ make_floatx80_init(0x5133, 0xeb05b537d94996f7),
+/* 1327 */ make_floatx80_init(0x5137, 0x92e39142e7cdfe5a),
+/* 1328 */ make_floatx80_init(0x513a, 0xb79c7593a1c17df1),
+/* 1329 */ make_floatx80_init(0x513d, 0xe58392f88a31dd6d),
+/* 1330 */ make_floatx80_init(0x5141, 0x8f723bdb565f2a64),
+/* 1331 */ make_floatx80_init(0x5144, 0xb34ecad22bf6f4fd),
+/* 1332 */ make_floatx80_init(0x5147, 0xe0227d86b6f4b23d),
+/* 1333 */ make_floatx80_init(0x514b, 0x8c158e743258ef66),
+/* 1334 */ make_floatx80_init(0x514e, 0xaf1af2113eef2b3f),
+/* 1335 */ make_floatx80_init(0x5151, 0xdae1ae958eaaf60f),
+/* 1336 */ make_floatx80_init(0x5155, 0x88cd0d1d792ad9ca),
+/* 1337 */ make_floatx80_init(0x5158, 0xab005064d775903c),
+/* 1338 */ make_floatx80_init(0x515b, 0xd5c0647e0d52f44b),
+/* 1339 */ make_floatx80_init(0x515f, 0x85983ecec853d8af),
+/* 1340 */ make_floatx80_init(0x5162, 0xa6fe4e827a68cedb),
+/* 1341 */ make_floatx80_init(0x5165, 0xd0bde22319030291),
+/* 1342 */ make_floatx80_init(0x5169, 0x8276ad55efa1e19b),
+/* 1343 */ make_floatx80_init(0x516c, 0xa31458ab6b8a5a01),
+/* 1344 */ make_floatx80_init(0x516f, 0xcbd96ed6466cf082),
+/* 1345 */ make_floatx80_init(0x5172, 0xfecfca8bd8082ca2),
+/* 1346 */ make_floatx80_init(0x5176, 0x9f41de9767051be5),
+/* 1347 */ make_floatx80_init(0x5179, 0xc712563d40c662df),
+/* 1348 */ make_floatx80_init(0x517c, 0xf8d6ebcc90f7fb96),
+/* 1349 */ make_floatx80_init(0x5180, 0x9b86535fda9afd3e),
+/* 1350 */ make_floatx80_init(0x5183, 0xc267e837d141bc8d),
+/* 1351 */ make_floatx80_init(0x5186, 0xf301e245c5922bb1),
+/* 1352 */ make_floatx80_init(0x518a, 0x97e12d6b9b7b5b4f),
+/* 1353 */ make_floatx80_init(0x518d, 0xbdd978c6825a3222),
+/* 1354 */ make_floatx80_init(0x5190, 0xed4fd6f822f0beab),
+/* 1355 */ make_floatx80_init(0x5194, 0x9451e65b15d6772b),
+/* 1356 */ make_floatx80_init(0x5197, 0xb9665ff1db4c14f5),
+/* 1357 */ make_floatx80_init(0x519a, 0xe7bff7ee521f1a33),
+/* 1358 */ make_floatx80_init(0x519e, 0x90d7faf4f3537060),
+/* 1359 */ make_floatx80_init(0x51a1, 0xb50df9b230284c78),
+/* 1360 */ make_floatx80_init(0x51a4, 0xe251781ebc325f96),
+/* 1361 */ make_floatx80_init(0x51a8, 0x8d72eb13359f7bbd),
+/* 1362 */ make_floatx80_init(0x51ab, 0xb0cfa5d803075aad),
+/* 1363 */ make_floatx80_init(0x51ae, 0xdd038f4e03c93158),
+/* 1364 */ make_floatx80_init(0x51b2, 0x8a223990c25dbed7),
+/* 1365 */ make_floatx80_init(0x51b5, 0xacaac7f4f2f52e8d),
+/* 1366 */ make_floatx80_init(0x51b8, 0xd7d579f22fb27a30),
+/* 1367 */ make_floatx80_init(0x51bc, 0x86e56c375dcf8c5e),
+/* 1368 */ make_floatx80_init(0x51bf, 0xa89ec74535436f75),
+/* 1369 */ make_floatx80_init(0x51c2, 0xd2c6791682944b53),
+/* 1370 */ make_floatx80_init(0x51c6, 0x83bc0bae119caf14),
+/* 1371 */ make_floatx80_init(0x51c9, 0xa4ab0e999603dad9),
+/* 1372 */ make_floatx80_init(0x51cc, 0xcdd5d23ffb84d18f),
+/* 1373 */ make_floatx80_init(0x51d0, 0x80a5a367fd3302f9),
+/* 1374 */ make_floatx80_init(0x51d3, 0xa0cf0c41fc7fc3b8),
+/* 1375 */ make_floatx80_init(0x51d6, 0xc902cf527b9fb4a6),
+/* 1376 */ make_floatx80_init(0x51d9, 0xfb4383271a87a1cf),
+/* 1377 */ make_floatx80_init(0x51dd, 0x9d0a31f87094c521),
+/* 1378 */ make_floatx80_init(0x51e0, 0xc44cbe768cb9f66a),
+/* 1379 */ make_floatx80_init(0x51e3, 0xf55fee142fe87404),
+/* 1380 */ make_floatx80_init(0x51e7, 0x995bf4cc9df14883),
+/* 1381 */ make_floatx80_init(0x51ea, 0xbfb2f1ffc56d9aa3),
+/* 1382 */ make_floatx80_init(0x51ed, 0xef9fae7fb6c9014c),
+/* 1383 */ make_floatx80_init(0x51f1, 0x95c3cd0fd23da0cf),
+/* 1384 */ make_floatx80_init(0x51f4, 0xbb34c053c6cd0903),
+/* 1385 */ make_floatx80_init(0x51f7, 0xea01f068b8804b44),
+/* 1386 */ make_floatx80_init(0x51fb, 0x9241364173502f0b),
+/* 1387 */ make_floatx80_init(0x51fe, 0xb6d183d1d0243acd),
+/* 1388 */ make_floatx80_init(0x5201, 0xe485e4c6442d4981),
+/* 1389 */ make_floatx80_init(0x5205, 0x8ed3aefbea9c4df0),
+/* 1390 */ make_floatx80_init(0x5208, 0xb2889abae543616c),
+/* 1391 */ make_floatx80_init(0x520b, 0xdf2ac1699e9439c8),
+/* 1392 */ make_floatx80_init(0x520f, 0x8b7ab8e2031ca41d),
+/* 1393 */ make_floatx80_init(0x5212, 0xae59671a83e3cd24),
+/* 1394 */ make_floatx80_init(0x5215, 0xd9efc0e124dcc06d),
+/* 1395 */ make_floatx80_init(0x5219, 0x8835d88cb709f844),
+/* 1396 */ make_floatx80_init(0x521c, 0xaa434eafe4cc7655),
+/* 1397 */ make_floatx80_init(0x521f, 0xd4d4225bddff93ea),
+/* 1398 */ make_floatx80_init(0x5223, 0x850495796abfbc72),
+/* 1399 */ make_floatx80_init(0x5226, 0xa645bad7c56fab8f),
+/* 1400 */ make_floatx80_init(0x5229, 0xcfd7298db6cb9673),
+/* 1401 */ make_floatx80_init(0x522d, 0x81e679f8923f3e08),
+/* 1402 */ make_floatx80_init(0x5230, 0xa2601876b6cf0d8a),
+/* 1403 */ make_floatx80_init(0x5233, 0xcaf81e946482d0ec),
+/* 1404 */ make_floatx80_init(0x5236, 0xfdb626397da38527),
+/* 1405 */ make_floatx80_init(0x523a, 0x9e91d7e3ee863339),
+/* 1406 */ make_floatx80_init(0x523d, 0xc6364ddcea27c007),
+/* 1407 */ make_floatx80_init(0x5240, 0xf7c3e15424b1b008),
+/* 1408 */ make_floatx80_init(0x5244, 0x9ada6cd496ef0e05),
+/* 1409 */ make_floatx80_init(0x5247, 0xc1910809bcaad186),
+/* 1410 */ make_floatx80_init(0x524a, 0xf1f54a0c2bd585e8),
+/* 1411 */ make_floatx80_init(0x524e, 0x97394e479b6573b1),
+/* 1412 */ make_floatx80_init(0x5251, 0xbd07a1d9823ed09d),
+/* 1413 */ make_floatx80_init(0x5254, 0xec498a4fe2ce84c5),
+/* 1414 */ make_floatx80_init(0x5258, 0x93adf671edc112fb),
+/* 1415 */ make_floatx80_init(0x525b, 0xb899740e693157ba),
+/* 1416 */ make_floatx80_init(0x525e, 0xe6bfd112037dada8),
+/* 1417 */ make_floatx80_init(0x5262, 0x9037e2ab422e8c89),
+/* 1418 */ make_floatx80_init(0x5265, 0xb445db5612ba2fab),
+/* 1419 */ make_floatx80_init(0x5268, 0xe157522b9768bb96),
+/* 1420 */ make_floatx80_init(0x526c, 0x8cd6935b3ea1753e),
+/* 1421 */ make_floatx80_init(0x526f, 0xb00c38320e49d28d),
+/* 1422 */ make_floatx80_init(0x5272, 0xdc0f463e91dc4731),
+/* 1423 */ make_floatx80_init(0x5276, 0x89898be71b29ac7e),
+/* 1424 */ make_floatx80_init(0x5279, 0xabebeee0e1f4179e),
+/* 1425 */ make_floatx80_init(0x527c, 0xd6e6ea991a711d85),
+/* 1426 */ make_floatx80_init(0x5280, 0x8650529fb086b273),
+/* 1427 */ make_floatx80_init(0x5283, 0xa7e467479ca85f10),
+/* 1428 */ make_floatx80_init(0x5286, 0xd1dd811983d276d4),
+/* 1429 */ make_floatx80_init(0x528a, 0x832a70aff2638a45),
+/* 1430 */ make_floatx80_init(0x528d, 0xa3f50cdbeefc6cd6),
+/* 1431 */ make_floatx80_init(0x5290, 0xccf25012eabb880b),
+/* 1432 */ make_floatx80_init(0x5294, 0x8017720bd2b53507),
+/* 1433 */ make_floatx80_init(0x5297, 0xa01d4e8ec7628249),
+/* 1434 */ make_floatx80_init(0x529a, 0xc824a232793b22db),
+/* 1435 */ make_floatx80_init(0x529d, 0xfa2dcabf1789eb92),
+/* 1436 */ make_floatx80_init(0x52a1, 0x9c5c9eb76eb6333b),
+/* 1437 */ make_floatx80_init(0x52a4, 0xc373c6654a63c00a),
+/* 1438 */ make_floatx80_init(0x52a7, 0xf450b7fe9cfcb00c),
+/* 1439 */ make_floatx80_init(0x52ab, 0x98b272ff221dee08),
+/* 1440 */ make_floatx80_init(0x52ae, 0xbedf0fbeeaa5698a),
+/* 1441 */ make_floatx80_init(0x52b1, 0xee96d3aea54ec3ec),
+/* 1442 */ make_floatx80_init(0x52b5, 0x951e444d27513a74),
+/* 1443 */ make_floatx80_init(0x52b8, 0xba65d56071258910),
+/* 1444 */ make_floatx80_init(0x52bb, 0xe8ff4ab88d6eeb55),
+/* 1445 */ make_floatx80_init(0x52bf, 0x919f8eb358655315),
+/* 1446 */ make_floatx80_init(0x52c2, 0xb60772602e7ea7da),
+/* 1447 */ make_floatx80_init(0x52c5, 0xe3894ef83a1e51d1),
+/* 1448 */ make_floatx80_init(0x52c9, 0x8e35d15b2452f322),
+/* 1449 */ make_floatx80_init(0x52cc, 0xb1c345b1ed67afeb),
+/* 1450 */ make_floatx80_init(0x52cf, 0xde34171e68c19be6),
+/* 1451 */ make_floatx80_init(0x52d3, 0x8ae08e7301790170),
+/* 1452 */ make_floatx80_init(0x52d6, 0xad98b20fc1d741cb),
+/* 1453 */ make_floatx80_init(0x52d9, 0xd8fede93b24d123e),
+/* 1454 */ make_floatx80_init(0x52dd, 0x879f4b1c4f702b67),
+/* 1455 */ make_floatx80_init(0x52e0, 0xa9871de3634c3641),
+/* 1456 */ make_floatx80_init(0x52e3, 0xd3e8e55c3c1f43d1),
+/* 1457 */ make_floatx80_init(0x52e7, 0x84718f59a5938a63),
+/* 1458 */ make_floatx80_init(0x52ea, 0xa58df3300ef86cfb),
+/* 1459 */ make_floatx80_init(0x52ed, 0xcef16ffc12b6883a),
+/* 1460 */ make_floatx80_init(0x52f1, 0x8156e5fd8bb21524),
+/* 1461 */ make_floatx80_init(0x52f4, 0xa1ac9f7cee9e9a6d),
+/* 1462 */ make_floatx80_init(0x52f7, 0xca17c75c2a464109),
+/* 1463 */ make_floatx80_init(0x52fa, 0xfc9db93334d7d14b),
+/* 1464 */ make_floatx80_init(0x52fe, 0x9de293c00106e2cf),
+/* 1465 */ make_floatx80_init(0x5301, 0xc55b38b001489b82),
+/* 1466 */ make_floatx80_init(0x5304, 0xf6b206dc019ac263),
+/* 1467 */ make_floatx80_init(0x5308, 0x9a2f44498100b97e),
+/* 1468 */ make_floatx80_init(0x530b, 0xc0bb155be140e7dd),
+/* 1469 */ make_floatx80_init(0x530e, 0xf0e9dab2d99121d5),
+/* 1470 */ make_floatx80_init(0x5312, 0x969228afc7fab525),
+/* 1471 */ make_floatx80_init(0x5315, 0xbc36b2dbb9f9626e),
+/* 1472 */ make_floatx80_init(0x5318, 0xeb445f92a877bb0a),
+/* 1473 */ make_floatx80_init(0x531c, 0x930abbbba94ad4e6),
+/* 1474 */ make_floatx80_init(0x531f, 0xb7cd6aaa939d8a20),
+/* 1475 */ make_floatx80_init(0x5322, 0xe5c0c5553884eca8),
+/* 1476 */ make_floatx80_init(0x5326, 0x8f987b55435313e9),
+/* 1477 */ make_floatx80_init(0x5329, 0xb37e9a2a9427d8e3),
+/* 1478 */ make_floatx80_init(0x532c, 0xe05e40b53931cf1c),
+/* 1479 */ make_floatx80_init(0x5330, 0x8c3ae87143bf2171),
+/* 1480 */ make_floatx80_init(0x5333, 0xaf49a28d94aee9ce),
+/* 1481 */ make_floatx80_init(0x5336, 0xdb1c0b30f9daa441),
+/* 1482 */ make_floatx80_init(0x533a, 0x88f186fe9c28a6a9),
+/* 1483 */ make_floatx80_init(0x533d, 0xab2de8be4332d053),
+/* 1484 */ make_floatx80_init(0x5340, 0xd5f962edd3ff8467),
+/* 1485 */ make_floatx80_init(0x5344, 0x85bbddd4a47fb2c1),
+/* 1486 */ make_floatx80_init(0x5347, 0xa72ad549cd9f9f71),
+/* 1487 */ make_floatx80_init(0x534a, 0xd0f58a9c4107874d),
+/* 1488 */ make_floatx80_init(0x534e, 0x829976a1a8a4b490),
+/* 1489 */ make_floatx80_init(0x5351, 0xa33fd44a12cde1b4),
+/* 1490 */ make_floatx80_init(0x5354, 0xcc0fc95c97815a21),
+/* 1491 */ make_floatx80_init(0x5357, 0xff13bbb3bd61b0a9),
+/* 1492 */ make_floatx80_init(0x535b, 0x9f6c5550565d0e6a),
+/* 1493 */ make_floatx80_init(0x535e, 0xc7476aa46bf45204),
+/* 1494 */ make_floatx80_init(0x5361, 0xf919454d86f16686),
+/* 1495 */ make_floatx80_init(0x5365, 0x9bafcb507456e013),
+/* 1496 */ make_floatx80_init(0x5368, 0xc29bbe24916c9818),
+/* 1497 */ make_floatx80_init(0x536b, 0xf342adadb5c7be1e),
+/* 1498 */ make_floatx80_init(0x536f, 0x9809ac8c919cd6d3),
+/* 1499 */ make_floatx80_init(0x5372, 0xbe0c17afb6040c88),
+/* 1500 */ make_floatx80_init(0x5375, 0xed8f1d9ba3850faa),
+/* 1501 */ make_floatx80_init(0x5379, 0x94797281463329ca),
+/* 1502 */ make_floatx80_init(0x537c, 0xb997cf2197bff43d),
+/* 1503 */ make_floatx80_init(0x537f, 0xe7fdc2e9fdaff14c),
+/* 1504 */ make_floatx80_init(0x5383, 0x90fe99d23e8df6cf),
+/* 1505 */ make_floatx80_init(0x5386, 0xb53e4046ce317483),
+/* 1506 */ make_floatx80_init(0x5389, 0xe28dd05881bdd1a4),
+/* 1507 */ make_floatx80_init(0x538d, 0x8d98a2375116a306),
+/* 1508 */ make_floatx80_init(0x5390, 0xb0fecac5255c4bc8),
+/* 1509 */ make_floatx80_init(0x5393, 0xdd3e7d766eb35eba),
+/* 1510 */ make_floatx80_init(0x5397, 0x8a470e6a05301b34),
+/* 1511 */ make_floatx80_init(0x539a, 0xacd8d204867c2201),
+/* 1512 */ make_floatx80_init(0x539d, 0xd80f0685a81b2a82),
+/* 1513 */ make_floatx80_init(0x53a1, 0x870964138910fa91),
+/* 1514 */ make_floatx80_init(0x53a4, 0xa8cbbd186b553935),
+/* 1515 */ make_floatx80_init(0x53a7, 0xd2feac5e862a8783),
+/* 1516 */ make_floatx80_init(0x53ab, 0x83df2bbb13da94b2),
+/* 1517 */ make_floatx80_init(0x53ae, 0xa4d6f6a9d8d139de),
+/* 1518 */ make_floatx80_init(0x53b1, 0xce0cb4544f058856),
+/* 1519 */ make_floatx80_init(0x53b5, 0x80c7f0b4b1637536),
+/* 1520 */ make_floatx80_init(0x53b8, 0xa0f9ece1ddbc5283),
+/* 1521 */ make_floatx80_init(0x53bb, 0xc938681a552b6724),
+/* 1522 */ make_floatx80_init(0x53be, 0xfb868220ea7640ed),
+/* 1523 */ make_floatx80_init(0x53c2, 0x9d3411549289e894),
+/* 1524 */ make_floatx80_init(0x53c5, 0xc48115a9b72c62b9),
+/* 1525 */ make_floatx80_init(0x53c8, 0xf5a15b1424f77b67),
+/* 1526 */ make_floatx80_init(0x53cc, 0x9984d8ec971aad20),
+/* 1527 */ make_floatx80_init(0x53cf, 0xbfe60f27bce15868),
+/* 1528 */ make_floatx80_init(0x53d2, 0xefdf92f1ac19ae83),
+/* 1529 */ make_floatx80_init(0x53d6, 0x95ebbbd70b900d12),
+/* 1530 */ make_floatx80_init(0x53d9, 0xbb66aaccce741056),
+/* 1531 */ make_floatx80_init(0x53dc, 0xea4055800211146b),
+/* 1532 */ make_floatx80_init(0x53e0, 0x92683570014aacc3),
+/* 1533 */ make_floatx80_init(0x53e3, 0xb70242cc019d57f4),
+/* 1534 */ make_floatx80_init(0x53e6, 0xe4c2d37f0204adf1),
+/* 1535 */ make_floatx80_init(0x53ea, 0x8ef9c42f6142ecb7),
+/* 1536 */ make_floatx80_init(0x53ed, 0xb2b8353b3993a7e4),
+/* 1537 */ make_floatx80_init(0x53f0, 0xdf66428a07f891dd),
+/* 1538 */ make_floatx80_init(0x53f4, 0x8b9fe99644fb5b2a),
+/* 1539 */ make_floatx80_init(0x53f7, 0xae87e3fbd63a31f5),
+/* 1540 */ make_floatx80_init(0x53fa, 0xda29dcfacbc8be72),
+/* 1541 */ make_floatx80_init(0x53fe, 0x885a2a1cbf5d7707),
+/* 1542 */ make_floatx80_init(0x5401, 0xaa70b4a3ef34d4c9),
+/* 1543 */ make_floatx80_init(0x5404, 0xd50ce1cceb0209fb),
+/* 1544 */ make_floatx80_init(0x5408, 0x85280d2012e1463d),
+/* 1545 */ make_floatx80_init(0x540b, 0xa6721068179997cc),
+/* 1546 */ make_floatx80_init(0x540e, 0xd00e94821d7ffdc0),
+/* 1547 */ make_floatx80_init(0x5412, 0x82091cd1526ffe98),
+/* 1548 */ make_floatx80_init(0x5415, 0xa28b6405a70bfe3e),
+/* 1549 */ make_floatx80_init(0x5418, 0xcb2e3d0710cefdcd),
+/* 1550 */ make_floatx80_init(0x541b, 0xfdf9cc48d502bd40),
+/* 1551 */ make_floatx80_init(0x541f, 0x9ebc1fad8521b648),
+/* 1552 */ make_floatx80_init(0x5422, 0xc66b2798e66a23da),
+/* 1553 */ make_floatx80_init(0x5425, 0xf805f17f2004acd1),
+/* 1554 */ make_floatx80_init(0x5429, 0x9b03b6ef7402ec03),
+/* 1555 */ make_floatx80_init(0x542c, 0xc1c4a4ab5103a703),
+/* 1556 */ make_floatx80_init(0x542f, 0xf235cdd6254490c4),
+/* 1557 */ make_floatx80_init(0x5433, 0x9761a0a5d74ada7a),
+/* 1558 */ make_floatx80_init(0x5436, 0xbd3a08cf4d1d9119),
+/* 1559 */ make_floatx80_init(0x5439, 0xec888b032064f55f),
+/* 1560 */ make_floatx80_init(0x543d, 0x93d556e1f43f195c),
+/* 1561 */ make_floatx80_init(0x5440, 0xb8caac9a714edfb2),
+/* 1562 */ make_floatx80_init(0x5443, 0xe6fd57c10da2979f),
+/* 1563 */ make_floatx80_init(0x5447, 0x905e56d8a8859ec3),
+/* 1564 */ make_floatx80_init(0x544a, 0xb475ec8ed2a70674),
+/* 1565 */ make_floatx80_init(0x544d, 0xe19367b28750c811),
+/* 1566 */ make_floatx80_init(0x5451, 0x8cfc20cf94927d0b),
+/* 1567 */ make_floatx80_init(0x5454, 0xb03b290379b71c4e),
+/* 1568 */ make_floatx80_init(0x5457, 0xdc49f3445824e361),
+/* 1569 */ make_floatx80_init(0x545b, 0x89ae380ab7170e1d),
+/* 1570 */ make_floatx80_init(0x545e, 0xac19c60d64dcd1a4),
+/* 1571 */ make_floatx80_init(0x5461, 0xd7203790be14060d),
+/* 1572 */ make_floatx80_init(0x5465, 0x867422ba76cc83c8),
+/* 1573 */ make_floatx80_init(0x5468, 0xa8112b69147fa4ba),
+/* 1574 */ make_floatx80_init(0x546b, 0xd2157643599f8de8),
+/* 1575 */ make_floatx80_init(0x546f, 0x834d69ea1803b8b1),
+/* 1576 */ make_floatx80_init(0x5472, 0xa420c4649e04a6de),
+/* 1577 */ make_floatx80_init(0x5475, 0xcd28f57dc585d095),
+/* 1578 */ make_floatx80_init(0x5479, 0x8039996e9b73a25d),
+/* 1579 */ make_floatx80_init(0x547c, 0xa047ffca42508af4),
+/* 1580 */ make_floatx80_init(0x547f, 0xc859ffbcd2e4adb1),
+/* 1581 */ make_floatx80_init(0x5482, 0xfa707fac079dd91e),
+/* 1582 */ make_floatx80_init(0x5486, 0x9c864fcb84c2a7b3),
+/* 1583 */ make_floatx80_init(0x5489, 0xc3a7e3be65f3519f),
+/* 1584 */ make_floatx80_init(0x548c, 0xf491dcadff702607),
+/* 1585 */ make_floatx80_init(0x5490, 0x98db29ecbfa617c4),
+/* 1586 */ make_floatx80_init(0x5493, 0xbf11f467ef8f9db6),
+/* 1587 */ make_floatx80_init(0x5496, 0xeed67181eb738523),
+/* 1588 */ make_floatx80_init(0x549a, 0x954606f133283336),
+/* 1589 */ make_floatx80_init(0x549d, 0xba9788ad7ff24003),
+/* 1590 */ make_floatx80_init(0x54a0, 0xe93d6ad8dfeed004),
+/* 1591 */ make_floatx80_init(0x54a4, 0x91c662c78bf54203),
+/* 1592 */ make_floatx80_init(0x54a7, 0xb637fb796ef29283),
+/* 1593 */ make_floatx80_init(0x54aa, 0xe3c5fa57caaf3724),
+/* 1594 */ make_floatx80_init(0x54ae, 0x8e5bbc76dead8277),
+/* 1595 */ make_floatx80_init(0x54b1, 0xb1f2ab949658e314),
+/* 1596 */ make_floatx80_init(0x54b4, 0xde6f5679bbef1bd9),
+/* 1597 */ make_floatx80_init(0x54b8, 0x8b05960c15757168),
+/* 1598 */ make_floatx80_init(0x54bb, 0xadc6fb8f1ad2cdc2),
+/* 1599 */ make_floatx80_init(0x54be, 0xd938ba72e1878132),
+/* 1600 */ make_floatx80_init(0x54c2, 0x87c37487ccf4b0bf),
+/* 1601 */ make_floatx80_init(0x54c5, 0xa9b451a9c031dcef),
+/* 1602 */ make_floatx80_init(0x54c8, 0xd4216614303e542b),
+/* 1603 */ make_floatx80_init(0x54cc, 0x8494dfcc9e26f49b),
+/* 1604 */ make_floatx80_init(0x54cf, 0xa5ba17bfc5b0b1c2),
+/* 1605 */ make_floatx80_init(0x54d2, 0xcf289dafb71cde32),
+/* 1606 */ make_floatx80_init(0x54d6, 0x8179628dd2720adf),
+/* 1607 */ make_floatx80_init(0x54d9, 0xa1d7bb31470e8d97),
+/* 1608 */ make_floatx80_init(0x54dc, 0xca4da9fd98d230fd),
+/* 1609 */ make_floatx80_init(0x54df, 0xfce1147cff06bd3c),
+/* 1610 */ make_floatx80_init(0x54e3, 0x9e0cacce1f643645),
+/* 1611 */ make_floatx80_init(0x54e6, 0xc58fd801a73d43d7),
+/* 1612 */ make_floatx80_init(0x54e9, 0xf6f3ce02110c94cd),
+/* 1613 */ make_floatx80_init(0x54ed, 0x9a5860c14aa7dd00),
+/* 1614 */ make_floatx80_init(0x54f0, 0xc0ee78f19d51d440),
+/* 1615 */ make_floatx80_init(0x54f3, 0xf12a172e04a64950),
+/* 1616 */ make_floatx80_init(0x54f7, 0x96ba4e7cc2e7edd2),
+/* 1617 */ make_floatx80_init(0x54fa, 0xbc68e21bf3a1e946),
+/* 1618 */ make_floatx80_init(0x54fd, 0xeb831aa2f08a6398),
+/* 1619 */ make_floatx80_init(0x5501, 0x9331f0a5d6567e3f),
+/* 1620 */ make_floatx80_init(0x5504, 0xb7fe6ccf4bec1dcf),
+/* 1621 */ make_floatx80_init(0x5507, 0xe5fe08031ee72542),
+/* 1622 */ make_floatx80_init(0x550b, 0x8fbec501f3507749),
+/* 1623 */ make_floatx80_init(0x550e, 0xb3ae76427024951c),
+/* 1624 */ make_floatx80_init(0x5511, 0xe09a13d30c2dba63),
+/* 1625 */ make_floatx80_init(0x5515, 0x8c604c63e79c947e),
+/* 1626 */ make_floatx80_init(0x5518, 0xaf785f7ce183b99d),
+/* 1627 */ make_floatx80_init(0x551b, 0xdb56775c19e4a804),
+/* 1628 */ make_floatx80_init(0x551f, 0x89160a99902ee903),
+/* 1629 */ make_floatx80_init(0x5522, 0xab5b8d3ff43aa343),
+/* 1630 */ make_floatx80_init(0x5525, 0xd632708ff1494c14),
+/* 1631 */ make_floatx80_init(0x5529, 0x85df8659f6cdcf8d),
+/* 1632 */ make_floatx80_init(0x552c, 0xa75767f074814370),
+/* 1633 */ make_floatx80_init(0x552f, 0xd12d41ec91a1944c),
+/* 1634 */ make_floatx80_init(0x5533, 0x82bc4933db04fcaf),
+/* 1635 */ make_floatx80_init(0x5536, 0xa36b5b80d1c63bdb),
+/* 1636 */ make_floatx80_init(0x5539, 0xcc4632610637cad2),
+/* 1637 */ make_floatx80_init(0x553c, 0xff57bef947c5bd87),
+/* 1638 */ make_floatx80_init(0x5540, 0x9f96d75bccdb9674),
+/* 1639 */ make_floatx80_init(0x5543, 0xc77c8d32c0127c11),
+/* 1640 */ make_floatx80_init(0x5546, 0xf95bb07f70171b15),
+/* 1641 */ make_floatx80_init(0x554a, 0x9bd94e4fa60e70ed),
+/* 1642 */ make_floatx80_init(0x554d, 0xc2cfa1e38f920d29),
+/* 1643 */ make_floatx80_init(0x5550, 0xf3838a5c73769073),
+/* 1644 */ make_floatx80_init(0x5554, 0x98323679c82a1a48),
+/* 1645 */ make_floatx80_init(0x5557, 0xbe3ec4183a34a0da),
+/* 1646 */ make_floatx80_init(0x555a, 0xedce751e48c1c910),
+/* 1647 */ make_floatx80_init(0x555e, 0x94a10932ed791daa),
+/* 1648 */ make_floatx80_init(0x5561, 0xb9c94b7fa8d76515),
+/* 1649 */ make_floatx80_init(0x5564, 0xe83b9e5f930d3e5a),
+/* 1650 */ make_floatx80_init(0x5568, 0x912542fbbbe846f8),
+/* 1651 */ make_floatx80_init(0x556b, 0xb56e93baaae258b6),
+/* 1652 */ make_floatx80_init(0x556e, 0xe2ca38a9559aeee4),
+/* 1653 */ make_floatx80_init(0x5572, 0x8dbe6369d580d54e),
+/* 1654 */ make_floatx80_init(0x5575, 0xb12dfc444ae10aa2),
+/* 1655 */ make_floatx80_init(0x5578, 0xdd797b555d994d4a),
+/* 1656 */ make_floatx80_init(0x557c, 0x8a6bed155a7fd04f),
+/* 1657 */ make_floatx80_init(0x557f, 0xad06e85ab11fc462),
+/* 1658 */ make_floatx80_init(0x5582, 0xd848a2715d67b57b),
+/* 1659 */ make_floatx80_init(0x5586, 0x872d6586da60d16d),
+/* 1660 */ make_floatx80_init(0x5589, 0xa8f8bee890f905c8),
+/* 1661 */ make_floatx80_init(0x558c, 0xd336eea2b537473a),
+/* 1662 */ make_floatx80_init(0x5590, 0x84025525b1428c84),
+/* 1663 */ make_floatx80_init(0x5593, 0xa502ea6f1d932fa5),
+/* 1664 */ make_floatx80_init(0x5596, 0xce43a50ae4f7fb8e),
+/* 1665 */ make_floatx80_init(0x559a, 0x80ea4726cf1afd39),
+/* 1666 */ make_floatx80_init(0x559d, 0xa124d8f082e1bc87),
+/* 1667 */ make_floatx80_init(0x55a0, 0xc96e0f2ca39a2ba9),
+/* 1668 */ make_floatx80_init(0x55a3, 0xfbc992f7cc80b693),
+/* 1669 */ make_floatx80_init(0x55a7, 0x9d5dfbdadfd0721c),
+/* 1670 */ make_floatx80_init(0x55aa, 0xc4b57ad197c48ea3),
+/* 1671 */ make_floatx80_init(0x55ad, 0xf5e2d985fdb5b24c),
+/* 1672 */ make_floatx80_init(0x55b1, 0x99adc7f3be918f6f),
+/* 1673 */ make_floatx80_init(0x55b4, 0xc01939f0ae35f34b),
+/* 1674 */ make_floatx80_init(0x55b7, 0xf01f886cd9c3701e),
+/* 1675 */ make_floatx80_init(0x55bb, 0x9613b544081a2613),
+/* 1676 */ make_floatx80_init(0x55be, 0xbb98a2950a20af98),
+/* 1677 */ make_floatx80_init(0x55c1, 0xea7ecb3a4ca8db7d),
+/* 1678 */ make_floatx80_init(0x55c5, 0x928f3f046fe9892e),
+/* 1679 */ make_floatx80_init(0x55c8, 0xb7330ec58be3eb7a),
+/* 1680 */ make_floatx80_init(0x55cb, 0xe4ffd276eedce659),
+/* 1681 */ make_floatx80_init(0x55cf, 0x8f1fe38a554a0ff7),
+/* 1682 */ make_floatx80_init(0x55d2, 0xb2e7dc6cea9c93f5),
+/* 1683 */ make_floatx80_init(0x55d5, 0xdfa1d3882543b8f2),
+/* 1684 */ make_floatx80_init(0x55d9, 0x8bc52435174a5398),
+/* 1685 */ make_floatx80_init(0x55dc, 0xaeb66d425d1ce87d),
+/* 1686 */ make_floatx80_init(0x55df, 0xda640892f464229d),
+/* 1687 */ make_floatx80_init(0x55e3, 0x887e855bd8be95a2),
+/* 1688 */ make_floatx80_init(0x55e6, 0xaa9e26b2ceee3b0a),
+/* 1689 */ make_floatx80_init(0x55e9, 0xd545b05f82a9c9cd),
+/* 1690 */ make_floatx80_init(0x55ed, 0x854b8e3bb1aa1e20),
+/* 1691 */ make_floatx80_init(0x55f0, 0xa69e71ca9e14a5a8),
+/* 1692 */ make_floatx80_init(0x55f3, 0xd0460e3d4599cf12),
+/* 1693 */ make_floatx80_init(0x55f7, 0x822bc8e64b80216b),
+/* 1694 */ make_floatx80_init(0x55fa, 0xa2b6bb1fde6029c6),
+/* 1695 */ make_floatx80_init(0x55fd, 0xcb6469e7d5f83438),
+/* 1696 */ make_floatx80_init(0x5600, 0xfe3d8461cb764146),
+/* 1697 */ make_floatx80_init(0x5604, 0x9ee672bd1f29e8cc),
+/* 1698 */ make_floatx80_init(0x5607, 0xc6a00f6c66f462ff),
+/* 1699 */ make_floatx80_init(0x560a, 0xf848134780b17bbe),
+/* 1700 */ make_floatx80_init(0x560e, 0x9b2d0c0cb06eed57),
+/* 1701 */ make_floatx80_init(0x5611, 0xc1f84f0fdc8aa8ad),
+/* 1702 */ make_floatx80_init(0x5614, 0xf27662d3d3ad52d8),
+/* 1703 */ make_floatx80_init(0x5618, 0x9789fdc4644c53c7),
+/* 1704 */ make_floatx80_init(0x561b, 0xbd6c7d357d5f68b9),
+/* 1705 */ make_floatx80_init(0x561e, 0xecc79c82dcb742e7),
+/* 1706 */ make_floatx80_init(0x5622, 0x93fcc1d1c9f289d0),
+/* 1707 */ make_floatx80_init(0x5625, 0xb8fbf2463c6f2c44),
+/* 1708 */ make_floatx80_init(0x5628, 0xe73aeed7cb8af755),
+/* 1709 */ make_floatx80_init(0x562c, 0x9084d546df36da95),
+/* 1710 */ make_floatx80_init(0x562f, 0xb4a60a989704913b),
+/* 1711 */ make_floatx80_init(0x5632, 0xe1cf8d3ebcc5b589),
+/* 1712 */ make_floatx80_init(0x5636, 0x8d21b84735fb9176),
+/* 1713 */ make_floatx80_init(0x5639, 0xb06a2659037a75d3),
+/* 1714 */ make_floatx80_init(0x563c, 0xdc84afef44591348),
+/* 1715 */ make_floatx80_init(0x5640, 0x89d2edf58ab7ac0d),
+/* 1716 */ make_floatx80_init(0x5643, 0xac47a972ed659710),
+/* 1717 */ make_floatx80_init(0x5646, 0xd75993cfa8befcd4),
+/* 1718 */ make_floatx80_init(0x564a, 0x8697fc61c9775e05),
+/* 1719 */ make_floatx80_init(0x564d, 0xa83dfb7a3bd53586),
+/* 1720 */ make_floatx80_init(0x5650, 0xd24d7a58caca82e7),
+/* 1721 */ make_floatx80_init(0x5654, 0x83706c777ebe91d1),
+/* 1722 */ make_floatx80_init(0x5657, 0xa44c87955e6e3645),
+/* 1723 */ make_floatx80_init(0x565a, 0xcd5fa97ab609c3d6),
+/* 1724 */ make_floatx80_init(0x565e, 0x805bc9ecb1c61a66),
+/* 1725 */ make_floatx80_init(0x5661, 0xa072bc67de37a0ff),
+/* 1726 */ make_floatx80_init(0x5664, 0xc88f6b81d5c5893f),
+/* 1727 */ make_floatx80_init(0x5667, 0xfab346624b36eb8f),
+/* 1728 */ make_floatx80_init(0x566b, 0x9cb00bfd6f025339),
+/* 1729 */ make_floatx80_init(0x566e, 0xc3dc0efccac2e807),
+/* 1730 */ make_floatx80_init(0x5671, 0xf4d312bbfd73a209),
+/* 1731 */ make_floatx80_init(0x5675, 0x9903ebb57e684546),
+/* 1732 */ make_floatx80_init(0x5678, 0xbf44e6a2de025697),
+/* 1733 */ make_floatx80_init(0x567b, 0xef16204b9582ec3d),
+/* 1734 */ make_floatx80_init(0x567f, 0x956dd42f3d71d3a6),
+/* 1735 */ make_floatx80_init(0x5682, 0xbac9493b0cce4890),
+/* 1736 */ make_floatx80_init(0x5685, 0xe97b9b89d001dab4),
+/* 1737 */ make_floatx80_init(0x5689, 0x91ed4136220128b0),
+/* 1738 */ make_floatx80_init(0x568c, 0xb6689183aa8172dc),
+/* 1739 */ make_floatx80_init(0x568f, 0xe402b5e49521cf93),
+/* 1740 */ make_floatx80_init(0x5693, 0x8e81b1aedd3521bc),
+/* 1741 */ make_floatx80_init(0x5696, 0xb2221e1a94826a2b),
+/* 1742 */ make_floatx80_init(0x5699, 0xdeaaa5a139a304b6),
+/* 1743 */ make_floatx80_init(0x569d, 0x8b2aa784c405e2f2),
+/* 1744 */ make_floatx80_init(0x56a0, 0xadf55165f5075bae),
+/* 1745 */ make_floatx80_init(0x56a3, 0xd972a5bf7249329a),
+/* 1746 */ make_floatx80_init(0x56a7, 0x87e7a797a76dbfa0),
+/* 1747 */ make_floatx80_init(0x56aa, 0xa9e1917d91492f88),
+/* 1748 */ make_floatx80_init(0x56ad, 0xd459f5dcf59b7b6a),
+/* 1749 */ make_floatx80_init(0x56b1, 0x84b839aa19812d22),
+/* 1750 */ make_floatx80_init(0x56b4, 0xa5e648149fe1786b),
+/* 1751 */ make_floatx80_init(0x56b7, 0xcf5fda19c7d9d686),
+/* 1752 */ make_floatx80_init(0x56bb, 0x819be8501ce82614),
+/* 1753 */ make_floatx80_init(0x56be, 0xa202e26424222f98),
+/* 1754 */ make_floatx80_init(0x56c1, 0xca839afd2d2abb7f),
+/* 1755 */ make_floatx80_init(0x56c4, 0xfd2481bc78756a5e),
+/* 1756 */ make_floatx80_init(0x56c8, 0x9e36d115cb49627b),
+/* 1757 */ make_floatx80_init(0x56cb, 0xc5c4855b3e1bbb1a),
+/* 1758 */ make_floatx80_init(0x56ce, 0xf735a6b20da2a9e0),
+/* 1759 */ make_floatx80_init(0x56d2, 0x9a81882f4885aa2c),
+/* 1760 */ make_floatx80_init(0x56d5, 0xc121ea3b1aa714b7),
+/* 1761 */ make_floatx80_init(0x56d8, 0xf16a64c9e150d9e5),
+/* 1762 */ make_floatx80_init(0x56dc, 0x96e27efe2cd2882f),
+/* 1763 */ make_floatx80_init(0x56df, 0xbc9b1ebdb8072a3b),
+/* 1764 */ make_floatx80_init(0x56e2, 0xebc1e66d2608f4c9),
+/* 1765 */ make_floatx80_init(0x56e6, 0x9359300437c598fe),
+/* 1766 */ make_floatx80_init(0x56e9, 0xb82f7c0545b6ff3d),
+/* 1767 */ make_floatx80_init(0x56ec, 0xe63b5b069724bf0d),
+/* 1768 */ make_floatx80_init(0x56f0, 0x8fe518e41e76f768),
+/* 1769 */ make_floatx80_init(0x56f3, 0xb3de5f1d2614b542),
+/* 1770 */ make_floatx80_init(0x56f6, 0xe0d5f6e46f99e292),
+/* 1771 */ make_floatx80_init(0x56fa, 0x8c85ba4ec5c02d9b),
+/* 1772 */ make_floatx80_init(0x56fd, 0xafa728e277303902),
+/* 1773 */ make_floatx80_init(0x5700, 0xdb90f31b14fc4743),
+/* 1774 */ make_floatx80_init(0x5704, 0x893a97f0ed1dac8a),
+/* 1775 */ make_floatx80_init(0x5707, 0xab893ded286517ac),
+/* 1776 */ make_floatx80_init(0x570a, 0xd66b8d68727e5d97),
+/* 1777 */ make_floatx80_init(0x570e, 0x86033861478efa7f),
+/* 1778 */ make_floatx80_init(0x5711, 0xa78406799972b91e),
+/* 1779 */ make_floatx80_init(0x5714, 0xd1650817ffcf6766),
+/* 1780 */ make_floatx80_init(0x5718, 0x82df250effe1a0a0),
+/* 1781 */ make_floatx80_init(0x571b, 0xa396ee52bfda08c8),
+/* 1782 */ make_floatx80_init(0x571e, 0xcc7ca9e76fd08af9),
+/* 1783 */ make_floatx80_init(0x5721, 0xff9bd4614bc4adb8),
+/* 1784 */ make_floatx80_init(0x5725, 0x9fc164bccf5aec93),
+/* 1785 */ make_floatx80_init(0x5728, 0xc7b1bdec0331a7b8),
+/* 1786 */ make_floatx80_init(0x572b, 0xf99e2d6703fe11a5),
+/* 1787 */ make_floatx80_init(0x572f, 0x9c02dc60627ecb07),
+/* 1788 */ make_floatx80_init(0x5732, 0xc30393787b1e7dc9),
+/* 1789 */ make_floatx80_init(0x5735, 0xf3c4785699e61d3c),
+/* 1790 */ make_floatx80_init(0x5739, 0x985acb36202fd245),
+/* 1791 */ make_floatx80_init(0x573c, 0xbe717e03a83bc6d7),
+/* 1792 */ make_floatx80_init(0x573f, 0xee0ddd84924ab88c),
+/* 1793 */ make_floatx80_init(0x5743, 0x94c8aa72db6eb358),
+/* 1794 */ make_floatx80_init(0x5746, 0xb9fad50f924a602e),
+/* 1795 */ make_floatx80_init(0x5749, 0xe8798a5376dcf839),
+/* 1796 */ make_floatx80_init(0x574d, 0x914bf6742a4a1b24),
+/* 1797 */ make_floatx80_init(0x5750, 0xb59ef41134dca1ec),
+/* 1798 */ make_floatx80_init(0x5753, 0xe306b1158213ca68),
+/* 1799 */ make_floatx80_init(0x5757, 0x8de42ead714c5e81),
+/* 1800 */ make_floatx80_init(0x575a, 0xb15d3a58cd9f7621),
+/* 1801 */ make_floatx80_init(0x575d, 0xddb488ef010753a9),
+/* 1802 */ make_floatx80_init(0x5761, 0x8a90d59560a4944a),
+/* 1803 */ make_floatx80_init(0x5764, 0xad350afab8cdb95c),
+/* 1804 */ make_floatx80_init(0x5767, 0xd8824db9670127b3),
+/* 1805 */ make_floatx80_init(0x576b, 0x87517093e060b8d0),
+/* 1806 */ make_floatx80_init(0x576e, 0xa925ccb8d878e704),
+/* 1807 */ make_floatx80_init(0x5771, 0xd36f3fe70e9720c5),
+/* 1808 */ make_floatx80_init(0x5775, 0x842587f0691e747b),
+/* 1809 */ make_floatx80_init(0x5778, 0xa52ee9ec8366119a),
+/* 1810 */ make_floatx80_init(0x577b, 0xce7aa467a43f9600),
+/* 1811 */ make_floatx80_init(0x577f, 0x810ca6c0c6a7bdc0),
+/* 1812 */ make_floatx80_init(0x5782, 0xa14fd070f851ad30),
+/* 1813 */ make_floatx80_init(0x5785, 0xc9a3c48d3666187c),
+/* 1814 */ make_floatx80_init(0x5788, 0xfc0cb5b083ff9e9b),
+/* 1815 */ make_floatx80_init(0x578c, 0x9d87f18e527fc321),
+/* 1816 */ make_floatx80_init(0x578f, 0xc4e9edf1e71fb3e9),
+/* 1817 */ make_floatx80_init(0x5792, 0xf624696e60e7a0e4),
+/* 1818 */ make_floatx80_init(0x5796, 0x99d6c1e4fc90c48e),
+/* 1819 */ make_floatx80_init(0x5799, 0xc04c725e3bb4f5b2),
+/* 1820 */ make_floatx80_init(0x579c, 0xf05f8ef5caa2331e),
+/* 1821 */ make_floatx80_init(0x57a0, 0x963bb9599ea55ff3),
+/* 1822 */ make_floatx80_init(0x57a3, 0xbbcaa7b0064eb7f0),
+/* 1823 */ make_floatx80_init(0x57a6, 0xeabd519c07e265ec),
+/* 1824 */ make_floatx80_init(0x57aa, 0x92b6530184ed7fb3),
+/* 1825 */ make_floatx80_init(0x57ad, 0xb763e7c1e628dfa0),
+/* 1826 */ make_floatx80_init(0x57b0, 0xe53ce1b25fb31788),
+/* 1827 */ make_floatx80_init(0x57b4, 0x8f460d0f7bcfeeb5),
+/* 1828 */ make_floatx80_init(0x57b7, 0xb31790535ac3ea62),
+/* 1829 */ make_floatx80_init(0x57ba, 0xdfdd74683174e4fb),
+/* 1830 */ make_floatx80_init(0x57be, 0x8bea68c11ee90f1d),
+/* 1831 */ make_floatx80_init(0x57c1, 0xaee502f166a352e4),
+/* 1832 */ make_floatx80_init(0x57c4, 0xda9e43adc04c279d),
+/* 1833 */ make_floatx80_init(0x57c8, 0x88a2ea4c982f98c2),
+/* 1834 */ make_floatx80_init(0x57cb, 0xaacba4dfbe3b7ef3),
+/* 1835 */ make_floatx80_init(0x57ce, 0xd57e8e17adca5eaf),
+/* 1836 */ make_floatx80_init(0x57d2, 0x856f18cecc9e7b2e),
+/* 1837 */ make_floatx80_init(0x57d5, 0xa6cadf027fc619f9),
+/* 1838 */ make_floatx80_init(0x57d8, 0xd07d96c31fb7a077),
+/* 1839 */ make_floatx80_init(0x57dc, 0x824e7e39f3d2c44b),
+/* 1840 */ make_floatx80_init(0x57df, 0xa2e21dc870c7755d),
+/* 1841 */ make_floatx80_init(0x57e2, 0xcb9aa53a8cf952b5),
+/* 1842 */ make_floatx80_init(0x57e5, 0xfe814e893037a762),
+/* 1843 */ make_floatx80_init(0x57e9, 0x9f10d115be22c89d),
+/* 1844 */ make_floatx80_init(0x57ec, 0xc6d5055b2dab7ac4),
+/* 1845 */ make_floatx80_init(0x57ef, 0xf88a46b1f9165975),
+/* 1846 */ make_floatx80_init(0x57f3, 0x9b566c2f3badf7e9),
+/* 1847 */ make_floatx80_init(0x57f6, 0xc22c073b0a9975e4),
+/* 1848 */ make_floatx80_init(0x57f9, 0xf2b70909cd3fd35d),
+/* 1849 */ make_floatx80_init(0x57fd, 0x97b265a62047e41a),
+/* 1850 */ make_floatx80_init(0x5800, 0xbd9eff0fa859dd20),
+/* 1851 */ make_floatx80_init(0x5803, 0xed06bed392705468),
+/* 1852 */ make_floatx80_init(0x5807, 0x942437443b8634c1),
+/* 1853 */ make_floatx80_init(0x580a, 0xb92d45154a67c1f2),
+/* 1854 */ make_floatx80_init(0x580d, 0xe778965a9d01b26e),
+/* 1855 */ make_floatx80_init(0x5811, 0x90ab5df8a2210f85),
+/* 1856 */ make_floatx80_init(0x5814, 0xb4d63576caa95366),
+/* 1857 */ make_floatx80_init(0x5817, 0xe20bc2d47d53a83f),
+/* 1858 */ make_floatx80_init(0x581b, 0x8d4759c4ce544928),
+/* 1859 */ make_floatx80_init(0x581e, 0xb099303601e95b72),
+/* 1860 */ make_floatx80_init(0x5821, 0xdcbf7c438263b24e),
+/* 1861 */ make_floatx80_init(0x5825, 0x89f7adaa317e4f71),
+/* 1862 */ make_floatx80_init(0x5828, 0xac759914bddde34d),
+/* 1863 */ make_floatx80_init(0x582b, 0xd792ff59ed555c20),
+/* 1864 */ make_floatx80_init(0x582f, 0x86bbdf9834555994),
+/* 1865 */ make_floatx80_init(0x5832, 0xa86ad77e416aaff9),
+/* 1866 */ make_floatx80_init(0x5835, 0xd2858d5dd1c55bf7),
+/* 1867 */ make_floatx80_init(0x5839, 0x8393785aa31b597b),
+/* 1868 */ make_floatx80_init(0x583c, 0xa47856714be22fd9),
+/* 1869 */ make_floatx80_init(0x583f, 0xcd966c0d9edabbd0),
+/* 1870 */ make_floatx80_init(0x5843, 0x807e03888348b562),
+/* 1871 */ make_floatx80_init(0x5846, 0xa09d846aa41ae2ba),
+/* 1872 */ make_floatx80_init(0x5849, 0xc8c4e5854d219b69),
+/* 1873 */ make_floatx80_init(0x584c, 0xfaf61ee6a06a0243),
+/* 1874 */ make_floatx80_init(0x5850, 0x9cd9d3502442416a),
+/* 1875 */ make_floatx80_init(0x5853, 0xc41048242d52d1c4),
+/* 1876 */ make_floatx80_init(0x5856, 0xf5145a2d38a78635),
+/* 1877 */ make_floatx80_init(0x585a, 0x992cb85c4368b3e1),
+/* 1878 */ make_floatx80_init(0x585d, 0xbf77e6735442e0da),
+/* 1879 */ make_floatx80_init(0x5860, 0xef55e01029539910),
+/* 1880 */ make_floatx80_init(0x5864, 0x9595ac0a19d43faa),
+/* 1881 */ make_floatx80_init(0x5867, 0xbafb170ca0494f95),
+/* 1882 */ make_floatx80_init(0x586a, 0xe9b9dccfc85ba37a),
+/* 1883 */ make_floatx80_init(0x586e, 0x92142a01dd39462c),
+/* 1884 */ make_floatx80_init(0x5871, 0xb6993482548797b7),
+/* 1885 */ make_floatx80_init(0x5874, 0xe43f81a2e9a97da5),
+/* 1886 */ make_floatx80_init(0x5878, 0x8ea7b105d209ee87),
+/* 1887 */ make_floatx80_init(0x587b, 0xb2519d47468c6a29),
+/* 1888 */ make_floatx80_init(0x587e, 0xdee60499182f84b3),
+/* 1889 */ make_floatx80_init(0x5882, 0x8b4fc2dfaf1db2f0),
+/* 1890 */ make_floatx80_init(0x5885, 0xae23b3979ae51fac),
+/* 1891 */ make_floatx80_init(0x5888, 0xd9aca07d819e6797),
+/* 1892 */ make_floatx80_init(0x588c, 0x880be44e710300be),
+/* 1893 */ make_floatx80_init(0x588f, 0xaa0edd620d43c0ee),
+/* 1894 */ make_floatx80_init(0x5892, 0xd49294ba9094b129),
+/* 1895 */ make_floatx80_init(0x5896, 0x84db9cf49a5ceeba),
+/* 1896 */ make_floatx80_init(0x5899, 0xa6128431c0f42a68),
+/* 1897 */ make_floatx80_init(0x589c, 0xcf97253e31313502),
+/* 1898 */ make_floatx80_init(0x58a0, 0x81be7746debec121),
+/* 1899 */ make_floatx80_init(0x58a3, 0xa22e1518966e716a),
+/* 1900 */ make_floatx80_init(0x58a6, 0xcab99a5ebc0a0dc4),
+/* 1901 */ make_floatx80_init(0x58a9, 0xfd6800f66b0c9135),
+/* 1902 */ make_floatx80_init(0x58ad, 0x9e61009a02e7dac1),
+/* 1903 */ make_floatx80_init(0x58b0, 0xc5f940c083a1d172),
+/* 1904 */ make_floatx80_init(0x58b3, 0xf77790f0a48a45ce),
+/* 1905 */ make_floatx80_init(0x58b7, 0x9aaaba9666d66ba1),
+/* 1906 */ make_floatx80_init(0x58ba, 0xc155693c008c0689),
+/* 1907 */ make_floatx80_init(0x58bd, 0xf1aac38b00af082b),
+/* 1908 */ make_floatx80_init(0x58c1, 0x970aba36e06d651b),
+/* 1909 */ make_floatx80_init(0x58c4, 0xbccd68c49888be62),
+/* 1910 */ make_floatx80_init(0x58c7, 0xec00c2f5beaaedfa),
+/* 1911 */ make_floatx80_init(0x58cb, 0x938079d9972ad4bc),
+/* 1912 */ make_floatx80_init(0x58ce, 0xb860984ffcf589eb),
+/* 1913 */ make_floatx80_init(0x58d1, 0xe678be63fc32ec66),
+/* 1914 */ make_floatx80_init(0x58d5, 0x900b76fe7d9fd3c0),
+/* 1915 */ make_floatx80_init(0x58d8, 0xb40e54be1d07c8b0),
+/* 1916 */ make_floatx80_init(0x58db, 0xe111e9eda449badc),
+/* 1917 */ make_floatx80_init(0x58df, 0x8cab323486ae14c9),
+/* 1918 */ make_floatx80_init(0x58e2, 0xafd5fec1a85999fc),
+/* 1919 */ make_floatx80_init(0x58e5, 0xdbcb7e721270007b),
+/* 1920 */ make_floatx80_init(0x58e9, 0x895f2f074b86004d),
+/* 1921 */ make_floatx80_init(0x58ec, 0xabb6fac91e678060),
+/* 1922 */ make_floatx80_init(0x58ef, 0xd6a4b97b66016078),
+/* 1923 */ make_floatx80_init(0x58f3, 0x8626f3ed1fc0dc4b),
+/* 1924 */ make_floatx80_init(0x58f6, 0xa7b0b0e867b1135e),
+/* 1925 */ make_floatx80_init(0x58f9, 0xd19cdd22819d5835),
+/* 1926 */ make_floatx80_init(0x58fd, 0x83020a3591025721),
+/* 1927 */ make_floatx80_init(0x5900, 0xa3c28cc2f542ece9),
+/* 1928 */ make_floatx80_init(0x5903, 0xccb32ff3b293a824),
+/* 1929 */ make_floatx80_init(0x5906, 0xffdffbf09f38922d),
+/* 1930 */ make_floatx80_init(0x590a, 0x9febfd7663835b5c),
+/* 1931 */ make_floatx80_init(0x590d, 0xc7e6fcd3fc643233),
+/* 1932 */ make_floatx80_init(0x5910, 0xf9e0bc08fb7d3ec0),
+/* 1933 */ make_floatx80_init(0x5914, 0x9c2c75859d2e4738),
+/* 1934 */ make_floatx80_init(0x5917, 0xc33792e70479d906),
+/* 1935 */ make_floatx80_init(0x591a, 0xf40577a0c5984f47),
+/* 1936 */ make_floatx80_init(0x591e, 0x98836ac47b7f318d),
+/* 1937 */ make_floatx80_init(0x5921, 0xbea445759a5efdf0),
+/* 1938 */ make_floatx80_init(0x5924, 0xee4d56d300f6bd6c),
+/* 1939 */ make_floatx80_init(0x5928, 0x94f05643e09a3663),
+/* 1940 */ make_floatx80_init(0x592b, 0xba2c6bd4d8c0c3fc),
+/* 1941 */ make_floatx80_init(0x592e, 0xe8b786ca0ef0f4fb),
+/* 1942 */ make_floatx80_init(0x5932, 0x9172b43e4956991d),
+/* 1943 */ make_floatx80_init(0x5935, 0xb5cf614ddbac3f64),
+/* 1944 */ make_floatx80_init(0x5938, 0xe34339a152974f3d),
+/* 1945 */ make_floatx80_init(0x593c, 0x8e0a0404d39e9186),
+/* 1946 */ make_floatx80_init(0x593f, 0xb18c8506088635e8),
+/* 1947 */ make_floatx80_init(0x5942, 0xddefa6478aa7c362),
+/* 1948 */ make_floatx80_init(0x5946, 0x8ab5c7ecb6a8da1d),
+/* 1949 */ make_floatx80_init(0x5949, 0xad6339e7e45310a4),
+/* 1950 */ make_floatx80_init(0x594c, 0xd8bc0861dd67d4cd),
+/* 1951 */ make_floatx80_init(0x5950, 0x8775853d2a60e500),
+/* 1952 */ make_floatx80_init(0x5953, 0xa952e68c74f91e41),
+/* 1953 */ make_floatx80_init(0x5956, 0xd3a7a02f923765d1),
+/* 1954 */ make_floatx80_init(0x595a, 0x8448c41dbb629fa2),
+/* 1955 */ make_floatx80_init(0x595d, 0xa55af5252a3b478b),
+/* 1956 */ make_floatx80_init(0x5960, 0xceb1b26e74ca196e),
+/* 1957 */ make_floatx80_init(0x5964, 0x812f0f8508fe4fe5),
+/* 1958 */ make_floatx80_init(0x5967, 0xa17ad3664b3de3de),
+/* 1959 */ make_floatx80_init(0x596a, 0xc9d9883fde0d5cd5),
+/* 1960 */ make_floatx80_init(0x596d, 0xfc4fea4fd590b40a),
+/* 1961 */ make_floatx80_init(0x5971, 0x9db1f271e57a7087),
+/* 1962 */ make_floatx80_init(0x5974, 0xc51e6f0e5ed90ca8),
+/* 1963 */ make_floatx80_init(0x5977, 0xf6660ad1f68f4fd2),
+/* 1964 */ make_floatx80_init(0x597b, 0x99ffc6c33a1991e3),
+/* 1965 */ make_floatx80_init(0x597e, 0xc07fb874089ff65c),
+/* 1966 */ make_floatx80_init(0x5981, 0xf09fa6910ac7f3f3),
+/* 1967 */ make_floatx80_init(0x5985, 0x9663c81aa6bcf878),
+/* 1968 */ make_floatx80_init(0x5988, 0xbbfcba21506c3696),
+/* 1969 */ make_floatx80_init(0x598b, 0xeafbe8a9a487443c),
+/* 1970 */ make_floatx80_init(0x598f, 0x92dd716a06d48aa5),
+/* 1971 */ make_floatx80_init(0x5992, 0xb794cdc48889ad4f),
+/* 1972 */ make_floatx80_init(0x5995, 0xe57a0135aaac18a2),
+/* 1973 */ make_floatx80_init(0x5999, 0x8f6c40c18aab8f65),
+/* 1974 */ make_floatx80_init(0x599c, 0xb34750f1ed56733f),
+/* 1975 */ make_floatx80_init(0x599f, 0xe019252e68ac100e),
+/* 1976 */ make_floatx80_init(0x59a3, 0x8c0fb73d016b8a09),
+/* 1977 */ make_floatx80_init(0x59a6, 0xaf13a50c41c66c8b),
+/* 1978 */ make_floatx80_init(0x59a9, 0xdad88e4f523807ae),
+/* 1979 */ make_floatx80_init(0x59ad, 0x88c758f1936304cd),
+/* 1980 */ make_floatx80_init(0x59b0, 0xaaf92f2df83bc600),
+/* 1981 */ make_floatx80_init(0x59b3, 0xd5b77af9764ab780),
+/* 1982 */ make_floatx80_init(0x59b7, 0x8592acdbe9eeb2b0),
+/* 1983 */ make_floatx80_init(0x59ba, 0xa6f75812e46a5f5c),
+/* 1984 */ make_floatx80_init(0x59bd, 0xd0b52e179d84f733),
+/* 1985 */ make_floatx80_init(0x59c1, 0x82713ccec2731a80),
+/* 1986 */ make_floatx80_init(0x59c4, 0xa30d8c02730fe120),
+/* 1987 */ make_floatx80_init(0x59c7, 0xcbd0ef030fd3d968),
+/* 1988 */ make_floatx80_init(0x59ca, 0xfec52ac3d3c8cfc2),
+/* 1989 */ make_floatx80_init(0x59ce, 0x9f3b3aba645d81d9),
+/* 1990 */ make_floatx80_init(0x59d1, 0xc70a0968fd74e24f),
+/* 1991 */ make_floatx80_init(0x59d4, 0xf8cc8bc33cd21ae3),
+/* 1992 */ make_floatx80_init(0x59d8, 0x9b7fd75a060350ce),
+/* 1993 */ make_floatx80_init(0x59db, 0xc25fcd3087842501),
+/* 1994 */ make_floatx80_init(0x59de, 0xf2f7c07ca9652e42),
+/* 1995 */ make_floatx80_init(0x59e2, 0x97dad84de9df3ce9),
+/* 1996 */ make_floatx80_init(0x59e5, 0xbdd18e6164570c23),
+/* 1997 */ make_floatx80_init(0x59e8, 0xed45f1f9bd6ccf2c),
+/* 1998 */ make_floatx80_init(0x59ec, 0x944bb73c1664017c),
+/* 1999 */ make_floatx80_init(0x59ef, 0xb95ea50b1bfd01db),
+/* 2000 */ make_floatx80_init(0x59f2, 0xe7b64e4de2fc4251),
+/* 2001 */ make_floatx80_init(0x59f6, 0x90d1f0f0addda973),
+/* 2002 */ make_floatx80_init(0x59f9, 0xb5066d2cd95513d0),
+/* 2003 */ make_floatx80_init(0x59fc, 0xe24808780faa58c3),
+/* 2004 */ make_floatx80_init(0x5a00, 0x8d6d054b09ca777a),
+/* 2005 */ make_floatx80_init(0x5a03, 0xb0c8469dcc3d1559),
+/* 2006 */ make_floatx80_init(0x5a06, 0xdcfa58453f4c5aaf),
+/* 2007 */ make_floatx80_init(0x5a0a, 0x8a1c772b478fb8ad),
+/* 2008 */ make_floatx80_init(0x5a0d, 0xaca394f61973a6d9),
+/* 2009 */ make_floatx80_init(0x5a10, 0xd7cc7a339fd0908f),
+/* 2010 */ make_floatx80_init(0x5a14, 0x86dfcc6043e25a59),
+/* 2011 */ make_floatx80_init(0x5a17, 0xa897bf7854daf0ef),
+/* 2012 */ make_floatx80_init(0x5a1a, 0xd2bdaf566a11ad2b),
+/* 2013 */ make_floatx80_init(0x5a1e, 0x83b68d96024b0c3b),
+/* 2014 */ make_floatx80_init(0x5a21, 0xa4a430fb82ddcf4a),
+/* 2015 */ make_floatx80_init(0x5a24, 0xcdcd3d3a6395431c),
+/* 2016 */ make_floatx80_init(0x5a28, 0x80a046447e3d49f2),
+/* 2017 */ make_floatx80_init(0x5a2b, 0xa0c857d59dcc9c6e),
+/* 2018 */ make_floatx80_init(0x5a2e, 0xc8fa6dcb053fc38a),
+/* 2019 */ make_floatx80_init(0x5a31, 0xfb39093dc68fb46c),
+/* 2020 */ make_floatx80_init(0x5a35, 0x9d03a5c69c19d0c4),
+/* 2021 */ make_floatx80_init(0x5a38, 0xc4448f38432044f4),
+/* 2022 */ make_floatx80_init(0x5a3b, 0xf555b30653e85632),
+/* 2023 */ make_floatx80_init(0x5a3f, 0x99558fe3f47135df),
+/* 2024 */ make_floatx80_init(0x5a42, 0xbfaaf3dcf18d8357),
+/* 2025 */ make_floatx80_init(0x5a45, 0xef95b0d42df0e42c),
+/* 2026 */ make_floatx80_init(0x5a49, 0x95bd8e849cb68e9c),
+/* 2027 */ make_floatx80_init(0x5a4c, 0xbb2cf225c3e43243),
+/* 2028 */ make_floatx80_init(0x5a4f, 0xe9f82eaf34dd3ed3),
+/* 2029 */ make_floatx80_init(0x5a53, 0x923b1d2d810a4744),
+/* 2030 */ make_floatx80_init(0x5a56, 0xb6c9e478e14cd915),
+/* 2031 */ make_floatx80_init(0x5a59, 0xe47c5d9719a00f5a),
+/* 2032 */ make_floatx80_init(0x5a5d, 0x8ecdba7e70040999),
+/* 2033 */ make_floatx80_init(0x5a60, 0xb281291e0c050bff),
+/* 2034 */ make_floatx80_init(0x5a63, 0xdf2173658f064efe),
+/* 2035 */ make_floatx80_init(0x5a67, 0x8b74e81f7963f15f),
+/* 2036 */ make_floatx80_init(0x5a6a, 0xae52222757bcedb7),
+/* 2037 */ make_floatx80_init(0x5a6d, 0xd9e6aab12dac2924),
+/* 2038 */ make_floatx80_init(0x5a71, 0x88302aaebc8b99b7),
+/* 2039 */ make_floatx80_init(0x5a74, 0xaa3c355a6bae8024),
+/* 2040 */ make_floatx80_init(0x5a77, 0xd4cb42b1069a202d),
+/* 2041 */ make_floatx80_init(0x5a7b, 0x84ff09aea420541c),
+/* 2042 */ make_floatx80_init(0x5a7e, 0xa63ecc1a4d286924),
+/* 2043 */ make_floatx80_init(0x5a81, 0xcfce7f20e072836c),
+/* 2044 */ make_floatx80_init(0x5a85, 0x81e10f748c479224),
+/* 2045 */ make_floatx80_init(0x5a88, 0xa2595351af5976ad),
+/* 2046 */ make_floatx80_init(0x5a8b, 0xcaefa8261b2fd458),
+/* 2047 */ make_floatx80_init(0x5a8e, 0xfdab922fa1fbc96e),
+/* 2048 */ make_floatx80_init(0x5a92, 0x9e8b3b5dc53d5de5),
+/* 2049 */ make_floatx80_init(0x5a95, 0xc62e0a35368cb55e),
+/* 2050 */ make_floatx80_init(0x5a98, 0xf7b98cc2842fe2b5),
+/* 2051 */ make_floatx80_init(0x5a9c, 0x9ad3f7f9929dedb1),
+/* 2052 */ make_floatx80_init(0x5a9f, 0xc188f5f7f745691e),
+/* 2053 */ make_floatx80_init(0x5aa2, 0xf1eb3375f516c365),
+/* 2054 */ make_floatx80_init(0x5aa6, 0x97330029b92e3a1f),
+/* 2055 */ make_floatx80_init(0x5aa9, 0xbcffc0342779c8a7),
+/* 2056 */ make_floatx80_init(0x5aac, 0xec3fb04131583ad1),
+/* 2057 */ make_floatx80_init(0x5ab0, 0x93a7ce28bed724c2),
+/* 2058 */ make_floatx80_init(0x5ab3, 0xb891c1b2ee8cedf3),
+/* 2059 */ make_floatx80_init(0x5ab6, 0xe6b6321faa302970),
+/* 2060 */ make_floatx80_init(0x5aba, 0x9031df53ca5e19e6),
+/* 2061 */ make_floatx80_init(0x5abd, 0xb43e5728bcf5a05f),
+/* 2062 */ make_floatx80_init(0x5ac0, 0xe14decf2ec330877),
+/* 2063 */ make_floatx80_init(0x5ac4, 0x8cd0b417d39fe54a),
+/* 2064 */ make_floatx80_init(0x5ac7, 0xb004e11dc887de9d),
+/* 2065 */ make_floatx80_init(0x5aca, 0xdc0619653aa9d644),
+/* 2066 */ make_floatx80_init(0x5ace, 0x8983cfdf44aa25eb),
+/* 2067 */ make_floatx80_init(0x5ad1, 0xabe4c3d715d4af65),
+/* 2068 */ make_floatx80_init(0x5ad4, 0xd6ddf4ccdb49db3f),
+/* 2069 */ make_floatx80_init(0x5ad8, 0x864ab900090e2907),
+/* 2070 */ make_floatx80_init(0x5adb, 0xa7dd67400b51b349),
+/* 2071 */ make_floatx80_init(0x5ade, 0xd1d4c1100e26201b),
+/* 2072 */ make_floatx80_init(0x5ae2, 0x8324f8aa08d7d411),
+/* 2073 */ make_floatx80_init(0x5ae5, 0xa3ee36d48b0dc915),
+/* 2074 */ make_floatx80_init(0x5ae8, 0xcce9c489add13b5b),
+/* 2075 */ make_floatx80_init(0x5aec, 0x80121ad60ca2c519),
+/* 2076 */ make_floatx80_init(0x5aef, 0xa016a18b8fcb765f),
+/* 2077 */ make_floatx80_init(0x5af2, 0xc81c49ee73be53f7),
+/* 2078 */ make_floatx80_init(0x5af5, 0xfa235c6a10ade8f4),
+/* 2079 */ make_floatx80_init(0x5af9, 0x9c5619c24a6cb199),
+/* 2080 */ make_floatx80_init(0x5afc, 0xc36ba032dd07ddff),
+/* 2081 */ make_floatx80_init(0x5aff, 0xf446883f9449d57e),
+/* 2082 */ make_floatx80_init(0x5b03, 0x98ac1527bcae256f),
+/* 2083 */ make_floatx80_init(0x5b06, 0xbed71a71abd9aecb),
+/* 2084 */ make_floatx80_init(0x5b09, 0xee8ce10e16d01a7d),
+/* 2085 */ make_floatx80_init(0x5b0d, 0x95180ca8ce42108e),
+/* 2086 */ make_floatx80_init(0x5b10, 0xba5e0fd301d294b2),
+/* 2087 */ make_floatx80_init(0x5b13, 0xe8f593c7c24739df),
+/* 2088 */ make_floatx80_init(0x5b17, 0x91997c5cd96c842b),
+/* 2089 */ make_floatx80_init(0x5b1a, 0xb5ffdb740fc7a536),
+/* 2090 */ make_floatx80_init(0x5b1d, 0xe37fd25113b98e83),
+/* 2091 */ make_floatx80_init(0x5b21, 0x8e2fe372ac53f912),
+/* 2092 */ make_floatx80_init(0x5b24, 0xb1bbdc4f5768f757),
+/* 2093 */ make_floatx80_init(0x5b27, 0xde2ad3632d43352c),
+/* 2094 */ make_floatx80_init(0x5b2b, 0x8adac41dfc4a013c),
+/* 2095 */ make_floatx80_init(0x5b2e, 0xad9175257b5c818b),
+/* 2096 */ make_floatx80_init(0x5b31, 0xd8f5d26eda33a1ed),
+/* 2097 */ make_floatx80_init(0x5b35, 0x8799a38548604534),
+/* 2098 */ make_floatx80_init(0x5b38, 0xa9800c669a785681),
+/* 2099 */ make_floatx80_init(0x5b3b, 0xd3e00f8041166c22),
+/* 2100 */ make_floatx80_init(0x5b3f, 0x846c09b028ae0395),
+/* 2101 */ make_floatx80_init(0x5b42, 0xa5870c1c32d9847a),
+/* 2102 */ make_floatx80_init(0x5b45, 0xcee8cf233f8fe599),
+/* 2103 */ make_floatx80_init(0x5b49, 0x8151817607b9ef80),
+/* 2104 */ make_floatx80_init(0x5b4c, 0xa1a5e1d389a86b5f),
+/* 2105 */ make_floatx80_init(0x5b4f, 0xca0f5a486c128637),
+/* 2106 */ make_floatx80_init(0x5b52, 0xfc9330da871727c5),
+/* 2107 */ make_floatx80_init(0x5b56, 0x9ddbfe88946e78db),
+/* 2108 */ make_floatx80_init(0x5b59, 0xc552fe2ab98a1712),
+/* 2109 */ make_floatx80_init(0x5b5c, 0xf6a7bdb567ec9cd6),
+/* 2110 */ make_floatx80_init(0x5b60, 0x9a28d69160f3e206),
+/* 2111 */ make_floatx80_init(0x5b63, 0xc0b30c35b930da88),
+/* 2112 */ make_floatx80_init(0x5b66, 0xf0dfcf43277d1129),
+/* 2113 */ make_floatx80_init(0x5b6a, 0x968be189f8ae2aba),
+/* 2114 */ make_floatx80_init(0x5b6d, 0xbc2ed9ec76d9b568),
+/* 2115 */ make_floatx80_init(0x5b70, 0xeb3a9067949022c2),
+/* 2116 */ make_floatx80_init(0x5b74, 0x93049a40bcda15ba),
+/* 2117 */ make_floatx80_init(0x5b77, 0xb7c5c0d0ec109b28),
+/* 2118 */ make_floatx80_init(0x5b7a, 0xe5b731052714c1f2),
+/* 2119 */ make_floatx80_init(0x5b7e, 0x8f927ea3386cf937),
+/* 2120 */ make_floatx80_init(0x5b81, 0xb3771e4c06883785),
+/* 2121 */ make_floatx80_init(0x5b84, 0xe054e5df082a4566),
+/* 2122 */ make_floatx80_init(0x5b88, 0x8c350fab651a6b60),
+/* 2123 */ make_floatx80_init(0x5b8b, 0xaf4253963e610638),
+/* 2124 */ make_floatx80_init(0x5b8e, 0xdb12e87bcdf947c6),
+/* 2125 */ make_floatx80_init(0x5b92, 0x88ebd14d60bbccdc),
+/* 2126 */ make_floatx80_init(0x5b95, 0xab26c5a0b8eac013),
+/* 2127 */ make_floatx80_init(0x5b98, 0xd5f07708e7257017),
+/* 2128 */ make_floatx80_init(0x5b9c, 0x85b64a659077660e),
+/* 2129 */ make_floatx80_init(0x5b9f, 0xa723dcfef4953f92),
+/* 2130 */ make_floatx80_init(0x5ba2, 0xd0ecd43eb1ba8f77),
+/* 2131 */ make_floatx80_init(0x5ba6, 0x829404a72f1499aa),
+/* 2132 */ make_floatx80_init(0x5ba9, 0xa33905d0fad9c015),
+/* 2133 */ make_floatx80_init(0x5bac, 0xcc0747453990301a),
+/* 2134 */ make_floatx80_init(0x5baf, 0xff09191687f43c20),
+/* 2135 */ make_floatx80_init(0x5bb3, 0x9f65afae14f8a594),
+/* 2136 */ make_floatx80_init(0x5bb6, 0xc73f1b999a36cef9),
+/* 2137 */ make_floatx80_init(0x5bb9, 0xf90ee28000c482b8),
+/* 2138 */ make_floatx80_init(0x5bbd, 0x9ba94d90007ad1b3),
+/* 2139 */ make_floatx80_init(0x5bc0, 0xc293a0f40099861f),
+/* 2140 */ make_floatx80_init(0x5bc3, 0xf338893100bfe7a7),
+/* 2141 */ make_floatx80_init(0x5bc7, 0x980355bea077f0c9),
+/* 2142 */ make_floatx80_init(0x5bca, 0xbe042b2e4895ecfb),
+/* 2143 */ make_floatx80_init(0x5bcd, 0xed8535f9dabb6839),
+/* 2144 */ make_floatx80_init(0x5bd1, 0x947341bc28b52124),
+/* 2145 */ make_floatx80_init(0x5bd4, 0xb990122b32e2696d),
+/* 2146 */ make_floatx80_init(0x5bd7, 0xe7f416b5ff9b03c8),
+/* 2147 */ make_floatx80_init(0x5bdb, 0x90f88e31bfc0e25d),
+/* 2148 */ make_floatx80_init(0x5bde, 0xb536b1be2fb11af4),
+/* 2149 */ make_floatx80_init(0x5be1, 0xe2845e2dbb9d61b1),
+/* 2150 */ make_floatx80_init(0x5be5, 0x8d92badc95425d0f),
+/* 2151 */ make_floatx80_init(0x5be8, 0xb0f76993ba92f453),
+/* 2152 */ make_floatx80_init(0x5beb, 0xdd3543f8a937b167),
+/* 2153 */ make_floatx80_init(0x5bef, 0x8a414a7b69c2cee0),
+/* 2154 */ make_floatx80_init(0x5bf2, 0xacd19d1a44338299),
+/* 2155 */ make_floatx80_init(0x5bf5, 0xd8060460d540633f),
+/* 2156 */ make_floatx80_init(0x5bf9, 0x8703c2bc85483e07),
+/* 2157 */ make_floatx80_init(0x5bfc, 0xa8c4b36ba69a4d89),
+/* 2158 */ make_floatx80_init(0x5bff, 0xd2f5e0469040e0eb),
+/* 2159 */ make_floatx80_init(0x5c03, 0x83d9ac2c1a288c93),
+/* 2160 */ make_floatx80_init(0x5c06, 0xa4d0173720b2afb8),
+/* 2161 */ make_floatx80_init(0x5c09, 0xce041d04e8df5ba6),
+/* 2162 */ make_floatx80_init(0x5c0d, 0x80c29223118b9948),
+/* 2163 */ make_floatx80_init(0x5c10, 0xa0f336abd5ee7f9a),
+/* 2164 */ make_floatx80_init(0x5c13, 0xc9300456cb6a1f80),
+/* 2165 */ make_floatx80_init(0x5c16, 0xfb7c056c7e44a760),
+/* 2166 */ make_floatx80_init(0x5c1a, 0x9d2d8363ceeae89c),
+/* 2167 */ make_floatx80_init(0x5c1d, 0xc478e43cc2a5a2c3),
+/* 2168 */ make_floatx80_init(0x5c20, 0xf5971d4bf34f0b74),
+/* 2169 */ make_floatx80_init(0x5c24, 0x997e724f78116728),
+/* 2170 */ make_floatx80_init(0x5c27, 0xbfde0ee35615c0f2),
+/* 2171 */ make_floatx80_init(0x5c2a, 0xefd5929c2b9b312f),
+/* 2172 */ make_floatx80_init(0x5c2e, 0x95e57ba19b40febd),
+/* 2173 */ make_floatx80_init(0x5c31, 0xbb5eda8a02113e6d),
+/* 2174 */ make_floatx80_init(0x5c34, 0xea36912c82958e08),
+/* 2175 */ make_floatx80_init(0x5c38, 0x92621abbd19d78c5),
+/* 2176 */ make_floatx80_init(0x5c3b, 0xb6faa16ac604d6f6),
+/* 2177 */ make_floatx80_init(0x5c3e, 0xe4b949c577860cb4),
+/* 2178 */ make_floatx80_init(0x5c42, 0x8ef3ce1b6ab3c7f0),
+/* 2179 */ make_floatx80_init(0x5c45, 0xb2b0c1a24560b9ec),
+/* 2180 */ make_floatx80_init(0x5c48, 0xdf5cf20ad6b8e867),
+/* 2181 */ make_floatx80_init(0x5c4c, 0x8b9a1746c6339141),
+/* 2182 */ make_floatx80_init(0x5c4f, 0xae809d1877c07591),
+/* 2183 */ make_floatx80_init(0x5c52, 0xda20c45e95b092f5),
+/* 2184 */ make_floatx80_init(0x5c56, 0x88547abb1d8e5bd9),
+/* 2185 */ make_floatx80_init(0x5c59, 0xaa699969e4f1f2cf),
+/* 2186 */ make_floatx80_init(0x5c5c, 0xd503ffc45e2e6f83),
+/* 2187 */ make_floatx80_init(0x5c60, 0x85227fdabadd05b2),
+/* 2188 */ make_floatx80_init(0x5c63, 0xa66b1fd16994471f),
+/* 2189 */ make_floatx80_init(0x5c66, 0xd005e7c5c3f958e6),
+/* 2190 */ make_floatx80_init(0x5c6a, 0x8203b0db9a7bd790),
+/* 2191 */ make_floatx80_init(0x5c6d, 0xa2849d12811acd74),
+/* 2192 */ make_floatx80_init(0x5c70, 0xcb25c457216180d1),
+/* 2193 */ make_floatx80_init(0x5c73, 0xfdef356ce9b9e105),
+/* 2194 */ make_floatx80_init(0x5c77, 0x9eb5816412142ca3),
+/* 2195 */ make_floatx80_init(0x5c7a, 0xc662e1bd169937cc),
+/* 2196 */ make_floatx80_init(0x5c7d, 0xf7fb9a2c5c3f85bf),
+/* 2197 */ make_floatx80_init(0x5c81, 0x9afd405bb9a7b397),
+/* 2198 */ make_floatx80_init(0x5c84, 0xc1bc9072a811a07d),
+/* 2199 */ make_floatx80_init(0x5c87, 0xf22bb48f5216089c),
+/* 2200 */ make_floatx80_init(0x5c8b, 0x975b50d9934dc562),
+/* 2201 */ make_floatx80_init(0x5c8e, 0xbd32250ff82136ba),
+/* 2202 */ make_floatx80_init(0x5c91, 0xec7eae53f6298469),
+/* 2203 */ make_floatx80_init(0x5c95, 0x93cf2cf479d9f2c1),
+/* 2204 */ make_floatx80_init(0x5c98, 0xb8c2f83198506f72),
+/* 2205 */ make_floatx80_init(0x5c9b, 0xe6f3b63dfe648b4e),
+/* 2206 */ make_floatx80_init(0x5c9f, 0x905851e6befed711),
+/* 2207 */ make_floatx80_init(0x5ca2, 0xb46e66606ebe8cd5),
+/* 2208 */ make_floatx80_init(0x5ca5, 0xe189fff88a6e300a),
+/* 2209 */ make_floatx80_init(0x5ca9, 0x8cf63ffb5684de07),
+/* 2210 */ make_floatx80_init(0x5cac, 0xb033cffa2c261588),
+/* 2211 */ make_floatx80_init(0x5caf, 0xdc40c3f8b72f9aea),
+/* 2212 */ make_floatx80_init(0x5cb3, 0x89a87a7b727dc0d2),
+/* 2213 */ make_floatx80_init(0x5cb6, 0xac12991a4f1d3107),
+/* 2214 */ make_floatx80_init(0x5cb9, 0xd7173f60e2e47d49),
+/* 2215 */ make_floatx80_init(0x5cbd, 0x866e879c8dcece4d),
+/* 2216 */ make_floatx80_init(0x5cc0, 0xa80a2983b14281e1),
+/* 2217 */ make_floatx80_init(0x5cc3, 0xd20cb3e49d932259),
+/* 2218 */ make_floatx80_init(0x5cc7, 0x8347f06ee27bf578),
+/* 2219 */ make_floatx80_init(0x5cca, 0xa419ec8a9b1af2d6),
+/* 2220 */ make_floatx80_init(0x5ccd, 0xcd2067ad41e1af8b),
+/* 2221 */ make_floatx80_init(0x5cd1, 0x803440cc492d0db7),
+/* 2222 */ make_floatx80_init(0x5cd4, 0xa04150ff5b785125),
+/* 2223 */ make_floatx80_init(0x5cd7, 0xc851a53f3256656e),
+/* 2224 */ make_floatx80_init(0x5cda, 0xfa660e8efeebfec9),
+/* 2225 */ make_floatx80_init(0x5cde, 0x9c7fc9195f537f3e),
+/* 2226 */ make_floatx80_init(0x5ce1, 0xc39fbb5fb7285f0d),
+/* 2227 */ make_floatx80_init(0x5ce4, 0xf487aa37a4f276d0),
+/* 2228 */ make_floatx80_init(0x5ce8, 0x98d4ca62c7178a42),
+/* 2229 */ make_floatx80_init(0x5ceb, 0xbf09fcfb78dd6cd3),
+/* 2230 */ make_floatx80_init(0x5cee, 0xeecc7c3a5714c807),
+/* 2231 */ make_floatx80_init(0x5cf2, 0x953fcda4766cfd05),
+/* 2232 */ make_floatx80_init(0x5cf5, 0xba8fc10d94083c46),
+/* 2233 */ make_floatx80_init(0x5cf8, 0xe933b150f90a4b57),
+/* 2234 */ make_floatx80_init(0x5cfc, 0x91c04ed29ba66f17),
+/* 2235 */ make_floatx80_init(0x5cff, 0xb630628742900adc),
+/* 2236 */ make_floatx80_init(0x5d02, 0xe3bc7b2913340d93),
+/* 2237 */ make_floatx80_init(0x5d06, 0x8e55ccf9ac00887c),
+/* 2238 */ make_floatx80_init(0x5d09, 0xb1eb40381700aa9b),
+/* 2239 */ make_floatx80_init(0x5d0c, 0xde6610461cc0d542),
+/* 2240 */ make_floatx80_init(0x5d10, 0x8affca2bd1f88549),
+/* 2241 */ make_floatx80_init(0x5d13, 0xadbfbcb6c676a69b),
+/* 2242 */ make_floatx80_init(0x5d16, 0xd92fabe478145042),
+/* 2243 */ make_floatx80_init(0x5d1a, 0x87bdcb6ecb0cb229),
+/* 2244 */ make_floatx80_init(0x5d1d, 0xa9ad3e4a7dcfdeb4),
+/* 2245 */ make_floatx80_init(0x5d20, 0xd4188ddd1d43d661),
+/* 2246 */ make_floatx80_init(0x5d24, 0x848f58aa324a65fc),
+/* 2247 */ make_floatx80_init(0x5d27, 0xa5b32ed4bedcff7c),
+/* 2248 */ make_floatx80_init(0x5d2a, 0xcf1ffa89ee943f5a),
+/* 2249 */ make_floatx80_init(0x5d2e, 0x8173fc96351ca799),
+/* 2250 */ make_floatx80_init(0x5d31, 0xa1d0fbbbc263d17f),
+/* 2251 */ make_floatx80_init(0x5d34, 0xca453aaab2fcc5de),
+/* 2252 */ make_floatx80_init(0x5d37, 0xfcd689555fbbf756),
+/* 2253 */ make_floatx80_init(0x5d3b, 0x9e0615d55bd57a96),
+/* 2254 */ make_floatx80_init(0x5d3e, 0xc5879b4ab2cad93b),
+/* 2255 */ make_floatx80_init(0x5d41, 0xf6e9821d5f7d8f8a),
+/* 2256 */ make_floatx80_init(0x5d45, 0x9a51f1525bae79b6),
+/* 2257 */ make_floatx80_init(0x5d48, 0xc0e66da6f29a1824),
+/* 2258 */ make_floatx80_init(0x5d4b, 0xf1200910af409e2d),
+/* 2259 */ make_floatx80_init(0x5d4f, 0x96b405aa6d8862dc),
+/* 2260 */ make_floatx80_init(0x5d52, 0xbc61071508ea7b93),
+/* 2261 */ make_floatx80_init(0x5d55, 0xeb7948da4b251a78),
+/* 2262 */ make_floatx80_init(0x5d59, 0x932bcd886ef7308b),
+/* 2263 */ make_floatx80_init(0x5d5c, 0xb7f6c0ea8ab4fcad),
+/* 2264 */ make_floatx80_init(0x5d5f, 0xe5f471252d623bd9),
+/* 2265 */ make_floatx80_init(0x5d63, 0x8fb8c6b73c5d6567),
+/* 2266 */ make_floatx80_init(0x5d66, 0xb3a6f8650b74bec1),
+/* 2267 */ make_floatx80_init(0x5d69, 0xe090b67e4e51ee72),
+/* 2268 */ make_floatx80_init(0x5d6d, 0x8c5a720ef0f33507),
+/* 2269 */ make_floatx80_init(0x5d70, 0xaf710e92ad300249),
+/* 2270 */ make_floatx80_init(0x5d73, 0xdb4d5237587c02db),
+/* 2271 */ make_floatx80_init(0x5d77, 0x89105362974d81c9),
+/* 2272 */ make_floatx80_init(0x5d7a, 0xab54683b3d20e23b),
+/* 2273 */ make_floatx80_init(0x5d7d, 0xd629824a0c691aca),
+/* 2274 */ make_floatx80_init(0x5d81, 0x85d9f16e47c1b0be),
+/* 2275 */ make_floatx80_init(0x5d84, 0xa7506dc9d9b21cee),
+/* 2276 */ make_floatx80_init(0x5d87, 0xd124893c501ea429),
+/* 2277 */ make_floatx80_init(0x5d8b, 0x82b6d5c5b213269a),
+/* 2278 */ make_floatx80_init(0x5d8e, 0xa3648b371e97f040),
+/* 2279 */ make_floatx80_init(0x5d91, 0xcc3dae04e63dec50),
+/* 2280 */ make_floatx80_init(0x5d94, 0xff4d19861fcd6764),
+/* 2281 */ make_floatx80_init(0x5d98, 0x9f902ff3d3e0609f),
+/* 2282 */ make_floatx80_init(0x5d9b, 0xc7743bf0c8d878c6),
+/* 2283 */ make_floatx80_init(0x5d9e, 0xf9514aecfb0e96f8),
+/* 2284 */ make_floatx80_init(0x5da2, 0x9bd2ced41ce91e5b),
+/* 2285 */ make_floatx80_init(0x5da5, 0xc2c78289242365f2),
+/* 2286 */ make_floatx80_init(0x5da8, 0xf379632b6d2c3f6e),
+/* 2287 */ make_floatx80_init(0x5dac, 0x982bddfb243ba7a5),
+/* 2288 */ make_floatx80_init(0x5daf, 0xbe36d579ed4a918e),
+/* 2289 */ make_floatx80_init(0x5db2, 0xedc48ad8689d35f2),
+/* 2290 */ make_floatx80_init(0x5db6, 0x949ad6c7416241b7),
+/* 2291 */ make_floatx80_init(0x5db9, 0xb9c18c7911bad225),
+/* 2292 */ make_floatx80_init(0x5dbc, 0xe831ef97562986ae),
+/* 2293 */ make_floatx80_init(0x5dc0, 0x911f35be95d9f42d),
+/* 2294 */ make_floatx80_init(0x5dc3, 0xb567032e3b507138),
+/* 2295 */ make_floatx80_init(0x5dc6, 0xe2c0c3f9ca248d86),
+/* 2296 */ make_floatx80_init(0x5dca, 0x8db87a7c1e56d874),
+/* 2297 */ make_floatx80_init(0x5dcd, 0xb126991b25ec8e91),
+/* 2298 */ make_floatx80_init(0x5dd0, 0xdd703f61ef67b235),
+/* 2299 */ make_floatx80_init(0x5dd4, 0x8a66279d35a0cf61),
+/* 2300 */ make_floatx80_init(0x5dd7, 0xacffb18483090339),
+/* 2301 */ make_floatx80_init(0x5dda, 0xd83f9de5a3cb4407),
+/* 2302 */ make_floatx80_init(0x5dde, 0x8727c2af865f0a85),
+/* 2303 */ make_floatx80_init(0x5de1, 0xa8f1b35b67f6cd26),
+/* 2304 */ make_floatx80_init(0x5de4, 0xd32e203241f4806f),
+/* 2305 */ make_floatx80_init(0x5de8, 0x83fcd41f6938d046),
+/* 2306 */ make_floatx80_init(0x5deb, 0xa4fc092743870457),
+/* 2307 */ make_floatx80_init(0x5dee, 0xce3b0b711468c56d),
+/* 2308 */ make_floatx80_init(0x5df2, 0x80e4e726acc17b64),
+/* 2309 */ make_floatx80_init(0x5df5, 0xa11e20f057f1da3d),
+/* 2310 */ make_floatx80_init(0x5df8, 0xc965a92c6dee50cc),
+/* 2311 */ make_floatx80_init(0x5dfb, 0xfbbf13778969e4ff),
+/* 2312 */ make_floatx80_init(0x5dff, 0x9d576c2ab5e22f1f),
+/* 2313 */ make_floatx80_init(0x5e02, 0xc4ad4735635abae7),
+/* 2314 */ make_floatx80_init(0x5e05, 0xf5d89902bc3169a1),
+/* 2315 */ make_floatx80_init(0x5e09, 0x99a75fa1b59ee205),
+/* 2316 */ make_floatx80_init(0x5e0c, 0xc011378a23069a86),
+/* 2317 */ make_floatx80_init(0x5e0f, 0xf015856cabc84127),
+/* 2318 */ make_floatx80_init(0x5e13, 0x960d7363eb5d28b9),
+/* 2319 */ make_floatx80_init(0x5e16, 0xbb90d03ce63472e7),
+/* 2320 */ make_floatx80_init(0x5e19, 0xea75044c1fc18fa0),
+/* 2321 */ make_floatx80_init(0x5e1d, 0x928922af93d8f9c4),
+/* 2322 */ make_floatx80_init(0x5e20, 0xb72b6b5b78cf3835),
+/* 2323 */ make_floatx80_init(0x5e23, 0xe4f6463257030643),
+/* 2324 */ make_floatx80_init(0x5e27, 0x8f19ebdf7661e3ea),
+/* 2325 */ make_floatx80_init(0x5e2a, 0xb2e066d753fa5ce4),
+/* 2326 */ make_floatx80_init(0x5e2d, 0xdf98808d28f8f41d),
+/* 2327 */ make_floatx80_init(0x5e31, 0x8bbf5058399b9892),
+/* 2328 */ make_floatx80_init(0x5e34, 0xaeaf246e48027eb7),
+/* 2329 */ make_floatx80_init(0x5e37, 0xda5aed89da031e64),
+/* 2330 */ make_floatx80_init(0x5e3b, 0x8878d4762841f2ff),
+/* 2331 */ make_floatx80_init(0x5e3e, 0xaa970993b2526fbe),
+/* 2332 */ make_floatx80_init(0x5e41, 0xd53ccbf89ee70bae),
+/* 2333 */ make_floatx80_init(0x5e45, 0x8545ff7b6350674d),
+/* 2334 */ make_floatx80_init(0x5e48, 0xa6977f5a3c248120),
+/* 2335 */ make_floatx80_init(0x5e4b, 0xd03d5f30cb2da168),
+/* 2336 */ make_floatx80_init(0x5e4f, 0x82265b7e7efc84e1),
+/* 2337 */ make_floatx80_init(0x5e52, 0xa2aff25e1ebba619),
+/* 2338 */ make_floatx80_init(0x5e55, 0xcb5beef5a66a8fa0),
+/* 2339 */ make_floatx80_init(0x5e58, 0xfe32eab310053387),
+/* 2340 */ make_floatx80_init(0x5e5c, 0x9edfd2afea034035),
+/* 2341 */ make_floatx80_init(0x5e5f, 0xc697c75be4841042),
+/* 2342 */ make_floatx80_init(0x5e62, 0xf83db932dda51452),
+/* 2343 */ make_floatx80_init(0x5e66, 0x9b2693bfca872cb3),
+/* 2344 */ make_floatx80_init(0x5e69, 0xc1f038afbd28f7e0),
+/* 2345 */ make_floatx80_init(0x5e6c, 0xf26c46dbac7335d8),
+/* 2346 */ make_floatx80_init(0x5e70, 0x9783ac494bc801a7),
+/* 2347 */ make_floatx80_init(0x5e73, 0xbd64975b9eba0211),
+/* 2348 */ make_floatx80_init(0x5e76, 0xecbdbd3286688295),
+/* 2349 */ make_floatx80_init(0x5e7a, 0x93f6963f9401519d),
+/* 2350 */ make_floatx80_init(0x5e7d, 0xb8f43bcf7901a605),
+/* 2351 */ make_floatx80_init(0x5e80, 0xe7314ac357420f86),
+/* 2352 */ make_floatx80_init(0x5e84, 0x907eceba168949b4),
+/* 2353 */ make_floatx80_init(0x5e87, 0xb49e82689c2b9c21),
+/* 2354 */ make_floatx80_init(0x5e8a, 0xe1c62302c3368329),
+/* 2355 */ make_floatx80_init(0x5e8e, 0x8d1bd5e1ba0211f9),
+/* 2356 */ make_floatx80_init(0x5e91, 0xb062cb5a28829678),
+/* 2357 */ make_floatx80_init(0x5e94, 0xdc7b7e30b2a33c16),
+/* 2358 */ make_floatx80_init(0x5e98, 0x89cd2ede6fa6058e),
+/* 2359 */ make_floatx80_init(0x5e9b, 0xac407a960b8f86f1),
+/* 2360 */ make_floatx80_init(0x5e9e, 0xd750993b8e7368ad),
+/* 2361 */ make_floatx80_init(0x5ea2, 0x86925fc53908216c),
+/* 2362 */ make_floatx80_init(0x5ea5, 0xa836f7b6874a29c7),
+/* 2363 */ make_floatx80_init(0x5ea8, 0xd244b5a4291cb439),
+/* 2364 */ make_floatx80_init(0x5eac, 0x836af18699b1f0a4),
+/* 2365 */ make_floatx80_init(0x5eaf, 0xa445ade8401e6ccd),
+/* 2366 */ make_floatx80_init(0x5eb2, 0xcd57196250260800),
+/* 2367 */ make_floatx80_init(0x5eb6, 0x80566fdd7217c500),
+/* 2368 */ make_floatx80_init(0x5eb9, 0xa06c0bd4ce9db640),
+/* 2369 */ make_floatx80_init(0x5ebc, 0xc8870eca024523d0),
+/* 2370 */ make_floatx80_init(0x5ebf, 0xfaa8d27c82d66cc4),
+/* 2371 */ make_floatx80_init(0x5ec3, 0x9ca9838dd1c603fa),
+/* 2372 */ make_floatx80_init(0x5ec6, 0xc3d3e471463784f9),
+/* 2373 */ make_floatx80_init(0x5ec9, 0xf4c8dd8d97c56637),
+/* 2374 */ make_floatx80_init(0x5ecd, 0x98fd8a787edb5fe2),
+/* 2375 */ make_floatx80_init(0x5ed0, 0xbf3ced169e9237db),
+/* 2376 */ make_floatx80_init(0x5ed3, 0xef0c285c4636c5d2),
+/* 2377 */ make_floatx80_init(0x5ed7, 0x95679939abe23ba3),
+/* 2378 */ make_floatx80_init(0x5eda, 0xbac17f8816daca8c),
+/* 2379 */ make_floatx80_init(0x5edd, 0xe971df6a1c917d2f),
+/* 2380 */ make_floatx80_init(0x5ee1, 0x91e72ba251daee3d),
+/* 2381 */ make_floatx80_init(0x5ee4, 0xb660f68ae651a9cd),
+/* 2382 */ make_floatx80_init(0x5ee7, 0xe3f9342d9fe61440),
+/* 2383 */ make_floatx80_init(0x5eeb, 0x8e7bc09c83efcca8),
+/* 2384 */ make_floatx80_init(0x5eee, 0xb21ab0c3a4ebbfd2),
+/* 2385 */ make_floatx80_init(0x5ef1, 0xdea15cf48e26afc6),
+/* 2386 */ make_floatx80_init(0x5ef5, 0x8b24da18d8d82ddc),
+/* 2387 */ make_floatx80_init(0x5ef8, 0xadee109f0f0e3953),
+/* 2388 */ make_floatx80_init(0x5efb, 0xd96994c6d2d1c7a8),
+/* 2389 */ make_floatx80_init(0x5eff, 0x87e1fcfc43c31cc9),
+/* 2390 */ make_floatx80_init(0x5f02, 0xa9da7c3b54b3e3fb),
+/* 2391 */ make_floatx80_init(0x5f05, 0xd4511b4a29e0dcfa),
+/* 2392 */ make_floatx80_init(0x5f09, 0x84b2b10e5a2c8a1c),
+/* 2393 */ make_floatx80_init(0x5f0c, 0xa5df5d51f0b7aca3),
+/* 2394 */ make_floatx80_init(0x5f0f, 0xcf5734a66ce597cc),
+/* 2395 */ make_floatx80_init(0x5f13, 0x819680e8040f7edf),
+/* 2396 */ make_floatx80_init(0x5f16, 0xa1fc212205135e97),
+/* 2397 */ make_floatx80_init(0x5f19, 0xca7b296a8658363d),
+/* 2398 */ make_floatx80_init(0x5f1c, 0xfd19f3c527ee43cc),
+/* 2399 */ make_floatx80_init(0x5f20, 0x9e30385b38f4ea60),
+/* 2400 */ make_floatx80_init(0x5f23, 0xc5bc4672073224f8),
+/* 2401 */ make_floatx80_init(0x5f26, 0xf72b580e88feae36),
+/* 2402 */ make_floatx80_init(0x5f2a, 0x9a7b1709159f2ce2),
+/* 2403 */ make_floatx80_init(0x5f2d, 0xc119dccb5b06f81a),
+/* 2404 */ make_floatx80_init(0x5f30, 0xf16053fe31c8b620),
+/* 2405 */ make_floatx80_init(0x5f34, 0x96dc347edf1d71d4),
+/* 2406 */ make_floatx80_init(0x5f37, 0xbc93419e96e4ce49),
+/* 2407 */ make_floatx80_init(0x5f3a, 0xebb812063c9e01dc),
+/* 2408 */ make_floatx80_init(0x5f3e, 0x93530b43e5e2c129),
+/* 2409 */ make_floatx80_init(0x5f41, 0xb827ce14df5b7174),
+/* 2410 */ make_floatx80_init(0x5f44, 0xe631c19a17324dd0),
+/* 2411 */ make_floatx80_init(0x5f48, 0x8fdf19004e7f70a2),
+/* 2412 */ make_floatx80_init(0x5f4b, 0xb3d6df40621f4ccb),
+/* 2413 */ make_floatx80_init(0x5f4e, 0xe0cc97107aa71ffe),
+/* 2414 */ make_floatx80_init(0x5f52, 0x8c7fde6a4ca873fe),
+/* 2415 */ make_floatx80_init(0x5f55, 0xaf9fd604dfd290fe),
+/* 2416 */ make_floatx80_init(0x5f58, 0xdb87cb8617c7353e),
+/* 2417 */ make_floatx80_init(0x5f5c, 0x8934df33cedc8147),
+/* 2418 */ make_floatx80_init(0x5f5f, 0xab821700c293a198),
+/* 2419 */ make_floatx80_init(0x5f62, 0xd6629cc0f33889fe),
+/* 2420 */ make_floatx80_init(0x5f66, 0x85fda1f89803563f),
+/* 2421 */ make_floatx80_init(0x5f69, 0xa77d0a76be042bcf),
+/* 2422 */ make_floatx80_init(0x5f6c, 0xd15c4d146d8536c2),
+/* 2423 */ make_floatx80_init(0x5f70, 0x82d9b02cc4734239),
+/* 2424 */ make_floatx80_init(0x5f73, 0xa3901c37f59012c8),
+/* 2425 */ make_floatx80_init(0x5f76, 0xcc742345f2f4177a),
+/* 2426 */ make_floatx80_init(0x5f79, 0xff912c176fb11d58),
+/* 2427 */ make_floatx80_init(0x5f7d, 0x9fbabb8ea5ceb257),
+/* 2428 */ make_floatx80_init(0x5f80, 0xc7a96a724f425eed),
+/* 2429 */ make_floatx80_init(0x5f83, 0xf993c50ee312f6a8),
+/* 2430 */ make_floatx80_init(0x5f87, 0x9bfc5b294debda29),
+/* 2431 */ make_floatx80_init(0x5f8a, 0xc2fb71f3a166d0b3),
+/* 2432 */ make_floatx80_init(0x5f8d, 0xf3ba4e7089c084e0),
+/* 2433 */ make_floatx80_init(0x5f91, 0x985471065618530c),
+/* 2434 */ make_floatx80_init(0x5f94, 0xbe698d47eb9e67cf),
+/* 2435 */ make_floatx80_init(0x5f97, 0xee03f099e68601c3),
+/* 2436 */ make_floatx80_init(0x5f9b, 0x94c276603013c11a),
+/* 2437 */ make_floatx80_init(0x5f9e, 0xb9f313f83c18b160),
+/* 2438 */ make_floatx80_init(0x5fa1, 0xe86fd8f64b1eddb8),
+/* 2439 */ make_floatx80_init(0x5fa5, 0x9145e799eef34a93),
+/* 2440 */ make_floatx80_init(0x5fa8, 0xb59761806ab01d38),
+/* 2441 */ make_floatx80_init(0x5fab, 0xe2fd39e0855c2486),
+/* 2442 */ make_floatx80_init(0x5faf, 0x8dde442c535996d4),
+/* 2443 */ make_floatx80_init(0x5fb2, 0xb155d537682ffc89),
+/* 2444 */ make_floatx80_init(0x5fb5, 0xddab4a85423bfbab),
+/* 2445 */ make_floatx80_init(0x5fb9, 0x8a8b0e9349657d4b),
+/* 2446 */ make_floatx80_init(0x5fbc, 0xad2dd2381bbedc9d),
+/* 2447 */ make_floatx80_init(0x5fbf, 0xd87946c622ae93c5),
+/* 2448 */ make_floatx80_init(0x5fc3, 0x874bcc3bd5ad1c5b),
+/* 2449 */ make_floatx80_init(0x5fc6, 0xa91ebf4acb186372),
+/* 2450 */ make_floatx80_init(0x5fc9, 0xd3666f1d7dde7c4e),
+/* 2451 */ make_floatx80_init(0x5fcd, 0x842005726eab0db1),
+/* 2452 */ make_floatx80_init(0x5fd0, 0xa52806cf0a55d11d),
+/* 2453 */ make_floatx80_init(0x5fd3, 0xce720882cceb4564),
+/* 2454 */ make_floatx80_init(0x5fd7, 0x81074551c0130b5f),
+/* 2455 */ make_floatx80_init(0x5fda, 0xa14916a63017ce36),
+/* 2456 */ make_floatx80_init(0x5fdd, 0xc99b5c4fbc1dc1c4),
+/* 2457 */ make_floatx80_init(0x5fe0, 0xfc023363ab253235),
+/* 2458 */ make_floatx80_init(0x5fe4, 0x9d81601e4af73f61),
+/* 2459 */ make_floatx80_init(0x5fe7, 0xc4e1b825ddb50f39),
+/* 2460 */ make_floatx80_init(0x5fea, 0xf61a262f55225308),
+/* 2461 */ make_floatx80_init(0x5fee, 0x99d057dd953573e5),
+/* 2462 */ make_floatx80_init(0x5ff1, 0xc0446dd4fa82d0de),
+/* 2463 */ make_floatx80_init(0x5ff4, 0xf055894a39238516),
+/* 2464 */ make_floatx80_init(0x5ff8, 0x963575ce63b6332d),
+/* 2465 */ make_floatx80_init(0x5ffb, 0xbbc2d341fca3bff9),
+/* 2466 */ make_floatx80_init(0x5ffe, 0xeab388127bccaff7),
+/* 2467 */ make_floatx80_init(0x6002, 0x92b0350b8d5fedfa),
+/* 2468 */ make_floatx80_init(0x6005, 0xb75c424e70b7e979),
+/* 2469 */ make_floatx80_init(0x6008, 0xe53352e20ce5e3d7),
+/* 2470 */ make_floatx80_init(0x600c, 0x8f4013cd480fae67),
+/* 2471 */ make_floatx80_init(0x600f, 0xb31018c09a139a00),
+/* 2472 */ make_floatx80_init(0x6012, 0xdfd41ef0c0988080),
+/* 2473 */ make_floatx80_init(0x6016, 0x8be49356785f5050),
+/* 2474 */ make_floatx80_init(0x6019, 0xaeddb82c16772464),
+/* 2475 */ make_floatx80_init(0x601c, 0xda9526371c14ed7d),
+/* 2476 */ make_floatx80_init(0x6020, 0x889d37e2718d146e),
+/* 2477 */ make_floatx80_init(0x6023, 0xaac485db0df0598a),
+/* 2478 */ make_floatx80_init(0x6026, 0xd575a751d16c6fec),
+/* 2479 */ make_floatx80_init(0x602a, 0x8569889322e3c5f4),
+/* 2480 */ make_floatx80_init(0x602d, 0xa6c3eab7eb9cb771),
+/* 2481 */ make_floatx80_init(0x6030, 0xd074e565e683e54d),
+/* 2482 */ make_floatx80_init(0x6034, 0x82490f5fb0126f50),
+/* 2483 */ make_floatx80_init(0x6037, 0xa2db53379c170b24),
+/* 2484 */ make_floatx80_init(0x603a, 0xcb922805831ccded),
+/* 2485 */ make_floatx80_init(0x603d, 0xfe76b206e3e40168),
+/* 2486 */ make_floatx80_init(0x6041, 0x9f0a2f444e6e80e1),
+/* 2487 */ make_floatx80_init(0x6044, 0xc6ccbb15620a2119),
+/* 2488 */ make_floatx80_init(0x6047, 0xf87fe9daba8ca960),
+/* 2489 */ make_floatx80_init(0x604b, 0x9b4ff228b497e9dc),
+/* 2490 */ make_floatx80_init(0x604e, 0xc223eeb2e1bde453),
+/* 2491 */ make_floatx80_init(0x6051, 0xf2acea5f9a2d5d68),
+/* 2492 */ make_floatx80_init(0x6055, 0x97ac127bc05c5a61),
+/* 2493 */ make_floatx80_init(0x6058, 0xbd97171ab07370f9),
+/* 2494 */ make_floatx80_init(0x605b, 0xecfcdce15c904d37),
+/* 2495 */ make_floatx80_init(0x605f, 0x941e0a0cd9da3042),
+/* 2496 */ make_floatx80_init(0x6062, 0xb9258c901050bc53),
+/* 2497 */ make_floatx80_init(0x6065, 0xe76eefb41464eb68),
+/* 2498 */ make_floatx80_init(0x6069, 0x90a555d08cbf1321),
+/* 2499 */ make_floatx80_init(0x606c, 0xb4ceab44afeed7e9),
+/* 2500 */ make_floatx80_init(0x606f, 0xe2025615dbea8de3),
+/* 2501 */ make_floatx80_init(0x6073, 0x8d4175cda97298ae),
+/* 2502 */ make_floatx80_init(0x6076, 0xb091d34113cf3eda),
+/* 2503 */ make_floatx80_init(0x6079, 0xdcb6481158c30e90),
+/* 2504 */ make_floatx80_init(0x607d, 0x89f1ed0ad779e91a),
+/* 2505 */ make_floatx80_init(0x6080, 0xac6e684d8d586361),
+/* 2506 */ make_floatx80_init(0x6083, 0xd78a0260f0ae7c39),
+/* 2507 */ make_floatx80_init(0x6087, 0x86b6417c966d0da3),
+/* 2508 */ make_floatx80_init(0x608a, 0xa863d1dbbc08510c),
+/* 2509 */ make_floatx80_init(0x608d, 0xd27cc652ab0a654f),
+/* 2510 */ make_floatx80_init(0x6091, 0x838dfbf3aae67f52),
+/* 2511 */ make_floatx80_init(0x6094, 0xa4717af095a01f26),
+/* 2512 */ make_floatx80_init(0x6097, 0xcd8dd9acbb0826ef),
+/* 2513 */ make_floatx80_init(0x609b, 0x8078a80bf4e51856),
+/* 2514 */ make_floatx80_init(0x609e, 0xa096d20ef21e5e6b),
+/* 2515 */ make_floatx80_init(0x60a1, 0xc8bc8692aea5f606),
+/* 2516 */ make_floatx80_init(0x60a4, 0xfaeba8375a4f7387),
+/* 2517 */ make_floatx80_init(0x60a8, 0x9cd349229871a835),
+/* 2518 */ make_floatx80_init(0x60ab, 0xc4081b6b3e8e1242),
+/* 2519 */ make_floatx80_init(0x60ae, 0xf50a22460e3196d2),
+/* 2520 */ make_floatx80_init(0x60b2, 0x9926556bc8defe43),
+/* 2521 */ make_floatx80_init(0x60b5, 0xbf6feac6bb16bdd4),
+/* 2522 */ make_floatx80_init(0x60b8, 0xef4be57869dc6d49),
+/* 2523 */ make_floatx80_init(0x60bc, 0x958f6f6b4229c44e),
+/* 2524 */ make_floatx80_init(0x60bf, 0xbaf34b4612b43561),
+/* 2525 */ make_floatx80_init(0x60c2, 0xe9b01e17976142ba),
+/* 2526 */ make_floatx80_init(0x60c6, 0x920e12cebe9cc9b4),
+/* 2527 */ make_floatx80_init(0x60c9, 0xb69197826e43fc21),
+/* 2528 */ make_floatx80_init(0x60cc, 0xe435fd6309d4fb29),
+/* 2529 */ make_floatx80_init(0x60d0, 0x8ea1be5de6251cfa),
+/* 2530 */ make_floatx80_init(0x60d3, 0xb24a2df55fae6438),
+/* 2531 */ make_floatx80_init(0x60d6, 0xdedcb972b799fd46),
+/* 2532 */ make_floatx80_init(0x60da, 0x8b49f3e7b2c03e4c),
+/* 2533 */ make_floatx80_init(0x60dd, 0xae1c70e19f704ddf),
+/* 2534 */ make_floatx80_init(0x60e0, 0xd9a38d1a074c6157),
+/* 2535 */ make_floatx80_init(0x60e4, 0x88063830448fbcd6),
+/* 2536 */ make_floatx80_init(0x60e7, 0xaa07c63c55b3ac0c),
+/* 2537 */ make_floatx80_init(0x60ea, 0xd489b7cb6b20970f),
+/* 2538 */ make_floatx80_init(0x60ee, 0x84d612df22f45e69),
+/* 2539 */ make_floatx80_init(0x60f1, 0xa60b9796ebb17603),
+/* 2540 */ make_floatx80_init(0x60f4, 0xcf8e7d7ca69dd384),
+/* 2541 */ make_floatx80_init(0x60f8, 0x81b90e6de822a433),
+/* 2542 */ make_floatx80_init(0x60fb, 0xa2275209622b4d3f),
+/* 2543 */ make_floatx80_init(0x60fe, 0xcab1268bbab6208f),
+/* 2544 */ make_floatx80_init(0x6101, 0xfd5d702ea963a8b3),
+/* 2545 */ make_floatx80_init(0x6105, 0x9e5a661d29de4970),
+/* 2546 */ make_floatx80_init(0x6108, 0xc5f0ffa47455dbcc),
+/* 2547 */ make_floatx80_init(0x610b, 0xf76d3f8d916b52bf),
+/* 2548 */ make_floatx80_init(0x610f, 0x9aa447b87ae313b7),
+/* 2549 */ make_floatx80_init(0x6112, 0xc14d59a6999bd8a5),
+/* 2550 */ make_floatx80_init(0x6115, 0xf1a0b0104002cece),
+/* 2551 */ make_floatx80_init(0x6119, 0x97046e0a2801c141),
+/* 2552 */ make_floatx80_init(0x611c, 0xbcc5898cb2023191),
+/* 2553 */ make_floatx80_init(0x611f, 0xebf6ebefde82bdf5),
+/* 2554 */ make_floatx80_init(0x6123, 0x937a5375eb11b6b9),
+/* 2555 */ make_floatx80_init(0x6126, 0xb858e85365d62468),
+/* 2556 */ make_floatx80_init(0x6129, 0xe66f22683f4bad82),
+/* 2557 */ make_floatx80_init(0x612d, 0x90057581278f4c71),
+/* 2558 */ make_floatx80_init(0x6130, 0xb406d2e171731f8d),
+/* 2559 */ make_floatx80_init(0x6133, 0xe1088799cdcfe771),
+/* 2560 */ make_floatx80_init(0x6137, 0x8ca554c020a1f0a6),
+/* 2561 */ make_floatx80_init(0x613a, 0xafcea9f028ca6cd0),
+/* 2562 */ make_floatx80_init(0x613d, 0xdbc2546c32fd0804),
+/* 2563 */ make_floatx80_init(0x6141, 0x895974c39fde2502),
+/* 2564 */ make_floatx80_init(0x6144, 0xabafd1f487d5ae43),
+/* 2565 */ make_floatx80_init(0x6147, 0xd69bc671a9cb19d4),
+/* 2566 */ make_floatx80_init(0x614b, 0x86215c070a1ef024),
+/* 2567 */ make_floatx80_init(0x614e, 0xa7a9b308cca6ac2e),
+/* 2568 */ make_floatx80_init(0x6151, 0xd1941fcaffd05739),
+/* 2569 */ make_floatx80_init(0x6155, 0x82fc93dedfe23684),
+/* 2570 */ make_floatx80_init(0x6158, 0xa3bbb8d697dac424),
+/* 2571 */ make_floatx80_init(0x615b, 0xccaaa70c3dd1752e),
+/* 2572 */ make_floatx80_init(0x615e, 0xffd550cf4d45d279),
+/* 2573 */ make_floatx80_init(0x6162, 0x9fe55281904ba38c),
+/* 2574 */ make_floatx80_init(0x6165, 0xc7dea721f45e8c6e),
+/* 2575 */ make_floatx80_init(0x6168, 0xf9d650ea71762f8a),
+/* 2576 */ make_floatx80_init(0x616c, 0x9c25f29286e9ddb6),
+/* 2577 */ make_floatx80_init(0x616f, 0xc32f6f3728a45524),
+/* 2578 */ make_floatx80_init(0x6172, 0xf3fb4b04f2cd6a6d),
+/* 2579 */ make_floatx80_init(0x6176, 0x987d0ee317c06284),
+/* 2580 */ make_floatx80_init(0x6179, 0xbe9c529bddb07b25),
+/* 2581 */ make_floatx80_init(0x617c, 0xee436742d51c99ee),
+/* 2582 */ make_floatx80_init(0x6180, 0x94ea2089c531e035),
+/* 2583 */ make_floatx80_init(0x6183, 0xba24a8ac367e5842),
+/* 2584 */ make_floatx80_init(0x6186, 0xe8add2d7441dee53),
+/* 2585 */ make_floatx80_init(0x618a, 0x916ca3c68a92b4f4),
+/* 2586 */ make_floatx80_init(0x618d, 0xb5c7ccb82d376231),
+/* 2587 */ make_floatx80_init(0x6190, 0xe339bfe638853abd),
+/* 2588 */ make_floatx80_init(0x6194, 0x8e0417efe35344b6),
+/* 2589 */ make_floatx80_init(0x6197, 0xb1851debdc2815e3),
+/* 2590 */ make_floatx80_init(0x619a, 0xdde66566d3321b5c),
+/* 2591 */ make_floatx80_init(0x619e, 0x8aafff6043ff511a),
+/* 2592 */ make_floatx80_init(0x61a1, 0xad5bff3854ff2560),
+/* 2593 */ make_floatx80_init(0x61a4, 0xd8b2ff066a3eeeb8),
+/* 2594 */ make_floatx80_init(0x61a8, 0x876fdf6402675533),
+/* 2595 */ make_floatx80_init(0x61ab, 0xa94bd73d03012a80),
+/* 2596 */ make_floatx80_init(0x61ae, 0xd39ecd0c43c17520),
+/* 2597 */ make_floatx80_init(0x61b2, 0x84434027aa58e934),
+/* 2598 */ make_floatx80_init(0x61b5, 0xa554103194ef2381),
+/* 2599 */ make_floatx80_init(0x61b8, 0xcea9143dfa2aec61),
+/* 2600 */ make_floatx80_init(0x61bc, 0x8129aca6bc5ad3bd),
+/* 2601 */ make_floatx80_init(0x61bf, 0xa17417d06b7188ac),
+/* 2602 */ make_floatx80_init(0x61c2, 0xc9d11dc4864dead7),
+/* 2603 */ make_floatx80_init(0x61c5, 0xfc456535a7e1658d),
+/* 2604 */ make_floatx80_init(0x61c9, 0x9dab5f4188ecdf78),
+/* 2605 */ make_floatx80_init(0x61cc, 0xc5163711eb281756),
+/* 2606 */ make_floatx80_init(0x61cf, 0xf65bc4d665f21d2b),
+/* 2607 */ make_floatx80_init(0x61d3, 0x99f95b05ffb7523b),
+/* 2608 */ make_floatx80_init(0x61d6, 0xc077b1c77fa526ca),
+/* 2609 */ make_floatx80_init(0x61d9, 0xf0959e395f8e707c),
+/* 2610 */ make_floatx80_init(0x61dd, 0x965d82e3dbb9064e),
+/* 2611 */ make_floatx80_init(0x61e0, 0xbbf4e39cd2a747e1),
+/* 2612 */ make_floatx80_init(0x61e3, 0xeaf21c84075119d9),
+/* 2613 */ make_floatx80_init(0x61e7, 0x92d751d28492b028),
+/* 2614 */ make_floatx80_init(0x61ea, 0xb78d264725b75c32),
+/* 2615 */ make_floatx80_init(0x61ed, 0xe5706fd8ef25333e),
+/* 2616 */ make_floatx80_init(0x61f1, 0x8f6645e795774007),
+/* 2617 */ make_floatx80_init(0x61f4, 0xb33fd7617ad51009),
+/* 2618 */ make_floatx80_init(0x61f7, 0xe00fcd39d98a540b),
+/* 2619 */ make_floatx80_init(0x61fb, 0x8c09e04427f67487),
+/* 2620 */ make_floatx80_init(0x61fe, 0xaf0c585531f411a8),
+/* 2621 */ make_floatx80_init(0x6201, 0xdacf6e6a7e711613),
+/* 2622 */ make_floatx80_init(0x6205, 0x88c1a5028f06adcc),
+/* 2623 */ make_floatx80_init(0x6208, 0xaaf20e4332c8593e),
+/* 2624 */ make_floatx80_init(0x620b, 0xd5ae91d3ff7a6f8e),
+/* 2625 */ make_floatx80_init(0x620f, 0x858d1b247fac85b9),
+/* 2626 */ make_floatx80_init(0x6212, 0xa6f061ed9f97a727),
+/* 2627 */ make_floatx80_init(0x6215, 0xd0ac7a69077d90f1),
+/* 2628 */ make_floatx80_init(0x6219, 0x826bcc81a4ae7a96),
+/* 2629 */ make_floatx80_init(0x621c, 0xa306bfa20dda193c),
+/* 2630 */ make_floatx80_init(0x621f, 0xcbc86f8a91509f8b),
+/* 2631 */ make_floatx80_init(0x6222, 0xfeba8b6d35a4c76e),
+/* 2632 */ make_floatx80_init(0x6226, 0x9f3497244186fca5),
+/* 2633 */ make_floatx80_init(0x6229, 0xc701bced51e8bbce),
+/* 2634 */ make_floatx80_init(0x622c, 0xf8c22c28a662eac1),
+/* 2635 */ make_floatx80_init(0x6230, 0x9b795b9967fdd2b9),
+/* 2636 */ make_floatx80_init(0x6233, 0xc257b27fc1fd4767),
+/* 2637 */ make_floatx80_init(0x6236, 0xf2ed9f1fb27c9941),
+/* 2638 */ make_floatx80_init(0x623a, 0x97d48373cf8ddfc9),
+/* 2639 */ make_floatx80_init(0x623d, 0xbdc9a450c37157bb),
+/* 2640 */ make_floatx80_init(0x6240, 0xed3c0d64f44dada9),
+/* 2641 */ make_floatx80_init(0x6244, 0x9445885f18b08c8a),
+/* 2642 */ make_floatx80_init(0x6247, 0xb956ea76dedcafac),
+/* 2643 */ make_floatx80_init(0x624a, 0xe7aca5149693db97),
+/* 2644 */ make_floatx80_init(0x624e, 0x90cbe72cde1c693f),
+/* 2645 */ make_floatx80_init(0x6251, 0xb4fee0f815a3838e),
+/* 2646 */ make_floatx80_init(0x6254, 0xe23e99361b0c6472),
+/* 2647 */ make_floatx80_init(0x6258, 0x8d671fc1d0e7bec7),
+/* 2648 */ make_floatx80_init(0x625b, 0xb0c0e7b24521ae79),
+/* 2649 */ make_floatx80_init(0x625e, 0xdcf1219ed66a1a17),
+/* 2650 */ make_floatx80_init(0x6262, 0x8a16b5034602504e),
+/* 2651 */ make_floatx80_init(0x6265, 0xac9c62441782e462),
+/* 2652 */ make_floatx80_init(0x6268, 0xd7c37ad51d639d7b),
+/* 2653 */ make_floatx80_init(0x626c, 0x86da2cc5325e426d),
+/* 2654 */ make_floatx80_init(0x626f, 0xa890b7f67ef5d308),
+/* 2655 */ make_floatx80_init(0x6272, 0xd2b4e5f41eb347ca),
+/* 2656 */ make_floatx80_init(0x6276, 0x83b10fb893300cde),
+/* 2657 */ make_floatx80_init(0x6279, 0xa49d53a6b7fc1016),
+/* 2658 */ make_floatx80_init(0x627c, 0xcdc4a89065fb141b),
+/* 2659 */ make_floatx80_init(0x6280, 0x809ae95a3fbcec91),
+/* 2660 */ make_floatx80_init(0x6283, 0xa0c1a3b0cfac27b5),
+/* 2661 */ make_floatx80_init(0x6286, 0xc8f20c9d039731a2),
+/* 2662 */ make_floatx80_init(0x6289, 0xfb2e8fc4447cfe0b),
+/* 2663 */ make_floatx80_init(0x628d, 0x9cfd19daaace1ec7),
+/* 2664 */ make_floatx80_init(0x6290, 0xc43c60515581a679),
+/* 2665 */ make_floatx80_init(0x6293, 0xf54b7865aae21017),
+/* 2666 */ make_floatx80_init(0x6297, 0x994f2b3f8acd4a0e),
+/* 2667 */ make_floatx80_init(0x629a, 0xbfa2f60f6d809c92),
+/* 2668 */ make_floatx80_init(0x629d, 0xef8bb39348e0c3b6),
+/* 2669 */ make_floatx80_init(0x62a1, 0x95b7503c0d8c7a52),
+/* 2670 */ make_floatx80_init(0x62a4, 0xbb25244b10ef98e6),
+/* 2671 */ make_floatx80_init(0x62a7, 0xe9ee6d5dd52b7f20),
+/* 2672 */ make_floatx80_init(0x62ab, 0x9235045aa53b2f74),
+/* 2673 */ make_floatx80_init(0x62ae, 0xb6c245714e89fb51),
+/* 2674 */ make_floatx80_init(0x62b1, 0xe472d6cda22c7a25),
+/* 2675 */ make_floatx80_init(0x62b5, 0x8ec7c640855bcc57),
+/* 2676 */ make_floatx80_init(0x62b8, 0xb279b7d0a6b2bf6d),
+/* 2677 */ make_floatx80_init(0x62bb, 0xdf1825c4d05f6f48),
+/* 2678 */ make_floatx80_init(0x62bf, 0x8b6f179b023ba58d),
+/* 2679 */ make_floatx80_init(0x62c2, 0xae4add81c2ca8ef0),
+/* 2680 */ make_floatx80_init(0x62c5, 0xd9dd94e2337d32ad),
+/* 2681 */ make_floatx80_init(0x62c9, 0x882a7d0d602e3fac),
+/* 2682 */ make_floatx80_init(0x62cc, 0xaa351c50b839cf97),
+/* 2683 */ make_floatx80_init(0x62cf, 0xd4c26364e648437d),
+/* 2684 */ make_floatx80_init(0x62d3, 0x84f97e1f0fed2a2e),
+/* 2685 */ make_floatx80_init(0x62d6, 0xa637dda6d3e874b9),
+/* 2686 */ make_floatx80_init(0x62d9, 0xcfc5d51088e291e8),
+/* 2687 */ make_floatx80_init(0x62dd, 0x81dba52a558d9b31),
+/* 2688 */ make_floatx80_init(0x62e0, 0xa2528e74eaf101fd),
+/* 2689 */ make_floatx80_init(0x62e3, 0xcae7321225ad427c),
+/* 2690 */ make_floatx80_init(0x62e6, 0xfda0fe96af18931b),
+/* 2691 */ make_floatx80_init(0x62ea, 0x9e849f1e2d6f5bf1),
+/* 2692 */ make_floatx80_init(0x62ed, 0xc625c6e5b8cb32ed),
+/* 2693 */ make_floatx80_init(0x62f0, 0xf7af389f26fdffa9),
+/* 2694 */ make_floatx80_init(0x62f4, 0x9acd8363785ebfc9),
+/* 2695 */ make_floatx80_init(0x62f7, 0xc180e43c56766fbc),
+/* 2696 */ make_floatx80_init(0x62fa, 0xf1e11d4b6c140bab),
+/* 2697 */ make_floatx80_init(0x62fe, 0x972cb24f238c874b),
+/* 2698 */ make_floatx80_init(0x6301, 0xbcf7dee2ec6fa91d),
+/* 2699 */ make_floatx80_init(0x6304, 0xec35d69ba78b9365),
+/* 2700 */ make_floatx80_init(0x6308, 0x93a1a62148b73c1f),
+/* 2701 */ make_floatx80_init(0x630b, 0xb88a0fa99ae50b27),
+/* 2702 */ make_floatx80_init(0x630e, 0xe6ac9394019e4df0),
+/* 2703 */ make_floatx80_init(0x6312, 0x902bdc3c8102f0b6),
+/* 2704 */ make_floatx80_init(0x6315, 0xb436d34ba143ace4),
+/* 2705 */ make_floatx80_init(0x6318, 0xe144881e8994981d),
+/* 2706 */ make_floatx80_init(0x631c, 0x8ccad51315fcdf12),
+/* 2707 */ make_floatx80_init(0x631f, 0xaffd8a57db7c16d6),
+/* 2708 */ make_floatx80_init(0x6322, 0xdbfcecedd25b1c8c),
+/* 2709 */ make_floatx80_init(0x6326, 0x897e1414a378f1d7),
+/* 2710 */ make_floatx80_init(0x6329, 0xabdd9919cc572e4d),
+/* 2711 */ make_floatx80_init(0x632c, 0xd6d4ff603f6cf9e1),
+/* 2712 */ make_floatx80_init(0x6330, 0x86451f9c27a41c2c),
+/* 2713 */ make_floatx80_init(0x6333, 0xa7d66783318d2338),
+/* 2714 */ make_floatx80_init(0x6336, 0xd1cc0163fdf06c05),
+/* 2715 */ make_floatx80_init(0x633a, 0x831f80de7eb64383),
+/* 2716 */ make_floatx80_init(0x633d, 0xa3e761161e63d464),
+/* 2717 */ make_floatx80_init(0x6340, 0xcce1395ba5fcc97d),
+/* 2718 */ make_floatx80_init(0x6344, 0x800cc3d947bdfdee),
+/* 2719 */ make_floatx80_init(0x6347, 0xa00ff4cf99ad7d6a),
+/* 2720 */ make_floatx80_init(0x634a, 0xc813f2038018dcc4),
+/* 2721 */ make_floatx80_init(0x634d, 0xfa18ee84601f13f5),
+/* 2722 */ make_floatx80_init(0x6351, 0x9c4f9512bc136c79),
+/* 2723 */ make_floatx80_init(0x6354, 0xc3637a576b184798),
+/* 2724 */ make_floatx80_init(0x6357, 0xf43c58ed45de597e),
+/* 2725 */ make_floatx80_init(0x635b, 0x98a5b7944baaf7ef),
+/* 2726 */ make_floatx80_init(0x635e, 0xbecf25795e95b5ea),
+/* 2727 */ make_floatx80_init(0x6361, 0xee82eed7b63b2365),
+/* 2728 */ make_floatx80_init(0x6365, 0x9511d546d1e4f61f),
+/* 2729 */ make_floatx80_init(0x6368, 0xba564a98865e33a7),
+/* 2730 */ make_floatx80_init(0x636b, 0xe8ebdd3ea7f5c090),
+/* 2731 */ make_floatx80_init(0x636f, 0x91936a4728f9985a),
+/* 2732 */ make_floatx80_init(0x6372, 0xb5f844d8f337fe71),
+/* 2733 */ make_floatx80_init(0x6375, 0xe376560f3005fe0d),
+/* 2734 */ make_floatx80_init(0x6379, 0x8e29f5c97e03bec8),
+/* 2735 */ make_floatx80_init(0x637c, 0xb1b4733bdd84ae7a),
+/* 2736 */ make_floatx80_init(0x637f, 0xde21900ad4e5da19),
+/* 2737 */ make_floatx80_init(0x6383, 0x8ad4fa06c50fa84f),
+/* 2738 */ make_floatx80_init(0x6386, 0xad8a388876539263),
+/* 2739 */ make_floatx80_init(0x6389, 0xd8ecc6aa93e876fc),
+/* 2740 */ make_floatx80_init(0x638d, 0x8793fc2a9c714a5e),
+/* 2741 */ make_floatx80_init(0x6390, 0xa978fb35438d9cf5),
+/* 2742 */ make_floatx80_init(0x6393, 0xd3d73a0294710432),
+/* 2743 */ make_floatx80_init(0x6397, 0x846684419cc6a29f),
+/* 2744 */ make_floatx80_init(0x639a, 0xa580255203f84b47),
+/* 2745 */ make_floatx80_init(0x639d, 0xcee02ea684f65e19),
+/* 2746 */ make_floatx80_init(0x63a1, 0x814c1d281319fad0),
+/* 2747 */ make_floatx80_init(0x63a4, 0xa19f247217e07984),
+/* 2748 */ make_floatx80_init(0x63a7, 0xca06ed8e9dd897e4),
+/* 2749 */ make_floatx80_init(0x63aa, 0xfc88a8f2454ebdde),
+/* 2750 */ make_floatx80_init(0x63ae, 0x9dd569976b5136aa),
+/* 2751 */ make_floatx80_init(0x63b1, 0xc54ac3fd46258455),
+/* 2752 */ make_floatx80_init(0x63b4, 0xf69d74fc97aee56a),
+/* 2753 */ make_floatx80_init(0x63b8, 0x9a22691ddecd4f62),
+/* 2754 */ make_floatx80_init(0x63bb, 0xc0ab03655680a33b),
+/* 2755 */ make_floatx80_init(0x63be, 0xf0d5c43eac20cc0a),
+/* 2756 */ make_floatx80_init(0x63c2, 0x96859aa72b947f86),
+/* 2757 */ make_floatx80_init(0x63c5, 0xbc270150f6799f68),
+/* 2758 */ make_floatx80_init(0x63c8, 0xeb30c1a534180742),
+/* 2759 */ make_floatx80_init(0x63cc, 0x92fe7907408f0489),
+/* 2760 */ make_floatx80_init(0x63cf, 0xb7be174910b2c5ab),
+/* 2761 */ make_floatx80_init(0x63d2, 0xe5ad9d1b54df7716),
+/* 2762 */ make_floatx80_init(0x63d6, 0x8f8c8231150baa6e),
+/* 2763 */ make_floatx80_init(0x63d9, 0xb36fa2bd5a4e9509),
+/* 2764 */ make_floatx80_init(0x63dc, 0xe04b8b6cb0e23a4c),
+/* 2765 */ make_floatx80_init(0x63e0, 0x8c2f3723ee8d646f),
+/* 2766 */ make_floatx80_init(0x63e3, 0xaf3b04ecea30bd8b),
+/* 2767 */ make_floatx80_init(0x63e6, 0xdb09c62824bcecee),
+/* 2768 */ make_floatx80_init(0x63ea, 0x88e61bd916f61415),
+/* 2769 */ make_floatx80_init(0x63ed, 0xab1fa2cf5cb3991a),
+/* 2770 */ make_floatx80_init(0x63f0, 0xd5e78b8333e07f60),
+/* 2771 */ make_floatx80_init(0x63f4, 0x85b0b732006c4f9c),
+/* 2772 */ make_floatx80_init(0x63f7, 0xa71ce4fe80876383),
+/* 2773 */ make_floatx80_init(0x63fa, 0xd0e41e3e20a93c64),
+/* 2774 */ make_floatx80_init(0x63fe, 0x828e92e6d469c5be),
+/* 2775 */ make_floatx80_init(0x6401, 0xa33237a08984372e),
+/* 2776 */ make_floatx80_init(0x6404, 0xcbfec588abe544fa),
+/* 2777 */ make_floatx80_init(0x6407, 0xfefe76ead6de9638),
+/* 2778 */ make_floatx80_init(0x640b, 0x9f5f0a52c64b1de3),
+/* 2779 */ make_floatx80_init(0x640e, 0xc736cce777dde55c),
+/* 2780 */ make_floatx80_init(0x6411, 0xf904802155d55eb3),
+/* 2781 */ make_floatx80_init(0x6415, 0x9ba2d014d5a55b30),
+/* 2782 */ make_floatx80_init(0x6418, 0xc28b841a0b0eb1fc),
+/* 2783 */ make_floatx80_init(0x641b, 0xf32e65208dd25e7b),
+/* 2784 */ make_floatx80_init(0x641f, 0x97fcff3458a37b0d),
+/* 2785 */ make_floatx80_init(0x6422, 0xbdfc3f016ecc59d0),
+/* 2786 */ make_floatx80_init(0x6425, 0xed7b4ec1ca7f7044),
+/* 2787 */ make_floatx80_init(0x6429, 0x946d11391e8fa62a),
+/* 2788 */ make_floatx80_init(0x642c, 0xb988558766338fb5),
+/* 2789 */ make_floatx80_init(0x642f, 0xe7ea6ae93fc073a2),
+/* 2790 */ make_floatx80_init(0x6433, 0x90f282d1c7d84845),
+/* 2791 */ make_floatx80_init(0x6436, 0xb52f238639ce5a57),
+/* 2792 */ make_floatx80_init(0x6439, 0xe27aec67c841f0ec),
+/* 2793 */ make_floatx80_init(0x643d, 0x8d8cd3c0dd293694),
+/* 2794 */ make_floatx80_init(0x6440, 0xb0f008b114738439),
+/* 2795 */ make_floatx80_init(0x6443, 0xdd2c0add59906547),
+/* 2796 */ make_floatx80_init(0x6447, 0x8a3b86ca57fa3f4c),
+/* 2797 */ make_floatx80_init(0x644a, 0xacca687cedf8cf1f),
+/* 2798 */ make_floatx80_init(0x644d, 0xd7fd029c297702e7),
+/* 2799 */ make_floatx80_init(0x6451, 0x86fe21a199ea61d0),
+/* 2800 */ make_floatx80_init(0x6454, 0xa8bdaa0a0064fa45),
+/* 2801 */ make_floatx80_init(0x6457, 0xd2ed148c807e38d6),
+/* 2802 */ make_floatx80_init(0x645b, 0x83d42cd7d04ee386),
+/* 2803 */ make_floatx80_init(0x645e, 0xa4c9380dc4629c67),
+/* 2804 */ make_floatx80_init(0x6461, 0xcdfb8611357b4381),
+/* 2805 */ make_floatx80_init(0x6465, 0x80bd33cac16d0a30),
+/* 2806 */ make_floatx80_init(0x6468, 0xa0ec80bd71c84cbd),
+/* 2807 */ make_floatx80_init(0x646b, 0xc927a0ecce3a5fec),
+/* 2808 */ make_floatx80_init(0x646e, 0xfb71892801c8f7e7),
+/* 2809 */ make_floatx80_init(0x6472, 0x9d26f5b9011d9af0),
+/* 2810 */ make_floatx80_init(0x6475, 0xc470b327416501ac),
+/* 2811 */ make_floatx80_init(0x6478, 0xf58cdff111be4217),
+/* 2812 */ make_floatx80_init(0x647c, 0x99780bf6ab16e94e),
+/* 2813 */ make_floatx80_init(0x647f, 0xbfd60ef455dca3a2),
+/* 2814 */ make_floatx80_init(0x6482, 0xefcb92b16b53cc8b),
+/* 2815 */ make_floatx80_init(0x6486, 0x95df3baee3145fd7),
+/* 2816 */ make_floatx80_init(0x6489, 0xbb570a9a9bd977cc),
+/* 2817 */ make_floatx80_init(0x648c, 0xea2ccd4142cfd5bf),
+/* 2818 */ make_floatx80_init(0x6490, 0x925c0048c9c1e598),
+/* 2819 */ make_floatx80_init(0x6493, 0xb6f3005afc325efe),
+/* 2820 */ make_floatx80_init(0x6496, 0xe4afc071bb3ef6bd),
+/* 2821 */ make_floatx80_init(0x649a, 0x8eedd84715075a36),
+/* 2822 */ make_floatx80_init(0x649d, 0xb2a94e58da4930c4),
+/* 2823 */ make_floatx80_init(0x64a0, 0xdf53a1ef10db7cf4),
+/* 2824 */ make_floatx80_init(0x64a4, 0x8b9445356a892e19),
+/* 2825 */ make_floatx80_init(0x64a7, 0xae795682c52b799f),
+/* 2826 */ make_floatx80_init(0x64aa, 0xda17ac2376765807),
+/* 2827 */ make_floatx80_init(0x64ae, 0x884ecb962a09f704),
+/* 2828 */ make_floatx80_init(0x64b1, 0xaa627e7bb48c74c5),
+/* 2829 */ make_floatx80_init(0x64b4, 0xd4fb1e1aa1af91f7),
+/* 2830 */ make_floatx80_init(0x64b8, 0x851cf2d0a50dbb3a),
+/* 2831 */ make_floatx80_init(0x64bb, 0xa6642f84ce512a09),
+/* 2832 */ make_floatx80_init(0x64be, 0xcffd3b6601e5748b),
+/* 2833 */ make_floatx80_init(0x64c2, 0x81fe451fc12f68d7),
+/* 2834 */ make_floatx80_init(0x64c5, 0xa27dd667b17b430c),
+/* 2835 */ make_floatx80_init(0x64c8, 0xcb1d4c019dda13d0),
+/* 2836 */ make_floatx80_init(0x64cb, 0xfde49f02055098c3),
+/* 2837 */ make_floatx80_init(0x64cf, 0x9eaee36143525f7a),
+/* 2838 */ make_floatx80_init(0x64d2, 0xc65a9c399426f759),
+/* 2839 */ make_floatx80_init(0x64d5, 0xf7f14347f930b52f),
+/* 2840 */ make_floatx80_init(0x64d9, 0x9af6ca0cfbbe713d),
+/* 2841 */ make_floatx80_init(0x64dc, 0xc1b47c903aae0d8d),
+/* 2842 */ make_floatx80_init(0x64df, 0xf2219bb4495990f0),
+/* 2843 */ make_floatx80_init(0x64e3, 0x97550150add7fa96),
+/* 2844 */ make_floatx80_init(0x64e6, 0xbd2a41a4d94df93b),
+/* 2845 */ make_floatx80_init(0x64e9, 0xec74d20e0fa1778a),
+/* 2846 */ make_floatx80_init(0x64ed, 0x93c90348c9c4eab6),
+/* 2847 */ make_floatx80_init(0x64f0, 0xb8bb441afc362564),
+/* 2848 */ make_floatx80_init(0x64f3, 0xe6ea1521bb43aebd),
+/* 2849 */ make_floatx80_init(0x64f7, 0x90524d35150a4d36),
+/* 2850 */ make_floatx80_init(0x64fa, 0xb466e0825a4ce084),
+/* 2851 */ make_floatx80_init(0x64fd, 0xe18098a2f0e018a4),
+/* 2852 */ make_floatx80_init(0x6501, 0x8cf05f65d68c0f67),
+/* 2853 */ make_floatx80_init(0x6504, 0xb02c773f4c2f1340),
+/* 2854 */ make_floatx80_init(0x6507, 0xdc37950f1f3ad811),
+/* 2855 */ make_floatx80_init(0x650b, 0x89a2bd297384c70a),
+/* 2856 */ make_floatx80_init(0x650e, 0xac0b6c73d065f8cd),
+/* 2857 */ make_floatx80_init(0x6511, 0xd70e4790c47f7700),
+/* 2858 */ make_floatx80_init(0x6515, 0x8668ecba7acfaa60),
+/* 2859 */ make_floatx80_init(0x6518, 0xa80327e9198394f8),
+/* 2860 */ make_floatx80_init(0x651b, 0xd203f1e35fe47a36),
+/* 2861 */ make_floatx80_init(0x651f, 0x8342772e1beecc62),
+/* 2862 */ make_floatx80_init(0x6522, 0xa41314f9a2ea7f7a),
+/* 2863 */ make_floatx80_init(0x6525, 0xcd17da380ba51f59),
+/* 2864 */ make_floatx80_init(0x6529, 0x802ee86307473398),
+/* 2865 */ make_floatx80_init(0x652c, 0xa03aa27bc919007d),
+/* 2866 */ make_floatx80_init(0x652f, 0xc8494b1abb5f409d),
+/* 2867 */ make_floatx80_init(0x6532, 0xfa5b9de16a3710c4),
+/* 2868 */ make_floatx80_init(0x6536, 0x9c7942ace2626a7b),
+/* 2869 */ make_floatx80_init(0x6539, 0xc39793581afb0519),
+/* 2870 */ make_floatx80_init(0x653c, 0xf47d782e21b9c65f),
+/* 2871 */ make_floatx80_init(0x6540, 0x98ce6b1cd5141bfc),
+/* 2872 */ make_floatx80_init(0x6543, 0xbf0205e40a5922fb),
+/* 2873 */ make_floatx80_init(0x6546, 0xeec2875d0cef6bb9),
+/* 2874 */ make_floatx80_init(0x654a, 0x9539949a2815a354),
+/* 2875 */ make_floatx80_init(0x654d, 0xba87f9c0b21b0c29),
+/* 2876 */ make_floatx80_init(0x6550, 0xe929f830dea1cf33),
+/* 2877 */ make_floatx80_init(0x6554, 0x91ba3b1e8b252180),
+/* 2878 */ make_floatx80_init(0x6557, 0xb628c9e62dee69e0),
+/* 2879 */ make_floatx80_init(0x655a, 0xe3b2fc5fb96a0458),
+/* 2880 */ make_floatx80_init(0x655e, 0x8e4fddbbd3e242b7),
+/* 2881 */ make_floatx80_init(0x6561, 0xb1e3d52ac8dad365),
+/* 2882 */ make_floatx80_init(0x6564, 0xde5cca757b11883e),
+/* 2883 */ make_floatx80_init(0x6568, 0x8af9fe896ceaf527),
+/* 2884 */ make_floatx80_init(0x656b, 0xadb87e2bc825b270),
+/* 2885 */ make_floatx80_init(0x656e, 0xd9269db6ba2f1f0c),
+/* 2886 */ make_floatx80_init(0x6572, 0x87b82292345d7368),
+/* 2887 */ make_floatx80_init(0x6575, 0xa9a62b36c174d042),
+/* 2888 */ make_floatx80_init(0x6578, 0xd40fb60471d20452),
+/* 2889 */ make_floatx80_init(0x657c, 0x8489d1c2c72342b3),
+/* 2890 */ make_floatx80_init(0x657f, 0xa5ac463378ec1360),
+/* 2891 */ make_floatx80_init(0x6582, 0xcf1757c057271838),
+/* 2892 */ make_floatx80_init(0x6586, 0x816e96d836786f23),
+/* 2893 */ make_floatx80_init(0x6589, 0xa1ca3c8e44168aec),
+/* 2894 */ make_floatx80_init(0x658c, 0xca3ccbb1d51c2da7),
+/* 2895 */ make_floatx80_init(0x658f, 0xfccbfe9e4a633910),
+/* 2896 */ make_floatx80_init(0x6593, 0x9dff7f22ee7e03aa),
+/* 2897 */ make_floatx80_init(0x6596, 0xc57f5eebaa1d8495),
+/* 2898 */ make_floatx80_init(0x6599, 0xf6df36a694a4e5ba),
+/* 2899 */ make_floatx80_init(0x659d, 0x9a4b82281ce70f94),
+/* 2900 */ make_floatx80_init(0x65a0, 0xc0de62b22420d379),
+/* 2901 */ make_floatx80_init(0x65a3, 0xf115fb5ead290858),
+/* 2902 */ make_floatx80_init(0x65a7, 0x96adbd1b2c39a537),
+/* 2903 */ make_floatx80_init(0x65aa, 0xbc592c61f7480e84),
+/* 2904 */ make_floatx80_init(0x65ad, 0xeb6f777a751a1226),
+/* 2905 */ make_floatx80_init(0x65b1, 0x9325aaac89304b57),
+/* 2906 */ make_floatx80_init(0x65b4, 0xb7ef1557ab7c5e2d),
+/* 2907 */ make_floatx80_init(0x65b7, 0xe5eadaad965b75b9),
+/* 2908 */ make_floatx80_init(0x65bb, 0x8fb2c8ac7df92993),
+/* 2909 */ make_floatx80_init(0x65be, 0xb39f7ad79d7773f8),
+/* 2910 */ make_floatx80_init(0x65c1, 0xe087598d84d550f6),
+/* 2911 */ make_floatx80_init(0x65c5, 0x8c5497f87305529a),
+/* 2912 */ make_floatx80_init(0x65c8, 0xaf69bdf68fc6a740),
+/* 2913 */ make_floatx80_init(0x65cb, 0xdb442d7433b85111),
+/* 2914 */ make_floatx80_init(0x65cf, 0x890a9c68a05332aa),
+/* 2915 */ make_floatx80_init(0x65d2, 0xab4d4382c867ff55),
+/* 2916 */ make_floatx80_init(0x65d5, 0xd62094637a81ff2a),
+/* 2917 */ make_floatx80_init(0x65d9, 0x85d45cbe2c913f7a),
+/* 2918 */ make_floatx80_init(0x65dc, 0xa74973edb7b58f59),
+/* 2919 */ make_floatx80_init(0x65df, 0xd11bd0e925a2f32f),
+/* 2920 */ make_floatx80_init(0x65e3, 0x82b16291b785d7fe),
+/* 2921 */ make_floatx80_init(0x65e6, 0xa35dbb3625674dfd),
+/* 2922 */ make_floatx80_init(0x65e9, 0xcc352a03aec1217c),
+/* 2923 */ make_floatx80_init(0x65ec, 0xff4274849a7169db),
+/* 2924 */ make_floatx80_init(0x65f0, 0x9f8988d2e086e229),
+/* 2925 */ make_floatx80_init(0x65f3, 0xc76beb0798a89ab3),
+/* 2926 */ make_floatx80_init(0x65f6, 0xf946e5c97ed2c160),
+/* 2927 */ make_floatx80_init(0x65fa, 0x9bcc4f9def43b8dc),
+/* 2928 */ make_floatx80_init(0x65fd, 0xc2bf63856b14a713),
+/* 2929 */ make_floatx80_init(0x6600, 0xf36f3c66c5d9d0d8),
+/* 2930 */ make_floatx80_init(0x6604, 0x982585c03ba82287),
+/* 2931 */ make_floatx80_init(0x6607, 0xbe2ee7304a922b29),
+/* 2932 */ make_floatx80_init(0x660a, 0xedbaa0fc5d36b5f3),
+/* 2933 */ make_floatx80_init(0x660e, 0x9494a49dba4231b8),
+/* 2934 */ make_floatx80_init(0x6611, 0xb9b9cdc528d2be26),
+/* 2935 */ make_floatx80_init(0x6614, 0xe828413673076daf),
+/* 2936 */ make_floatx80_init(0x6618, 0x911928c207e4a48d),
+/* 2937 */ make_floatx80_init(0x661b, 0xb55f72f289ddcdb1),
+/* 2938 */ make_floatx80_init(0x661e, 0xe2b74faf2c55411d),
+/* 2939 */ make_floatx80_init(0x6622, 0x8db291cd7bb548b2),
+/* 2940 */ make_floatx80_init(0x6625, 0xb11f3640daa29adf),
+/* 2941 */ make_floatx80_init(0x6628, 0xdd6703d1114b4196),
+/* 2942 */ make_floatx80_init(0x662c, 0x8a606262aacf08fe),
+/* 2943 */ make_floatx80_init(0x662f, 0xacf87afb5582cb3d),
+/* 2944 */ make_floatx80_init(0x6632, 0xd83699ba2ae37e0d),
+/* 2945 */ make_floatx80_init(0x6636, 0x872220145ace2ec8),
+/* 2946 */ make_floatx80_init(0x6639, 0xa8eaa8197181ba7a),
+/* 2947 */ make_floatx80_init(0x663c, 0xd325521fcde22918),
+/* 2948 */ make_floatx80_init(0x6640, 0x83f75353e0ad59af),
+/* 2949 */ make_floatx80_init(0x6643, 0xa4f52828d8d8b01b),
+/* 2950 */ make_floatx80_init(0x6646, 0xce3272330f0edc22),
+/* 2951 */ make_floatx80_init(0x664a, 0x80df875fe9694995),
+/* 2952 */ make_floatx80_init(0x664d, 0xa1176937e3c39bfa),
+/* 2953 */ make_floatx80_init(0x6650, 0xc95d4385dcb482f9),
+/* 2954 */ make_floatx80_init(0x6653, 0xfbb4946753e1a3b7),
+/* 2955 */ make_floatx80_init(0x6657, 0x9d50dcc0946d0653),
+/* 2956 */ make_floatx80_init(0x665a, 0xc4a513f0b98847e7),
+/* 2957 */ make_floatx80_init(0x665d, 0xf5ce58ece7ea59e1),
+/* 2958 */ make_floatx80_init(0x6661, 0x99a0f79410f2782d),
+/* 2959 */ make_floatx80_init(0x6664, 0xc0093579152f1638),
+/* 2960 */ make_floatx80_init(0x6667, 0xf00b82d75a7adbc6),
+/* 2961 */ make_floatx80_init(0x666b, 0x960731c6988cc95c),
+/* 2962 */ make_floatx80_init(0x666e, 0xbb88fe383eaffbb2),
+/* 2963 */ make_floatx80_init(0x6671, 0xea6b3dc64e5bfa9f),
+/* 2964 */ make_floatx80_init(0x6675, 0x9283069bf0f97ca3),
+/* 2965 */ make_floatx80_init(0x6678, 0xb723c842ed37dbcc),
+/* 2966 */ make_floatx80_init(0x667b, 0xe4ecba53a885d2bf),
+/* 2967 */ make_floatx80_init(0x667f, 0x8f13f4744953a3b8),
+/* 2968 */ make_floatx80_init(0x6682, 0xb2d8f1915ba88ca5),
+/* 2969 */ make_floatx80_init(0x6685, 0xdf8f2df5b292afcf),
+/* 2970 */ make_floatx80_init(0x6689, 0x8bb97cb98f9bade1),
+/* 2971 */ make_floatx80_init(0x668c, 0xaea7dbe7f382995a),
+/* 2972 */ make_floatx80_init(0x668f, 0xda51d2e1f0633fb0),
+/* 2973 */ make_floatx80_init(0x6693, 0x887323cd363e07ce),
+/* 2974 */ make_floatx80_init(0x6696, 0xaa8fecc083cd89c2),
+/* 2975 */ make_floatx80_init(0x6699, 0xd533e7f0a4c0ec32),
+/* 2976 */ make_floatx80_init(0x669d, 0x854070f666f8939f),
+/* 2977 */ make_floatx80_init(0x66a0, 0xa6908d3400b6b887),
+/* 2978 */ make_floatx80_init(0x66a3, 0xd034b08100e466a9),
+/* 2979 */ make_floatx80_init(0x66a7, 0x8220ee50a08ec029),
+/* 2980 */ make_floatx80_init(0x66aa, 0xa2a929e4c8b27034),
+/* 2981 */ make_floatx80_init(0x66ad, 0xcb53745dfadf0c41),
+/* 2982 */ make_floatx80_init(0x66b0, 0xfe2851757996cf51),
+/* 2983 */ make_floatx80_init(0x66b4, 0x9ed932e96bfe4193),
+/* 2984 */ make_floatx80_init(0x66b7, 0xc68f7fa3c6fdd1f7),
+/* 2985 */ make_floatx80_init(0x66ba, 0xf8335f8cb8bd4675),
+/* 2986 */ make_floatx80_init(0x66be, 0x9b201bb7f3764c09),
+/* 2987 */ make_floatx80_init(0x66c1, 0xc1e822a5f053df0b),
+/* 2988 */ make_floatx80_init(0x66c4, 0xf2622b4f6c68d6ce),
+/* 2989 */ make_floatx80_init(0x66c8, 0x977d5b11a3c18641),
+/* 2990 */ make_floatx80_init(0x66cb, 0xbd5cb1d60cb1e7d1),
+/* 2991 */ make_floatx80_init(0x66ce, 0xecb3de4b8fde61c5),
+/* 2992 */ make_floatx80_init(0x66d2, 0x93f06aef39eafd1b),
+/* 2993 */ make_floatx80_init(0x66d5, 0xb8ec85ab0865bc62),
+/* 2994 */ make_floatx80_init(0x66d8, 0xe727a715ca7f2b7b),
+/* 2995 */ make_floatx80_init(0x66dc, 0x9078c86d9e8f7b2d),
+/* 2996 */ make_floatx80_init(0x66df, 0xb496fa89063359f8),
+/* 2997 */ make_floatx80_init(0x66e2, 0xe1bcb92b47c03076),
+/* 2998 */ make_floatx80_init(0x66e6, 0x8d15f3bb0cd81e4a),
+/* 2999 */ make_floatx80_init(0x66e9, 0xb05b70a9d00e25dc),
+/* 3000 */ make_floatx80_init(0x66ec, 0xdc724cd44411af53),
+/* 3001 */ make_floatx80_init(0x66f0, 0x89c77004aa8b0d94),
+/* 3002 */ make_floatx80_init(0x66f3, 0xac394c05d52dd0f9),
+/* 3003 */ make_floatx80_init(0x66f6, 0xd7479f074a794537),
+/* 3004 */ make_floatx80_init(0x66fa, 0x868cc3648e8bcb43),
+/* 3005 */ make_floatx80_init(0x66fd, 0xa82ff43db22ebe13),
+/* 3006 */ make_floatx80_init(0x6700, 0xd23bf14d1eba6d98),
+/* 3007 */ make_floatx80_init(0x6704, 0x836576d03334847f),
+/* 3008 */ make_floatx80_init(0x6707, 0xa43ed4844001a59f),
+/* 3009 */ make_floatx80_init(0x670a, 0xcd4e89a550020f06),
+/* 3010 */ make_floatx80_init(0x670e, 0x8051160752014964),
+/* 3011 */ make_floatx80_init(0x6711, 0xa0655b8926819bbd),
+/* 3012 */ make_floatx80_init(0x6714, 0xc87eb26b702202ac),
+/* 3013 */ make_floatx80_init(0x6717, 0xfa9e5f064c2a8357),
+/* 3014 */ make_floatx80_init(0x671b, 0x9ca2fb63ef9a9217),
+/* 3015 */ make_floatx80_init(0x671e, 0xc3cbba3ceb81369c),
+/* 3016 */ make_floatx80_init(0x6721, 0xf4bea8cc26618443),
+/* 3017 */ make_floatx80_init(0x6725, 0x98f7297f97fcf2aa),
+/* 3018 */ make_floatx80_init(0x6728, 0xbf34f3df7dfc2f55),
+/* 3019 */ make_floatx80_init(0x672b, 0xef0230d75d7b3b2a),
+/* 3020 */ make_floatx80_init(0x672f, 0x95615e869a6d04fa),
+/* 3021 */ make_floatx80_init(0x6732, 0xbab9b62841084639),
+/* 3022 */ make_floatx80_init(0x6735, 0xe96823b2514a57c7),
+/* 3023 */ make_floatx80_init(0x6739, 0x91e1164f72ce76dc),
+/* 3024 */ make_floatx80_init(0x673c, 0xb6595be34f821493),
+/* 3025 */ make_floatx80_init(0x673f, 0xe3efb2dc236299b8),
+/* 3026 */ make_floatx80_init(0x6743, 0x8e75cfc9961da013),
+/* 3027 */ make_floatx80_init(0x6746, 0xb21343bbfba50818),
+/* 3028 */ make_floatx80_init(0x6749, 0xde9814aafa8e4a1e),
+/* 3029 */ make_floatx80_init(0x674d, 0x8b1f0ceadc98ee53),
+/* 3030 */ make_floatx80_init(0x6750, 0xade6d02593bf29e7),
+/* 3031 */ make_floatx80_init(0x6753, 0xd960842ef8aef461),
+/* 3032 */ make_floatx80_init(0x6757, 0x87dc529d5b6d58bd),
+/* 3033 */ make_floatx80_init(0x675a, 0xa9d36744b248aeec),
+/* 3034 */ make_floatx80_init(0x675d, 0xd4484115dedadaa7),
+/* 3035 */ make_floatx80_init(0x6761, 0x84ad28adab48c8a8),
+/* 3036 */ make_floatx80_init(0x6764, 0xa5d872d9161afad2),
+/* 3037 */ make_floatx80_init(0x6767, 0xcf4e8f8f5ba1b987),
+/* 3038 */ make_floatx80_init(0x676b, 0x819119b9994513f4),
+/* 3039 */ make_floatx80_init(0x676e, 0xa1f56027ff9658f1),
+/* 3040 */ make_floatx80_init(0x6771, 0xca72b831ff7bef2e),
+/* 3041 */ make_floatx80_init(0x6774, 0xfd0f663e7f5aeaf9),
+/* 3042 */ make_floatx80_init(0x6778, 0x9e299fe70f98d2dc),
+/* 3043 */ make_floatx80_init(0x677b, 0xc5b407e0d37f0793),
+/* 3044 */ make_floatx80_init(0x677e, 0xf72109d9085ec977),
+/* 3045 */ make_floatx80_init(0x6782, 0x9a74a627a53b3deb),
+/* 3046 */ make_floatx80_init(0x6785, 0xc111cfb18e8a0d65),
+/* 3047 */ make_floatx80_init(0x6788, 0xf156439df22c90bf),
+/* 3048 */ make_floatx80_init(0x678c, 0x96d5ea42b75bda77),
+/* 3049 */ make_floatx80_init(0x678f, 0xbc8b64d36532d115),
+/* 3050 */ make_floatx80_init(0x6792, 0xebae3e083e7f855a),
+/* 3051 */ make_floatx80_init(0x6796, 0x934ce6c5270fb358),
+/* 3052 */ make_floatx80_init(0x6799, 0xb820207670d3a02e),
+/* 3053 */ make_floatx80_init(0x679c, 0xe62828940d08883a),
+/* 3054 */ make_floatx80_init(0x67a0, 0x8fd9195c88255524),
+/* 3055 */ make_floatx80_init(0x67a3, 0xb3cf5fb3aa2eaa6d),
+/* 3056 */ make_floatx80_init(0x67a6, 0xe0c337a094ba5509),
+/* 3057 */ make_floatx80_init(0x67aa, 0x8c7a02c45cf47525),
+/* 3058 */ make_floatx80_init(0x67ad, 0xaf9883757431926f),
+/* 3059 */ make_floatx80_init(0x67b0, 0xdb7ea452d13df70a),
+/* 3060 */ make_floatx80_init(0x67b4, 0x892f26b3c2c6ba66),
+/* 3061 */ make_floatx80_init(0x67b7, 0xab7af060b3786900),
+/* 3062 */ make_floatx80_init(0x67ba, 0xd659ac78e0568340),
+/* 3063 */ make_floatx80_init(0x67be, 0x85f80bcb8c361208),
+/* 3064 */ make_floatx80_init(0x67c1, 0xa7760ebe6f43968a),
+/* 3065 */ make_floatx80_init(0x67c4, 0xd153926e0b147c2d),
+/* 3066 */ make_floatx80_init(0x67c8, 0x82d43b84c6eccd9c),
+/* 3067 */ make_floatx80_init(0x67cb, 0xa3894a65f8a80103),
+/* 3068 */ make_floatx80_init(0x67ce, 0xcc6b9cff76d20144),
+/* 3069 */ make_floatx80_init(0x67d1, 0xff86843f54868194),
+/* 3070 */ make_floatx80_init(0x67d5, 0x9fb412a794d410fd),
+/* 3071 */ make_floatx80_init(0x67d8, 0xc7a117517a09153c),
+/* 3072 */ make_floatx80_init(0x67db, 0xf9895d25d88b5a8b),
+/* 3073 */ make_floatx80_init(0x67df, 0x9bf5da37a7571897),
+/* 3074 */ make_floatx80_init(0x67e2, 0xc2f350c5912cdebd),
+/* 3075 */ make_floatx80_init(0x67e5, 0xf3b024f6f578166c),
+/* 3076 */ make_floatx80_init(0x67e9, 0x984e171a596b0e03),
+/* 3077 */ make_floatx80_init(0x67ec, 0xbe619ce0efc5d184),
+/* 3078 */ make_floatx80_init(0x67ef, 0xedfa04192bb745e5),
+/* 3079 */ make_floatx80_init(0x67f3, 0x94bc428fbb528baf),
+/* 3080 */ make_floatx80_init(0x67f6, 0xb9eb5333aa272e9b),
+/* 3081 */ make_floatx80_init(0x67f9, 0xe866280094b0fa42),
+/* 3082 */ make_floatx80_init(0x67fd, 0x913fd9005cee9c69),
+/* 3083 */ make_floatx80_init(0x6800, 0xb58fcf40742a4383),
+/* 3084 */ make_floatx80_init(0x6803, 0xe2f3c3109134d464),
+/* 3085 */ make_floatx80_init(0x6807, 0x8dd859ea5ac104bf),
+/* 3086 */ make_floatx80_init(0x680a, 0xb14e7064f17145ee),
+/* 3087 */ make_floatx80_init(0x680d, 0xdda20c7e2dcd976a),
+/* 3088 */ make_floatx80_init(0x6811, 0x8a8547cedca07ea2),
+/* 3089 */ make_floatx80_init(0x6814, 0xad2699c293c89e4b),
+/* 3090 */ make_floatx80_init(0x6817, 0xd870403338bac5dd),
+/* 3091 */ make_floatx80_init(0x681b, 0x874628200374bbaa),
+/* 3092 */ make_floatx80_init(0x681e, 0xa917b2280451ea95),
+/* 3093 */ make_floatx80_init(0x6821, 0xd35d9eb20566653a),
+/* 3094 */ make_floatx80_init(0x6825, 0x841a832f435fff44),
+/* 3095 */ make_floatx80_init(0x6828, 0xa52123fb1437ff16),
+/* 3096 */ make_floatx80_init(0x682b, 0xce696cf9d945fedb),
+/* 3097 */ make_floatx80_init(0x682f, 0x8101e41c27cbbf49),
+/* 3098 */ make_floatx80_init(0x6832, 0xa1425d2331beaf1b),
+/* 3099 */ make_floatx80_init(0x6835, 0xc992f46bfe2e5ae2),
+/* 3100 */ make_floatx80_init(0x6838, 0xfbf7b186fdb9f19a),
+/* 3101 */ make_floatx80_init(0x683c, 0x9d7acef45e943700),
+/* 3102 */ make_floatx80_init(0x683f, 0xc4d982b1763944c0),
+/* 3103 */ make_floatx80_init(0x6842, 0xf60fe35dd3c795f1),
+/* 3104 */ make_floatx80_init(0x6846, 0x99c9ee1aa45cbdb6),
+/* 3105 */ make_floatx80_init(0x6849, 0xc03c69a14d73ed24),
+/* 3106 */ make_floatx80_init(0x684c, 0xf04b8409a0d0e86d),
+/* 3107 */ make_floatx80_init(0x6850, 0x962f328604829144),
+/* 3108 */ make_floatx80_init(0x6853, 0xbbbaff2785a33595),
+/* 3109 */ make_floatx80_init(0x6856, 0xeaa9bef1670c02fa),
+/* 3110 */ make_floatx80_init(0x685a, 0x92aa1756e06781dd),
+/* 3111 */ make_floatx80_init(0x685d, 0xb7549d2c98816254),
+/* 3112 */ make_floatx80_init(0x6860, 0xe529c477bea1bae9),
+/* 3113 */ make_floatx80_init(0x6864, 0x8f3a1acad72514d1),
+/* 3114 */ make_floatx80_init(0x6867, 0xb308a17d8cee5a06),
+/* 3115 */ make_floatx80_init(0x686a, 0xdfcac9dcf029f087),
+/* 3116 */ make_floatx80_init(0x686e, 0x8bdebe2a161a3654),
+/* 3117 */ make_floatx80_init(0x6871, 0xaed66db49ba0c3ea),
+/* 3118 */ make_floatx80_init(0x6874, 0xda8c0921c288f4e4),
+/* 3119 */ make_floatx80_init(0x6878, 0x889785b51995990e),
+/* 3120 */ make_floatx80_init(0x687b, 0xaabd67225ffaff52),
+/* 3121 */ make_floatx80_init(0x687e, 0xd56cc0eaf7f9bf27),
+/* 3122 */ make_floatx80_init(0x6882, 0x8563f892dafc1778),
+/* 3123 */ make_floatx80_init(0x6885, 0xa6bcf6b791bb1d56),
+/* 3124 */ make_floatx80_init(0x6888, 0xd06c34657629e4ac),
+/* 3125 */ make_floatx80_init(0x688c, 0x8243a0bf69da2eeb),
+/* 3126 */ make_floatx80_init(0x688f, 0xa2d488ef4450baa6),
+/* 3127 */ make_floatx80_init(0x6892, 0xcb89ab2b1564e950),
+/* 3128 */ make_floatx80_init(0x6895, 0xfe6c15f5dabe23a4),
+/* 3129 */ make_floatx80_init(0x6899, 0x9f038db9a8b6d646),
+/* 3130 */ make_floatx80_init(0x689c, 0xc6c4712812e48bd8),
+/* 3131 */ make_floatx80_init(0x689f, 0xf8758d72179daece),
+/* 3132 */ make_floatx80_init(0x68a3, 0x9b4978674ec28d41),
+/* 3133 */ make_floatx80_init(0x68a6, 0xc21bd68122733091),
+/* 3134 */ make_floatx80_init(0x68a9, 0xf2a2cc216b0ffcb5),
+/* 3135 */ make_floatx80_init(0x68ad, 0x97a5bf94e2e9fdf1),
+/* 3136 */ make_floatx80_init(0x68b0, 0xbd8f2f7a1ba47d6d),
+/* 3137 */ make_floatx80_init(0x68b3, 0xecf2fb58a28d9cc9),
+/* 3138 */ make_floatx80_init(0x68b7, 0x9417dd17659881fd),
+/* 3139 */ make_floatx80_init(0x68ba, 0xb91dd45d3efea27d),
+/* 3140 */ make_floatx80_init(0x68bd, 0xe76549748ebe4b1c),
+/* 3141 */ make_floatx80_init(0x68c1, 0x909f4de8d936eef1),
+/* 3142 */ make_floatx80_init(0x68c4, 0xb4c721630f84aaae),
+/* 3143 */ make_floatx80_init(0x68c7, 0xe1f8e9bbd365d559),
+/* 3144 */ make_floatx80_init(0x68cb, 0x8d3b9215641fa558),
+/* 3145 */ make_floatx80_init(0x68ce, 0xb08a769abd278eae),
+/* 3146 */ make_floatx80_init(0x68d1, 0xdcad14416c717259),
+/* 3147 */ make_floatx80_init(0x68d5, 0x89ec2ca8e3c6e778),
+/* 3148 */ make_floatx80_init(0x68d8, 0xac6737d31cb8a156),
+/* 3149 */ make_floatx80_init(0x68db, 0xd78105c7e3e6c9ab),
+/* 3150 */ make_floatx80_init(0x68df, 0x86b0a39cee703e0b),
+/* 3151 */ make_floatx80_init(0x68e2, 0xa85ccc842a0c4d8e),
+/* 3152 */ make_floatx80_init(0x68e5, 0xd273ffa5348f60f1),
+/* 3153 */ make_floatx80_init(0x68e9, 0x83887fc740d99c97),
+/* 3154 */ make_floatx80_init(0x68ec, 0xa46a9fb9111003bc),
+/* 3155 */ make_floatx80_init(0x68ef, 0xcd8547a7555404ab),
+/* 3156 */ make_floatx80_init(0x68f3, 0x80734cc8955482eb),
+/* 3157 */ make_floatx80_init(0x68f6, 0xa0901ffabaa9a3a6),
+/* 3158 */ make_floatx80_init(0x68f9, 0xc8b427f969540c8f),
+/* 3159 */ make_floatx80_init(0x68fc, 0xfae131f7c3a90fb3),
+/* 3160 */ make_floatx80_init(0x6900, 0x9cccbf3ada49a9d0),
+/* 3161 */ make_floatx80_init(0x6903, 0xc3ffef0990dc1444),
+/* 3162 */ make_floatx80_init(0x6906, 0xf4ffeacbf5131955),
+/* 3163 */ make_floatx80_init(0x690a, 0x991ff2bf792befd5),
+/* 3164 */ make_floatx80_init(0x690d, 0xbf67ef6f5776ebca),
+/* 3165 */ make_floatx80_init(0x6910, 0xef41eb4b2d54a6bd),
+/* 3166 */ make_floatx80_init(0x6914, 0x9589330efc54e836),
+/* 3167 */ make_floatx80_init(0x6917, 0xbaeb7fd2bb6a2244),
+/* 3168 */ make_floatx80_init(0x691a, 0xe9a65fc76a44aad5),
+/* 3169 */ make_floatx80_init(0x691e, 0x9207fbdca26aeac5),
+/* 3170 */ make_floatx80_init(0x6921, 0xb689fad3cb05a576),
+/* 3171 */ make_floatx80_init(0x6924, 0xe42c7988bdc70ed4),
+/* 3172 */ make_floatx80_init(0x6928, 0x8e9bcbf5769c6944),
+/* 3173 */ make_floatx80_init(0x692b, 0xb242bef2d4438395),
+/* 3174 */ make_floatx80_init(0x692e, 0xded36eaf8954647b),
+/* 3175 */ make_floatx80_init(0x6932, 0x8b44252db5d4becd),
+/* 3176 */ make_floatx80_init(0x6935, 0xae152e792349ee80),
+/* 3177 */ make_floatx80_init(0x6938, 0xd99a7a176c1c6a20),
+/* 3178 */ make_floatx80_init(0x693c, 0x88008c4ea391c254),
+/* 3179 */ make_floatx80_init(0x693f, 0xaa00af624c7632e9),
+/* 3180 */ make_floatx80_init(0x6942, 0xd480db3adf93bfa3),
+/* 3181 */ make_floatx80_init(0x6946, 0x84d08904cbbc57c6),
+/* 3182 */ make_floatx80_init(0x6949, 0xa604ab45feab6db7),
+/* 3183 */ make_floatx80_init(0x694c, 0xcf85d6177e564925),
+/* 3184 */ make_floatx80_init(0x6950, 0x81b3a5ceaef5edb7),
+/* 3185 */ make_floatx80_init(0x6953, 0xa2208f425ab36925),
+/* 3186 */ make_floatx80_init(0x6956, 0xcaa8b312f160436e),
+/* 3187 */ make_floatx80_init(0x6959, 0xfd52dfd7adb8544a),
+/* 3188 */ make_floatx80_init(0x695d, 0x9e53cbe6cc9334ae),
+/* 3189 */ make_floatx80_init(0x6960, 0xc5e8bee07fb801da),
+/* 3190 */ make_floatx80_init(0x6963, 0xf762ee989fa60250),
+/* 3191 */ make_floatx80_init(0x6967, 0x9a9dd51f63c7c172),
+/* 3192 */ make_floatx80_init(0x696a, 0xc1454a673cb9b1cf),
+/* 3193 */ make_floatx80_init(0x696d, 0xf1969d010be81e42),
+/* 3194 */ make_floatx80_init(0x6971, 0x96fe2220a77112ea),
+/* 3195 */ make_floatx80_init(0x6974, 0xbcbdaaa8d14d57a4),
+/* 3196 */ make_floatx80_init(0x6977, 0xebed155305a0ad8d),
+/* 3197 */ make_floatx80_init(0x697b, 0x93742d53e3846c78),
+/* 3198 */ make_floatx80_init(0x697e, 0xb85138a8dc658796),
+/* 3199 */ make_floatx80_init(0x6981, 0xe66586d3137ee97c),
+/* 3200 */ make_floatx80_init(0x6985, 0x8fff7443ec2f51ed),
+/* 3201 */ make_floatx80_init(0x6988, 0xb3ff5154e73b2669),
+/* 3202 */ make_floatx80_init(0x698b, 0xe0ff25aa2109f003),
+/* 3203 */ make_floatx80_init(0x698f, 0x8c9f778a54a63602),
+/* 3204 */ make_floatx80_init(0x6992, 0xafc7556ce9cfc382),
+/* 3205 */ make_floatx80_init(0x6995, 0xdbb92ac82443b463),
+/* 3206 */ make_floatx80_init(0x6999, 0x8953babd16aa50be),
+/* 3207 */ make_floatx80_init(0x699c, 0xaba8a96c5c54e4ed),
+/* 3208 */ make_floatx80_init(0x699f, 0xd692d3c7736a1e28),
+/* 3209 */ make_floatx80_init(0x69a3, 0x861bc45ca82252d9),
+/* 3210 */ make_floatx80_init(0x69a6, 0xa7a2b573d22ae78f),
+/* 3211 */ make_floatx80_init(0x69a9, 0xd18b62d0c6b5a173),
+/* 3212 */ make_floatx80_init(0x69ad, 0x82f71dc27c3184e8),
+/* 3213 */ make_floatx80_init(0x69b0, 0xa3b4e5331b3de622),
+/* 3214 */ make_floatx80_init(0x69b3, 0xcca21e7fe20d5fab),
+/* 3215 */ make_floatx80_init(0x69b6, 0xffcaa61fda90b795),
+/* 3216 */ make_floatx80_init(0x69ba, 0x9fdea7d3e89a72bd),
+/* 3217 */ make_floatx80_init(0x69bd, 0xc7d651c8e2c10f6d),
+/* 3218 */ make_floatx80_init(0x69c0, 0xf9cbe63b1b715348),
+/* 3219 */ make_floatx80_init(0x69c4, 0x9c1f6fe4f126d40d),
+/* 3220 */ make_floatx80_init(0x69c7, 0xc3274bde2d708910),
+/* 3221 */ make_floatx80_init(0x69ca, 0xf3f11ed5b8ccab54),
+/* 3222 */ make_floatx80_init(0x69ce, 0x9876b345937feb15),
+/* 3223 */ make_floatx80_init(0x69d1, 0xbe946016f85fe5da),
+/* 3224 */ make_floatx80_init(0x69d4, 0xee39781cb677df50),
+/* 3225 */ make_floatx80_init(0x69d8, 0x94e3eb11f20aeb92),
+/* 3226 */ make_floatx80_init(0x69db, 0xba1ce5d66e8da677),
+/* 3227 */ make_floatx80_init(0x69de, 0xe8a41f4c0a311014),
+/* 3228 */ make_floatx80_init(0x69e2, 0x9166938f865eaa0d),
+/* 3229 */ make_floatx80_init(0x69e5, 0xb5c0387367f65490),
+/* 3230 */ make_floatx80_init(0x69e8, 0xe330469041f3e9b4),
+/* 3231 */ make_floatx80_init(0x69ec, 0x8dfe2c1a29387210),
+/* 3232 */ make_floatx80_init(0x69ef, 0xb17db720b3868e94),
+/* 3233 */ make_floatx80_init(0x69f2, 0xdddd24e8e068323a),
+/* 3234 */ make_floatx80_init(0x69f6, 0x8aaa37118c411f64),
+/* 3235 */ make_floatx80_init(0x69f9, 0xad54c4d5ef51673d),
+/* 3236 */ make_floatx80_init(0x69fc, 0xd8a9f60b6b25c10c),
+/* 3237 */ make_floatx80_init(0x6a00, 0x876a39c722f798a8),
+/* 3238 */ make_floatx80_init(0x6a03, 0xa944c838ebb57ed2),
+/* 3239 */ make_floatx80_init(0x6a06, 0xd395fa4726a2de86),
+/* 3240 */ make_floatx80_init(0x6a0a, 0x843dbc6c7825cb14),
+/* 3241 */ make_floatx80_init(0x6a0d, 0xa54d2b87962f3dd9),
+/* 3242 */ make_floatx80_init(0x6a10, 0xcea076697bbb0d4f),
+/* 3243 */ make_floatx80_init(0x6a14, 0x81244a01ed54e851),
+/* 3244 */ make_floatx80_init(0x6a17, 0xa16d5c8268aa2266),
+/* 3245 */ make_floatx80_init(0x6a1a, 0xc9c8b3a302d4aaff),
+/* 3246 */ make_floatx80_init(0x6a1d, 0xfc3ae08bc389d5bf),
+/* 3247 */ make_floatx80_init(0x6a21, 0x9da4cc575a362597),
+/* 3248 */ make_floatx80_init(0x6a24, 0xc50dff6d30c3aefd),
+/* 3249 */ make_floatx80_init(0x6a27, 0xf6517f487cf49abc),
+/* 3250 */ make_floatx80_init(0x6a2b, 0x99f2ef8d4e18e0b6),
+/* 3251 */ make_floatx80_init(0x6a2e, 0xc06fab70a19f18e3),
+/* 3252 */ make_floatx80_init(0x6a31, 0xf08b964cca06df1c),
+/* 3253 */ make_floatx80_init(0x6a35, 0x96573deffe444b71),
+/* 3254 */ make_floatx80_init(0x6a38, 0xbbed0d6bfdd55e4e),
+/* 3255 */ make_floatx80_init(0x6a3b, 0xeae850c6fd4ab5e1),
+/* 3256 */ make_floatx80_init(0x6a3f, 0x92d1327c5e4eb1ad),
+/* 3257 */ make_floatx80_init(0x6a42, 0xb7857f1b75e25e18),
+/* 3258 */ make_floatx80_init(0x6a45, 0xe566dee2535af59e),
+/* 3259 */ make_floatx80_init(0x6a49, 0x8f604b4d7418d983),
+/* 3260 */ make_floatx80_init(0x6a4c, 0xb3385e20d11f0fe3),
+/* 3261 */ make_floatx80_init(0x6a4f, 0xe00675a90566d3dc),
+/* 3262 */ make_floatx80_init(0x6a53, 0x8c040989a360446a),
+/* 3263 */ make_floatx80_init(0x6a56, 0xaf050bec0c385584),
+/* 3264 */ make_floatx80_init(0x6a59, 0xdac64ee70f466ae5),
+/* 3265 */ make_floatx80_init(0x6a5d, 0x88bbf150698c02cf),
+/* 3266 */ make_floatx80_init(0x6a60, 0xaaeaeda483ef0383),
+/* 3267 */ make_floatx80_init(0x6a63, 0xd5a5a90da4eac464),
+/* 3268 */ make_floatx80_init(0x6a67, 0x858789a88712babe),
+/* 3269 */ make_floatx80_init(0x6a6a, 0xa6e96c12a8d7696e),
+/* 3270 */ make_floatx80_init(0x6a6d, 0xd0a3c717530d43c9),
+/* 3271 */ make_floatx80_init(0x6a71, 0x82665c6e93e84a5e),
+/* 3272 */ make_floatx80_init(0x6a74, 0xa2fff38a38e25cf5),
+/* 3273 */ make_floatx80_init(0x6a77, 0xcbbff06cc71af433),
+/* 3274 */ make_floatx80_init(0x6a7a, 0xfeafec87f8e1b13f),
+/* 3275 */ make_floatx80_init(0x6a7e, 0x9f2df3d4fb8d0ec8),
+/* 3276 */ make_floatx80_init(0x6a81, 0xc6f970ca3a705279),
+/* 3277 */ make_floatx80_init(0x6a84, 0xf8b7ccfcc90c6718),
+/* 3278 */ make_floatx80_init(0x6a88, 0x9b72e01dfda7c06f),
+/* 3279 */ make_floatx80_init(0x6a8b, 0xc24f98257d11b08b),
+/* 3280 */ make_floatx80_init(0x6a8e, 0xf2e37e2edc561cad),
+/* 3281 */ make_floatx80_init(0x6a92, 0x97ce2edd49b5d1ec),
+/* 3282 */ make_floatx80_init(0x6a95, 0xbdc1ba949c234667),
+/* 3283 */ make_floatx80_init(0x6a98, 0xed322939c32c1801),
+/* 3284 */ make_floatx80_init(0x6a9c, 0x943f59c419fb8f01),
+/* 3285 */ make_floatx80_init(0x6a9f, 0xb94f3035207a72c1),
+/* 3286 */ make_floatx80_init(0x6aa2, 0xe7a2fc4268990f71),
+/* 3287 */ make_floatx80_init(0x6aa6, 0x90c5dda9815fa9a7),
+/* 3288 */ make_floatx80_init(0x6aa9, 0xb4f75513e1b79410),
+/* 3289 */ make_floatx80_init(0x6aac, 0xe2352a58da257914),
+/* 3290 */ make_floatx80_init(0x6ab0, 0x8d613a7788576bad),
+/* 3291 */ make_floatx80_init(0x6ab3, 0xb0b989156a6d4698),
+/* 3292 */ make_floatx80_init(0x6ab6, 0xdce7eb5ac508983e),
+/* 3293 */ make_floatx80_init(0x6aba, 0x8a10f318bb255f27),
+/* 3294 */ make_floatx80_init(0x6abd, 0xac952fdee9eeb6f0),
+/* 3295 */ make_floatx80_init(0x6ac0, 0xd7ba7bd6a46a64ad),
+/* 3296 */ make_floatx80_init(0x6ac4, 0x86d48d6626c27eec),
+/* 3297 */ make_floatx80_init(0x6ac7, 0xa889b0bfb0731ea7),
+/* 3298 */ make_floatx80_init(0x6aca, 0xd2ac1cef9c8fe650),
+/* 3299 */ make_floatx80_init(0x6ace, 0x83ab9215c1d9eff2),
+/* 3300 */ make_floatx80_init(0x6ad1, 0xa496769b32506bef),
+/* 3301 */ make_floatx80_init(0x6ad4, 0xcdbc1441fee486eb),
+/* 3302 */ make_floatx80_init(0x6ad8, 0x80958ca93f4ed453),
+/* 3303 */ make_floatx80_init(0x6adb, 0xa0baefd38f228967),
+/* 3304 */ make_floatx80_init(0x6ade, 0xc8e9abc872eb2bc1),
+/* 3305 */ make_floatx80_init(0x6ae1, 0xfb2416ba8fa5f6b1),
+/* 3306 */ make_floatx80_init(0x6ae5, 0x9cf68e3499c7ba2f),
+/* 3307 */ make_floatx80_init(0x6ae8, 0xc43431c1c039a8bb),
+/* 3308 */ make_floatx80_init(0x6aeb, 0xf5413e32304812e9),
+/* 3309 */ make_floatx80_init(0x6aef, 0x9948c6df5e2d0bd2),
+/* 3310 */ make_floatx80_init(0x6af2, 0xbf9af89735b84ec6),
+/* 3311 */ make_floatx80_init(0x6af5, 0xef81b6bd03266278),
+/* 3312 */ make_floatx80_init(0x6af9, 0x95b1123621f7fd8b),
+/* 3313 */ make_floatx80_init(0x6afc, 0xbb1d56c3aa75fcee),
+/* 3314 */ make_floatx80_init(0x6aff, 0xe9e4ac7495137c29),
+/* 3315 */ make_floatx80_init(0x6b03, 0x922eebc8dd2c2d9a),
+/* 3316 */ make_floatx80_init(0x6b06, 0xb6baa6bb14773900),
+/* 3317 */ make_floatx80_init(0x6b09, 0xe4695069d9950740),
+/* 3318 */ make_floatx80_init(0x6b0d, 0x8ec1d24227fd2488),
+/* 3319 */ make_floatx80_init(0x6b10, 0xb27246d2b1fc6daa),
+/* 3320 */ make_floatx80_init(0x6b13, 0xdf0ed8875e7b8914),
+/* 3321 */ make_floatx80_init(0x6b17, 0x8b6947549b0d35ad),
+/* 3322 */ make_floatx80_init(0x6b1a, 0xae439929c1d08318),
+/* 3323 */ make_floatx80_init(0x6b1d, 0xd9d47f743244a3de),
+/* 3324 */ make_floatx80_init(0x6b21, 0x8824cfa89f6ae66b),
+/* 3325 */ make_floatx80_init(0x6b24, 0xaa2e0392c745a005),
+/* 3326 */ make_floatx80_init(0x6b27, 0xd4b9847779170807),
+/* 3327 */ make_floatx80_init(0x6b2b, 0x84f3f2caabae6504),
+/* 3328 */ make_floatx80_init(0x6b2e, 0xa630ef7d5699fe45),
+/* 3329 */ make_floatx80_init(0x6b31, 0xcfbd2b5cac407dd7),
+/* 3330 */ make_floatx80_init(0x6b35, 0x81d63b19eba84ea6),
+/* 3331 */ make_floatx80_init(0x6b38, 0xa24bc9e066926250),
+/* 3332 */ make_floatx80_init(0x6b3b, 0xcadebc588036fae4),
+/* 3333 */ make_floatx80_init(0x6b3e, 0xfd966b6ea044b99d),
+/* 3334 */ make_floatx80_init(0x6b42, 0x9e7e0325242af402),
+/* 3335 */ make_floatx80_init(0x6b45, 0xc61d83ee6d35b102),
+/* 3336 */ make_floatx80_init(0x6b48, 0xf7a4e4ea08831d43),
+/* 3337 */ make_floatx80_init(0x6b4c, 0x9ac70f124551f24a),
+/* 3338 */ make_floatx80_init(0x6b4f, 0xc178d2d6d6a66edc),
+/* 3339 */ make_floatx80_init(0x6b52, 0xf1d7078c8c500a93),
+/* 3340 */ make_floatx80_init(0x6b56, 0x972664b7d7b2069c),
+/* 3341 */ make_floatx80_init(0x6b59, 0xbceffde5cd9e8843),
+/* 3342 */ make_floatx80_init(0x6b5c, 0xec2bfd5f41062a54),
+/* 3343 */ make_floatx80_init(0x6b60, 0x939b7e5b88a3da74),
+/* 3344 */ make_floatx80_init(0x6b63, 0xb8825df26accd111),
+/* 3345 */ make_floatx80_init(0x6b66, 0xe6a2f56f05800556),
+/* 3346 */ make_floatx80_init(0x6b6a, 0x9025d96563700356),
+/* 3347 */ make_floatx80_init(0x6b6d, 0xb42f4fbebc4c042b),
+/* 3348 */ make_floatx80_init(0x6b70, 0xe13b23ae6b5f0536),
+/* 3349 */ make_floatx80_init(0x6b74, 0x8cc4f64d031b6342),
+/* 3350 */ make_floatx80_init(0x6b77, 0xaff633e043e23c12),
+/* 3351 */ make_floatx80_init(0x6b7a, 0xdbf3c0d854dacb17),
+/* 3352 */ make_floatx80_init(0x6b7e, 0x897858873508beee),
+/* 3353 */ make_floatx80_init(0x6b81, 0xabd66ea9024aeeaa),
+/* 3354 */ make_floatx80_init(0x6b84, 0xd6cc0a5342ddaa54),
+/* 3355 */ make_floatx80_init(0x6b88, 0x863f867409ca8a75),
+/* 3356 */ make_floatx80_init(0x6b8b, 0xa7cf68110c3d2d12),
+/* 3357 */ make_floatx80_init(0x6b8e, 0xd1c342154f4c7856),
+/* 3358 */ make_floatx80_init(0x6b92, 0x831a094d518fcb36),
+/* 3359 */ make_floatx80_init(0x6b95, 0xa3e08ba0a5f3be03),
+/* 3360 */ make_floatx80_init(0x6b98, 0xccd8ae88cf70ad84),
+/* 3361 */ make_floatx80_init(0x6b9c, 0x80076d1581a66c73),
+/* 3362 */ make_floatx80_init(0x6b9f, 0xa009485ae210078f),
+/* 3363 */ make_floatx80_init(0x6ba2, 0xc80b9a719a940973),
+/* 3364 */ make_floatx80_init(0x6ba5, 0xfa0e810e01390bd0),
+/* 3365 */ make_floatx80_init(0x6ba9, 0x9c4910a8c0c3a762),
+/* 3366 */ make_floatx80_init(0x6bac, 0xc35b54d2f0f4913a),
+/* 3367 */ make_floatx80_init(0x6baf, 0xf4322a07ad31b589),
+/* 3368 */ make_floatx80_init(0x6bb3, 0x989f5a44cc3f1176),
+/* 3369 */ make_floatx80_init(0x6bb6, 0xbec730d5ff4ed5d3),
+/* 3370 */ make_floatx80_init(0x6bb9, 0xee78fd0b7f228b48),
+/* 3371 */ make_floatx80_init(0x6bbd, 0x950b9e272f75970d),
+/* 3372 */ make_floatx80_init(0x6bc0, 0xba4e85b0fb52fcd0),
+/* 3373 */ make_floatx80_init(0x6bc3, 0xe8e2271d3a27bc04),
+/* 3374 */ make_floatx80_init(0x6bc7, 0x918d58724458d582),
+/* 3375 */ make_floatx80_init(0x6bca, 0xb5f0ae8ed56f0ae3),
+/* 3376 */ make_floatx80_init(0x6bcd, 0xe36cda328acacd9c),
+/* 3377 */ make_floatx80_init(0x6bd1, 0x8e24085f96bec081),
+/* 3378 */ make_floatx80_init(0x6bd4, 0xb1ad0a777c6e70a2),
+/* 3379 */ make_floatx80_init(0x6bd7, 0xde184d155b8a0cca),
+/* 3380 */ make_floatx80_init(0x6bdb, 0x8acf302d593647fe),
+/* 3381 */ make_floatx80_init(0x6bde, 0xad82fc38af83d9fe),
+/* 3382 */ make_floatx80_init(0x6be1, 0xd8e3bb46db64d07d),
+/* 3383 */ make_floatx80_init(0x6be5, 0x878e550c491f024e),
+/* 3384 */ make_floatx80_init(0x6be8, 0xa971ea4f5b66c2e2),
+/* 3385 */ make_floatx80_init(0x6beb, 0xd3ce64e33240739b),
+/* 3386 */ make_floatx80_init(0x6bef, 0x8460ff0dff684841),
+/* 3387 */ make_floatx80_init(0x6bf2, 0xa5793ed17f425a51),
+/* 3388 */ make_floatx80_init(0x6bf5, 0xced78e85df12f0e5),
+/* 3389 */ make_floatx80_init(0x6bf9, 0x8146b913ab6bd68f),
+/* 3390 */ make_floatx80_init(0x6bfc, 0xa19867589646cc33),
+/* 3391 */ make_floatx80_init(0x6bff, 0xc9fe812ebbd87f40),
+/* 3392 */ make_floatx80_init(0x6c02, 0xfc7e217a6ace9f0f),
+/* 3393 */ make_floatx80_init(0x6c06, 0x9dced4ec82c1236a),
+/* 3394 */ make_floatx80_init(0x6c09, 0xc5428a27a3716c44),
+/* 3395 */ make_floatx80_init(0x6c0c, 0xf6932cb18c4dc755),
+/* 3396 */ make_floatx80_init(0x6c10, 0x9a1bfbeef7b09c95),
+/* 3397 */ make_floatx80_init(0x6c13, 0xc0a2faeab59cc3ba),
+/* 3398 */ make_floatx80_init(0x6c16, 0xf0cbb9a56303f4a9),
+/* 3399 */ make_floatx80_init(0x6c1a, 0x967f54075de278ea),
+/* 3400 */ make_floatx80_init(0x6c1d, 0xbc1f2909355b1724),
+/* 3401 */ make_floatx80_init(0x6c20, 0xeb26f34b82b1dced),
+/* 3402 */ make_floatx80_init(0x6c24, 0x92f8580f31af2a14),
+/* 3403 */ make_floatx80_init(0x6c27, 0xb7b66e12fe1af499),
+/* 3404 */ make_floatx80_init(0x6c2a, 0xe5a40997bda1b1c0),
+/* 3405 */ make_floatx80_init(0x6c2e, 0x8f8685fed6850f18),
+/* 3406 */ make_floatx80_init(0x6c31, 0xb368277e8c2652de),
+/* 3407 */ make_floatx80_init(0x6c34, 0xe042315e2f2fe795),
+/* 3408 */ make_floatx80_init(0x6c38, 0x8c295edadd7df0bd),
+/* 3409 */ make_floatx80_init(0x6c3b, 0xaf33b69194dd6cec),
+/* 3410 */ make_floatx80_init(0x6c3e, 0xdb00a435fa14c828),
+/* 3411 */ make_floatx80_init(0x6c42, 0x88e066a1bc4cfd19),
+/* 3412 */ make_floatx80_init(0x6c45, 0xab18804a2b603c5f),
+/* 3413 */ make_floatx80_init(0x6c48, 0xd5dea05cb6384b77),
+/* 3414 */ make_floatx80_init(0x6c4c, 0x85ab2439f1e32f2a),
+/* 3415 */ make_floatx80_init(0x6c4f, 0xa715ed486e5bfaf5),
+/* 3416 */ make_floatx80_init(0x6c52, 0xd0db689a89f2f9b2),
+/* 3417 */ make_floatx80_init(0x6c56, 0x828921609637dc0f),
+/* 3418 */ make_floatx80_init(0x6c59, 0xa32b69b8bbc5d313),
+/* 3419 */ make_floatx80_init(0x6c5c, 0xcbf64426eab747d8),
+/* 3420 */ make_floatx80_init(0x6c5f, 0xfef3d530a56519ce),
+/* 3421 */ make_floatx80_init(0x6c63, 0x9f58653e675f3021),
+/* 3422 */ make_floatx80_init(0x6c66, 0xc72e7e8e0136fc29),
+/* 3423 */ make_floatx80_init(0x6c69, 0xf8fa1e318184bb33),
+/* 3424 */ make_floatx80_init(0x6c6d, 0x9b9c52def0f2f500),
+/* 3425 */ make_floatx80_init(0x6c70, 0xc2836796ad2fb240),
+/* 3426 */ make_floatx80_init(0x6c73, 0xf324417c587b9ed0),
+/* 3427 */ make_floatx80_init(0x6c77, 0x97f6a8edb74d4342),
+/* 3428 */ make_floatx80_init(0x6c7a, 0xbdf4532925209412),
+/* 3429 */ make_floatx80_init(0x6c7d, 0xed7167f36e68b917),
+/* 3430 */ make_floatx80_init(0x6c81, 0x9466e0f8250173ae),
+/* 3431 */ make_floatx80_init(0x6c84, 0xb98099362e41d09a),
+/* 3432 */ make_floatx80_init(0x6c87, 0xe7e0bf83b9d244c0),
+/* 3433 */ make_floatx80_init(0x6c8b, 0x90ec77b254236af8),
+/* 3434 */ make_floatx80_init(0x6c8e, 0xb527959ee92c45b6),
+/* 3435 */ make_floatx80_init(0x6c91, 0xe2717b06a3775724),
+/* 3436 */ make_floatx80_init(0x6c95, 0x8d86ece4262a9676),
+/* 3437 */ make_floatx80_init(0x6c98, 0xb0e8a81d2fb53c14),
+/* 3438 */ make_floatx80_init(0x6c9b, 0xdd22d2247ba28b19),
+/* 3439 */ make_floatx80_init(0x6c9f, 0x8a35c356cd4596f0),
+/* 3440 */ make_floatx80_init(0x6ca2, 0xacc3342c8096fcab),
+/* 3441 */ make_floatx80_init(0x6ca5, 0xd7f40137a0bcbbd6),
+/* 3442 */ make_floatx80_init(0x6ca9, 0x86f880c2c475f566),
+/* 3443 */ make_floatx80_init(0x6cac, 0xa8b6a0f3759372bf),
+/* 3444 */ make_floatx80_init(0x6caf, 0xd2e4493052f84f6f),
+/* 3445 */ make_floatx80_init(0x6cb3, 0x83ceadbe33db31a6),
+/* 3446 */ make_floatx80_init(0x6cb6, 0xa4c2592dc0d1fe0f),
+/* 3447 */ make_floatx80_init(0x6cb9, 0xcdf2ef7931067d93),
+/* 3448 */ make_floatx80_init(0x6cbd, 0x80b7d5abbea40e7c),
+/* 3449 */ make_floatx80_init(0x6cc0, 0xa0e5cb16ae4d121b),
+/* 3450 */ make_floatx80_init(0x6cc3, 0xc91f3ddc59e056a1),
+/* 3451 */ make_floatx80_init(0x6cc6, 0xfb670d5370586c4a),
+/* 3452 */ make_floatx80_init(0x6cca, 0x9d206854263743ae),
+/* 3453 */ make_floatx80_init(0x6ccd, 0xc46882692fc51499),
+/* 3454 */ make_floatx80_init(0x6cd0, 0xf582a3037bb659c0),
+/* 3455 */ make_floatx80_init(0x6cd4, 0x9971a5e22d51f818),
+/* 3456 */ make_floatx80_init(0x6cd7, 0xbfce0f5ab8a6761e),
+/* 3457 */ make_floatx80_init(0x6cda, 0xefc1933166d013a5),
+/* 3458 */ make_floatx80_init(0x6cde, 0x95d8fbfee0420c47),
+/* 3459 */ make_floatx80_init(0x6ce1, 0xbb4f3afe98528f59),
+/* 3460 */ make_floatx80_init(0x6ce4, 0xea2309be3e67332f),
+/* 3461 */ make_floatx80_init(0x6ce8, 0x9255e616e7007ffe),
+/* 3462 */ make_floatx80_init(0x6ceb, 0xb6eb5f9ca0c09ffd),
+/* 3463 */ make_floatx80_init(0x6cee, 0xe4a63783c8f0c7fc),
+/* 3464 */ make_floatx80_init(0x6cf2, 0x8ee7e2b25d967cfe),
+/* 3465 */ make_floatx80_init(0x6cf5, 0xb2a1db5ef4fc1c3d),
+/* 3466 */ make_floatx80_init(0x6cf8, 0xdf4a5236b23b234c),
+/* 3467 */ make_floatx80_init(0x6cfc, 0x8b8e73622f64f610),
+/* 3468 */ make_floatx80_init(0x6cff, 0xae72103abb3e3394),
+/* 3469 */ make_floatx80_init(0x6d02, 0xda0e94496a0dc079),
+/* 3470 */ make_floatx80_init(0x6d06, 0x88491cade248984b),
+/* 3471 */ make_floatx80_init(0x6d09, 0xaa5b63d95adabe5e),
+/* 3472 */ make_floatx80_init(0x6d0c, 0xd4f23ccfb1916df6),
+/* 3473 */ make_floatx80_init(0x6d10, 0x85176601cefae4ba),
+/* 3474 */ make_floatx80_init(0x6d13, 0xa65d3f8242b99de8),
+/* 3475 */ make_floatx80_init(0x6d16, 0xcff48f62d3680562),
+/* 3476 */ make_floatx80_init(0x6d1a, 0x81f8d99dc421035d),
+/* 3477 */ make_floatx80_init(0x6d1d, 0xa277100535294435),
+/* 3478 */ make_floatx80_init(0x6d20, 0xcb14d40682739542),
+/* 3479 */ make_floatx80_init(0x6d23, 0xfdda090823107a92),
+/* 3480 */ make_floatx80_init(0x6d27, 0x9ea845a515ea4c9b),
+/* 3481 */ make_floatx80_init(0x6d2a, 0xc652570e5b64dfc2),
+/* 3482 */ make_floatx80_init(0x6d2d, 0xf7e6ecd1f23e17b3),
+/* 3483 */ make_floatx80_init(0x6d31, 0x9af054033766ced0),
+/* 3484 */ make_floatx80_init(0x6d34, 0xc1ac690405408284),
+/* 3485 */ make_floatx80_init(0x6d37, 0xf21783450690a325),
+/* 3486 */ make_floatx80_init(0x6d3b, 0x974eb20b241a65f7),
+/* 3487 */ make_floatx80_init(0x6d3e, 0xbd225e8ded20ff75),
+/* 3488 */ make_floatx80_init(0x6d41, 0xec6af63168693f52),
+/* 3489 */ make_floatx80_init(0x6d45, 0x93c2d9dee141c793),
+/* 3490 */ make_floatx80_init(0x6d48, 0xb8b3905699923978),
+/* 3491 */ make_floatx80_init(0x6d4b, 0xe6e0746c3ff6c7d6),
+/* 3492 */ make_floatx80_init(0x6d4f, 0x904c48c3a7fa3ce6),
+/* 3493 */ make_floatx80_init(0x6d52, 0xb45f5af491f8cc1f),
+/* 3494 */ make_floatx80_init(0x6d55, 0xe17731b1b676ff27),
+/* 3495 */ make_floatx80_init(0x6d59, 0x8cea7f0f120a5f78),
+/* 3496 */ make_floatx80_init(0x6d5c, 0xb0251ed2d68cf756),
+/* 3497 */ make_floatx80_init(0x6d5f, 0xdc2e66878c30352c),
+/* 3498 */ make_floatx80_init(0x6d63, 0x899d0014b79e213b),
+/* 3499 */ make_floatx80_init(0x6d66, 0xac044019e585a98a),
+/* 3500 */ make_floatx80_init(0x6d69, 0xd70550205ee713ed),
+/* 3501 */ make_floatx80_init(0x6d6d, 0x866352143b506c74),
+/* 3502 */ make_floatx80_init(0x6d70, 0xa7fc26994a248791),
+/* 3503 */ make_floatx80_init(0x6d73, 0xd1fb303f9cada975),
+/* 3504 */ make_floatx80_init(0x6d77, 0x833cfe27c1ec89e9),
+/* 3505 */ make_floatx80_init(0x6d7a, 0xa40c3db1b267ac64),
+/* 3506 */ make_floatx80_init(0x6d7d, 0xcd0f4d1e1f01977d),
+/* 3507 */ make_floatx80_init(0x6d81, 0x80299032d360feae),
+/* 3508 */ make_floatx80_init(0x6d84, 0xa033f43f88393e59),
+/* 3509 */ make_floatx80_init(0x6d87, 0xc840f14f6a478df0),
+/* 3510 */ make_floatx80_init(0x6d8a, 0xfa512da344d9716c),
+/* 3511 */ make_floatx80_init(0x6d8e, 0x9c72bc860b07e6e3),
+/* 3512 */ make_floatx80_init(0x6d91, 0xc38f6ba78dc9e09c),
+/* 3513 */ make_floatx80_init(0x6d94, 0xf4734691713c58c3),
+/* 3514 */ make_floatx80_init(0x6d98, 0x98c80c1ae6c5b77a),
+/* 3515 */ make_floatx80_init(0x6d9b, 0xbefa0f21a0772558),
+/* 3516 */ make_floatx80_init(0x6d9e, 0xeeb892ea0894eeae),
+/* 3517 */ make_floatx80_init(0x6da2, 0x95335bd2455d152d),
+/* 3518 */ make_floatx80_init(0x6da5, 0xba8032c6d6b45a78),
+/* 3519 */ make_floatx80_init(0x6da8, 0xe9203f788c617116),
+/* 3520 */ make_floatx80_init(0x6dac, 0x91b427ab57bce6ae),
+/* 3521 */ make_floatx80_init(0x6daf, 0xb62131962dac2059),
+/* 3522 */ make_floatx80_init(0x6db2, 0xe3a97dfbb9172870),
+/* 3523 */ make_floatx80_init(0x6db6, 0x8e49eebd53ae7946),
+/* 3524 */ make_floatx80_init(0x6db9, 0xb1dc6a6ca89a1797),
+/* 3525 */ make_floatx80_init(0x6dbc, 0xde538507d2c09d7d),
+/* 3526 */ make_floatx80_init(0x6dc0, 0x8af43324e3b8626e),
+/* 3527 */ make_floatx80_init(0x6dc3, 0xadb13fee1ca67b0a),
+/* 3528 */ make_floatx80_init(0x6dc6, 0xd91d8fe9a3d019cc),
+/* 3529 */ make_floatx80_init(0x6dca, 0x87b279f206621020),
+/* 3530 */ make_floatx80_init(0x6dcd, 0xa99f186e87fa9428),
+/* 3531 */ make_floatx80_init(0x6dd0, 0xd406de8a29f93931),
+/* 3532 */ make_floatx80_init(0x6dd4, 0x84844b165a3bc3bf),
+/* 3533 */ make_floatx80_init(0x6dd7, 0xa5a55ddbf0cab4af),
+/* 3534 */ make_floatx80_init(0x6dda, 0xcf0eb552ecfd61da),
+/* 3535 */ make_floatx80_init(0x6dde, 0x81693153d41e5d28),
+/* 3536 */ make_floatx80_init(0x6de1, 0xa1c37da8c925f473),
+/* 3537 */ make_floatx80_init(0x6de4, 0xca345d12fb6f718f),
+/* 3538 */ make_floatx80_init(0x6de7, 0xfcc17457ba4b4df3),
+/* 3539 */ make_floatx80_init(0x6deb, 0x9df8e8b6d46f10b8),
+/* 3540 */ make_floatx80_init(0x6dee, 0xc57722e4898ad4e6),
+/* 3541 */ make_floatx80_init(0x6df1, 0xf6d4eb9dabed8a1f),
+/* 3542 */ make_floatx80_init(0x6df5, 0x9a4513428b747654),
+/* 3543 */ make_floatx80_init(0x6df8, 0xc0d658132e5193e8),
+/* 3544 */ make_floatx80_init(0x6dfb, 0xf10bee17f9e5f8e3),
+/* 3545 */ make_floatx80_init(0x6dff, 0x96a774cefc2fbb8e),
+/* 3546 */ make_floatx80_init(0x6e02, 0xbc515202bb3baa71),
+/* 3547 */ make_floatx80_init(0x6e05, 0xeb65a6836a0a950d),
+/* 3548 */ make_floatx80_init(0x6e09, 0x931f881222469d28),
+/* 3549 */ make_floatx80_init(0x6e0c, 0xb7e76a16aad84472),
+/* 3550 */ make_floatx80_init(0x6e0f, 0xe5e1449c558e558f),
+/* 3551 */ make_floatx80_init(0x6e13, 0x8faccae1b578f579),
+/* 3552 */ make_floatx80_init(0x6e16, 0xb397fd9a22d732d8),
+/* 3553 */ make_floatx80_init(0x6e19, 0xe07dfd00ab8cff8e),
+/* 3554 */ make_floatx80_init(0x6e1d, 0x8c4ebe206b381fb9),
+/* 3555 */ make_floatx80_init(0x6e20, 0xaf626da8860627a7),
+/* 3556 */ make_floatx80_init(0x6e23, 0xdb3b0912a787b190),
+/* 3557 */ make_floatx80_init(0x6e27, 0x8904e5aba8b4cefa),
+/* 3558 */ make_floatx80_init(0x6e2a, 0xab461f1692e202b9),
+/* 3559 */ make_floatx80_init(0x6e2d, 0xd617a6dc379a8367),
+/* 3560 */ make_floatx80_init(0x6e31, 0x85cec849a2c09220),
+/* 3561 */ make_floatx80_init(0x6e34, 0xa7427a5c0b70b6a8),
+/* 3562 */ make_floatx80_init(0x6e37, 0xd11318f30e4ce452),
+/* 3563 */ make_floatx80_init(0x6e3b, 0x82abef97e8f00eb4),
+/* 3564 */ make_floatx80_init(0x6e3e, 0xa356eb7de32c1260),
+/* 3565 */ make_floatx80_init(0x6e41, 0xcc2ca65d5bf716f9),
+/* 3566 */ make_floatx80_init(0x6e44, 0xff37cff4b2f4dcb7),
+/* 3567 */ make_floatx80_init(0x6e48, 0x9f82e1f8efd909f2),
+/* 3568 */ make_floatx80_init(0x6e4b, 0xc7639a772bcf4c6f),
+/* 3569 */ make_floatx80_init(0x6e4e, 0xf93c8114f6c31f8a),
+/* 3570 */ make_floatx80_init(0x6e52, 0x9bc5d0ad1a39f3b7),
+/* 3571 */ make_floatx80_init(0x6e55, 0xc2b744d860c870a4),
+/* 3572 */ make_floatx80_init(0x6e58, 0xf365160e78fa8ccd),
+/* 3573 */ make_floatx80_init(0x6e5c, 0x981f2dc90b9c9800),
+/* 3574 */ make_floatx80_init(0x6e5f, 0xbe26f93b4e83be00),
+/* 3575 */ make_floatx80_init(0x6e62, 0xedb0b78a2224ad80),
+/* 3576 */ make_floatx80_init(0x6e66, 0x948e72b65556ec70),
+/* 3577 */ make_floatx80_init(0x6e69, 0xb9b20f63eaaca78c),
+/* 3578 */ make_floatx80_init(0x6e6c, 0xe81e933ce557d16f),
+/* 3579 */ make_floatx80_init(0x6e70, 0x91131c060f56e2e6),
+/* 3580 */ make_floatx80_init(0x6e73, 0xb557e307932c9b9f),
+/* 3581 */ make_floatx80_init(0x6e76, 0xe2addbc977f7c287),
+/* 3582 */ make_floatx80_init(0x6e7a, 0x8daca95deafad994),
+/* 3583 */ make_floatx80_init(0x6e7d, 0xb117d3b565b98ff9),
+/* 3584 */ make_floatx80_init(0x6e80, 0xdd5dc8a2bf27f3f8),
+/* 3585 */ make_floatx80_init(0x6e84, 0x8a5a9d65b778f87b),
+/* 3586 */ make_floatx80_init(0x6e87, 0xacf144bf25573699),
+/* 3587 */ make_floatx80_init(0x6e8a, 0xd82d95eeeead0440),
+/* 3588 */ make_floatx80_init(0x6e8e, 0x871c7db5552c22a8),
+/* 3589 */ make_floatx80_init(0x6e91, 0xa8e39d22aa772b52),
+/* 3590 */ make_floatx80_init(0x6e94, 0xd31c846b5514f626),
+/* 3591 */ make_floatx80_init(0x6e98, 0x83f1d2c3152d19d8),
+/* 3592 */ make_floatx80_init(0x6e9b, 0xa4ee4773da78604e),
+/* 3593 */ make_floatx80_init(0x6e9e, 0xce29d950d1167861),
+/* 3594 */ make_floatx80_init(0x6ea2, 0x80da27d282ae0b3d),
+/* 3595 */ make_floatx80_init(0x6ea5, 0xa110b1c723598e0c),
+/* 3596 */ make_floatx80_init(0x6ea8, 0xc954de38ec2ff18f),
+/* 3597 */ make_floatx80_init(0x6eab, 0xfbaa15c7273bedf3),
+/* 3598 */ make_floatx80_init(0x6eaf, 0x9d4a4d9c788574b8),
+/* 3599 */ make_floatx80_init(0x6eb2, 0xc49ce10396a6d1e6),
+/* 3600 */ make_floatx80_init(0x6eb5, 0xf5c419447c50865f),
+/* 3601 */ make_floatx80_init(0x6eb9, 0x999a8fcacdb253fb),
+/* 3602 */ make_floatx80_init(0x6ebc, 0xc00133bd811ee8fa),
+/* 3603 */ make_floatx80_init(0x6ebf, 0xf00180ace166a339),
+/* 3604 */ make_floatx80_init(0x6ec3, 0x9600f06c0ce02604),
+/* 3605 */ make_floatx80_init(0x6ec6, 0xbb812c8710182f85),
+/* 3606 */ make_floatx80_init(0x6ec9, 0xea6177a8d41e3b66),
+/* 3607 */ make_floatx80_init(0x6ecd, 0x927ceac98492e520),
+/* 3608 */ make_floatx80_init(0x6ed0, 0xb71c257be5b79e67),
+/* 3609 */ make_floatx80_init(0x6ed3, 0xe4e32edadf258601),
+/* 3610 */ make_floatx80_init(0x6ed7, 0x8f0dfd48cb7773c1),
+/* 3611 */ make_floatx80_init(0x6eda, 0xb2d17c9afe5550b1),
+/* 3612 */ make_floatx80_init(0x6edd, 0xdf85dbc1bdeaa4dd),
+/* 3613 */ make_floatx80_init(0x6ee1, 0x8bb3a95916b2a70a),
+/* 3614 */ make_floatx80_init(0x6ee4, 0xaea093af5c5f50cd),
+/* 3615 */ make_floatx80_init(0x6ee7, 0xda48b89b33772500),
+/* 3616 */ make_floatx80_init(0x6eeb, 0x886d7361002a7720),
+/* 3617 */ make_floatx80_init(0x6eee, 0xaa88d039403514e8),
+/* 3618 */ make_floatx80_init(0x6ef1, 0xd52b044790425a22),
+/* 3619 */ make_floatx80_init(0x6ef5, 0x853ae2acba297855),
+/* 3620 */ make_floatx80_init(0x6ef8, 0xa6899b57e8b3d66b),
+/* 3621 */ make_floatx80_init(0x6efb, 0xd02c022de2e0cc05),
+/* 3622 */ make_floatx80_init(0x6eff, 0x821b815cadcc7f83),
+/* 3623 */ make_floatx80_init(0x6f02, 0xa2a261b3d93f9f64),
+/* 3624 */ make_floatx80_init(0x6f05, 0xcb4afa20cf8f873d),
+/* 3625 */ make_floatx80_init(0x6f08, 0xfe1db8a90373690c),
+/* 3626 */ make_floatx80_init(0x6f0c, 0x9ed29369a22821a8),
+/* 3627 */ make_floatx80_init(0x6f0f, 0xc68738440ab22a12),
+/* 3628 */ make_floatx80_init(0x6f12, 0xf82906550d5eb496),
+/* 3629 */ make_floatx80_init(0x6f16, 0x9b19a3f5285b30de),
+/* 3630 */ make_floatx80_init(0x6f19, 0xc1e00cf27271fd15),
+/* 3631 */ make_floatx80_init(0x6f1c, 0xf258102f0f0e7c5b),
+/* 3632 */ make_floatx80_init(0x6f20, 0x97770a1d69690db9),
+/* 3633 */ make_floatx80_init(0x6f23, 0xbd54cca4c3c35127),
+/* 3634 */ make_floatx80_init(0x6f26, 0xeca9ffcdf4b42570),
+/* 3635 */ make_floatx80_init(0x6f2a, 0x93ea3fe0b8f09766),
+/* 3636 */ make_floatx80_init(0x6f2d, 0xb8e4cfd8e72cbd40),
+/* 3637 */ make_floatx80_init(0x6f30, 0xe71e03cf20f7ec90),
+/* 3638 */ make_floatx80_init(0x6f34, 0x9072c261749af3da),
+/* 3639 */ make_floatx80_init(0x6f37, 0xb48f72f9d1c1b0d0),
+/* 3640 */ make_floatx80_init(0x6f3a, 0xe1b34fb846321d04),
+/* 3641 */ make_floatx80_init(0x6f3e, 0x8d1011d32bdf5223),
+/* 3642 */ make_floatx80_init(0x6f41, 0xb0541647f6d726ab),
+/* 3643 */ make_floatx80_init(0x6f44, 0xdc691bd9f48cf056),
+/* 3644 */ make_floatx80_init(0x6f48, 0x89c1b16838d81636),
+/* 3645 */ make_floatx80_init(0x6f4b, 0xac321dc2470e1bc3),
+/* 3646 */ make_floatx80_init(0x6f4e, 0xd73ea532d8d1a2b4),
+/* 3647 */ make_floatx80_init(0x6f52, 0x8687273fc78305b1),
+/* 3648 */ make_floatx80_init(0x6f55, 0xa828f10fb963c71d),
+/* 3649 */ make_floatx80_init(0x6f58, 0xd2332d53a7bcb8e4),
+/* 3650 */ make_floatx80_init(0x6f5c, 0x835ffc5448d5f38f),
+/* 3651 */ make_floatx80_init(0x6f5f, 0xa437fb695b0b7072),
+/* 3652 */ make_floatx80_init(0x6f62, 0xcd45fa43b1ce4c8f),
+/* 3653 */ make_floatx80_init(0x6f66, 0x804bbc6a4f20efd9),
+/* 3654 */ make_floatx80_init(0x6f69, 0xa05eab84e2e92bd0),
+/* 3655 */ make_floatx80_init(0x6f6c, 0xc87656661ba376c3),
+/* 3656 */ make_floatx80_init(0x6f6f, 0xfa93ebffa28c5474),
+/* 3657 */ make_floatx80_init(0x6f73, 0x9c9c737fc597b4c9),
+/* 3658 */ make_floatx80_init(0x6f76, 0xc3c3905fb6fda1fb),
+/* 3659 */ make_floatx80_init(0x6f79, 0xf4b47477a4bd0a7a),
+/* 3660 */ make_floatx80_init(0x6f7d, 0x98f0c8cac6f6268c),
+/* 3661 */ make_floatx80_init(0x6f80, 0xbf2cfafd78b3b02f),
+/* 3662 */ make_floatx80_init(0x6f83, 0xeef839bcd6e09c3b),
+/* 3663 */ make_floatx80_init(0x6f87, 0x955b2416064c61a5),
+/* 3664 */ make_floatx80_init(0x6f8a, 0xbab1ed1b87df7a0e),
+/* 3665 */ make_floatx80_init(0x6f8d, 0xe95e686269d75891),
+/* 3666 */ make_floatx80_init(0x6f91, 0x91db013d8226975b),
+/* 3667 */ make_floatx80_init(0x6f94, 0xb651c18ce2b03d32),
+/* 3668 */ make_floatx80_init(0x6f97, 0xe3e631f01b5c4c7e),
+/* 3669 */ make_floatx80_init(0x6f9b, 0x8e6fdf361119afcf),
+/* 3670 */ make_floatx80_init(0x6f9e, 0xb20bd70395601bc2),
+/* 3671 */ make_floatx80_init(0x6fa1, 0xde8eccc47ab822b3),
+/* 3672 */ make_floatx80_init(0x6fa5, 0x8b193ffaccb315b0),
+/* 3673 */ make_floatx80_init(0x6fa8, 0xaddf8ff97fdfdb1c),
+/* 3674 */ make_floatx80_init(0x6fab, 0xd95773f7dfd7d1e3),
+/* 3675 */ make_floatx80_init(0x6faf, 0x87d6a87aebe6e32e),
+/* 3676 */ make_floatx80_init(0x6fb2, 0xa9cc5299a6e09bf9),
+/* 3677 */ make_floatx80_init(0x6fb5, 0xd43f67401098c2f7),
+/* 3678 */ make_floatx80_init(0x6fb9, 0x84a7a0880a5f79db),
+/* 3679 */ make_floatx80_init(0x6fbc, 0xa5d188aa0cf75851),
+/* 3680 */ make_floatx80_init(0x6fbf, 0xcf45ead490352e66),
+/* 3681 */ make_floatx80_init(0x6fc3, 0x818bb2c4da213d00),
+/* 3682 */ make_floatx80_init(0x6fc6, 0xa1ee9f7610a98c3f),
+/* 3683 */ make_floatx80_init(0x6fc9, 0xca6a475394d3ef4f),
+/* 3684 */ make_floatx80_init(0x6fcc, 0xfd04d9287a08eb23),
+/* 3685 */ make_floatx80_init(0x6fd0, 0x9e2307b94c4592f6),
+/* 3686 */ make_floatx80_init(0x6fd3, 0xc5abc9a79f56f7b3),
+/* 3687 */ make_floatx80_init(0x6fd6, 0xf716bc11872cb5a0),
+/* 3688 */ make_floatx80_init(0x6fda, 0x9a6e358af47bf184),
+/* 3689 */ make_floatx80_init(0x6fdd, 0xc109c2edb19aede5),
+/* 3690 */ make_floatx80_init(0x6fe0, 0xf14c33a91e01a95e),
+/* 3691 */ make_floatx80_init(0x6fe4, 0x96cfa049b2c109db),
+/* 3692 */ make_floatx80_init(0x6fe7, 0xbc83885c1f714c52),
+/* 3693 */ make_floatx80_init(0x6fea, 0xeba46a73274d9f66),
+/* 3694 */ make_floatx80_init(0x6fee, 0x9346c287f89083a0),
+/* 3695 */ make_floatx80_init(0x6ff1, 0xb8187329f6b4a488),
+/* 3696 */ make_floatx80_init(0x6ff4, 0xe61e8ff47461cdaa),
+/* 3697 */ make_floatx80_init(0x6ff8, 0x8fd319f8c8bd208a),
+/* 3698 */ make_floatx80_init(0x6ffb, 0xb3c7e076faec68ad),
+/* 3699 */ make_floatx80_init(0x6ffe, 0xe0b9d894b9a782d8),
+/* 3700 */ make_floatx80_init(0x7002, 0x8c74275cf408b1c7),
+/* 3701 */ make_floatx80_init(0x7005, 0xaf913134310ade39),
+/* 3702 */ make_floatx80_init(0x7008, 0xdb757d813d4d95c7),
+/* 3703 */ make_floatx80_init(0x700c, 0x89296e70c6507d9c),
+/* 3704 */ make_floatx80_init(0x700f, 0xab73ca0cf7e49d03),
+/* 3705 */ make_floatx80_init(0x7012, 0xd650bc9035ddc444),
+/* 3706 */ make_floatx80_init(0x7016, 0x85f275da21aa9aab),
+/* 3707 */ make_floatx80_init(0x7019, 0xa76f1350aa154155),
+/* 3708 */ make_floatx80_init(0x701c, 0xd14ad824d49a91ab),
+/* 3709 */ make_floatx80_init(0x7020, 0x82cec71704e09b0b),
+/* 3710 */ make_floatx80_init(0x7023, 0xa38278dcc618c1cd),
+/* 3711 */ make_floatx80_init(0x7026, 0xcc631713f79ef241),
+/* 3712 */ make_floatx80_init(0x7029, 0xff7bdcd8f586aed1),
+/* 3713 */ make_floatx80_init(0x702d, 0x9fad6a0799742d42),
+/* 3714 */ make_floatx80_init(0x7030, 0xc798c4897fd13893),
+/* 3715 */ make_floatx80_init(0x7033, 0xf97ef5abdfc586b8),
+/* 3716 */ make_floatx80_init(0x7037, 0x9bef598b6bdb7433),
+/* 3717 */ make_floatx80_init(0x703a, 0xc2eb2fee46d25140),
+/* 3718 */ make_floatx80_init(0x703d, 0xf3a5fbe9d886e590),
+/* 3719 */ make_floatx80_init(0x7041, 0x9847bd7227544f7a),
+/* 3720 */ make_floatx80_init(0x7044, 0xbe59acceb1296358),
+/* 3721 */ make_floatx80_init(0x7047, 0xedf018025d73bc2e),
+/* 3722 */ make_floatx80_init(0x704b, 0x94b60f017a68559d),
+/* 3723 */ make_floatx80_init(0x704e, 0xb9e392c1d9026b04),
+/* 3724 */ make_floatx80_init(0x7051, 0xe85c77724f4305c5),
+/* 3725 */ make_floatx80_init(0x7055, 0x9139caa77189e39b),
+/* 3726 */ make_floatx80_init(0x7058, 0xb5883d514dec5c82),
+/* 3727 */ make_floatx80_init(0x705b, 0xe2ea4ca5a16773a2),
+/* 3728 */ make_floatx80_init(0x705f, 0x8dd26fe784e0a846),
+/* 3729 */ make_floatx80_init(0x7062, 0xb1470be16618d257),
+/* 3730 */ make_floatx80_init(0x7065, 0xdd98ced9bf9f06ed),
+/* 3731 */ make_floatx80_init(0x7069, 0x8a7f814817c36454),
+/* 3732 */ make_floatx80_init(0x706c, 0xad1f619a1db43d69),
+/* 3733 */ make_floatx80_init(0x706f, 0xd8673a00a5214cc3),
+/* 3734 */ make_floatx80_init(0x7073, 0x874084406734cffa),
+/* 3735 */ make_floatx80_init(0x7076, 0xa910a550810203f8),
+/* 3736 */ make_floatx80_init(0x7079, 0xd354cea4a14284f7),
+/* 3737 */ make_floatx80_init(0x707d, 0x84150126e4c9931a),
+/* 3738 */ make_floatx80_init(0x7080, 0xa51a41709dfbf7e1),
+/* 3739 */ make_floatx80_init(0x7083, 0xce60d1ccc57af5d9),
+/* 3740 */ make_floatx80_init(0x7087, 0x80fc831ffb6cd9a7),
+/* 3741 */ make_floatx80_init(0x708a, 0xa13ba3e7fa481011),
+/* 3742 */ make_floatx80_init(0x708d, 0xc98a8ce1f8da1416),
+/* 3743 */ make_floatx80_init(0x7090, 0xfbed301a7710991b),
+/* 3744 */ make_floatx80_init(0x7094, 0x9d743e108a6a5fb1),
+/* 3745 */ make_floatx80_init(0x7097, 0xc4d14d94ad04f79d),
+/* 3746 */ make_floatx80_init(0x709a, 0xf605a0f9d8463584),
+/* 3747 */ make_floatx80_init(0x709e, 0x99c3849c272be173),
+/* 3748 */ make_floatx80_init(0x70a1, 0xc03465c330f6d9cf),
+/* 3749 */ make_floatx80_init(0x70a4, 0xf0417f33fd349043),
+/* 3750 */ make_floatx80_init(0x70a8, 0x9628ef807e40da2a),
+/* 3751 */ make_floatx80_init(0x70ab, 0xbbb32b609dd110b5),
+/* 3752 */ make_floatx80_init(0x70ae, 0xea9ff638c54554e2),
+/* 3753 */ make_floatx80_init(0x70b2, 0x92a3f9e37b4b550d),
+/* 3754 */ make_floatx80_init(0x70b5, 0xb74cf85c5a1e2a50),
+/* 3755 */ make_floatx80_init(0x70b8, 0xe520367370a5b4e4),
+/* 3756 */ make_floatx80_init(0x70bc, 0x8f3422082667910f),
+/* 3757 */ make_floatx80_init(0x70bf, 0xb3012a8a30017553),
+/* 3758 */ make_floatx80_init(0x70c2, 0xdfc1752cbc01d2a7),
+/* 3759 */ make_floatx80_init(0x70c6, 0x8bd8e93bf58123a8),
+/* 3760 */ make_floatx80_init(0x70c9, 0xaecf238af2e16c93),
+/* 3761 */ make_floatx80_init(0x70cc, 0xda82ec6daf99c7b7),
+/* 3762 */ make_floatx80_init(0x70d0, 0x8891d3c48dc01cd3),
+/* 3763 */ make_floatx80_init(0x70d3, 0xaab648b5b1302407),
+/* 3764 */ make_floatx80_init(0x70d6, 0xd563dae31d7c2d09),
+/* 3765 */ make_floatx80_init(0x70da, 0x855e68cdf26d9c26),
+/* 3766 */ make_floatx80_init(0x70dd, 0xa6b603016f09032f),
+/* 3767 */ make_floatx80_init(0x70e0, 0xd06383c1cacb43fb),
+/* 3768 */ make_floatx80_init(0x70e4, 0x823e32591ebf0a7d),
+/* 3769 */ make_floatx80_init(0x70e7, 0xa2cdbeef666ecd1c),
+/* 3770 */ make_floatx80_init(0x70ea, 0xcb812eab400a8063),
+/* 3771 */ make_floatx80_init(0x70ed, 0xfe617a56100d207c),
+/* 3772 */ make_floatx80_init(0x70f1, 0x9efcec75ca08344d),
+/* 3773 */ make_floatx80_init(0x70f4, 0xc6bc27933c8a4161),
+/* 3774 */ make_floatx80_init(0x70f7, 0xf86b31780bacd1b9),
+/* 3775 */ make_floatx80_init(0x70fb, 0x9b42feeb074c0313),
+/* 3776 */ make_floatx80_init(0x70fe, 0xc213bea5c91f03d8),
+/* 3777 */ make_floatx80_init(0x7101, 0xf298ae4f3b66c4ce),
+/* 3778 */ make_floatx80_init(0x7105, 0x979f6cf185203b01),
+/* 3779 */ make_floatx80_init(0x7108, 0xbd87482de66849c1),
+/* 3780 */ make_floatx80_init(0x710b, 0xece91a3960025c31),
+/* 3781 */ make_floatx80_init(0x710f, 0x9411b063dc01799f),
+/* 3782 */ make_floatx80_init(0x7112, 0xb9161c7cd301d807),
+/* 3783 */ make_floatx80_init(0x7115, 0xe75ba39c07c24e08),
+/* 3784 */ make_floatx80_init(0x7119, 0x9099464184d970c5),
+/* 3785 */ make_floatx80_init(0x711c, 0xb4bf97d1e60fccf7),
+/* 3786 */ make_floatx80_init(0x711f, 0xe1ef7dc65f93c034),
+/* 3787 */ make_floatx80_init(0x7123, 0x8d35ae9bfbbc5821),
+/* 3788 */ make_floatx80_init(0x7126, 0xb0831a42faab6e29),
+/* 3789 */ make_floatx80_init(0x7129, 0xdca3e0d3b95649b3),
+/* 3790 */ make_floatx80_init(0x712d, 0x89e66c8453d5ee10),
+/* 3791 */ make_floatx80_init(0x7130, 0xac6007a568cb6994),
+/* 3792 */ make_floatx80_init(0x7133, 0xd778098ec2fe43f9),
+/* 3793 */ make_floatx80_init(0x7137, 0x86ab05f939deea7b),
+/* 3794 */ make_floatx80_init(0x713a, 0xa855c7778856a51a),
+/* 3795 */ make_floatx80_init(0x713d, 0xd26b39556a6c4e61),
+/* 3796 */ make_floatx80_init(0x7141, 0x838303d56283b0fd),
+/* 3797 */ make_floatx80_init(0x7144, 0xa463c4cabb249d3c),
+/* 3798 */ make_floatx80_init(0x7147, 0xcd7cb5fd69edc48b),
+/* 3799 */ make_floatx80_init(0x714b, 0x806df1be62349ad7),
+/* 3800 */ make_floatx80_init(0x714e, 0xa0896e2dfac1c18c),
+/* 3801 */ make_floatx80_init(0x7151, 0xc8abc9b9797231ef),
+/* 3802 */ make_floatx80_init(0x7154, 0xfad6bc27d7cebe6b),
+/* 3803 */ make_floatx80_init(0x7158, 0x9cc63598e6e13703),
+/* 3804 */ make_floatx80_init(0x715b, 0xc3f7c2ff209984c4),
+/* 3805 */ make_floatx80_init(0x715e, 0xf4f5b3bee8bfe5f5),
+/* 3806 */ make_floatx80_init(0x7162, 0x991990575177efb9),
+/* 3807 */ make_floatx80_init(0x7165, 0xbf5ff46d25d5eba7),
+/* 3808 */ make_floatx80_init(0x7168, 0xef37f1886f4b6691),
+/* 3809 */ make_floatx80_init(0x716c, 0x9582f6f5458f201b),
+/* 3810 */ make_floatx80_init(0x716f, 0xbae3b4b296f2e821),
+/* 3811 */ make_floatx80_init(0x7172, 0xe99ca1df3cafa22a),
+/* 3812 */ make_floatx80_init(0x7176, 0x9201e52b85edc55a),
+/* 3813 */ make_floatx80_init(0x7179, 0xb6825e76676936b0),
+/* 3814 */ make_floatx80_init(0x717c, 0xe422f6140143845d),
+/* 3815 */ make_floatx80_init(0x7180, 0x8e95d9cc80ca32ba),
+/* 3816 */ make_floatx80_init(0x7183, 0xb23b503fa0fcbf68),
+/* 3817 */ make_floatx80_init(0x7186, 0xdeca244f893bef42),
+/* 3818 */ make_floatx80_init(0x718a, 0x8b3e56b1b5c5758a),
+/* 3819 */ make_floatx80_init(0x718d, 0xae0dec5e2336d2ec),
+/* 3820 */ make_floatx80_init(0x7190, 0xd9916775ac0487a7),
+/* 3821 */ make_floatx80_init(0x7194, 0x87fae0a98b82d4c8),
+/* 3822 */ make_floatx80_init(0x7197, 0xa9f998d3ee6389fa),
+/* 3823 */ make_floatx80_init(0x719a, 0xd477ff08e9fc6c79),
+/* 3824 */ make_floatx80_init(0x719e, 0x84caff65923dc3cc),
+/* 3825 */ make_floatx80_init(0x71a1, 0xa5fdbf3ef6cd34be),
+/* 3826 */ make_floatx80_init(0x71a4, 0xcf7d2f0eb48081ee),
+/* 3827 */ make_floatx80_init(0x71a8, 0x81ae3d6930d05135),
+/* 3828 */ make_floatx80_init(0x71ab, 0xa219ccc37d046582),
+/* 3829 */ make_floatx80_init(0x71ae, 0xcaa03ff45c457ee3),
+/* 3830 */ make_floatx80_init(0x71b1, 0xfd484ff17356de9b),
+/* 3831 */ make_floatx80_init(0x71b5, 0x9e4d31f6e8164b21),
+/* 3832 */ make_floatx80_init(0x71b8, 0xc5e07e74a21bdde9),
+/* 3833 */ make_floatx80_init(0x71bb, 0xf7589e11caa2d564),
+/* 3834 */ make_floatx80_init(0x71bf, 0x9a9762cb1ea5c55e),
+/* 3835 */ make_floatx80_init(0x71c2, 0xc13d3b7de64f36b6),
+/* 3836 */ make_floatx80_init(0x71c5, 0xf18c8a5d5fe30463),
+/* 3837 */ make_floatx80_init(0x71c9, 0x96f7d67a5bede2be),
+/* 3838 */ make_floatx80_init(0x71cc, 0xbcb5cc18f2e95b6e),
+/* 3839 */ make_floatx80_init(0x71cf, 0xebe33f1f2fa3b249),
+/* 3840 */ make_floatx80_init(0x71d3, 0x936e07737dc64f6e),
+/* 3841 */ make_floatx80_init(0x71d6, 0xb84989505d37e349),
+/* 3842 */ make_floatx80_init(0x71d9, 0xe65beba47485dc1b),
+/* 3843 */ make_floatx80_init(0x71dd, 0x8ff97346c8d3a991),
+/* 3844 */ make_floatx80_init(0x71e0, 0xb3f7d0187b0893f5),
+/* 3845 */ make_floatx80_init(0x71e3, 0xe0f5c41e99cab8f3),
+/* 3846 */ make_floatx80_init(0x71e7, 0x8c999a93201eb398),
+/* 3847 */ make_floatx80_init(0x71ea, 0xafc00137e826607d),
+/* 3848 */ make_floatx80_init(0x71ed, 0xdbb00185e22ff89d),
+/* 3849 */ make_floatx80_init(0x71f1, 0x894e00f3ad5dfb62),
+/* 3850 */ make_floatx80_init(0x71f4, 0xaba1813098b57a3b),
+/* 3851 */ make_floatx80_init(0x71f7, 0xd689e17cbee2d8c9),
+/* 3852 */ make_floatx80_init(0x71fb, 0x86162cedf74dc77e),
+/* 3853 */ make_floatx80_init(0x71fe, 0xa79bb8297521395d),
+/* 3854 */ make_floatx80_init(0x7201, 0xd182a633d26987b4),
+/* 3855 */ make_floatx80_init(0x7205, 0x82f1a7e06381f4d1),
+/* 3856 */ make_floatx80_init(0x7208, 0xa3ae11d87c627205),
+/* 3857 */ make_floatx80_init(0x720b, 0xcc99964e9b7b0e86),
+/* 3858 */ make_floatx80_init(0x720e, 0xffbffbe24259d228),
+/* 3859 */ make_floatx80_init(0x7212, 0x9fd7fd6d69782359),
+/* 3860 */ make_floatx80_init(0x7215, 0xc7cdfcc8c3d62c2f),
+/* 3861 */ make_floatx80_init(0x7218, 0xf9c17bfaf4cbb73b),
+/* 3862 */ make_floatx80_init(0x721c, 0x9c18ed7cd8ff5285),
+/* 3863 */ make_floatx80_init(0x721f, 0xc31f28dc0f3f2726),
+/* 3864 */ make_floatx80_init(0x7222, 0xf3e6f313130ef0ef),
+/* 3865 */ make_floatx80_init(0x7226, 0x987057ebebe95696),
+/* 3866 */ make_floatx80_init(0x7229, 0xbe8c6de6e6e3ac3b),
+/* 3867 */ make_floatx80_init(0x722c, 0xee2f8960a09c974a),
+/* 3868 */ make_floatx80_init(0x7230, 0x94ddb5dc6461de8e),
+/* 3869 */ make_floatx80_init(0x7233, 0xba1523537d7a5632),
+/* 3870 */ make_floatx80_init(0x7236, 0xe89a6c285cd8ebbe),
+/* 3871 */ make_floatx80_init(0x723a, 0x916083993a079357),
+/* 3872 */ make_floatx80_init(0x723d, 0xb5b8a47f8889782d),
+/* 3873 */ make_floatx80_init(0x7240, 0xe326cd9f6aabd638),
+/* 3874 */ make_floatx80_init(0x7244, 0x8df84083a2ab65e3),
+/* 3875 */ make_floatx80_init(0x7247, 0xb17650a48b563f5b),
+/* 3876 */ make_floatx80_init(0x724a, 0xddd3e4cdae2bcf32),
+/* 3877 */ make_floatx80_init(0x724e, 0x8aa46f008cdb617f),
+/* 3878 */ make_floatx80_init(0x7251, 0xad4d8ac0b01239df),
+/* 3879 */ make_floatx80_init(0x7254, 0xd8a0ed70dc16c857),
+/* 3880 */ make_floatx80_init(0x7258, 0x87649466898e3d36),
+/* 3881 */ make_floatx80_init(0x725b, 0xa93db9802bf1cc84),
+/* 3882 */ make_floatx80_init(0x725e, 0xd38d27e036ee3fa5),
+/* 3883 */ make_floatx80_init(0x7262, 0x843838ec2254e7c7),
+/* 3884 */ make_floatx80_init(0x7265, 0xa54647272aea21b9),
+/* 3885 */ make_floatx80_init(0x7268, 0xce97d8f0f5a4aa27),
+/* 3886 */ make_floatx80_init(0x726c, 0x811ee7969986ea59),
+/* 3887 */ make_floatx80_init(0x726f, 0xa166a17c3fe8a4ef),
+/* 3888 */ make_floatx80_init(0x7272, 0xc9c049db4fe2ce2a),
+/* 3889 */ make_floatx80_init(0x7275, 0xfc305c5223db81b5),
+/* 3890 */ make_floatx80_init(0x7279, 0x9d9e39b356693111),
+/* 3891 */ make_floatx80_init(0x727c, 0xc505c8202c037d55),
+/* 3892 */ make_floatx80_init(0x727f, 0xf6473a2837045cab),
+/* 3893 */ make_floatx80_init(0x7283, 0x99ec84592262b9eb),
+/* 3894 */ make_floatx80_init(0x7286, 0xc067a56f6afb6865),
+/* 3895 */ make_floatx80_init(0x7289, 0xf0818ecb45ba427f),
+/* 3896 */ make_floatx80_init(0x728d, 0x9650f93f0b94698f),
+/* 3897 */ make_floatx80_init(0x7290, 0xbbe5378ece7983f3),
+/* 3898 */ make_floatx80_init(0x7293, 0xeade85728217e4f0),
+/* 3899 */ make_floatx80_init(0x7297, 0x92cb1367914eef16),
+/* 3900 */ make_floatx80_init(0x729a, 0xb77dd84175a2aadb),
+/* 3901 */ make_floatx80_init(0x729d, 0xe55d4e51d30b5592),
+/* 3902 */ make_floatx80_init(0x72a1, 0x8f5a50f323e7157b),
+/* 3903 */ make_floatx80_init(0x72a4, 0xb330e52fece0dada),
+/* 3904 */ make_floatx80_init(0x72a7, 0xdffd1e7be8191191),
+/* 3905 */ make_floatx80_init(0x72ab, 0x8bfe330d710faafa),
+/* 3906 */ make_floatx80_init(0x72ae, 0xaefdbfd0cd5395b9),
+/* 3907 */ make_floatx80_init(0x72b1, 0xdabd2fc500a87b27),
+/* 3908 */ make_floatx80_init(0x72b5, 0x88b63ddb20694cf9),
+/* 3909 */ make_floatx80_init(0x72b8, 0xaae3cd51e883a037),
+/* 3910 */ make_floatx80_init(0x72bb, 0xd59cc0a662a48844),
+/* 3911 */ make_floatx80_init(0x72bf, 0x8581f867fda6d52b),
+/* 3912 */ make_floatx80_init(0x72c2, 0xa6e27681fd108a75),
+/* 3913 */ make_floatx80_init(0x72c5, 0xd09b14227c54ad13),
+/* 3914 */ make_floatx80_init(0x72c9, 0x8260ec958db4ec2c),
+/* 3915 */ make_floatx80_init(0x72cc, 0xa2f927baf1222737),
+/* 3916 */ make_floatx80_init(0x72cf, 0xcbb771a9ad6ab104),
+/* 3917 */ make_floatx80_init(0x72d2, 0xfea54e1418c55d45),
+/* 3918 */ make_floatx80_init(0x72d6, 0x9f2750cc8f7b5a4b),
+/* 3919 */ make_floatx80_init(0x72d9, 0xc6f124ffb35a30de),
+/* 3920 */ make_floatx80_init(0x72dc, 0xf8ad6e3fa030bd16),
+/* 3921 */ make_floatx80_init(0x72e0, 0x9b6c64e7c41e762e),
+/* 3922 */ make_floatx80_init(0x72e3, 0xc2477e21b52613b9),
+/* 3923 */ make_floatx80_init(0x72e6, 0xf2d95daa226f98a7),
+/* 3924 */ make_floatx80_init(0x72ea, 0x97c7da8a5585bf69),
+/* 3925 */ make_floatx80_init(0x72ed, 0xbdb9d12ceae72f43),
+/* 3926 */ make_floatx80_init(0x72f0, 0xed28457825a0fb13),
+/* 3927 */ make_floatx80_init(0x72f4, 0x94392b6b17849cec),
+/* 3928 */ make_floatx80_init(0x72f7, 0xb9477645dd65c427),
+/* 3929 */ make_floatx80_init(0x72fa, 0xe79953d754bf3531),
+/* 3930 */ make_floatx80_init(0x72fe, 0x90bfd46694f7813f),
+/* 3931 */ make_floatx80_init(0x7301, 0xb4efc9803a35618e),
+/* 3932 */ make_floatx80_init(0x7304, 0xe22bbbe048c2b9f2),
+/* 3933 */ make_floatx80_init(0x7308, 0x8d5b556c2d79b437),
+/* 3934 */ make_floatx80_init(0x730b, 0xb0b22ac738d82145),
+/* 3935 */ make_floatx80_init(0x730e, 0xdcdeb579070e2996),
+/* 3936 */ make_floatx80_init(0x7312, 0x8a0b316ba468d9fe),
+/* 3937 */ make_floatx80_init(0x7315, 0xac8dfdc68d83107d),
+/* 3938 */ make_floatx80_init(0x7318, 0xd7b17d3830e3d49d),
+/* 3939 */ make_floatx80_init(0x731c, 0x86ceee431e8e64e2),
+/* 3940 */ make_floatx80_init(0x731f, 0xa882a9d3e631fe1a),
+/* 3941 */ make_floatx80_init(0x7322, 0xd2a35448dfbe7da1),
+/* 3942 */ make_floatx80_init(0x7326, 0x83a614ad8bd70e85),
+/* 3943 */ make_floatx80_init(0x7329, 0xa48f99d8eeccd226),
+/* 3944 */ make_floatx80_init(0x732c, 0xcdb3804f2a8006af),
+/* 3945 */ make_floatx80_init(0x7330, 0x809030317a90042d),
+/* 3946 */ make_floatx80_init(0x7333, 0xa0b43c3dd9340539),
+/* 3947 */ make_floatx80_init(0x7336, 0xc8e14b4d4f810687),
+/* 3948 */ make_floatx80_init(0x7339, 0xfb199e20a3614829),
+/* 3949 */ make_floatx80_init(0x733d, 0x9cf002d4661ccd19),
+/* 3950 */ make_floatx80_init(0x7340, 0xc42c03897fa40060),
+/* 3951 */ make_floatx80_init(0x7343, 0xf537046bdf8d0078),
+/* 3952 */ make_floatx80_init(0x7347, 0x994262c36bb8204b),
+/* 3953 */ make_floatx80_init(0x734a, 0xbf92fb7446a6285e),
+/* 3954 */ make_floatx80_init(0x734d, 0xef77ba51584fb275),
+/* 3955 */ make_floatx80_init(0x7351, 0x95aad472d731cf89),
+/* 3956 */ make_floatx80_init(0x7354, 0xbb15898f8cfe436b),
+/* 3957 */ make_floatx80_init(0x7357, 0xe9daebf3703dd446),
+/* 3958 */ make_floatx80_init(0x735b, 0x9228d3782626a4ac),
+/* 3959 */ make_floatx80_init(0x735e, 0xb6b308562fb04dd7),
+/* 3960 */ make_floatx80_init(0x7361, 0xe45fca6bbb9c614d),
+/* 3961 */ make_floatx80_init(0x7365, 0x8ebbde835541bcd0),
+/* 3962 */ make_floatx80_init(0x7368, 0xb26ad6242a922c04),
+/* 3963 */ make_floatx80_init(0x736b, 0xdf058bad3536b705),
+/* 3964 */ make_floatx80_init(0x736f, 0x8b63774c41423263),
+/* 3965 */ make_floatx80_init(0x7372, 0xae3c551f5192befc),
+/* 3966 */ make_floatx80_init(0x7375, 0xd9cb6a6725f76ebb),
+/* 3967 */ make_floatx80_init(0x7379, 0x881f228077baa535),
+/* 3968 */ make_floatx80_init(0x737c, 0xaa26eb2095a94e82),
+/* 3969 */ make_floatx80_init(0x737f, 0xd4b0a5e8bb13a222),
+/* 3970 */ make_floatx80_init(0x7383, 0x84ee67b174ec4555),
+/* 3971 */ make_floatx80_init(0x7386, 0xa62a019dd22756ab),
+/* 3972 */ make_floatx80_init(0x7389, 0xcfb4820546b12c56),
+/* 3973 */ make_floatx80_init(0x738d, 0x81d0d1434c2ebbb5),
+/* 3974 */ make_floatx80_init(0x7390, 0xa24505941f3a6aa3),
+/* 3975 */ make_floatx80_init(0x7393, 0xcad646f92709054c),
+/* 3976 */ make_floatx80_init(0x7396, 0xfd8bd8b770cb469e),
+/* 3977 */ make_floatx80_init(0x739a, 0x9e776772a67f0c23),
+/* 3978 */ make_floatx80_init(0x739d, 0xc615414f501ecf2c),
+/* 3979 */ make_floatx80_init(0x73a0, 0xf79a91a3242682f7),
+/* 3980 */ make_floatx80_init(0x73a4, 0x9ac09b05f69811da),
+/* 3981 */ make_floatx80_init(0x73a7, 0xc170c1c7743e1651),
+/* 3982 */ make_floatx80_init(0x73aa, 0xf1ccf239514d9be5),
+/* 3983 */ make_floatx80_init(0x73ae, 0x97201763d2d0816f),
+/* 3984 */ make_floatx80_init(0x73b1, 0xbce81d3cc784a1cb),
+/* 3985 */ make_floatx80_init(0x73b4, 0xec22248bf965ca3e),
+/* 3986 */ make_floatx80_init(0x73b8, 0x939556d77bdf9e66),
+/* 3987 */ make_floatx80_init(0x73bb, 0xb87aac8d5ad78600),
+/* 3988 */ make_floatx80_init(0x73be, 0xe69957b0b18d6780),
+/* 3989 */ make_floatx80_init(0x73c2, 0x901fd6ce6ef860b0),
+/* 3990 */ make_floatx80_init(0x73c5, 0xb427cc820ab678dc),
+/* 3991 */ make_floatx80_init(0x73c8, 0xe131bfa28d641713),
+/* 3992 */ make_floatx80_init(0x73cc, 0x8cbf17c5985e8e6c),
+/* 3993 */ make_floatx80_init(0x73cf, 0xafeeddb6fe763207),
+/* 3994 */ make_floatx80_init(0x73d2, 0xdbea9524be13be89),
+/* 3995 */ make_floatx80_init(0x73d6, 0x89729d36f6cc5715),
+/* 3996 */ make_floatx80_init(0x73d9, 0xabcf4484b47f6cdb),
+/* 3997 */ make_floatx80_init(0x73dc, 0xd6c315a5e19f4811),
+/* 3998 */ make_floatx80_init(0x73e0, 0x8639ed87ad038d0b),
+/* 3999 */ make_floatx80_init(0x73e3, 0xa7c868e99844704e),
+/* 4000 */ make_floatx80_init(0x73e6, 0xd1ba8323fe558c61),
+/* 4001 */ make_floatx80_init(0x73ea, 0x831491f67ef577bd),
+/* 4002 */ make_floatx80_init(0x73ed, 0xa3d9b6741eb2d5ac),
+/* 4003 */ make_floatx80_init(0x73f0, 0xccd02411265f8b17),
+/* 4004 */ make_floatx80_init(0x73f4, 0x8002168ab7fbb6ee),
+/* 4005 */ make_floatx80_init(0x73f7, 0xa0029c2d65faa4aa),
+/* 4006 */ make_floatx80_init(0x73fa, 0xc8034338bf794dd4),
+/* 4007 */ make_floatx80_init(0x73fd, 0xfa041406ef57a149),
+/* 4008 */ make_floatx80_init(0x7401, 0x9c428c845596c4ce),
+/* 4009 */ make_floatx80_init(0x7404, 0xc3532fa56afc7601),
+/* 4010 */ make_floatx80_init(0x7407, 0xf427fb8ec5bb9382),
+/* 4011 */ make_floatx80_init(0x740b, 0x9898fd393b953c31),
+/* 4012 */ make_floatx80_init(0x740e, 0xbebf3c878a7a8b3d),
+/* 4013 */ make_floatx80_init(0x7411, 0xee6f0ba96d192e0d),
+/* 4014 */ make_floatx80_init(0x7415, 0x95056749e42fbcc8),
+/* 4015 */ make_floatx80_init(0x7418, 0xba46c11c5d3babfa),
+/* 4016 */ make_floatx80_init(0x741b, 0xe8d87163748a96f8),
+/* 4017 */ make_floatx80_init(0x741f, 0x918746de28d69e5b),
+/* 4018 */ make_floatx80_init(0x7422, 0xb5e91895b30c45f2),
+/* 4019 */ make_floatx80_init(0x7425, 0xe3635ebb1fcf576e),
+/* 4020 */ make_floatx80_init(0x7429, 0x8e1e1b34f3e196a5),
+/* 4021 */ make_floatx80_init(0x742c, 0xb1a5a20230d9fc4e),
+/* 4022 */ make_floatx80_init(0x742f, 0xde0f0a82bd107b62),
+/* 4023 */ make_floatx80_init(0x7433, 0x8ac96691b62a4d1d),
+/* 4024 */ make_floatx80_init(0x7436, 0xad7bc03623b4e064),
+/* 4025 */ make_floatx80_init(0x7439, 0xd8dab043aca2187e),
+/* 4026 */ make_floatx80_init(0x743d, 0x8788ae2a4be54f4e),
+/* 4027 */ make_floatx80_init(0x7440, 0xa96ad9b4dedea322),
+/* 4028 */ make_floatx80_init(0x7443, 0xd3c5902216964beb),
+/* 4029 */ make_floatx80_init(0x7447, 0x845b7a154e1def73),
+/* 4030 */ make_floatx80_init(0x744a, 0xa572589aa1a56b4f),
+/* 4031 */ make_floatx80_init(0x744d, 0xceceeec14a0ec623),
+/* 4032 */ make_floatx80_init(0x7451, 0x81415538ce493bd6),
+/* 4033 */ make_floatx80_init(0x7454, 0xa191aa8701db8acb),
+/* 4034 */ make_floatx80_init(0x7457, 0xc9f61528c2526d7e),
+/* 4035 */ make_floatx80_init(0x745a, 0xfc739a72f2e708de),
+/* 4036 */ make_floatx80_init(0x745e, 0x9dc84087d7d0658b),
+/* 4037 */ make_floatx80_init(0x7461, 0xc53a50a9cdc47eed),
+/* 4038 */ make_floatx80_init(0x7464, 0xf688e4d441359ea9),
+/* 4039 */ make_floatx80_init(0x7468, 0x9a158f04a8c18329),
+/* 4040 */ make_floatx80_init(0x746b, 0xc09af2c5d2f1e3f4),
+/* 4041 */ make_floatx80_init(0x746e, 0xf0c1af7747ae5cf1),
+/* 4042 */ make_floatx80_init(0x7472, 0x96790daa8cccfa16),
+/* 4043 */ make_floatx80_init(0x7475, 0xbc1751153000389c),
+/* 4044 */ make_floatx80_init(0x7478, 0xeb1d255a7c0046c3),
+/* 4045 */ make_floatx80_init(0x747c, 0x92f237588d802c3a),
+/* 4046 */ make_floatx80_init(0x747f, 0xb7aec52eb0e03748),
+/* 4047 */ make_floatx80_init(0x7482, 0xe59a767a5d18451a),
+/* 4048 */ make_floatx80_init(0x7486, 0x8f808a0c7a2f2b31),
+/* 4049 */ make_floatx80_init(0x7489, 0xb360ac8f98baf5fd),
+/* 4050 */ make_floatx80_init(0x748c, 0xe038d7b37ee9b37c),
+/* 4051 */ make_floatx80_init(0x7490, 0x8c2386d02f52102d),
+/* 4052 */ make_floatx80_init(0x7493, 0xaf2c68843b269439),
+/* 4053 */ make_floatx80_init(0x7496, 0xdaf782a549f03947),
+/* 4054 */ make_floatx80_init(0x749a, 0x88dab1a74e3623cc),
+/* 4055 */ make_floatx80_init(0x749d, 0xab115e1121c3acbf),
+/* 4056 */ make_floatx80_init(0x74a0, 0xd5d5b5956a3497ef),
+/* 4057 */ make_floatx80_init(0x74a4, 0x85a5917d6260def6),
+/* 4058 */ make_floatx80_init(0x74a7, 0xa70ef5dcbaf916b3),
+/* 4059 */ make_floatx80_init(0x74aa, 0xd0d2b353e9b75c60),
+/* 4060 */ make_floatx80_init(0x74ae, 0x8283b014721299bc),
+/* 4061 */ make_floatx80_init(0x74b1, 0xa3249c198e97402b),
+/* 4062 */ make_floatx80_init(0x74b4, 0xcbedc31ff23d1035),
+/* 4063 */ make_floatx80_init(0x74b7, 0xfee933e7eecc5443),
+/* 4064 */ make_floatx80_init(0x74bb, 0x9f51c070f53fb4aa),
+/* 4065 */ make_floatx80_init(0x74be, 0xc726308d328fa1d4),
+/* 4066 */ make_floatx80_init(0x74c1, 0xf8efbcb07f338a49),
+/* 4067 */ make_floatx80_init(0x74c5, 0x9b95d5ee4f80366e),
+/* 4068 */ make_floatx80_init(0x74c8, 0xc27b4b69e3604409),
+/* 4069 */ make_floatx80_init(0x74cb, 0xf31a1e445c38550c),
+/* 4070 */ make_floatx80_init(0x74cf, 0x97f052eab9a33527),
+/* 4071 */ make_floatx80_init(0x74d2, 0xbdec67a5680c0271),
+/* 4072 */ make_floatx80_init(0x74d5, 0xed67818ec20f030d),
+/* 4073 */ make_floatx80_init(0x74d9, 0x9460b0f9394961e8),
+/* 4074 */ make_floatx80_init(0x74dc, 0xb978dd37879bba62),
+/* 4075 */ make_floatx80_init(0x74df, 0xe7d714856982a8fb),
+/* 4076 */ make_floatx80_init(0x74e3, 0x90e66cd361f1a99d),
+/* 4077 */ make_floatx80_init(0x74e6, 0xb52008083a6e1404),
+/* 4078 */ make_floatx80_init(0x74e9, 0xe2680a0a49099905),
+/* 4079 */ make_floatx80_init(0x74ed, 0x8d8106466da5ffa3),
+/* 4080 */ make_floatx80_init(0x74f0, 0xb0e147d8090f7f8c),
+/* 4081 */ make_floatx80_init(0x74f3, 0xdd1999ce0b535f6f),
+/* 4082 */ make_floatx80_init(0x74f7, 0x8a300020c7141ba5),
+/* 4083 */ make_floatx80_init(0x74fa, 0xacbc0028f8d9228f),
+/* 4084 */ make_floatx80_init(0x74fd, 0xd7eb0033370f6b32),
+/* 4085 */ make_floatx80_init(0x7501, 0x86f2e0200269a2ff),
+/* 4086 */ make_floatx80_init(0x7504, 0xa8af982803040bbf),
+/* 4087 */ make_floatx80_init(0x7507, 0xd2db7e3203c50eaf),
+/* 4088 */ make_floatx80_init(0x750b, 0x83c92edf425b292d),
+/* 4089 */ make_floatx80_init(0x750e, 0xa4bb7a9712f1f379),
+/* 4090 */ make_floatx80_init(0x7511, 0xcdea593cd7ae7057),
+/* 4091 */ make_floatx80_init(0x7515, 0x80b277c606cd0636),
+/* 4092 */ make_floatx80_init(0x7518, 0xa0df15b7888047c4),
+/* 4093 */ make_floatx80_init(0x751b, 0xc916db256aa059b5),
+/* 4094 */ make_floatx80_init(0x751e, 0xfb5c91eec5487022),
+/* 4095 */ make_floatx80_init(0x7522, 0x9d19db353b4d4615),
+/* 4096 */ make_floatx80_init(0x7525, 0xc46052028a20979b),
+/* 4097 */ make_floatx80_init(0x7528, 0xf57866832ca8bd81),
+/* 4098 */ make_floatx80_init(0x752c, 0x996b4011fbe97671),
+/* 4099 */ make_floatx80_init(0x752f, 0xbfc610167ae3d40d),
+/* 4100 */ make_floatx80_init(0x7532, 0xefb7941c199cc910),
+/* 4101 */ make_floatx80_init(0x7536, 0x95d2bc919001fdaa),
+/* 4102 */ make_floatx80_init(0x7539, 0xbb476bb5f4027d15),
+/* 4103 */ make_floatx80_init(0x753c, 0xea1946a371031c5a),
+/* 4104 */ make_floatx80_init(0x7540, 0x924fcc2626a1f1b8),
+/* 4105 */ make_floatx80_init(0x7543, 0xb6e3bf2fb04a6e26),
+/* 4106 */ make_floatx80_init(0x7546, 0xe49caefb9c5d09b0),
+/* 4107 */ make_floatx80_init(0x754a, 0x8ee1ed5d41ba260e),
+/* 4108 */ make_floatx80_init(0x754d, 0xb29a68b49228af91),
+/* 4109 */ make_floatx80_init(0x7550, 0xdf4102e1b6b2db76),
+/* 4110 */ make_floatx80_init(0x7554, 0x8b88a1cd122fc92a),
+/* 4111 */ make_floatx80_init(0x7557, 0xae6aca4056bbbb74),
+/* 4112 */ make_floatx80_init(0x755a, 0xda057cd06c6aaa51),
+/* 4113 */ make_floatx80_init(0x755e, 0x88436e0243c2aa73),
+/* 4114 */ make_floatx80_init(0x7561, 0xaa544982d4b3550f),
+/* 4115 */ make_floatx80_init(0x7564, 0xd4e95be389e02a53),
+/* 4116 */ make_floatx80_init(0x7568, 0x8511d96e362c1a74),
+/* 4117 */ make_floatx80_init(0x756b, 0xa6564fc9c3b72111),
+/* 4118 */ make_floatx80_init(0x756e, 0xcfebe3bc34a4e955),
+/* 4119 */ make_floatx80_init(0x7572, 0x81f36e55a0e711d5),
+/* 4120 */ make_floatx80_init(0x7575, 0xa27049eb0920d64b),
+/* 4121 */ make_floatx80_init(0x7578, 0xcb0c5c65cb690bdd),
+/* 4122 */ make_floatx80_init(0x757b, 0xfdcf737f3e434ed5),
+/* 4123 */ make_floatx80_init(0x757f, 0x9ea1a82f86ea1145),
+/* 4124 */ make_floatx80_init(0x7582, 0xc64a123b68a49596),
+/* 4125 */ make_floatx80_init(0x7585, 0xf7dc96ca42cdbafc),
+/* 4126 */ make_floatx80_init(0x7589, 0x9ae9de3e69c094dd),
+/* 4127 */ make_floatx80_init(0x758c, 0xc1a455ce0430ba15),
+/* 4128 */ make_floatx80_init(0x758f, 0xf20d6b41853ce89a),
+/* 4129 */ make_floatx80_init(0x7593, 0x97486308f3461160),
+/* 4130 */ make_floatx80_init(0x7596, 0xbd1a7bcb301795b8),
+/* 4131 */ make_floatx80_init(0x7599, 0xec611abdfc1d7b26),
+/* 4132 */ make_floatx80_init(0x759d, 0x93bcb0b6bd926cf8),
+/* 4133 */ make_floatx80_init(0x75a0, 0xb8abdce46cf70836),
+/* 4134 */ make_floatx80_init(0x75a3, 0xe6d6d41d8834ca43),
+/* 4135 */ make_floatx80_init(0x75a7, 0x904644927520fe6a),
+/* 4136 */ make_floatx80_init(0x75aa, 0xb457d5b712693e04),
+/* 4137 */ make_floatx80_init(0x75ad, 0xe16dcb24d7038d86),
+/* 4138 */ make_floatx80_init(0x75b1, 0x8ce49ef706623873),
+/* 4139 */ make_floatx80_init(0x75b4, 0xb01dc6b4c7fac690),
+/* 4140 */ make_floatx80_init(0x75b7, 0xdc253861f9f97834),
+/* 4141 */ make_floatx80_init(0x75bb, 0x8997433d3c3beb21),
+/* 4142 */ make_floatx80_init(0x75be, 0xabfd140c8b4ae5e9),
+/* 4143 */ make_floatx80_init(0x75c1, 0xd6fc590fae1d9f63),
+/* 4144 */ make_floatx80_init(0x75c5, 0x865db7a9ccd2839e),
+/* 4145 */ make_floatx80_init(0x75c8, 0xa7f5259440072486),
+/* 4146 */ make_floatx80_init(0x75cb, 0xd1f26ef95008eda7),
+/* 4147 */ make_floatx80_init(0x75cf, 0x8337855bd2059488),
+/* 4148 */ make_floatx80_init(0x75d2, 0xa40566b2c686f9aa),
+/* 4149 */ make_floatx80_init(0x75d5, 0xcd06c05f7828b815),
+/* 4150 */ make_floatx80_init(0x75d9, 0x8024383bab19730d),
+/* 4151 */ make_floatx80_init(0x75dc, 0xa02d464a95dfcfd0),
+/* 4152 */ make_floatx80_init(0x75df, 0xc83897dd3b57c3c4),
+/* 4153 */ make_floatx80_init(0x75e2, 0xfa46bdd48a2db4b6),
+/* 4154 */ make_floatx80_init(0x75e6, 0x9c6c36a4d65c90f2),
+/* 4155 */ make_floatx80_init(0x75e9, 0xc387444e0bf3b52e),
+/* 4156 */ make_floatx80_init(0x75ec, 0xf46915618ef0a279),
+/* 4157 */ make_floatx80_init(0x75f0, 0x98c1ad5cf956658c),
+/* 4158 */ make_floatx80_init(0x75f3, 0xbef218b437abfeef),
+/* 4159 */ make_floatx80_init(0x75f6, 0xeeae9ee14596feab),
+/* 4160 */ make_floatx80_init(0x75fa, 0x952d234ccb7e5f2b),
+/* 4161 */ make_floatx80_init(0x75fd, 0xba786c1ffe5df6f5),
+/* 4162 */ make_floatx80_init(0x7600, 0xe9168727fdf574b3),
+/* 4163 */ make_floatx80_init(0x7604, 0x91ae1478feb968f0),
+/* 4164 */ make_floatx80_init(0x7607, 0xb61999973e67c32b),
+/* 4165 */ make_floatx80_init(0x760a, 0xe39ffffd0e01b3f6),
+/* 4166 */ make_floatx80_init(0x760e, 0x8e43fffe28c1107a),
+/* 4167 */ make_floatx80_init(0x7611, 0xb1d4fffdb2f15498),
+/* 4168 */ make_floatx80_init(0x7614, 0xde4a3ffd1fada9bf),
+/* 4169 */ make_floatx80_init(0x7618, 0x8aee67fe33cc8a17),
+/* 4170 */ make_floatx80_init(0x761b, 0xadaa01fdc0bfac9d),
+/* 4171 */ make_floatx80_init(0x761e, 0xd914827d30ef97c4),
+/* 4172 */ make_floatx80_init(0x7622, 0x87acd18e3e95bedb),
+/* 4173 */ make_floatx80_init(0x7625, 0xa99805f1ce3b2e91),
+/* 4174 */ make_floatx80_init(0x7628, 0xd3fe076e41c9fa35),
+/* 4175 */ make_floatx80_init(0x762c, 0x847ec4a4e91e3c61),
+/* 4176 */ make_floatx80_init(0x762f, 0xa59e75ce2365cb7a),
+/* 4177 */ make_floatx80_init(0x7632, 0xcf061341ac3f3e58),
+/* 4178 */ make_floatx80_init(0x7636, 0x8163cc090ba786f7),
+/* 4179 */ make_floatx80_init(0x7639, 0xa1bcbf0b4e9168b5),
+/* 4180 */ make_floatx80_init(0x763c, 0xca2beece2235c2e2),
+/* 4181 */ make_floatx80_init(0x763f, 0xfcb6ea81aac3339b),
+/* 4182 */ make_floatx80_init(0x7643, 0x9df252910aba0041),
+/* 4183 */ make_floatx80_init(0x7646, 0xc56ee7354d688051),
+/* 4184 */ make_floatx80_init(0x7649, 0xf6caa102a0c2a065),
+/* 4185 */ make_floatx80_init(0x764d, 0x9a3ea4a1a479a43f),
+/* 4186 */ make_floatx80_init(0x7650, 0xc0ce4dca0d980d4f),
+/* 4187 */ make_floatx80_init(0x7653, 0xf101e13c90fe10a3),
+/* 4188 */ make_floatx80_init(0x7657, 0x96a12cc5da9eca66),
+/* 4189 */ make_floatx80_init(0x765a, 0xbc4977f751467cff),
+/* 4190 */ make_floatx80_init(0x765d, 0xeb5bd5f525981c3f),
+/* 4191 */ make_floatx80_init(0x7661, 0x931965b9377f11a7),
+/* 4192 */ make_floatx80_init(0x7664, 0xb7dfbf27855ed611),
+/* 4193 */ make_floatx80_init(0x7667, 0xe5d7aef166b68b95),
+/* 4194 */ make_floatx80_init(0x766b, 0x8fa6cd56e032173d),
+/* 4195 */ make_floatx80_init(0x766e, 0xb39080ac983e9d0d),
+/* 4196 */ make_floatx80_init(0x7671, 0xe074a0d7be4e4450),
+/* 4197 */ make_floatx80_init(0x7675, 0x8c48e486d6f0eab2),
+/* 4198 */ make_floatx80_init(0x7678, 0xaf5b1da88cad255e),
+/* 4199 */ make_floatx80_init(0x767b, 0xdb31e512afd86eb6),
+/* 4200 */ make_floatx80_init(0x767f, 0x88ff2f2bade74532),
+/* 4201 */ make_floatx80_init(0x7682, 0xab3efaf69961167e),
+/* 4202 */ make_floatx80_init(0x7685, 0xd60eb9b43fb95c1e),
+/* 4203 */ make_floatx80_init(0x7689, 0x85c93410a7d3d993),
+/* 4204 */ make_floatx80_init(0x768c, 0xa73b8114d1c8cff7),
+/* 4205 */ make_floatx80_init(0x768f, 0xd10a615a063b03f5),
+/* 4206 */ make_floatx80_init(0x7693, 0x82a67cd843e4e279),
+/* 4207 */ make_floatx80_init(0x7696, 0xa3501c0e54de1b17),
+/* 4208 */ make_floatx80_init(0x7699, 0xcc242311ea15a1dd),
+/* 4209 */ make_floatx80_init(0x769c, 0xff2d2bd6649b0a55),
+/* 4210 */ make_floatx80_init(0x76a0, 0x9f7c3b65fee0e675),
+/* 4211 */ make_floatx80_init(0x76a3, 0xc75b4a3f7e992012),
+/* 4212 */ make_floatx80_init(0x76a6, 0xf9321ccf5e3f6817),
+/* 4213 */ make_floatx80_init(0x76aa, 0x9bbf52019ae7a10e),
+/* 4214 */ make_floatx80_init(0x76ad, 0xc2af268201a18952),
+/* 4215 */ make_floatx80_init(0x76b0, 0xf35af0228209eba6),
+/* 4216 */ make_floatx80_init(0x76b4, 0x9818d61591463348),
+/* 4217 */ make_floatx80_init(0x76b7, 0xbe1f0b9af597c01a),
+/* 4218 */ make_floatx80_init(0x76ba, 0xeda6ce81b2fdb020),
+/* 4219 */ make_floatx80_init(0x76be, 0x948841110fde8e14),
+/* 4220 */ make_floatx80_init(0x76c1, 0xb9aa515553d63199),
+/* 4221 */ make_floatx80_init(0x76c4, 0xe814e5aaa8cbbe00),
+/* 4222 */ make_floatx80_init(0x76c8, 0x910d0f8aa97f56c0),
+/* 4223 */ make_floatx80_init(0x76cb, 0xb550536d53df2c70),
+/* 4224 */ make_floatx80_init(0x76ce, 0xe2a46848a8d6f78c),
+/* 4225 */ make_floatx80_init(0x76d2, 0x8da6c12d69865ab7),
+/* 4226 */ make_floatx80_init(0x76d5, 0xb1107178c3e7f165),
+/* 4227 */ make_floatx80_init(0x76d8, 0xdd548dd6f4e1edbe),
+/* 4228 */ make_floatx80_init(0x76dc, 0x8a54d8a6590d3497),
+/* 4229 */ make_floatx80_init(0x76df, 0xacea0ecfef5081bd),
+/* 4230 */ make_floatx80_init(0x76e2, 0xd8249283eb24a22c),
+/* 4231 */ make_floatx80_init(0x76e6, 0x8716db9272f6e55b),
+/* 4232 */ make_floatx80_init(0x76e9, 0xa8dc92770fb49eb2),
+/* 4233 */ make_floatx80_init(0x76ec, 0xd313b714d3a1c65f),
+/* 4234 */ make_floatx80_init(0x76f0, 0x83ec526d04451bfb),
+/* 4235 */ make_floatx80_init(0x76f3, 0xa4e76708455662fa),
+/* 4236 */ make_floatx80_init(0x76f6, 0xce2140ca56abfbb9),
+/* 4237 */ make_floatx80_init(0x76fa, 0x80d4c87e762b7d53),
+/* 4238 */ make_floatx80_init(0x76fd, 0xa109fa9e13b65ca8),
+/* 4239 */ make_floatx80_init(0x7700, 0xc94c794598a3f3d2),
+/* 4240 */ make_floatx80_init(0x7703, 0xfb9f9796feccf0c7),
+/* 4241 */ make_floatx80_init(0x7707, 0x9d43bebe5f40167c),
+/* 4242 */ make_floatx80_init(0x770a, 0xc494ae6df7101c1b),
+/* 4243 */ make_floatx80_init(0x770d, 0xf5b9da0974d42322),
+/* 4244 */ make_floatx80_init(0x7711, 0x99942845e90495f5),
+/* 4245 */ make_floatx80_init(0x7714, 0xbff932576345bb73),
+/* 4246 */ make_floatx80_init(0x7717, 0xeff77eed3c172a4f),
+/* 4247 */ make_floatx80_init(0x771b, 0x95faaf54458e7a72),
+/* 4248 */ make_floatx80_init(0x771e, 0xbb795b2956f2190e),
+/* 4249 */ make_floatx80_init(0x7721, 0xea57b1f3acae9f51),
+/* 4250 */ make_floatx80_init(0x7725, 0x9276cf384bed2393),
+/* 4251 */ make_floatx80_init(0x7728, 0xb71483065ee86c78),
+/* 4252 */ make_floatx80_init(0x772b, 0xe4d9a3c7f6a28796),
+/* 4253 */ make_floatx80_init(0x772f, 0x8f08065cfa2594bd),
+/* 4254 */ make_floatx80_init(0x7732, 0xb2ca07f438aef9ed),
+/* 4255 */ make_floatx80_init(0x7735, 0xdf7c89f146dab868),
+/* 4256 */ make_floatx80_init(0x7739, 0x8badd636cc48b341),
+/* 4257 */ make_floatx80_init(0x773c, 0xae994bc47f5ae011),
+/* 4258 */ make_floatx80_init(0x773f, 0xda3f9eb59f319816),
+/* 4259 */ make_floatx80_init(0x7743, 0x8867c331837eff0e),
+/* 4260 */ make_floatx80_init(0x7746, 0xaa81b3fde45ebed1),
+/* 4261 */ make_floatx80_init(0x7749, 0xd52220fd5d766e85),
+/* 4262 */ make_floatx80_init(0x774d, 0x8535549e5a6a0513),
+/* 4263 */ make_floatx80_init(0x7750, 0xa682a9c5f1048658),
+/* 4264 */ make_floatx80_init(0x7753, 0xd02354376d45a7ee),
+/* 4265 */ make_floatx80_init(0x7757, 0x821614a2a44b88f5),
+/* 4266 */ make_floatx80_init(0x775a, 0xa29b99cb4d5e6b32),
+/* 4267 */ make_floatx80_init(0x775d, 0xcb42803e20b605fe),
+/* 4268 */ make_floatx80_init(0x7760, 0xfe13204da8e3877e),
+/* 4269 */ make_floatx80_init(0x7764, 0x9ecbf430898e34af),
+/* 4270 */ make_floatx80_init(0x7767, 0xc67ef13cabf1c1da),
+/* 4271 */ make_floatx80_init(0x776a, 0xf81ead8bd6ee3251),
+/* 4272 */ make_floatx80_init(0x776e, 0x9b132c776654df73),
+/* 4273 */ make_floatx80_init(0x7771, 0xc1d7f7953fea174f),
+/* 4274 */ make_floatx80_init(0x7774, 0xf24df57a8fe49d23),
+/* 4275 */ make_floatx80_init(0x7778, 0x9770b96c99eee236),
+/* 4276 */ make_floatx80_init(0x777b, 0xbd4ce7c7c06a9ac3),
+/* 4277 */ make_floatx80_init(0x777e, 0xeca021b9b0854174),
+/* 4278 */ make_floatx80_init(0x7782, 0x93e415140e5348e9),
+/* 4279 */ make_floatx80_init(0x7785, 0xb8dd1a5911e81b23),
+/* 4280 */ make_floatx80_init(0x7788, 0xe71460ef566221ec),
+/* 4281 */ make_floatx80_init(0x778c, 0x906cbc9595fd5533),
+/* 4282 */ make_floatx80_init(0x778f, 0xb487ebbafb7caa80),
+/* 4283 */ make_floatx80_init(0x7792, 0xe1a9e6a9ba5bd520),
+/* 4284 */ make_floatx80_init(0x7796, 0x8d0a302a14796534),
+/* 4285 */ make_floatx80_init(0x7799, 0xb04cbc349997be81),
+/* 4286 */ make_floatx80_init(0x779c, 0xdc5feb41bffdae21),
+/* 4287 */ make_floatx80_init(0x77a0, 0x89bbf30917fe8cd5),
+/* 4288 */ make_floatx80_init(0x77a3, 0xac2aefcb5dfe300a),
+/* 4289 */ make_floatx80_init(0x77a6, 0xd735abbe357dbc0d),
+/* 4290 */ make_floatx80_init(0x77aa, 0x86818b56e16e9588),
+/* 4291 */ make_floatx80_init(0x77ad, 0xa821ee2c99ca3aea),
+/* 4292 */ make_floatx80_init(0x77b0, 0xd22a69b7c03cc9a4),
+/* 4293 */ make_floatx80_init(0x77b4, 0x835a8212d825fe07),
+/* 4294 */ make_floatx80_init(0x77b7, 0xa43122978e2f7d88),
+/* 4295 */ make_floatx80_init(0x77ba, 0xcd3d6b3d71bb5cea),
+/* 4296 */ make_floatx80_init(0x77be, 0x8046630667151a13),
+/* 4297 */ make_floatx80_init(0x77c1, 0xa057fbc800da6097),
+/* 4298 */ make_floatx80_init(0x77c4, 0xc86dfaba0110f8bd),
+/* 4299 */ make_floatx80_init(0x77c7, 0xfa897968815536ec),
+/* 4300 */ make_floatx80_init(0x77cb, 0x9c95ebe150d54254),
+/* 4301 */ make_floatx80_init(0x77ce, 0xc3bb66d9a50a92e8),
+/* 4302 */ make_floatx80_init(0x77d1, 0xf4aa40900e4d37a3),
+/* 4303 */ make_floatx80_init(0x77d5, 0x98ea685a08f042c6),
+/* 4304 */ make_floatx80_init(0x77d8, 0xbf2502708b2c5377),
+/* 4305 */ make_floatx80_init(0x77db, 0xeeee430cadf76855),
+/* 4306 */ make_floatx80_init(0x77df, 0x9554e9e7ecbaa135),
+/* 4307 */ make_floatx80_init(0x77e2, 0xbaaa2461e7e94982),
+/* 4308 */ make_floatx80_init(0x77e5, 0xe954ad7a61e39be3),
+/* 4309 */ make_floatx80_init(0x77e9, 0x91d4ec6c7d2e416e),
+/* 4310 */ make_floatx80_init(0x77ec, 0xb64a27879c79d1c9),
+/* 4311 */ make_floatx80_init(0x77ef, 0xe3dcb1698398463b),
+/* 4312 */ make_floatx80_init(0x77f3, 0x8e69eee1f23f2be5),
+/* 4313 */ make_floatx80_init(0x77f6, 0xb2046a9a6ecef6de),
+/* 4314 */ make_floatx80_init(0x77f9, 0xde8585410a82b496),
+/* 4315 */ make_floatx80_init(0x77fd, 0x8b137348a691b0de),
+/* 4316 */ make_floatx80_init(0x7800, 0xadd8501ad0361d15),
+/* 4317 */ make_floatx80_init(0x7803, 0xd94e64218443a45b),
+/* 4318 */ make_floatx80_init(0x7807, 0x87d0fe94f2aa46b9),
+/* 4319 */ make_floatx80_init(0x780a, 0xa9c53e3a2f54d867),
+/* 4320 */ make_floatx80_init(0x780d, 0xd4368dc8bb2a0e80),
+/* 4321 */ make_floatx80_init(0x7811, 0x84a2189d74fa4910),
+/* 4322 */ make_floatx80_init(0x7814, 0xa5ca9ec4d238db54),
+/* 4323 */ make_floatx80_init(0x7817, 0xcf3d467606c71229),
+/* 4324 */ make_floatx80_init(0x781b, 0x81864c09c43c6b5a),
+/* 4325 */ make_floatx80_init(0x781e, 0xa1e7df0c354b8630),
+/* 4326 */ make_floatx80_init(0x7821, 0xca61d6cf429e67bc),
+/* 4327 */ make_floatx80_init(0x7824, 0xfcfa4c83134601ac),
+/* 4328 */ make_floatx80_init(0x7828, 0x9e1c6fd1ec0bc10b),
+/* 4329 */ make_floatx80_init(0x782b, 0xc5a38bc6670eb14e),
+/* 4330 */ make_floatx80_init(0x782e, 0xf70c6eb800d25da2),
+/* 4331 */ make_floatx80_init(0x7832, 0x9a67c53300837a85),
+/* 4332 */ make_floatx80_init(0x7835, 0xc101b67fc0a45926),
+/* 4333 */ make_floatx80_init(0x7838, 0xf142241fb0cd6f70),
+/* 4334 */ make_floatx80_init(0x783c, 0x96c95693ce8065a6),
+/* 4335 */ make_floatx80_init(0x783f, 0xbc7bac38c2207f0f),
+/* 4336 */ make_floatx80_init(0x7842, 0xeb9a9746f2a89ed3),
+/* 4337 */ make_floatx80_init(0x7846, 0x93409e8c57a96344),
+/* 4338 */ make_floatx80_init(0x7849, 0xb810c62f6d93bc15),
+/* 4339 */ make_floatx80_init(0x784c, 0xe614f7bb48f8ab1a),
+/* 4340 */ make_floatx80_init(0x7850, 0x8fcd1ad50d9b6af0),
+/* 4341 */ make_floatx80_init(0x7853, 0xb3c0618a510245ac),
+/* 4342 */ make_floatx80_init(0x7856, 0xe0b079ece542d718),
+/* 4343 */ make_floatx80_init(0x785a, 0x8c6e4c340f49c66f),
+/* 4344 */ make_floatx80_init(0x785d, 0xaf89df41131c380a),
+/* 4345 */ make_floatx80_init(0x7860, 0xdb6c571157e3460d),
+/* 4346 */ make_floatx80_init(0x7864, 0x8923b66ad6ee0bc8),
+/* 4347 */ make_floatx80_init(0x7867, 0xab6ca4058ca98eba),
+/* 4348 */ make_floatx80_init(0x786a, 0xd647cd06efd3f269),
+/* 4349 */ make_floatx80_init(0x786e, 0x85ece02455e47781),
+/* 4350 */ make_floatx80_init(0x7871, 0xa768182d6b5d9562),
+/* 4351 */ make_floatx80_init(0x7874, 0xd1421e38c634faba),
+/* 4352 */ make_floatx80_init(0x7878, 0x82c952e37be11cb4),
+/* 4353 */ make_floatx80_init(0x787b, 0xa37ba79c5ad963e2),
+/* 4354 */ make_floatx80_init(0x787e, 0xcc5a9183718fbcda),
+/* 4355 */ make_floatx80_init(0x7881, 0xff7135e44df3ac10),
+/* 4356 */ make_floatx80_init(0x7885, 0x9fa6c1aeb0b84b8a),
+/* 4357 */ make_floatx80_init(0x7888, 0xc790721a5ce65e6d),
+/* 4358 */ make_floatx80_init(0x788b, 0xf9748ea0f41ff608),
+/* 4359 */ make_floatx80_init(0x788f, 0x9be8d9249893f9c5),
+/* 4360 */ make_floatx80_init(0x7892, 0xc2e30f6dbeb8f836),
+/* 4361 */ make_floatx80_init(0x7895, 0xf39bd3492e673644),
+/* 4362 */ make_floatx80_init(0x7899, 0x9841640dbd0081ea),
+/* 4363 */ make_floatx80_init(0x789c, 0xbe51bd112c40a265),
+/* 4364 */ make_floatx80_init(0x789f, 0xede62c557750cafe),
+/* 4365 */ make_floatx80_init(0x78a3, 0x94afdbb56a927edf),
+/* 4366 */ make_floatx80_init(0x78a6, 0xb9dbd2a2c5371e97),
+/* 4367 */ make_floatx80_init(0x78a9, 0xe852c74b7684e63c),
+/* 4368 */ make_floatx80_init(0x78ad, 0x9133bc8f2a130fe6),
+/* 4369 */ make_floatx80_init(0x78b0, 0xb580abb2f497d3df),
+/* 4370 */ make_floatx80_init(0x78b3, 0xe2e0d69fb1bdc8d7),
+/* 4371 */ make_floatx80_init(0x78b7, 0x8dcc8623cf169d86),
+/* 4372 */ make_floatx80_init(0x78ba, 0xb13fa7acc2dc44e8),
+/* 4373 */ make_floatx80_init(0x78bd, 0xdd8f9197f3935622),
+/* 4374 */ make_floatx80_init(0x78c1, 0x8a79bafef83c15d5),
+/* 4375 */ make_floatx80_init(0x78c4, 0xad1829beb64b1b4a),
+/* 4376 */ make_floatx80_init(0x78c7, 0xd85e342e63dde21d),
+/* 4377 */ make_floatx80_init(0x78cb, 0x873ae09cfe6aad52),
+/* 4378 */ make_floatx80_init(0x78ce, 0xa90998c43e0558a7),
+/* 4379 */ make_floatx80_init(0x78d1, 0xd34bfef54d86aed0),
+/* 4380 */ make_floatx80_init(0x78d5, 0x840f7f5950742d42),
+/* 4381 */ make_floatx80_init(0x78d8, 0xa5135f2fa4913893),
+/* 4382 */ make_floatx80_init(0x78db, 0xce5836fb8db586b7),
+/* 4383 */ make_floatx80_init(0x78df, 0x80f7225d38917433),
+/* 4384 */ make_floatx80_init(0x78e2, 0xa134eaf486b5d13f),
+/* 4385 */ make_floatx80_init(0x78e5, 0xc98225b1a863458f),
+/* 4386 */ make_floatx80_init(0x78e8, 0xfbe2af1e127c16f3),
+/* 4387 */ make_floatx80_init(0x78ec, 0x9d6dad72cb8d8e58),
+/* 4388 */ make_floatx80_init(0x78ef, 0xc4c918cf7e70f1ee),
+/* 4389 */ make_floatx80_init(0x78f2, 0xf5fb5f035e0d2e69),
+/* 4390 */ make_floatx80_init(0x78f6, 0x99bd1b621ac83d02),
+/* 4391 */ make_floatx80_init(0x78f9, 0xc02c623aa17a4c42),
+/* 4392 */ make_floatx80_init(0x78fc, 0xf0377ac949d8df53),
+/* 4393 */ make_floatx80_init(0x7900, 0x9622acbdce278b94),
+/* 4394 */ make_floatx80_init(0x7903, 0xbbab57ed41b16e79),
+/* 4395 */ make_floatx80_init(0x7906, 0xea962de8921dca17),
+/* 4396 */ make_floatx80_init(0x790a, 0x929ddcb15b529e4e),
+/* 4397 */ make_floatx80_init(0x790d, 0xb74553ddb22745e2),
+/* 4398 */ make_floatx80_init(0x7910, 0xe516a8d51eb1175a),
+/* 4399 */ make_floatx80_init(0x7914, 0x8f2e2985332eae98),
+/* 4400 */ make_floatx80_init(0x7917, 0xb2f9b3e67ffa5a3f),
+/* 4401 */ make_floatx80_init(0x791a, 0xdfb820e01ff8f0ce),
+/* 4402 */ make_floatx80_init(0x791e, 0x8bd3148c13fb9681),
+/* 4403 */ make_floatx80_init(0x7921, 0xaec7d9af18fa7c21),
+/* 4404 */ make_floatx80_init(0x7924, 0xda79d01adf391b29),
+/* 4405 */ make_floatx80_init(0x7928, 0x888c2210cb83b0fa),
+/* 4406 */ make_floatx80_init(0x792b, 0xaaaf2a94fe649d38),
+/* 4407 */ make_floatx80_init(0x792e, 0xd55af53a3dfdc486),
+/* 4408 */ make_floatx80_init(0x7932, 0x8558d94466be9ad4),
+/* 4409 */ make_floatx80_init(0x7935, 0xa6af0f95806e4189),
+/* 4410 */ make_floatx80_init(0x7938, 0xd05ad37ae089d1eb),
+/* 4411 */ make_floatx80_init(0x793c, 0x8238c42ccc562333),
+/* 4412 */ make_floatx80_init(0x793f, 0xa2c6f537ff6bac00),
+/* 4413 */ make_floatx80_init(0x7942, 0xcb78b285ff469700),
+/* 4414 */ make_floatx80_init(0x7945, 0xfe56df277f183cc0),
+/* 4415 */ make_floatx80_init(0x7949, 0x9ef64b78af6f25f8),
+/* 4416 */ make_floatx80_init(0x794c, 0xc6b3de56db4aef76),
+/* 4417 */ make_floatx80_init(0x794f, 0xf860d5ec921dab53),
+/* 4418 */ make_floatx80_init(0x7953, 0x9b3c85b3db528b14),
+/* 4419 */ make_floatx80_init(0x7956, 0xc20ba720d2272dd9),
+/* 4420 */ make_floatx80_init(0x7959, 0xf28e90e906b0f94f),
+/* 4421 */ make_floatx80_init(0x795d, 0x97991a91a42e9bd2),
+/* 4422 */ make_floatx80_init(0x7960, 0xbd7f61360d3a42c6),
+/* 4423 */ make_floatx80_init(0x7963, 0xecdf39839088d377),
+/* 4424 */ make_floatx80_init(0x7967, 0x940b83f23a55842b),
+/* 4425 */ make_floatx80_init(0x796a, 0xb90e64eec8eae535),
+/* 4426 */ make_floatx80_init(0x796d, 0xe751fe2a7b259e83),
+/* 4427 */ make_floatx80_init(0x7971, 0x90933eda8cf78312),
+/* 4428 */ make_floatx80_init(0x7974, 0xb4b80e91303563d6),
+/* 4429 */ make_floatx80_init(0x7977, 0xe1e612357c42bccc),
+/* 4430 */ make_floatx80_init(0x797b, 0x8d2fcb616da9b5ff),
+/* 4431 */ make_floatx80_init(0x797e, 0xb07bbe39c914237f),
+/* 4432 */ make_floatx80_init(0x7981, 0xdc9aadc83b592c5f),
+/* 4433 */ make_floatx80_init(0x7985, 0x89e0ac9d2517bbbb),
+/* 4434 */ make_floatx80_init(0x7988, 0xac58d7c46e5daaaa),
+/* 4435 */ make_floatx80_init(0x798b, 0xd76f0db589f51555),
+/* 4436 */ make_floatx80_init(0x798f, 0x86a5689176392d55),
+/* 4437 */ make_floatx80_init(0x7992, 0xa84ec2b5d3c778aa),
+/* 4438 */ make_floatx80_init(0x7995, 0xd262736348b956d5),
+/* 4439 */ make_floatx80_init(0x7999, 0x837d881e0d73d645),
+/* 4440 */ make_floatx80_init(0x799c, 0xa45cea2590d0cbd6),
+/* 4441 */ make_floatx80_init(0x799f, 0xcd7424aef504fecc),
+/* 4442 */ make_floatx80_init(0x79a3, 0x806896ed59231f3f),
+/* 4443 */ make_floatx80_init(0x79a6, 0xa082bca8af6be70f),
+/* 4444 */ make_floatx80_init(0x79a9, 0xc8a36bd2db46e0d3),
+/* 4445 */ make_floatx80_init(0x79ac, 0xfacc46c792189908),
+/* 4446 */ make_floatx80_init(0x79b0, 0x9cbfac3cbb4f5fa5),
+/* 4447 */ make_floatx80_init(0x79b3, 0xc3ef974bea23378e),
+/* 4448 */ make_floatx80_init(0x79b6, 0xf4eb7d1ee4ac0571),
+/* 4449 */ make_floatx80_init(0x79ba, 0x99132e334eeb8367),
+/* 4450 */ make_floatx80_init(0x79bd, 0xbf57f9c022a66441),
+/* 4451 */ make_floatx80_init(0x79c0, 0xef2df8302b4ffd51),
+/* 4452 */ make_floatx80_init(0x79c4, 0x957cbb1e1b11fe52),
+/* 4453 */ make_floatx80_init(0x79c7, 0xbadbe9e5a1d67de7),
+/* 4454 */ make_floatx80_init(0x79ca, 0xe992e45f0a4c1d61),
+/* 4455 */ make_floatx80_init(0x79ce, 0x91fbcebb666f925c),
+/* 4456 */ make_floatx80_init(0x79d1, 0xb67ac26a400b76f4),
+/* 4457 */ make_floatx80_init(0x79d4, 0xe4197304d00e54b1),
+/* 4458 */ make_floatx80_init(0x79d8, 0x8e8fe7e30208f4ee),
+/* 4459 */ make_floatx80_init(0x79db, 0xb233e1dbc28b322a),
+/* 4460 */ make_floatx80_init(0x79de, 0xdec0da52b32dfeb4),
+/* 4461 */ make_floatx80_init(0x79e2, 0x8b388873affcbf31),
+/* 4462 */ make_floatx80_init(0x79e5, 0xae06aa909bfbeefd),
+/* 4463 */ make_floatx80_init(0x79e8, 0xd9885534c2faeabc),
+/* 4464 */ make_floatx80_init(0x79ec, 0x87f53540f9dcd2b6),
+/* 4465 */ make_floatx80_init(0x79ef, 0xa9f2829138540763),
+/* 4466 */ make_floatx80_init(0x79f2, 0xd46f23358669093c),
+/* 4467 */ make_floatx80_init(0x79f6, 0x84c576017401a5c5),
+/* 4468 */ make_floatx80_init(0x79f9, 0xa5f6d381d1020f37),
+/* 4469 */ make_floatx80_init(0x79fc, 0xcf74886245429304),
+/* 4470 */ make_floatx80_init(0x7a00, 0x81a8d53d6b499be3),
+/* 4471 */ make_floatx80_init(0x7a03, 0xa2130a8cc61c02db),
+/* 4472 */ make_floatx80_init(0x7a06, 0xca97cd2ff7a30392),
+/* 4473 */ make_floatx80_init(0x7a09, 0xfd3dc07bf58bc477),
+/* 4474 */ make_floatx80_init(0x7a0d, 0x9e46984d79775aca),
+/* 4475 */ make_floatx80_init(0x7a10, 0xc5d83e60d7d5317d),
+/* 4476 */ make_floatx80_init(0x7a13, 0xf74e4df90dca7ddc),
+/* 4477 */ make_floatx80_init(0x7a17, 0x9a90f0bba89e8eaa),
+/* 4478 */ make_floatx80_init(0x7a1a, 0xc1352cea92c63254),
+/* 4479 */ make_floatx80_init(0x7a1d, 0xf18278253777bee9),
+/* 4480 */ make_floatx80_init(0x7a21, 0x96f18b1742aad752),
+/* 4481 */ make_floatx80_init(0x7a24, 0xbcadeddd13558d26),
+/* 4482 */ make_floatx80_init(0x7a27, 0xebd96954582af06f),
+/* 4483 */ make_floatx80_init(0x7a2b, 0x9367e1d4b71ad646),
+/* 4484 */ make_floatx80_init(0x7a2e, 0xb841da49e4e18bd7),
+/* 4485 */ make_floatx80_init(0x7a31, 0xe65250dc5e19eecd),
+/* 4486 */ make_floatx80_init(0x7a35, 0x8ff37289bad03540),
+/* 4487 */ make_floatx80_init(0x7a38, 0xb3f04f2c29844290),
+/* 4488 */ make_floatx80_init(0x7a3b, 0xe0ec62f733e55334),
+/* 4489 */ make_floatx80_init(0x7a3f, 0x8c93bdda806f5400),
+/* 4490 */ make_floatx80_init(0x7a42, 0xafb8ad51208b2901),
+/* 4491 */ make_floatx80_init(0x7a45, 0xdba6d8a568adf341),
+/* 4492 */ make_floatx80_init(0x7a49, 0x89484767616cb808),
+/* 4493 */ make_floatx80_init(0x7a4c, 0xab9a594139c7e60b),
+/* 4494 */ make_floatx80_init(0x7a4f, 0xd680ef918839df8d),
+/* 4495 */ make_floatx80_init(0x7a53, 0x861095baf5242bb8),
+/* 4496 */ make_floatx80_init(0x7a56, 0xa794bb29b26d36a6),
+/* 4497 */ make_floatx80_init(0x7a59, 0xd179e9f41f088450),
+/* 4498 */ make_floatx80_init(0x7a5d, 0x82ec3238936552b2),
+/* 4499 */ make_floatx80_init(0x7a60, 0xa3a73ec6b83ea75e),
+/* 4500 */ make_floatx80_init(0x7a63, 0xcc910e78664e5136),
+/* 4501 */ make_floatx80_init(0x7a66, 0xffb552167fe1e584),
+/* 4502 */ make_floatx80_init(0x7a6a, 0x9fd1534e0fed2f72),
+/* 4503 */ make_floatx80_init(0x7a6d, 0xc7c5a82193e87b4f),
+/* 4504 */ make_floatx80_init(0x7a70, 0xf9b71229f8e29a22),
+/* 4505 */ make_floatx80_init(0x7a74, 0x9c126b5a3b8da056),
+/* 4506 */ make_floatx80_init(0x7a77, 0xc3170630ca71086b),
+/* 4507 */ make_floatx80_init(0x7a7a, 0xf3dcc7bcfd0d4a86),
+/* 4508 */ make_floatx80_init(0x7a7e, 0x9869fcd61e284e94),
+/* 4509 */ make_floatx80_init(0x7a81, 0xbe847c0ba5b26238),
+/* 4510 */ make_floatx80_init(0x7a84, 0xee259b0e8f1efac7),
+/* 4511 */ make_floatx80_init(0x7a88, 0x94d780e919735cbc),
+/* 4512 */ make_floatx80_init(0x7a8b, 0xba0d61235fd033eb),
+/* 4513 */ make_floatx80_init(0x7a8e, 0xe890b96c37c440e6),
+/* 4514 */ make_floatx80_init(0x7a92, 0x915a73e3a2daa890),
+/* 4515 */ make_floatx80_init(0x7a95, 0xb5b110dc8b9152b4),
+/* 4516 */ make_floatx80_init(0x7a98, 0xe31d5513ae75a761),
+/* 4517 */ make_floatx80_init(0x7a9c, 0x8df2552c4d09889c),
+/* 4518 */ make_floatx80_init(0x7a9f, 0xb16eea77604beac3),
+/* 4519 */ make_floatx80_init(0x7aa2, 0xddcaa515385ee574),
+/* 4520 */ make_floatx80_init(0x7aa6, 0x8a9ea72d433b4f69),
+/* 4521 */ make_floatx80_init(0x7aa9, 0xad4650f8940a2343),
+/* 4522 */ make_floatx80_init(0x7aac, 0xd897e536b90cac14),
+/* 4523 */ make_floatx80_init(0x7ab0, 0x875eef4233a7eb8c),
+/* 4524 */ make_floatx80_init(0x7ab3, 0xa936ab12c091e66f),
+/* 4525 */ make_floatx80_init(0x7ab6, 0xd38455d770b6600b),
+/* 4526 */ make_floatx80_init(0x7aba, 0x8432b5a6a671fc07),
+/* 4527 */ make_floatx80_init(0x7abd, 0xa53f6310500e7b09),
+/* 4528 */ make_floatx80_init(0x7ac0, 0xce8f3bd4641219cb),
+/* 4529 */ make_floatx80_init(0x7ac4, 0x81198564be8b501f),
+/* 4530 */ make_floatx80_init(0x7ac7, 0xa15fe6bdee2e2426),
+/* 4531 */ make_floatx80_init(0x7aca, 0xc9b7e06d69b9ad30),
+/* 4532 */ make_floatx80_init(0x7acd, 0xfc25d888c428187c),
+/* 4533 */ make_floatx80_init(0x7ad1, 0x9d97a7557a990f4e),
+/* 4534 */ make_floatx80_init(0x7ad4, 0xc4fd912ad93f5321),
+/* 4535 */ make_floatx80_init(0x7ad7, 0xf63cf5758f8f27e9),
+/* 4536 */ make_floatx80_init(0x7adb, 0x99e6196979b978f2),
+/* 4537 */ make_floatx80_init(0x7ade, 0xc05f9fc3d827d72e),
+/* 4538 */ make_floatx80_init(0x7ae1, 0xf07787b4ce31ccfa),
+/* 4539 */ make_floatx80_init(0x7ae5, 0x964ab4d100df201c),
+/* 4540 */ make_floatx80_init(0x7ae8, 0xbbdd62054116e823),
+/* 4541 */ make_floatx80_init(0x7aeb, 0xead4ba86915ca22c),
+/* 4542 */ make_floatx80_init(0x7aef, 0x92c4f4941ad9e55b),
+/* 4543 */ make_floatx80_init(0x7af2, 0xb77631b921905eb2),
+/* 4544 */ make_floatx80_init(0x7af5, 0xe553be2769f4765f),
+/* 4545 */ make_floatx80_init(0x7af9, 0x8f5456d8a238c9fb),
+/* 4546 */ make_floatx80_init(0x7afc, 0xb3296c8ecac6fc7a),
+/* 4547 */ make_floatx80_init(0x7aff, 0xdff3c7b27d78bb99),
+/* 4548 */ make_floatx80_init(0x7b03, 0x8bf85ccf8e6b753f),
+/* 4549 */ make_floatx80_init(0x7b06, 0xaef674037206528f),
+/* 4550 */ make_floatx80_init(0x7b09, 0xdab411044e87e733),
+/* 4551 */ make_floatx80_init(0x7b0d, 0x88b08aa2b114f080),
+/* 4552 */ make_floatx80_init(0x7b10, 0xaadcad4b5d5a2ca0),
+/* 4553 */ make_floatx80_init(0x7b13, 0xd593d89e34b0b7c8),
+/* 4554 */ make_floatx80_init(0x7b17, 0x857c6762e0ee72dd),
+/* 4555 */ make_floatx80_init(0x7b1a, 0xa6db813b992a0f94),
+/* 4556 */ make_floatx80_init(0x7b1d, 0xd092618a7f749379),
+/* 4557 */ make_floatx80_init(0x7b21, 0x825b7cf68fa8dc2c),
+/* 4558 */ make_floatx80_init(0x7b24, 0xa2f25c3433931337),
+/* 4559 */ make_floatx80_init(0x7b27, 0xcbaef3414077d804),
+/* 4560 */ make_floatx80_init(0x7b2a, 0xfe9ab0119095ce05),
+/* 4561 */ make_floatx80_init(0x7b2e, 0x9f20ae0afa5da0c3),
+/* 4562 */ make_floatx80_init(0x7b31, 0xc6e8d98db8f508f4),
+/* 4563 */ make_floatx80_init(0x7b34, 0xf8a30ff127324b31),
+/* 4564 */ make_floatx80_init(0x7b38, 0x9b65e9f6b87f6eff),
+/* 4565 */ make_floatx80_init(0x7b3b, 0xc23f6474669f4abe),
+/* 4566 */ make_floatx80_init(0x7b3e, 0xf2cf3d9180471d6e),
+/* 4567 */ make_floatx80_init(0x7b42, 0x97c1867af02c7265),
+/* 4568 */ make_floatx80_init(0x7b45, 0xbdb1e819ac378efe),
+/* 4569 */ make_floatx80_init(0x7b48, 0xed1e6220174572be),
+/* 4570 */ make_floatx80_init(0x7b4c, 0x9432fd540e8b67b6),
+/* 4571 */ make_floatx80_init(0x7b4f, 0xb93fbca9122e41a4),
+/* 4572 */ make_floatx80_init(0x7b52, 0xe78fabd356b9d20d),
+/* 4573 */ make_floatx80_init(0x7b56, 0x90b9cb6416342348),
+/* 4574 */ make_floatx80_init(0x7b59, 0xb4e83e3d1bc12c1a),
+/* 4575 */ make_floatx80_init(0x7b5c, 0xe2224dcc62b17721),
+/* 4576 */ make_floatx80_init(0x7b60, 0x8d55709fbdaeea74),
+/* 4577 */ make_floatx80_init(0x7b63, 0xb0aaccc7ad1aa512),
+/* 4578 */ make_floatx80_init(0x7b66, 0xdcd57ff998614e56),
+/* 4579 */ make_floatx80_init(0x7b6a, 0x8a056ffbff3cd0f6),
+/* 4580 */ make_floatx80_init(0x7b6d, 0xac86cbfaff0c0533),
+/* 4581 */ make_floatx80_init(0x7b70, 0xd7a87ef9becf0680),
+/* 4582 */ make_floatx80_init(0x7b74, 0x86c94f5c17416410),
+/* 4583 */ make_floatx80_init(0x7b77, 0xa87ba3331d11bd14),
+/* 4584 */ make_floatx80_init(0x7b7a, 0xd29a8bffe4562c59),
+/* 4585 */ make_floatx80_init(0x7b7e, 0x83a0977feeb5dbb8),
+/* 4586 */ make_floatx80_init(0x7b81, 0xa488bd5fea6352a6),
+/* 4587 */ make_floatx80_init(0x7b84, 0xcdaaecb7e4fc274f),
+/* 4588 */ make_floatx80_init(0x7b88, 0x808ad3f2ef1d9891),
+/* 4589 */ make_floatx80_init(0x7b8b, 0xa0ad88efaae4feb6),
+/* 4590 */ make_floatx80_init(0x7b8e, 0xc8d8eb2b959e3e63),
+/* 4591 */ make_floatx80_init(0x7b91, 0xfb0f25f67b05cdfc),
+/* 4592 */ make_floatx80_init(0x7b95, 0x9ce977ba0ce3a0bd),
+/* 4593 */ make_floatx80_init(0x7b98, 0xc423d5a8901c88ed),
+/* 4594 */ make_floatx80_init(0x7b9b, 0xf52ccb12b423ab28),
+/* 4595 */ make_floatx80_init(0x7b9f, 0x993bfeebb0964af9),
+/* 4596 */ make_floatx80_init(0x7ba2, 0xbf8afea69cbbddb7),
+/* 4597 */ make_floatx80_init(0x7ba5, 0xef6dbe5043ead525),
+/* 4598 */ make_floatx80_init(0x7ba9, 0x95a496f22a72c537),
+/* 4599 */ make_floatx80_init(0x7bac, 0xbb0dbcaeb50f7685),
+/* 4600 */ make_floatx80_init(0x7baf, 0xe9d12bda62535426),
+/* 4601 */ make_floatx80_init(0x7bb3, 0x9222bb687d741498),
+/* 4602 */ make_floatx80_init(0x7bb6, 0xb6ab6a429cd119be),
+/* 4603 */ make_floatx80_init(0x7bb9, 0xe45644d34405602d),
+/* 4604 */ make_floatx80_init(0x7bbd, 0x8eb5eb040a835c1c),
+/* 4605 */ make_floatx80_init(0x7bc0, 0xb26365c50d243323),
+/* 4606 */ make_floatx80_init(0x7bc3, 0xdefc3f36506d3fec),
+/* 4607 */ make_floatx80_init(0x7bc7, 0x8b5da781f24447f4),
+/* 4608 */ make_floatx80_init(0x7bca, 0xae3511626ed559f0),
+/* 4609 */ make_floatx80_init(0x7bcd, 0xd9c255bb0a8ab06d),
+/* 4610 */ make_floatx80_init(0x7bd1, 0x88197594e696ae44),
+/* 4611 */ make_floatx80_init(0x7bd4, 0xaa1fd2fa203c59d5),
+/* 4612 */ make_floatx80_init(0x7bd7, 0xd4a7c7b8a84b704a),
+/* 4613 */ make_floatx80_init(0x7bdb, 0x84e8dcd3692f262e),
+/* 4614 */ make_floatx80_init(0x7bde, 0xa6231408437aefba),
+/* 4615 */ make_floatx80_init(0x7be1, 0xcfabd90a5459aba8),
+/* 4616 */ make_floatx80_init(0x7be5, 0x81cb67a674b80b49),
+/* 4617 */ make_floatx80_init(0x7be8, 0xa23e419011e60e1c),
+/* 4618 */ make_floatx80_init(0x7beb, 0xcacdd1f4165f91a2),
+/* 4619 */ make_floatx80_init(0x7bee, 0xfd8146711bf7760b),
+/* 4620 */ make_floatx80_init(0x7bf2, 0x9e70cc06b17aa9c7),
+/* 4621 */ make_floatx80_init(0x7bf5, 0xc60cff085dd95439),
+/* 4622 */ make_floatx80_init(0x7bf8, 0xf7903eca754fa947),
+/* 4623 */ make_floatx80_init(0x7bfc, 0x9aba273e8951c9cc),
+/* 4624 */ make_floatx80_init(0x7bff, 0xc168b10e2ba63c3f),
+/* 4625 */ make_floatx80_init(0x7c02, 0xf1c2dd51b68fcb4f),
+/* 4626 */ make_floatx80_init(0x7c06, 0x9719ca531219df11),
+/* 4627 */ make_floatx80_init(0x7c09, 0xbce03ce7d6a056d6),
+/* 4628 */ make_floatx80_init(0x7c0c, 0xec184c21cc486c8b),
+/* 4629 */ make_floatx80_init(0x7c10, 0x938f2f951fad43d7),
+/* 4630 */ make_floatx80_init(0x7c13, 0xb872fb7a679894cd),
+/* 4631 */ make_floatx80_init(0x7c16, 0xe68fba59017eba00),
+/* 4632 */ make_floatx80_init(0x7c1a, 0x9019d477a0ef3440),
+/* 4633 */ make_floatx80_init(0x7c1d, 0xb4204995892b0150),
+/* 4634 */ make_floatx80_init(0x7c20, 0xe1285bfaeb75c1a4),
+/* 4635 */ make_floatx80_init(0x7c24, 0x8cb9397cd3299906),
+/* 4636 */ make_floatx80_init(0x7c27, 0xafe787dc07f3ff48),
+/* 4637 */ make_floatx80_init(0x7c2a, 0xdbe169d309f0ff1a),
+/* 4638 */ make_floatx80_init(0x7c2e, 0x896ce223e6369f70),
+/* 4639 */ make_floatx80_init(0x7c31, 0xabc81aacdfc4474c),
+/* 4640 */ make_floatx80_init(0x7c34, 0xd6ba215817b55920),
+/* 4641 */ make_floatx80_init(0x7c38, 0x863454d70ed157b4),
+/* 4642 */ make_floatx80_init(0x7c3b, 0xa7c16a0cd285ada1),
+/* 4643 */ make_floatx80_init(0x7c3e, 0xd1b1c49007271909),
+/* 4644 */ make_floatx80_init(0x7c42, 0x830f1ada04786fa5),
+/* 4645 */ make_floatx80_init(0x7c45, 0xa3d2e19085968b8f),
+/* 4646 */ make_floatx80_init(0x7c48, 0xccc799f4a6fc2e73),
+/* 4647 */ make_floatx80_init(0x7c4b, 0xfff98071d0bb3a0f),
+/* 4648 */ make_floatx80_init(0x7c4f, 0x9ffbf0472275044a),
+/* 4649 */ make_floatx80_init(0x7c52, 0xc7faec58eb12455c),
+/* 4650 */ make_floatx80_init(0x7c55, 0xf9f9a76f25d6d6b3),
+/* 4651 */ make_floatx80_init(0x7c59, 0x9c3c08a577a64630),
+/* 4652 */ make_floatx80_init(0x7c5c, 0xc34b0aced58fd7bc),
+/* 4653 */ make_floatx80_init(0x7c5f, 0xf41dcd828af3cdab),
+/* 4654 */ make_floatx80_init(0x7c63, 0x9892a07196d8608b),
+/* 4655 */ make_floatx80_init(0x7c66, 0xbeb7488dfc8e78ad),
+/* 4656 */ make_floatx80_init(0x7c69, 0xee651ab17bb216d9),
+/* 4657 */ make_floatx80_init(0x7c6d, 0x94ff30aeed4f4e47),
+/* 4658 */ make_floatx80_init(0x7c70, 0xba3efcdaa8a321d9),
+/* 4659 */ make_floatx80_init(0x7c73, 0xe8cebc1152cbea50),
+/* 4660 */ make_floatx80_init(0x7c77, 0x9181358ad3bf7272),
+/* 4661 */ make_floatx80_init(0x7c7a, 0xb5e182ed88af4f0e),
+/* 4662 */ make_floatx80_init(0x7c7d, 0xe359e3a8eadb22d2),
+/* 4663 */ make_floatx80_init(0x7c81, 0x8e182e4992c8f5c3),
+/* 4664 */ make_floatx80_init(0x7c84, 0xb19e39dbf77b3334),
+/* 4665 */ make_floatx80_init(0x7c87, 0xde05c852f55a0001),
+/* 4666 */ make_floatx80_init(0x7c8b, 0x8ac39d33d9584000),
+/* 4667 */ make_floatx80_init(0x7c8e, 0xad748480cfae5001),
+/* 4668 */ make_floatx80_init(0x7c91, 0xd8d1a5a10399e401),
+/* 4669 */ make_floatx80_init(0x7c95, 0x87830784a2402e80),
+/* 4670 */ make_floatx80_init(0x7c98, 0xa963c965cad03a21),
+/* 4671 */ make_floatx80_init(0x7c9b, 0xd3bcbbbf3d8448a9),
+/* 4672 */ make_floatx80_init(0x7c9f, 0x8455f5578672ad69),
+/* 4673 */ make_floatx80_init(0x7ca2, 0xa56b72ad680f58c4),
+/* 4674 */ make_floatx80_init(0x7ca5, 0xcec64f58c2132ef5),
+/* 4675 */ make_floatx80_init(0x7ca9, 0x813bf197794bfd59),
+/* 4676 */ make_floatx80_init(0x7cac, 0xa18aedfd579efcaf),
+/* 4677 */ make_floatx80_init(0x7caf, 0xc9eda97cad86bbdb),
+/* 4678 */ make_floatx80_init(0x7cb2, 0xfc6913dbd8e86ad2),
+/* 4679 */ make_floatx80_init(0x7cb6, 0x9dc1ac69679142c3),
+/* 4680 */ make_floatx80_init(0x7cb9, 0xc5321783c1759374),
+/* 4681 */ make_floatx80_init(0x7cbc, 0xf67e9d64b1d2f851),
+/* 4682 */ make_floatx80_init(0x7cc0, 0x9a0f225eef23db33),
+/* 4683 */ make_floatx80_init(0x7cc3, 0xc092eaf6aaecd1ff),
+/* 4684 */ make_floatx80_init(0x7cc6, 0xf0b7a5b455a8067f),
+/* 4685 */ make_floatx80_init(0x7cca, 0x9672c790b589040f),
+/* 4686 */ make_floatx80_init(0x7ccd, 0xbc0f7974e2eb4513),
+/* 4687 */ make_floatx80_init(0x7cd0, 0xeb1357d21ba61658),
+/* 4688 */ make_floatx80_init(0x7cd4, 0x92ec16e35147cdf7),
+/* 4689 */ make_floatx80_init(0x7cd7, 0xb7a71c9c2599c175),
+/* 4690 */ make_floatx80_init(0x7cda, 0xe590e3c32f0031d2),
+/* 4691 */ make_floatx80_init(0x7cde, 0x8f7a8e59fd601f23),
+/* 4692 */ make_floatx80_init(0x7ce1, 0xb35931f07cb826ec),
+/* 4693 */ make_floatx80_init(0x7ce4, 0xe02f7e6c9be630a7),
+/* 4694 */ make_floatx80_init(0x7ce8, 0x8c1daf03e16fde68),
+/* 4695 */ make_floatx80_init(0x7ceb, 0xaf251ac4d9cbd603),
+/* 4696 */ make_floatx80_init(0x7cee, 0xdaee6176103ecb83),
+/* 4697 */ make_floatx80_init(0x7cf2, 0x88d4fce9ca273f32),
+/* 4698 */ make_floatx80_init(0x7cf5, 0xab0a3c243cb10efe),
+/* 4699 */ make_floatx80_init(0x7cf8, 0xd5cccb2d4bdd52be),
+/* 4700 */ make_floatx80_init(0x7cfc, 0x859ffefc4f6a53b7),
+/* 4701 */ make_floatx80_init(0x7cff, 0xa707febb6344e8a4),
+/* 4702 */ make_floatx80_init(0x7d02, 0xd0c9fe6a3c1622ce),
+/* 4703 */ make_floatx80_init(0x7d06, 0x827e3f02658dd5c1),
+/* 4704 */ make_floatx80_init(0x7d09, 0xa31dcec2fef14b31),
+/* 4705 */ make_floatx80_init(0x7d0c, 0xcbe54273bead9dfd),
+/* 4706 */ make_floatx80_init(0x7d0f, 0xfede9310ae59057c),
+/* 4707 */ make_floatx80_init(0x7d13, 0x9f4b1bea6cf7a36d),
+/* 4708 */ make_floatx80_init(0x7d16, 0xc71de2e508358c49),
+/* 4709 */ make_floatx80_init(0x7d19, 0xf8e55b9e4a42ef5b),
+/* 4710 */ make_floatx80_init(0x7d1d, 0x9b8f5942ee69d599),
+/* 4711 */ make_floatx80_init(0x7d20, 0xc2732f93aa044aff),
+/* 4712 */ make_floatx80_init(0x7d23, 0xf30ffb7894855dbf),
+/* 4713 */ make_floatx80_init(0x7d27, 0x97e9fd2b5cd35a97),
+/* 4714 */ make_floatx80_init(0x7d2a, 0xbde47c763408313d),
+/* 4715 */ make_floatx80_init(0x7d2d, 0xed5d9b93c10a3d8c),
+/* 4716 */ make_floatx80_init(0x7d31, 0x945a813c58a66678),
+/* 4717 */ make_floatx80_init(0x7d34, 0xb971218b6ed00016),
+/* 4718 */ make_floatx80_init(0x7d37, 0xe7cd69ee4a84001b),
+/* 4719 */ make_floatx80_init(0x7d3b, 0x90e06234ee928011),
+/* 4720 */ make_floatx80_init(0x7d3e, 0xb5187ac22a372015),
+/* 4721 */ make_floatx80_init(0x7d41, 0xe25e9972b4c4e81b),
+/* 4722 */ make_floatx80_init(0x7d45, 0x8d7b1fe7b0fb1111),
+/* 4723 */ make_floatx80_init(0x7d48, 0xb0d9e7e19d39d555),
+/* 4724 */ make_floatx80_init(0x7d4b, 0xdd1061da04884aaa),
+/* 4725 */ make_floatx80_init(0x7d4f, 0x8a2a3d2842d52eaa),
+/* 4726 */ make_floatx80_init(0x7d52, 0xacb4cc72538a7a55),
+/* 4727 */ make_floatx80_init(0x7d55, 0xd7e1ff8ee86d18ea),
+/* 4728 */ make_floatx80_init(0x7d59, 0x86ed3fb951442f92),
+/* 4729 */ make_floatx80_init(0x7d5c, 0xa8a88fa7a5953b77),
+/* 4730 */ make_floatx80_init(0x7d5f, 0xd2d2b3918efa8a54),
+/* 4731 */ make_floatx80_init(0x7d63, 0x83c3b03af95c9675),
+/* 4732 */ make_floatx80_init(0x7d66, 0xa4b49c49b7b3bc12),
+/* 4733 */ make_floatx80_init(0x7d69, 0xcde1c35c25a0ab16),
+/* 4734 */ make_floatx80_init(0x7d6d, 0x80ad1a1997846aee),
+/* 4735 */ make_floatx80_init(0x7d70, 0xa0d8609ffd6585aa),
+/* 4736 */ make_floatx80_init(0x7d73, 0xc90e78c7fcbee714),
+/* 4737 */ make_floatx80_init(0x7d76, 0xfb5216f9fbeea0d9),
+/* 4738 */ make_floatx80_init(0x7d7a, 0x9d134e5c3d752488),
+/* 4739 */ make_floatx80_init(0x7d7d, 0xc45821f34cd26da9),
+/* 4740 */ make_floatx80_init(0x7d80, 0xf56e2a7020070914),
+/* 4741 */ make_floatx80_init(0x7d84, 0x9964da86140465ac),
+/* 4742 */ make_floatx80_init(0x7d87, 0xbfbe112799057f18),
+/* 4743 */ make_floatx80_init(0x7d8a, 0xefad95717f46dedd),
+/* 4744 */ make_floatx80_init(0x7d8e, 0x95cc7d66ef8c4b4a),
+/* 4745 */ make_floatx80_init(0x7d91, 0xbb3f9cc0ab6f5e1d),
+/* 4746 */ make_floatx80_init(0x7d94, 0xea0f83f0d64b35a4),
+/* 4747 */ make_floatx80_init(0x7d98, 0x9249b27685ef0187),
+/* 4748 */ make_floatx80_init(0x7d9b, 0xb6dc1f14276ac1e8),
+/* 4749 */ make_floatx80_init(0x7d9e, 0xe49326d931457262),
+/* 4750 */ make_floatx80_init(0x7da2, 0x8edbf847becb677d),
+/* 4751 */ make_floatx80_init(0x7da5, 0xb292f659ae7e415d),
+/* 4752 */ make_floatx80_init(0x7da8, 0xdf37b3f01a1dd1b4),
+/* 4753 */ make_floatx80_init(0x7dac, 0x8b82d0761052a311),
+/* 4754 */ make_floatx80_init(0x7daf, 0xae63849394674bd5),
+/* 4755 */ make_floatx80_init(0x7db2, 0xd9fc65b879811eca),
+/* 4756 */ make_floatx80_init(0x7db6, 0x883dbf934bf0b33e),
+/* 4757 */ make_floatx80_init(0x7db9, 0xaa4d2f781eece00e),
+/* 4758 */ make_floatx80_init(0x7dbc, 0xd4e07b5626a81811),
+/* 4759 */ make_floatx80_init(0x7dc0, 0x850c4d15d8290f0b),
+/* 4760 */ make_floatx80_init(0x7dc3, 0xa64f605b4e3352cd),
+/* 4761 */ make_floatx80_init(0x7dc6, 0xcfe3387221c02781),
+/* 4762 */ make_floatx80_init(0x7dca, 0x81ee0347551818b0),
+/* 4763 */ make_floatx80_init(0x7dcd, 0xa26984192a5e1edd),
+/* 4764 */ make_floatx80_init(0x7dd0, 0xcb03e51f74f5a694),
+/* 4765 */ make_floatx80_init(0x7dd3, 0xfdc4de6752331039),
+/* 4766 */ make_floatx80_init(0x7dd7, 0x9e9b0b00935fea23),
+/* 4767 */ make_floatx80_init(0x7dda, 0xc641cdc0b837e4ac),
+/* 4768 */ make_floatx80_init(0x7ddd, 0xf7d24130e645ddd7),
+/* 4769 */ make_floatx80_init(0x7de1, 0x9ae368be8febaaa7),
+/* 4770 */ make_floatx80_init(0x7de4, 0xc19c42ee33e69550),
+/* 4771 */ make_floatx80_init(0x7de7, 0xf20353a9c0e03aa4),
+/* 4772 */ make_floatx80_init(0x7deb, 0x9742144a188c24a7),
+/* 4773 */ make_floatx80_init(0x7dee, 0xbd12995c9eaf2dd0),
+/* 4774 */ make_floatx80_init(0x7df1, 0xec573fb3c65af944),
+/* 4775 */ make_floatx80_init(0x7df5, 0x93b687d05bf8dbcb),
+/* 4776 */ make_floatx80_init(0x7df8, 0xb8a429c472f712bd),
+/* 4777 */ make_floatx80_init(0x7dfb, 0xe6cd34358fb4d76d),
+/* 4778 */ make_floatx80_init(0x7dff, 0x904040a179d106a4),
+/* 4779 */ make_floatx80_init(0x7e02, 0xb45050c9d845484d),
+/* 4780 */ make_floatx80_init(0x7e05, 0xe16464fc4e569a60),
+/* 4781 */ make_floatx80_init(0x7e09, 0x8cdebf1db0f6207c),
+/* 4782 */ make_floatx80_init(0x7e0c, 0xb0166ee51d33a89b),
+/* 4783 */ make_floatx80_init(0x7e0f, 0xdc1c0a9e648092c2),
+/* 4784 */ make_floatx80_init(0x7e13, 0x899186a2fed05bb9),
+/* 4785 */ make_floatx80_init(0x7e16, 0xabf5e84bbe8472a8),
+/* 4786 */ make_floatx80_init(0x7e19, 0xd6f3625eae258f51),
+/* 4787 */ make_floatx80_init(0x7e1d, 0x86581d7b2cd77993),
+/* 4788 */ make_floatx80_init(0x7e20, 0xa7ee24d9f80d57f8),
+/* 4789 */ make_floatx80_init(0x7e23, 0xd1e9ae107610adf6),
+/* 4790 */ make_floatx80_init(0x7e27, 0x83320cca49ca6cb9),
+/* 4791 */ make_floatx80_init(0x7e2a, 0xa3fe8ffcdc3d07e8),
+/* 4792 */ make_floatx80_init(0x7e2d, 0xccfe33fc134c49e2),
+/* 4793 */ make_floatx80_init(0x7e31, 0x801ee07d8c0fae2d),
+/* 4794 */ make_floatx80_init(0x7e34, 0xa026989cef1399b8),
+/* 4795 */ make_floatx80_init(0x7e37, 0xc8303ec42ad88026),
+/* 4796 */ make_floatx80_init(0x7e3a, 0xfa3c4e75358ea030),
+/* 4797 */ make_floatx80_init(0x7e3e, 0x9c65b1094179241e),
+/* 4798 */ make_floatx80_init(0x7e41, 0xc37f1d4b91d76d26),
+/* 4799 */ make_floatx80_init(0x7e44, 0xf45ee49e764d486f),
+/* 4800 */ make_floatx80_init(0x7e48, 0x98bb4ee309f04d45),
+/* 4801 */ make_floatx80_init(0x7e4b, 0xbeea229bcc6c6097),
+/* 4802 */ make_floatx80_init(0x7e4e, 0xeea4ab42bf8778bc),
+/* 4803 */ make_floatx80_init(0x7e52, 0x9526eb09b7b4ab76),
+/* 4804 */ make_floatx80_init(0x7e55, 0xba70a5cc25a1d653),
+/* 4805 */ make_floatx80_init(0x7e58, 0xe90ccf3f2f0a4be8),
+/* 4806 */ make_floatx80_init(0x7e5c, 0x91a801877d666f71),
+/* 4807 */ make_floatx80_init(0x7e5f, 0xb61201e95cc00b4d),
+/* 4808 */ make_floatx80_init(0x7e62, 0xe3968263b3f00e21),
+/* 4809 */ make_floatx80_init(0x7e66, 0x8e3e117e507608d4),
+/* 4810 */ make_floatx80_init(0x7e69, 0xb1cd95dde4938b09),
+/* 4811 */ make_floatx80_init(0x7e6c, 0xde40fb555db86dcc),
+/* 4812 */ make_floatx80_init(0x7e70, 0x8ae89d155a93449f),
+/* 4813 */ make_floatx80_init(0x7e73, 0xada2c45ab13815c7),
+/* 4814 */ make_floatx80_init(0x7e76, 0xd90b75715d861b39),
+/* 4815 */ make_floatx80_init(0x7e7a, 0x87a72966da73d104),
+/* 4816 */ make_floatx80_init(0x7e7d, 0xa990f3c09110c545),
+/* 4817 */ make_floatx80_init(0x7e80, 0xd3f530b0b554f696),
+/* 4818 */ make_floatx80_init(0x7e84, 0x84793e6e71551a1e),
+/* 4819 */ make_floatx80_init(0x7e87, 0xa5978e0a0daa60a5),
+/* 4820 */ make_floatx80_init(0x7e8a, 0xcefd718c9114f8ce),
+/* 4821 */ make_floatx80_init(0x7e8e, 0x815e66f7daad1b81),
+/* 4822 */ make_floatx80_init(0x7e91, 0xa1b600b5d1586261),
+/* 4823 */ make_floatx80_init(0x7e94, 0xca2380e345ae7af9),
+/* 4824 */ make_floatx80_init(0x7e97, 0xfcac611c171a19b8),
+/* 4825 */ make_floatx80_init(0x7e9b, 0x9debbcb18e705013),
+/* 4826 */ make_floatx80_init(0x7e9e, 0xc566abddf20c6417),
+/* 4827 */ make_floatx80_init(0x7ea1, 0xf6c056d56e8f7d1d),
+/* 4828 */ make_floatx80_init(0x7ea5, 0x9a3836456519ae32),
+/* 4829 */ make_floatx80_init(0x7ea8, 0xc0c643d6be6019bf),
+/* 4830 */ make_floatx80_init(0x7eab, 0xf0f7d4cc6df8202f),
+/* 4831 */ make_floatx80_init(0x7eaf, 0x969ae4ffc4bb141d),
+/* 4832 */ make_floatx80_init(0x7eb2, 0xbc419e3fb5e9d924),
+/* 4833 */ make_floatx80_init(0x7eb5, 0xeb5205cfa3644f6e),
+/* 4834 */ make_floatx80_init(0x7eb9, 0x931343a1c61eb1a4),
+/* 4835 */ make_floatx80_init(0x7ebc, 0xb7d8148a37a65e0e),
+/* 4836 */ make_floatx80_init(0x7ebf, 0xe5ce19acc58ff591),
+/* 4837 */ make_floatx80_init(0x7ec3, 0x8fa0d00bfb79f97b),
+/* 4838 */ make_floatx80_init(0x7ec6, 0xb389040efa5877d9),
+/* 4839 */ make_floatx80_init(0x7ec9, 0xe06b4512b8ee95d0),
+/* 4840 */ make_floatx80_init(0x7ecd, 0x8c430b2bb3951da2),
+/* 4841 */ make_floatx80_init(0x7ed0, 0xaf53cdf6a07a650a),
+/* 4842 */ make_floatx80_init(0x7ed3, 0xdb28c1744898fe4d),
+/* 4843 */ make_floatx80_init(0x7ed7, 0x88f978e8ad5f9ef0),
+/* 4844 */ make_floatx80_init(0x7eda, 0xab37d722d8b786ac),
+/* 4845 */ make_floatx80_init(0x7edd, 0xd605cceb8ee56857),
+/* 4846 */ make_floatx80_init(0x7ee1, 0x85c3a013394f6136),
+/* 4847 */ make_floatx80_init(0x7ee4, 0xa734881807a33984),
+/* 4848 */ make_floatx80_init(0x7ee7, 0xd101aa1e098c07e5),
+/* 4849 */ make_floatx80_init(0x7eeb, 0x82a10a52c5f784ef),
+/* 4850 */ make_floatx80_init(0x7eee, 0xa3494ce77775662b),
+/* 4851 */ make_floatx80_init(0x7ef1, 0xcc1ba0215552bfb6),
+/* 4852 */ make_floatx80_init(0x7ef4, 0xff228829aaa76fa3),
+/* 4853 */ make_floatx80_init(0x7ef8, 0x9f75951a0aa8a5c6),
+/* 4854 */ make_floatx80_init(0x7efb, 0xc752fa608d52cf37),
+/* 4855 */ make_floatx80_init(0x7efe, 0xf927b8f8b0a78305),
+/* 4856 */ make_floatx80_init(0x7f02, 0x9bb8d39b6e68b1e3),
+/* 4857 */ make_floatx80_init(0x7f05, 0xc2a708824a02de5c),
+/* 4858 */ make_floatx80_init(0x7f08, 0xf350caa2dc8395f3),
+/* 4859 */ make_floatx80_init(0x7f0c, 0x98127ea5c9d23db8),
+/* 4860 */ make_floatx80_init(0x7f0f, 0xbe171e4f3c46cd26),
+/* 4861 */ make_floatx80_init(0x7f12, 0xed9ce5e30b58806f),
+/* 4862 */ make_floatx80_init(0x7f16, 0x94820fade7175046),
+/* 4863 */ make_floatx80_init(0x7f19, 0xb9a2939960dd2457),
+/* 4864 */ make_floatx80_init(0x7f1c, 0xe80b387fb9146d6d),
+/* 4865 */ make_floatx80_init(0x7f20, 0x9107034fd3acc464),
+/* 4866 */ make_floatx80_init(0x7f23, 0xb548c423c897f57d),
+/* 4867 */ make_floatx80_init(0x7f26, 0xe29af52cbabdf2dc),
+/* 4868 */ make_floatx80_init(0x7f2a, 0x8da0d93bf4b6b7ca),
+/* 4869 */ make_floatx80_init(0x7f2d, 0xb1090f8af1e465bc),
+/* 4870 */ make_floatx80_init(0x7f30, 0xdd4b536dae5d7f2b),
+/* 4871 */ make_floatx80_init(0x7f34, 0x8a4f14248cfa6f7b),
+/* 4872 */ make_floatx80_init(0x7f37, 0xace2d92db0390b5a),
+/* 4873 */ make_floatx80_init(0x7f3a, 0xd81b8f791c474e30),
+/* 4874 */ make_floatx80_init(0x7f3e, 0x871139abb1ac90de),
+/* 4875 */ make_floatx80_init(0x7f41, 0xa8d588169e17b515),
+/* 4876 */ make_floatx80_init(0x7f44, 0xd30aea1c459da25b),
+/* 4877 */ make_floatx80_init(0x7f48, 0x83e6d251ab828579),
+/* 4878 */ make_floatx80_init(0x7f4b, 0xa4e086e6166326d7),
+/* 4879 */ make_floatx80_init(0x7f4e, 0xce18a89f9bfbf08d),
+/* 4880 */ make_floatx80_init(0x7f52, 0x80cf6963c17d7658),
+/* 4881 */ make_floatx80_init(0x7f55, 0xa10343bcb1dcd3ee),
+/* 4882 */ make_floatx80_init(0x7f58, 0xc94414abde5408e9),
+/* 4883 */ make_floatx80_init(0x7f5b, 0xfb9519d6d5e90b24),
+/* 4884 */ make_floatx80_init(0x7f5f, 0x9d3d302645b1a6f6),
+/* 4885 */ make_floatx80_init(0x7f62, 0xc48c7c2fd71e10b4),
+/* 4886 */ make_floatx80_init(0x7f65, 0xf5af9b3bcce594e1),
+/* 4887 */ make_floatx80_init(0x7f69, 0x998dc105600f7d0d),
+/* 4888 */ make_floatx80_init(0x7f6c, 0xbff13146b8135c50),
+/* 4889 */ make_floatx80_init(0x7f6f, 0xefed7d9866183364),
+/* 4890 */ make_floatx80_init(0x7f73, 0x95f46e7f3fcf201e),
+/* 4891 */ make_floatx80_init(0x7f76, 0xbb718a1f0fc2e826),
+/* 4892 */ make_floatx80_init(0x7f79, 0xea4deca6d3b3a22f),
+/* 4893 */ make_floatx80_init(0x7f7d, 0x9270b3e84450455e),
+/* 4894 */ make_floatx80_init(0x7f80, 0xb70ce0e2556456b5),
+/* 4895 */ make_floatx80_init(0x7f83, 0xe4d0191aeabd6c62),
+/* 4896 */ make_floatx80_init(0x7f87, 0x8f020fb0d2b663bd),
+/* 4897 */ make_floatx80_init(0x7f8a, 0xb2c2939d0763fcad),
+/* 4898 */ make_floatx80_init(0x7f8d, 0xdf733884493cfbd8),
+/* 4899 */ make_floatx80_init(0x7f91, 0x8ba80352adc61d67),
+/* 4900 */ make_floatx80_init(0x7f94, 0xae9204275937a4c1),
+/* 4901 */ make_floatx80_init(0x7f97, 0xda3685312f858df1),
+/* 4902 */ make_floatx80_init(0x7f9b, 0x8862133ebdb378b7),
+/* 4903 */ make_floatx80_init(0x7f9e, 0xaa7a980e6d2056e4),
+/* 4904 */ make_floatx80_init(0x7fa1, 0xd5193e1208686c9d),
+/* 4905 */ make_floatx80_init(0x7fa5, 0x852fc6cb454143e2),
+/* 4906 */ make_floatx80_init(0x7fa8, 0xa67bb87e169194db),
+/* 4907 */ make_floatx80_init(0x7fab, 0xd01aa69d9c35fa11),
+/* 4908 */ make_floatx80_init(0x7faf, 0x8210a82281a1bc4b),
+/* 4909 */ make_floatx80_init(0x7fb2, 0xa294d22b220a2b5e),
+/* 4910 */ make_floatx80_init(0x7fb5, 0xcb3a06b5ea8cb635),
+/* 4911 */ make_floatx80_init(0x7fb8, 0xfe088863652fe3c2),
+/* 4912 */ make_floatx80_init(0x7fbc, 0x9ec5553e1f3dee59),
+/* 4913 */ make_floatx80_init(0x7fbf, 0xc676aa8da70d69f0),
+/* 4914 */ make_floatx80_init(0x7fc2, 0xf814553110d0c46c),
+/* 4915 */ make_floatx80_init(0x7fc6, 0x9b0cb53eaa827ac3),
+/* 4916 */ make_floatx80_init(0x7fc9, 0xc1cfe28e55231974),
+/* 4917 */ make_floatx80_init(0x7fcc, 0xf243db31ea6bdfd1),
+/* 4918 */ make_floatx80_init(0x7fd0, 0x976a68ff32836be3),
+/* 4919 */ make_floatx80_init(0x7fd3, 0xbd45033eff2446db),
+/* 4920 */ make_floatx80_init(0x7fd6, 0xec96440ebeed5892),
+/* 4921 */ make_floatx80_init(0x7fda, 0x93ddea893754575b),
+/* 4922 */ make_floatx80_init(0x7fdd, 0xb8d5652b85296d32),
+/* 4923 */ make_floatx80_init(0x7fe0, 0xe70abe766673c87f),
+/* 4924 */ make_floatx80_init(0x7fe4, 0x9066b70a00085d4f),
+/* 4925 */ make_floatx80_init(0x7fe7, 0xb48064cc800a74a3),
+/* 4926 */ make_floatx80_init(0x7fea, 0xe1a07dffa00d11cc),
+/* 4927 */ make_floatx80_init(0x7fee, 0x8d044ebfc4082b1f),
+/* 4928 */ make_floatx80_init(0x7ff1, 0xb045626fb50a35e7),
+/* 4929 */ make_floatx80_init(0x7ff4, 0xdc56bb0ba24cc361),
+/* 4930 */ make_floatx80_init(0x7ff8, 0x89b634e7456ffa1d),
+/* 4931 */ make_floatx80_init(0x7ffb, 0xac23c22116cbf8a4),
+/* 4932 */ make_floatx80_init(0x7ffe, 0xd72cb2a95c7ef6cd),
-- 
2.43.0

Re: [PATCH v5 21/24] target/m68k: Implement packed decimal real loads and stores

[Andreas Schwab]

On Mai 07 2025, Richard Henderson wrote:

> +    /* Convert the 3 digit decimal exponent to binary. */
> +    exp = ((hi >> 24) & 0xf)
> +        + ((hi >> 20) & 0xf) * 10
> +        + ((hi >> 16) & 0xf) * 100;

This is backwards.  An exponent of 123 is stored as 0x01230000, not
0x03210000.

> +    for (int i = 24; exp10; i -= 4, exp10 /= 10) {
> +        res_hi |= (exp10 % 10) << i;

Again, this is backwards.  Also, the decimal exponent of an extended
precision number can be as big as 4951.  From the fpsp040:

| A15. Convert the exponent to bcd.
|      As in A14 above, the exp is converted to bcd and the
|      digits are stored in the final string.
|
|      Digits are stored in L_SCR1(a6) on return from BINDEC as:
|
|	 32               16 15                0
|	-----------------------------------------
|	|  0 | e3 | e2 | e1 | e4 |  X |  X |  X |
|	-----------------------------------------

That is, the fourth digit of the exponent is stored in the upper 4 bits
of the padding (OPERR is set if e4 is non-zero).

-- 
Andreas Schwab, schwab@linux-m68k.org
GPG Key fingerprint = 7578 EB47 D4E5 4D69 2510  2552 DF73 E780 A9DA AEC1
"And now for something completely different."

Re: [PATCH v5 21/24] target/m68k: Implement packed decimal real loads and stores

[Richard Henderson]

On 5/10/25 09:36, Andreas Schwab wrote:
> On Mai 07 2025, Richard Henderson wrote:
> 
>> +    /* Convert the 3 digit decimal exponent to binary. */
>> +    exp = ((hi >> 24) & 0xf)
>> +        + ((hi >> 20) & 0xf) * 10
>> +        + ((hi >> 16) & 0xf) * 100;
> 
> This is backwards.  An exponent of 123 is stored as 0x01230000, not
> 0x03210000.
> 
>> +    for (int i = 24; exp10; i -= 4, exp10 /= 10) {
>> +        res_hi |= (exp10 % 10) << i;
> 
> Again, this is backwards.  Also, the decimal exponent of an extended
> precision number can be as big as 4951.  From the fpsp040:
> 
> | A15. Convert the exponent to bcd.
> |      As in A14 above, the exp is converted to bcd and the
> |      digits are stored in the final string.
> |
> |      Digits are stored in L_SCR1(a6) on return from BINDEC as:
> |
> |	 32               16 15                0
> |	-----------------------------------------
> |	|  0 | e3 | e2 | e1 | e4 |  X |  X |  X |
> |	-----------------------------------------
> 
> That is, the fourth digit of the exponent is stored in the upper 4 bits
> of the padding (OPERR is set if e4 is non-zero).
> 

Well that's annoying.  There's a mis-print in the m68000pm/ad manual, where it says

   SE SM YY E0 E1 E0 E3 x x D16

I didn't notice E0 listed twice and so thought "0 1 2 3" was the order.

Will fix.


r~

[PATCH v5 22/24] tests/tcg/m68k: Add packed decimal tests

[Richard Henderson]

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 tests/tcg/m68k/packeddecimal-1.c | 41 ++++++++++++++++++++++++++++
 tests/tcg/m68k/packeddecimal-2.c | 46 ++++++++++++++++++++++++++++++++
 tests/tcg/m68k/Makefile.target   |  4 ++-
 3 files changed, 90 insertions(+), 1 deletion(-)
 create mode 100644 tests/tcg/m68k/packeddecimal-1.c
 create mode 100644 tests/tcg/m68k/packeddecimal-2.c

diff --git a/tests/tcg/m68k/packeddecimal-1.c b/tests/tcg/m68k/packeddecimal-1.c
new file mode 100644
index 0000000000..5433acd17b
--- /dev/null
+++ b/tests/tcg/m68k/packeddecimal-1.c
@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* Test packed decimal real conversion to long double. */
+
+#include <stdio.h>
+
+struct T {
+    unsigned int d[3];
+    long double f;
+};
+
+static const struct T tests[] = {
+    { { 0x00000001, 0x00000000, 0x00000000 }, 1.0e0l },
+    { { 0x01000001, 0x00000000, 0x00000000 }, 1.0e1l },
+    { { 0x00100001, 0x00000000, 0x00000000 }, 1.0e10l },
+    { { 0x00000000, 0x10000000, 0x00000000 }, 0.1e0l },
+    { { 0x41000001, 0x00000000, 0x00000000 }, 1.0e-1l },
+    { { 0x85000005, 0x55550000, 0x00000000 }, -5.5555e5l },
+    { { 0x09990009, 0x99999999, 0x99999999 }, 9.9999999999999999e999l },
+    { { 0x03210001, 0x23456789, 0x12345678 }, 1.2345678912345678e123l },
+    { { 0x00000000, 0x00000000, 0x00000000 }, 0.0l },
+    { { 0x80000000, 0x00000000, 0x00000000 }, -0.0l },
+    { { 0x09990000, 0x00000000, 0x00000000 }, 0.0e999l },
+};
+
+int main()
+{
+    int ret = 0;
+
+    for (int i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
+        const struct T *t = &tests[i];
+        long double f;
+
+        asm("fmove.p (%1),%0" : "=f"(f) : "a"(t->d));
+
+        if (f != t->f) {
+            fprintf(stderr, "Mismatch at %d: %.17Le != %.17Le\n", i, f, t->f);
+            ret = 1;
+        }
+    }
+    return ret;
+}
diff --git a/tests/tcg/m68k/packeddecimal-2.c b/tests/tcg/m68k/packeddecimal-2.c
new file mode 100644
index 0000000000..448e97ce89
--- /dev/null
+++ b/tests/tcg/m68k/packeddecimal-2.c
@@ -0,0 +1,46 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* Test packed decimal real conversion from long double, dynamic k-factor */
+
+#include <stdio.h>
+#include <float.h>
+
+struct T {
+    unsigned int d[3];
+    long double lf;
+    int kfactor;
+};
+
+static const struct T tests[] = {
+    { { 0x00000001, 0x00000000, 0x00000000 }, 1.0e0l, 0 },
+    { { 0x00100001, 0x00000000, 0x00000000 }, 1.0e10l, 0 },
+    { { 0x41000001, 0x00000000, 0x00000000 }, 1.0e-1l, 0 },
+    { { 0x85000005, 0x55550000, 0x00000000 }, -5.5555e5l, 5 },
+    { { 0x45000005, 0x55550000, 0x00000000 }, 5.5555e-5l, 5 },
+    { { 0x05000002, 0x22220000, 0x00000000 }, 2.2222e5, 99 },
+    { { 0x05000002, 0x22220000, 0x00000000 }, 2.2222e5, 5 },
+    { { 0x05000002, 0x20000000, 0x00000000 }, 2.2222e5, 2 },
+    { { 0x02394001, 0x18973149, 0x53572318 }, LDBL_MAX, 17 },
+    { { 0x42394001, 0x68105157, 0x15560468 }, LDBL_MIN, 17 },
+    { { 0x41594001, 0x82259976, 0x59412373 }, LDBL_TRUE_MIN, 17 },
+};
+
+int main()
+{
+    int ret = 0;
+
+    for (int i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
+        const struct T *t = &tests[i];
+        unsigned int out[3];
+
+        asm("fmove.p %1,(%0),%2"
+            : : "a"(out), "f"(t->lf), "d"(t->kfactor) : "memory");
+
+        if (out[0] != t->d[0] || out[1] != t->d[1] || out[2] != t->d[2]) {
+            fprintf(stderr, "Mismatch at %d: %08x%08x%08x != %08x%08x%08x\n",
+                    i, out[0], out[1], out[2],
+                    t->d[0], t->d[1], t->d[2]);
+            ret = 1;
+        }
+    }
+    return ret;
+}
diff --git a/tests/tcg/m68k/Makefile.target b/tests/tcg/m68k/Makefile.target
index 33f7b1b127..b505260b79 100644
--- a/tests/tcg/m68k/Makefile.target
+++ b/tests/tcg/m68k/Makefile.target
@@ -4,4 +4,6 @@
 #
 
 VPATH += $(SRC_PATH)/tests/tcg/m68k
-TESTS += trap denormal
+TESTS += trap denormal packeddecimal-1 packeddecimal-2
+
+run-packeddecimal-%: QEMU_OPTS += -cpu m68020
-- 
2.43.0

[PATCH v5 23/24] target/m68k: Make vmstate variables static

[Richard Henderson]

These need not be exported beyond cpu.c.
Fix a typo in vmstate_fpu.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index 866d32fc9f..fe53572542 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -478,7 +478,7 @@ static int fpu_post_load(void *opaque, int version)
     return 0;
 }
 
-const VMStateDescription vmmstate_fpu = {
+static const VMStateDescription vmstate_fpu = {
     .name = "cpu/fpu",
     .version_id = 1,
     .minimum_version_id = 1,
@@ -500,7 +500,7 @@ static bool cf_spregs_needed(void *opaque)
     return m68k_feature(&s->env, M68K_FEATURE_CF_ISA_A);
 }
 
-const VMStateDescription vmstate_cf_spregs = {
+static const VMStateDescription vmstate_cf_spregs = {
     .name = "cpu/cf_spregs",
     .version_id = 1,
     .minimum_version_id = 1,
@@ -522,7 +522,7 @@ static bool cpu_68040_mmu_needed(void *opaque)
     return m68k_feature(&s->env, M68K_FEATURE_M68040);
 }
 
-const VMStateDescription vmstate_68040_mmu = {
+static const VMStateDescription vmstate_68040_mmu = {
     .name = "cpu/68040_mmu",
     .version_id = 1,
     .minimum_version_id = 1,
@@ -547,7 +547,7 @@ static bool cpu_68040_spregs_needed(void *opaque)
     return m68k_feature(&s->env, M68K_FEATURE_M68040);
 }
 
-const VMStateDescription vmstate_68040_spregs = {
+static const VMStateDescription vmstate_68040_spregs = {
     .name = "cpu/68040_spregs",
     .version_id = 1,
     .minimum_version_id = 1,
@@ -583,7 +583,7 @@ static const VMStateDescription vmstate_m68k_cpu = {
         VMSTATE_END_OF_LIST()
     },
     .subsections = (const VMStateDescription * const []) {
-        &vmmstate_fpu,
+        &vmstate_fpu,
         &vmstate_cf_spregs,
         &vmstate_68040_mmu,
         &vmstate_68040_spregs,
-- 
2.43.0

[PATCH v5 24/24] target/m68k: Implement FPIAR

[Richard Henderson]

So far, this is only read-as-written.

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2497
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 target/m68k/cpu.h       |  1 +
 target/m68k/cpu.c       | 23 ++++++++++++++++++++++-
 target/m68k/helper.c    | 14 ++++++++------
 target/m68k/translate.c |  3 ++-
 4 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index 8c23d772e4..1b0bb17905 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -110,6 +110,7 @@ typedef struct CPUArchState {
     uint32_t fpsr;
     bool fpsr_inex1;  /* live only with an in-flight decimal operand */
     float_status fp_status;
+    uint32_t fpiar;
 
     uint64_t mactmp;
     /*
diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index fe53572542..00cba4d963 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -470,6 +470,23 @@ static const VMStateDescription vmstate_freg = {
     }
 };
 
+static bool fpu_fpiar_needed(void *opaque)
+{
+    M68kCPU *s = opaque;
+    return s->env.fpiar != 0;
+}
+
+static const VMStateDescription vmstate_fpiar = {
+    .name = "cpu/fpu/fpiar",
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .needed = fpu_fpiar_needed,
+    .fields = (const VMStateField[]) {
+        VMSTATE_UINT32(env.fpiar, M68kCPU),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static int fpu_post_load(void *opaque, int version)
 {
     M68kCPU *s = opaque;
@@ -490,7 +507,11 @@ static const VMStateDescription vmstate_fpu = {
         VMSTATE_STRUCT_ARRAY(env.fregs, M68kCPU, 8, 0, vmstate_freg, FPReg),
         VMSTATE_STRUCT(env.fp_result, M68kCPU, 0, vmstate_freg, FPReg),
         VMSTATE_END_OF_LIST()
-    }
+    },
+    .subsections = (const VMStateDescription * const []) {
+        &vmstate_fpiar,
+        NULL
+    },
 };
 
 static bool cf_spregs_needed(void *opaque)
diff --git a/target/m68k/helper.c b/target/m68k/helper.c
index b50ef6dec3..818c0dd057 100644
--- a/target/m68k/helper.c
+++ b/target/m68k/helper.c
@@ -47,8 +47,8 @@ static int cf_fpu_gdb_get_reg(CPUState *cs, GByteArray *mem_buf, int n)
         return gdb_get_reg32(mem_buf, env->fpcr);
     case 9: /* fpstatus */
         return gdb_get_reg32(mem_buf, env->fpsr);
-    case 10: /* fpiar, not implemented */
-        return gdb_get_reg32(mem_buf, 0);
+    case 10: /* fpiar */
+        return gdb_get_reg32(mem_buf, env->fpiar);
     }
     return 0;
 }
@@ -71,7 +71,8 @@ static int cf_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
     case 9: /* fpstatus */
         env->fpsr = ldl_be_p(mem_buf);
         return 4;
-    case 10: /* fpiar, not implemented */
+    case 10: /* fpiar */
+        env->fpiar = ldl_be_p(mem_buf);
         return 4;
     }
     return 0;
@@ -93,8 +94,8 @@ static int m68k_fpu_gdb_get_reg(CPUState *cs, GByteArray *mem_buf, int n)
         return gdb_get_reg32(mem_buf, env->fpcr);
     case 9: /* fpstatus */
         return gdb_get_reg32(mem_buf, env->fpsr);
-    case 10: /* fpiar, not implemented */
-        return gdb_get_reg32(mem_buf, 0);
+    case 10: /* fpiar */
+        return gdb_get_reg32(mem_buf, env->fpiar);
     }
     return 0;
 }
@@ -116,7 +117,8 @@ static int m68k_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
     case 9: /* fpstatus */
         env->fpsr = ldl_be_p(mem_buf);
         return 4;
-    case 10: /* fpiar, not implemented */
+    case 10: /* fpiar */
+        env->fpiar = ldl_be_p(mem_buf);
         return 4;
     }
     return 0;
diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 44c1b3c0cf..aa60480f95 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -4674,7 +4674,7 @@ static void gen_load_fcr(DisasContext *s, TCGv res, int reg)
 {
     switch (reg) {
     case M68K_FPIAR:
-        tcg_gen_movi_i32(res, 0);
+        tcg_gen_ld_i32(res, tcg_env, offsetof(CPUM68KState, fpiar));
         break;
     case M68K_FPSR:
         tcg_gen_ld_i32(res, tcg_env, offsetof(CPUM68KState, fpsr));
@@ -4689,6 +4689,7 @@ static void gen_store_fcr(DisasContext *s, TCGv val, int reg)
 {
     switch (reg) {
     case M68K_FPIAR:
+        tcg_gen_st_i32(val, tcg_env, offsetof(CPUM68KState, fpiar));
         break;
     case M68K_FPSR:
         tcg_gen_st_i32(val, tcg_env, offsetof(CPUM68KState, fpsr));
-- 
2.43.0

Re: [PATCH v5 00/24] target/m68k: fpu improvements

[Helge Deller]

On 5/7/25 23:12, Richard Henderson wrote:
> v3: https://lore.kernel.org/qemu-devel/20240909172823.649837-1-richard.henderson@linaro.org/
> v4: https://lore.kernel.org/qemu-devel/20250224171444.440135-1-richard.henderson@linaro.org/
> 
> Changes for v5:
>    - Rebase from February.  :-/
>    - Use ldl_be_p in m68k_fpu_gdb_set_reg (phil).
> 
> Patches needing review:
>    03-target-m68k-Keep-FPSR-up-to-date.patch
>    05-target-m68k-Update-FPSR-for-FMOVECR.patch
>    09-target-m68k-Use-OS_UNSIZED-in-LEA-PEA-JMP.patch
>    10-target-m68k-Move-pre-dec-post-inc-to-gen_lea_mode.patch
>    11-target-m68k-Split-gen_ea_mode-for-load-store.patch
>    21-target-m68k-Implement-packed-decimal-real-loads-a.patch

Hi Richard,
I noticed that the FPU emulation on hppa has some issues too.
Any suggestion, how one can test the runtime FP emulation (inside the VM)?

Helge

Re: [PATCH v5 00/24] target/m68k: fpu improvements

[Richard Henderson]

On 5/7/25 14:28, Helge Deller wrote:
> On 5/7/25 23:12, Richard Henderson wrote:
>> v3: https://lore.kernel.org/qemu-devel/20240909172823.649837-1- 
>> richard.henderson@linaro.org/
>> v4: https://lore.kernel.org/qemu-devel/20250224171444.440135-1- 
>> richard.henderson@linaro.org/
>>
>> Changes for v5:
>>    - Rebase from February.  :-/
>>    - Use ldl_be_p in m68k_fpu_gdb_set_reg (phil).
>>
>> Patches needing review:
>>    03-target-m68k-Keep-FPSR-up-to-date.patch
>>    05-target-m68k-Update-FPSR-for-FMOVECR.patch
>>    09-target-m68k-Use-OS_UNSIZED-in-LEA-PEA-JMP.patch
>>    10-target-m68k-Move-pre-dec-post-inc-to-gen_lea_mode.patch
>>    11-target-m68k-Split-gen_ea_mode-for-load-store.patch
>>    21-target-m68k-Implement-packed-decimal-real-loads-a.patch
> 
> Hi Richard,
> I noticed that the FPU emulation on hppa has some issues too.
> Any suggestion, how one can test the runtime FP emulation (inside the VM)?

RISU is probably best.


r~