* [PATCH v3 00/26] target/m68k: fpu improvements
@ 2024-09-09 17:27 Richard Henderson
2024-09-09 17:27 ` [PATCH v3 01/26] target/m68k: Always return a temporary from gen_lea_mode Richard Henderson
` (25 more replies)
0 siblings, 26 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:27 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Supercedes: 20240812004451.13711-1-richard.henderson@linaro.org
("[PATCH for-9.2 v2 0/4] target/m68k: Implement fmove.p")
Changes for v3:
- Implement FPSR.EXC. In particular, packed decimal sets a
different inexact bit.
- Lots of cleanup to the address/load/store translation, in
order to be able to pass down insn+ext only to gen_store_fp,
and not store it in DisasContext.
- Implement FPIAR stub.
r~
Richard Henderson (26):
target/m68k: Always return a temporary from gen_lea_mode
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
softfloat: Set QEMU_NO_HARDFLOAT for m68k
target/m68k: Invoke 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 | 7 +-
fpu/softfloat.c | 2 +-
target/m68k/cpu.c | 38 +-
target/m68k/fpu_helper.c | 351 ++-
target/m68k/gen-floatx80-pow10.c | 33 +
target/m68k/helper.c | 18 +-
target/m68k/translate.c | 800 +++--
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 +-
12 files changed, 5763 insertions(+), 539 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
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH v3 01/26] target/m68k: Always return a temporary from gen_lea_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
@ 2024-09-09 17:27 ` Richard Henderson
2024-09-09 17:27 ` [PATCH v3 02/26] target/m68k: Add FPSR exception bit defines Richard Henderson
` (24 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:27 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel, Philippe Mathieu-Daudé
Returning a raw areg does not preserve the value if the areg
is subsequently modified. Fixes, e.g. "jsr (sp)", where the
return address is pushed before the branch.
Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2483
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20240813000737.228470-1-richard.henderson@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
---
target/m68k/translate.c | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 445966fb6a..ad3ce34501 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -720,7 +720,9 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
}
/* fallthru */
case 2: /* Indirect register */
- return get_areg(s, reg0);
+ tmp = tcg_temp_new();
+ tcg_gen_mov_i32(tmp, get_areg(s, reg0));
+ return tmp;
case 4: /* Indirect predecrememnt. */
if (opsize == OS_UNSIZED) {
return NULL_QREG;
@@ -747,20 +749,23 @@ static TCGv gen_lea_mode(CPUM68KState *env, DisasContext *s,
switch (reg0) {
case 0: /* Absolute short. */
offset = (int16_t)read_im16(env, s);
- return tcg_constant_i32(offset);
+ break;
case 1: /* Absolute long. */
offset = read_im32(env, s);
- return tcg_constant_i32(offset);
+ break;
case 2: /* pc displacement */
offset = s->pc;
offset += (int16_t)read_im16(env, s);
- return tcg_constant_i32(offset);
+ break;
case 3: /* pc index+displacement. */
return gen_lea_indexed(env, s, NULL_QREG);
case 4: /* Immediate. */
default:
return NULL_QREG;
}
+ tmp = tcg_temp_new();
+ tcg_gen_movi_i32(tmp, offset);
+ return tmp;
}
/* Should never happen. */
return NULL_QREG;
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 02/26] target/m68k: Add FPSR exception bit defines
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
2024-09-09 17:27 ` [PATCH v3 01/26] target/m68k: Always return a temporary from gen_lea_mode Richard Henderson
@ 2024-09-09 17:27 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load Richard Henderson
` (23 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:27 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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 b5bbeedb7a..e8dd75d242 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -440,6 +440,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 8314791f50..c6d93b56a0 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -170,19 +170,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)) {
- 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;
}
@@ -192,19 +192,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;
@@ -214,7 +214,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
2024-09-09 17:27 ` [PATCH v3 01/26] target/m68k: Always return a temporary from gen_lea_mode Richard Henderson
2024-09-09 17:27 ` [PATCH v3 02/26] target/m68k: Add FPSR exception bit defines Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 21:59 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 04/26] target/m68k: Keep FPSR up-to-date Richard Henderson
` (22 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Call cpu_m68k_set_fpcr to make sure softfloat internals
are up-to-date with the restored FPCR.
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 1d49f4cb23..4d70cd50b4 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -402,6 +402,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 04/26] target/m68k: Keep FPSR up-to-date
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (2 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 05/26] target/m68k: Update FPSR.EXC Richard Henderson
` (21 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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, combine this
with the existing helper_ftst function to create helper_update_fpsr.
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
target/m68k/cpu.h | 2 -
target/m68k/helper.h | 4 +-
target/m68k/cpu.c | 10 ----
target/m68k/fpu_helper.c | 115 ++++++++++++---------------------------
target/m68k/helper.c | 4 +-
target/m68k/translate.c | 10 ++--
6 files changed, 42 insertions(+), 103 deletions(-)
diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index e8dd75d242..389cd1f364 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -199,8 +199,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..97a0b22ffb 100644
--- a/target/m68k/helper.h
+++ b/target/m68k/helper.h
@@ -54,10 +54,8 @@ 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_FLAGS_2(update_fpsr, TCG_CALL_NO_WG, void, env, fp)
DEF_HELPER_3(fconst, void, env, fp, i32)
DEF_HELPER_3(fmovemx_st_predec, i32, env, i32, i32)
DEF_HELPER_3(fmovemx_st_postinc, i32, env, i32, i32)
diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index 4d70cd50b4..8c28db2e95 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -390,20 +390,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;
}
@@ -412,7 +403,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 c6d93b56a0..56694418f2 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -164,76 +164,47 @@ 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)
+void HELPER(update_fpsr)(CPUM68KState *env, FPReg *pval)
{
- int target_bits = 0;
+ uint32_t fpsr = env->fpsr;
+ floatx80 val = pval->d;
+ int soft;
- 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)) {
- 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;
-/* Convert cpu_m68k exception flags to target form. */
-static int cpu_m68k_exceptbits_to_host(int target_bits)
-{
- int host_bits = 0;
-
- if (target_bits & FPSR_AEXP_IOP) {
- host_bits |= float_flag_invalid;
+ if (floatx80_is_neg(val)) {
+ fpsr |= FPSR_CC_N;
}
- if (target_bits & FPSR_AEXP_OVFL) {
- host_bits |= float_flag_overflow;
+ if (floatx80_is_any_nan(val)) {
+ fpsr |= FPSR_CC_A;
+ } else if (floatx80_is_infinity(val)) {
+ fpsr |= FPSR_CC_I;
+ } else if (floatx80_is_zero(val)) {
+ fpsr |= FPSR_CC_Z;
}
- if (target_bits & FPSR_AEXP_UNFL) {
- host_bits |= float_flag_underflow;
+
+ soft = get_float_exception_flags(&env->fp_status);
+ if (soft) {
+ set_float_exception_flags(0, &env->fp_status);
+
+ if (soft & float_flag_invalid) {
+ fpsr |= FPSR_AEXP_IOP;
+ }
+ if (soft & float_flag_overflow) {
+ fpsr |= FPSR_AEXP_OVFL;
+ }
+ if (soft & (float_flag_underflow | float_flag_output_denormal)) {
+ fpsr |= FPSR_AEXP_UNFL;
+ }
+ if (soft & float_flag_divbyzero) {
+ fpsr |= FPSR_AEXP_DZ;
+ }
+ if (soft & float_flag_inexact) {
+ fpsr |= FPSR_AEXC_INEX;
+ }
}
- 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) \
@@ -445,24 +416,6 @@ void HELPER(fcmp)(CPUM68KState *env, FPReg *val0, FPReg *val1)
env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | float_comp_to_cc(float_compare);
}
-void HELPER(ftst)(CPUM68KState *env, FPReg *val)
-{
- uint32_t cc = 0;
-
- if (floatx80_is_neg(val->d)) {
- cc |= FPSR_CC_N;
- }
-
- if (floatx80_is_any_nan(val->d)) {
- cc |= FPSR_CC_A;
- } else if (floatx80_is_infinity(val->d)) {
- cc |= FPSR_CC_I;
- } else if (floatx80_is_zero(val->d)) {
- cc |= FPSR_CC_Z;
- }
- env->fpsr = (env->fpsr & ~FPSR_CC_MASK) | cc;
-}
-
void HELPER(fconst)(CPUM68KState *env, FPReg *val, uint32_t offset)
{
val->d = fpu_rom[offset];
diff --git a/target/m68k/helper.c b/target/m68k/helper.c
index 4c85badd5d..6fc5afd296 100644
--- a/target/m68k/helper.c
+++ b/target/m68k/helper.c
@@ -88,7 +88,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);
}
@@ -110,7 +110,7 @@ static int m68k_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
cpu_m68k_set_fpcr(env, ldl_p(mem_buf));
return 4;
case 9: /* fpstatus */
- cpu_m68k_set_fpsr(env, ldl_p(mem_buf));
+ env->fpsr = ldl_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 ad3ce34501..423c663607 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -4732,7 +4732,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));
@@ -4746,7 +4746,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);
@@ -4965,7 +4965,7 @@ DISAS_INSN(fpu)
EA_STORE, IS_USER(s)) == -1) {
gen_addr_fault(s);
}
- gen_helper_ftst(tcg_env, cpu_src);
+ gen_helper_update_fpsr(tcg_env, cpu_src);
return;
case 4: /* fmove to control register. */
case 5: /* fmove from control register. */
@@ -5159,12 +5159,12 @@ DISAS_INSN(fpu)
gen_helper_fcmp(tcg_env, cpu_src, cpu_dest);
return;
case 0x3a: /* ftst */
- gen_helper_ftst(tcg_env, cpu_src);
+ gen_helper_update_fpsr(tcg_env, cpu_src);
return;
default:
goto undef;
}
- gen_helper_ftst(tcg_env, cpu_dest);
+ gen_helper_update_fpsr(tcg_env, cpu_dest);
return;
undef:
/* FIXME: Is this right for offset addressing modes? */
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 05/26] target/m68k: Update FPSR.EXC
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (3 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 04/26] target/m68k: Keep FPSR up-to-date Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 06/26] softfloat: Set QEMU_NO_HARDFLOAT for m68k Richard Henderson
` (20 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
So far we've only been updating the AEXC byte.
Update the EXC byte as well.
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 56694418f2..0c8c14966d 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -170,7 +170,7 @@ void HELPER(update_fpsr)(CPUM68KState *env, FPReg *pval)
floatx80 val = pval->d;
int soft;
- fpsr &= ~FPSR_CC_MASK;
+ fpsr &= ~(FPSR_CC_MASK | FPSR_EXC_MASK);
if (floatx80_is_neg(val)) {
fpsr |= FPSR_CC_N;
@@ -187,20 +187,22 @@ void HELPER(update_fpsr)(CPUM68KState *env, FPReg *pval)
if (soft) {
set_float_exception_flags(0, &env->fp_status);
- if (soft & float_flag_invalid) {
- fpsr |= FPSR_AEXP_IOP;
+ if (soft & float_flag_invalid_snan) {
+ fpsr |= FPSR_EXC_SNAN | FPSR_AEXP_IOP;
+ } else if (soft & float_flag_invalid) {
+ fpsr |= FPSR_EXC_OPERR | FPSR_AEXP_IOP;
}
if (soft & float_flag_overflow) {
- fpsr |= FPSR_AEXP_OVFL;
+ fpsr |= FPSR_EXC_OVFL | FPSR_AEXP_OVFL;
}
if (soft & (float_flag_underflow | float_flag_output_denormal)) {
- fpsr |= FPSR_AEXP_UNFL;
+ fpsr |= FPSR_EXC_UNFL | FPSR_AEXP_UNFL;
}
if (soft & float_flag_divbyzero) {
- fpsr |= FPSR_AEXP_DZ;
+ fpsr |= FPSR_EXC_DZ | FPSR_AEXP_DZ;
}
if (soft & float_flag_inexact) {
- fpsr |= FPSR_AEXC_INEX;
+ fpsr |= FPSR_EXC_INEX2 | FPSR_AEXC_INEX;
}
}
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 06/26] softfloat: Set QEMU_NO_HARDFLOAT for m68k
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (4 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 05/26] target/m68k: Update FPSR.EXC Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 07/26] target/m68k: Invoke update_fpsr for FMOVECR Richard Henderson
` (19 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Like ppc, m68k needs the complete set of exception flags for each
instruction, which means that float_flag_inexact will never be set
before each instruction. Thus the hardfloat path will not be used,
so we improve things by compiling it out.
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 027a8e576d..0e4ff874e4 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -220,7 +220,7 @@ GEN_INPUT_FLUSH3(float64_input_flush3, float64)
* the use of hardfloat, since hardfloat relies on the inexact flag being
* already set.
*/
-#if defined(TARGET_PPC) || defined(__FAST_MATH__)
+#if defined(TARGET_M68K) || defined(TARGET_PPC) || defined(__FAST_MATH__)
# if defined(__FAST_MATH__)
# warning disabling hardfloat due to -ffast-math: hardfloat requires an exact \
IEEE implementation
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 07/26] target/m68k: Invoke update_fpsr for FMOVECR
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (5 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 06/26] softfloat: Set QEMU_NO_HARDFLOAT for m68k Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 08/26] target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL Richard Henderson
` (18 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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/translate.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/target/m68k/translate.c b/target/m68k/translate.c
index 423c663607..003318163c 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -4955,6 +4955,7 @@ DISAS_INSN(fpu)
TCGv rom_offset = tcg_constant_i32(opmode);
cpu_dest = gen_fp_ptr(REG(ext, 7));
gen_helper_fconst(tcg_env, cpu_dest, rom_offset);
+ gen_helper_update_fpsr(tcg_env, cpu_dest);
return;
}
break;
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 08/26] target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (6 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 07/26] target/m68k: Invoke update_fpsr for FMOVECR Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA Richard Henderson
` (17 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel, Philippe Mathieu-Daudé
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 389cd1f364..b40c5b64fe 100644
--- a/target/m68k/cpu.h
+++ b/target/m68k/cpu.h
@@ -572,6 +572,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 8c28db2e95..188afc57f8 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -182,6 +182,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);
}
/*
@@ -224,6 +225,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (7 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 08/26] target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:02 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode Richard Henderson
` (16 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
This will enable further cleanups further down the call chain.
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 003318163c..1ba1220b21 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -896,14 +896,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();
@@ -1367,18 +1359,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (8 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:03 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 11/26] target/m68k: Use OS_UNSIZED in LEA, PEA, JMP Richard Henderson
` (15 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
The mode argument is extracted from 3 bits, and all cases are covered.
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 1ba1220b21..71dfa6d9a2 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -767,8 +767,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,
@@ -892,8 +891,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 11/26] target/m68k: Use OS_UNSIZED in LEA, PEA, JMP
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (9 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 12/26] target/m68k: Move pre-dec/post-inc to gen_lea_mode Richard Henderson
` (14 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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 71dfa6d9a2..c94ed8d463 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -2560,7 +2560,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;
@@ -2657,7 +2657,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;
@@ -2908,7 +2908,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 12/26] target/m68k: Move pre-dec/post-inc to gen_lea_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (10 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 11/26] target/m68k: Use OS_UNSIZED in LEA, PEA, JMP Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 13/26] target/m68k: Split gen_ea_mode for load/store Richard Henderson
` (13 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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 c94ed8d463..c6b901ff83 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -698,15 +698,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;
@@ -714,34 +722,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);
@@ -787,7 +798,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) {
@@ -795,76 +806,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) {
@@ -886,12 +846,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)
@@ -1068,43 +1053,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));
@@ -1147,11 +1098,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,
@@ -1359,8 +1321,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); \
@@ -1729,7 +1695,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 */
@@ -1766,7 +1732,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 */
@@ -2355,15 +2321,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)
@@ -2727,15 +2684,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;
- }
}
}
@@ -4452,17 +4400,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)
@@ -4845,7 +4782,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) {
@@ -4860,7 +4797,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);
}
}
}
@@ -4921,7 +4858,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 13/26] target/m68k: Split gen_ea_mode for load/store
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (11 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 12/26] target/m68k: Move pre-dec/post-inc to gen_lea_mode Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed Richard Henderson
` (12 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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 c6b901ff83..2c0852ac3a 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -59,8 +59,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)
{
@@ -104,7 +102,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 */
@@ -338,21 +335,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)
{
@@ -794,9 +776,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;
@@ -804,40 +786,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:
@@ -856,17 +826,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:
@@ -879,6 +845,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();
@@ -1321,13 +1324,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; \
@@ -1336,10 +1335,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; \
} \
@@ -1701,15 +1700,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);
}
@@ -1738,15 +1736,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);
}
@@ -3123,11 +3120,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (12 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 13/26] target/m68k: Split gen_ea_mode for load/store Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:05 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode Richard Henderson
` (11 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Use the env pointer in DisasContext.
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 2c0852ac3a..78a9358416 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -391,7 +391,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;
@@ -400,7 +400,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;
@@ -418,9 +418,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;
@@ -466,9 +466,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;
@@ -737,7 +737,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. */
@@ -751,7 +751,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (13 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode Richard Henderson
` (10 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Use the env pointer in DisasContext.
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 78a9358416..938c650c78 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -693,8 +693,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;
@@ -732,7 +731,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. */
@@ -741,14 +740,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);
@@ -768,7 +767,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);
}
/*
@@ -826,7 +825,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;
@@ -869,7 +868,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;
}
@@ -1109,7 +1108,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;
}
@@ -1930,7 +1929,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;
}
@@ -2672,7 +2671,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (14 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode Richard Henderson
` (9 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Use the env pointer in DisasContext.
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 938c650c78..a3452ace96 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -775,9 +775,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;
@@ -798,19 +797,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();
@@ -1323,7 +1322,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)) { \
@@ -1699,10 +1698,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);
@@ -1735,10 +1732,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);
@@ -3119,11 +3114,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (15 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp Richard Henderson
` (8 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Use the env pointer in DisasContext.
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 a3452ace96..8a96b38682 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -843,8 +843,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;
@@ -1334,7 +1333,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); \
@@ -1703,7 +1702,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);
}
@@ -1737,7 +1736,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (16 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store Richard Henderson
` (7 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Use the env pointer in DisasContext.
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 8a96b38682..5bfdf9aadf 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -1011,9 +1011,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;
@@ -1058,23 +1057,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:
@@ -1082,9 +1081,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:
@@ -1121,7 +1120,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (17 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:13 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp Richard Henderson
` (6 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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.
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 5bfdf9aadf..c81d093c61 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -329,12 +329,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)
{
@@ -1001,60 +995,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));
@@ -1096,7 +1068,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 */
@@ -1107,20 +1079,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_update_fpsr(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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (18 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:14 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp Richard Henderson
` (5 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
Move the exception to be raised into the helpers.
This in preparation for raising other exceptions,
and still wanting to return failure.
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 c81d093c61..df886ed062 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -1023,6 +1023,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 */
@@ -1079,6 +1080,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);
@@ -1112,6 +1114,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 */
@@ -1122,6 +1125,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_update_fpsr(tcg_env, cpu_src);
}
- gen_helper_update_fpsr(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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (19 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:16 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp Richard Henderson
` (4 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
This enables the exceptions raised by the actual load
to be reflected as a failure.
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 df886ed062..e966d2c929 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -901,53 +901,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)
{
@@ -995,8 +948,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);
@@ -1083,10 +1036,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (20 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:16 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 23/26] target/m68k: Implement packed decimal real loads and stores Richard Henderson
` (3 subsequent siblings)
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
This enables the exceptions raised by the actual store
to be reflected as a failure.
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 e966d2c929..9b1d39d7df 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -901,53 +901,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)
{
@@ -1087,12 +1040,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. */
@@ -1126,10 +1080,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_update_fpsr(tcg_env, cpu_src);
}
return;
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 23/26] target/m68k: Implement packed decimal real loads and stores
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (21 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 24/26] tests/tcg/m68k: Add packed decimal tests Richard Henderson
` (2 subsequent siblings)
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
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 | 236 ++
target/m68k/gen-floatx80-pow10.c | 33 +
target/m68k/translate.c | 55 +-
target/m68k/floatx80-pow10.c.inc | 4935 ++++++++++++++++++++++++++++++
6 files changed, 5245 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 b40c5b64fe..a676ae0b34 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 97a0b22ffb..a6a8b0ccb1 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 0c8c14966d..dcbbb985e9 100644
--- a/target/m68k/fpu_helper.c
+++ b/target/m68k/fpu_helper.c
@@ -206,6 +206,12 @@ void HELPER(update_fpsr)(CPUM68KState *env, FPReg *pval)
}
}
+ /* Incorporate packed decimal real inexact conversion. */
+ if (env->fpsr_inex1) {
+ env->fpsr_inex1 = false;
+ fpsr |= FPSR_EXC_INEX1 | FPSR_AEXC_INEX;
+ }
+
env->fpsr = fpsr;
}
@@ -704,3 +710,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.
+ * Adjust, so that we compute the value scaled by 10**17, which will
+ * allows an integer to be extracted to match the output digits.
+ */
+ 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 9b1d39d7df..7a23547beb 100644
--- a/target/m68k/translate.c
+++ b/target/m68k/translate.c
@@ -647,6 +647,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();
}
@@ -966,11 +967,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();
@@ -1028,20 +1031,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);
@@ -1119,12 +1122,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();
}
@@ -4869,6 +4887,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_update_fpsr(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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 24/26] tests/tcg/m68k: Add packed decimal tests
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (22 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 23/26] target/m68k: Implement packed decimal real loads and stores Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 17:28 ` [PATCH v3 25/26] target/m68k: Make vmstate variables static Richard Henderson
2024-09-09 17:28 ` [PATCH v3 26/26] target/m68k: Implement FPIAR Richard Henderson
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel, Philippe Mathieu-Daudé
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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 25/26] target/m68k: Make vmstate variables static
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (23 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 24/26] tests/tcg/m68k: Add packed decimal tests Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
2024-09-09 22:17 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 26/26] target/m68k: Implement FPIAR Richard Henderson
25 siblings, 1 reply; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
These need not be exported beyond cpu.c.
Fix a typo in vmstate_fpu.
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 188afc57f8..fd6c227820 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -400,7 +400,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,
@@ -422,7 +422,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,
@@ -444,7 +444,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,
@@ -469,7 +469,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,
@@ -505,7 +505,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
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [PATCH v3 26/26] target/m68k: Implement FPIAR
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
` (24 preceding siblings ...)
2024-09-09 17:28 ` [PATCH v3 25/26] target/m68k: Make vmstate variables static Richard Henderson
@ 2024-09-09 17:28 ` Richard Henderson
25 siblings, 0 replies; 40+ messages in thread
From: Richard Henderson @ 2024-09-09 17:28 UTC (permalink / raw)
To: qemu-devel; +Cc: laurent, daniel
So far, this is only read-as-written.
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
target/m68k/cpu.h | 1 +
target/m68k/cpu.c | 23 ++++++++++++++++++++++-
target/m68k/helper.c | 14 ++++++++------
3 files changed, 31 insertions(+), 7 deletions(-)
diff --git a/target/m68k/cpu.h b/target/m68k/cpu.h
index a676ae0b34..9d987b42be 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 fd6c227820..e36eb3e5d6 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -392,6 +392,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;
@@ -412,7 +429,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 6fc5afd296..dae6542e6d 100644
--- a/target/m68k/helper.c
+++ b/target/m68k/helper.c
@@ -44,8 +44,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;
}
@@ -67,7 +67,8 @@ static int cf_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
case 9: /* fpstatus */
env->fpsr = ldl_p(mem_buf);
return 4;
- case 10: /* fpiar, not implemented */
+ case 10: /* fpiar */
+ env->fpiar = ldl_p(mem_buf);
return 4;
}
return 0;
@@ -89,8 +90,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;
}
@@ -112,7 +113,8 @@ static int m68k_fpu_gdb_set_reg(CPUState *cs, uint8_t *mem_buf, int n)
case 9: /* fpstatus */
env->fpsr = ldl_p(mem_buf);
return 4;
- case 10: /* fpiar, not implemented */
+ case 10: /* fpiar */
+ env->fpiar = ldl_p(mem_buf);
return 4;
}
return 0;
--
2.43.0
^ permalink raw reply related [flat|nested] 40+ messages in thread
* Re: [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load
2024-09-09 17:28 ` [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load Richard Henderson
@ 2024-09-09 21:59 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 21:59 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Call cpu_m68k_set_fpcr to make sure softfloat internals
> are up-to-date with the restored FPCR.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/cpu.c | 1 +
> 1 file changed, 1 insertion(+)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA
2024-09-09 17:28 ` [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA Richard Henderson
@ 2024-09-09 22:02 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:02 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> This will enable further cleanups further down the call chain.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 24 ++++++++++--------------
> 1 file changed, 10 insertions(+), 14 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode
2024-09-09 17:28 ` [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode Richard Henderson
@ 2024-09-09 22:03 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:03 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> The mode argument is extracted from 3 bits, and all cases are covered.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 6 ++----
> 1 file changed, 2 insertions(+), 4 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed
2024-09-09 17:28 ` [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed Richard Henderson
@ 2024-09-09 22:05 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:05 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Use the env pointer in DisasContext.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 16 ++++++++--------
> 1 file changed, 8 insertions(+), 8 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode
2024-09-09 17:28 ` [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode Richard Henderson
@ 2024-09-09 22:06 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:06 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Use the env pointer in DisasContext.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 23 +++++++++++------------
> 1 file changed, 11 insertions(+), 12 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode
2024-09-09 17:28 ` [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode Richard Henderson
@ 2024-09-09 22:06 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:06 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Use the env pointer in DisasContext.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 31 ++++++++++++-------------------
> 1 file changed, 12 insertions(+), 19 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode
2024-09-09 17:28 ` [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode Richard Henderson
@ 2024-09-09 22:06 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:06 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Use the env pointer in DisasContext.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 9 ++++-----
> 1 file changed, 4 insertions(+), 5 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp
2024-09-09 17:28 ` [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp Richard Henderson
@ 2024-09-09 22:06 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:06 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Use the env pointer in DisasContext.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 21 ++++++++++-----------
> 1 file changed, 10 insertions(+), 11 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store
2024-09-09 17:28 ` [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store Richard Henderson
@ 2024-09-09 22:13 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:13 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> 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.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 125 +++++++++++++++++++++-------------------
> 1 file changed, 65 insertions(+), 60 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp
2024-09-09 17:28 ` [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp Richard Henderson
@ 2024-09-09 22:14 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:14 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> Move the exception to be raised into the helpers.
> This in preparation for raising other exceptions,
> and still wanting to return failure.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 10 ++++++----
> 1 file changed, 6 insertions(+), 4 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp
2024-09-09 17:28 ` [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp Richard Henderson
@ 2024-09-09 22:16 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:16 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> This enables the exceptions raised by the actual load
> to be reflected as a failure.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 104 ++++++++++++++++++++--------------------
> 1 file changed, 51 insertions(+), 53 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp
2024-09-09 17:28 ` [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp Richard Henderson
@ 2024-09-09 22:16 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:16 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> This enables the exceptions raised by the actual store
> to be reflected as a failure.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/translate.c | 107 ++++++++++++++++++++--------------------
> 1 file changed, 53 insertions(+), 54 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH v3 25/26] target/m68k: Make vmstate variables static
2024-09-09 17:28 ` [PATCH v3 25/26] target/m68k: Make vmstate variables static Richard Henderson
@ 2024-09-09 22:17 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 40+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-09-09 22:17 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: laurent, daniel
On 9/9/24 19:28, Richard Henderson wrote:
> These need not be exported beyond cpu.c.
> Fix a typo in vmstate_fpu.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> target/m68k/cpu.c | 10 +++++-----
> 1 file changed, 5 insertions(+), 5 deletions(-)
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 40+ messages in thread
end of thread, other threads:[~2024-09-09 22:17 UTC | newest]
Thread overview: 40+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-09-09 17:27 [PATCH v3 00/26] target/m68k: fpu improvements Richard Henderson
2024-09-09 17:27 ` [PATCH v3 01/26] target/m68k: Always return a temporary from gen_lea_mode Richard Henderson
2024-09-09 17:27 ` [PATCH v3 02/26] target/m68k: Add FPSR exception bit defines Richard Henderson
2024-09-09 17:28 ` [PATCH v3 03/26] target/m68k: Restore fp rounding mode on vm load Richard Henderson
2024-09-09 21:59 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 04/26] target/m68k: Keep FPSR up-to-date Richard Henderson
2024-09-09 17:28 ` [PATCH v3 05/26] target/m68k: Update FPSR.EXC Richard Henderson
2024-09-09 17:28 ` [PATCH v3 06/26] softfloat: Set QEMU_NO_HARDFLOAT for m68k Richard Henderson
2024-09-09 17:28 ` [PATCH v3 07/26] target/m68k: Invoke update_fpsr for FMOVECR Richard Henderson
2024-09-09 17:28 ` [PATCH v3 08/26] target/m68k: Introduce M68K_FEATURE_FPU_PACKED_DECIMAL Richard Henderson
2024-09-09 17:28 ` [PATCH v3 09/26] target/m68k: Merge gen_ea into SRC_EA and DEST_EA Richard Henderson
2024-09-09 22:02 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 10/26] target/m68k: Use g_assert_not_reached in gen_lea_mode and gen_ea_mode Richard Henderson
2024-09-09 22:03 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 11/26] target/m68k: Use OS_UNSIZED in LEA, PEA, JMP Richard Henderson
2024-09-09 17:28 ` [PATCH v3 12/26] target/m68k: Move pre-dec/post-inc to gen_lea_mode Richard Henderson
2024-09-09 17:28 ` [PATCH v3 13/26] target/m68k: Split gen_ea_mode for load/store Richard Henderson
2024-09-09 17:28 ` [PATCH v3 14/26] target/m68k: Remove env argument to gen_lea_indexed Richard Henderson
2024-09-09 22:05 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 15/26] target/m68k: Remove env argument to gen_lea_mode Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 16/26] target/m68k: Remove env argument to gen_load_mode Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 17/26] target/m68k: Remove env argument to gen_store_mode Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 18/26] target/m68k: Remove env argument to gen_ea_mode_fp Richard Henderson
2024-09-09 22:06 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 19/26] target/m68k: Split gen_ea_mode_fp for load/store Richard Henderson
2024-09-09 22:13 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 20/26] target/m68k: Move gen_addr_fault into gen_{load, store}_mode_fp Richard Henderson
2024-09-09 22:14 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 21/26] target/m68k: Merge gen_load_fp, gen_load_mode_fp Richard Henderson
2024-09-09 22:16 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 22/26] target/m68k: Merge gen_store_fp, gen_store_mode_fp Richard Henderson
2024-09-09 22:16 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 23/26] target/m68k: Implement packed decimal real loads and stores Richard Henderson
2024-09-09 17:28 ` [PATCH v3 24/26] tests/tcg/m68k: Add packed decimal tests Richard Henderson
2024-09-09 17:28 ` [PATCH v3 25/26] target/m68k: Make vmstate variables static Richard Henderson
2024-09-09 22:17 ` Philippe Mathieu-Daudé
2024-09-09 17:28 ` [PATCH v3 26/26] target/m68k: Implement FPIAR Richard Henderson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).