From patchwork Mon Sep 9 17:28:20 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Henderson X-Patchwork-Id: 826624 Delivered-To: patch@linaro.org Received: by 2002:adf:a345:0:b0:367:895a:4699 with SMTP id d5csp2130307wrb; Mon, 9 Sep 2024 10:30:22 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCUcXq/opLLCSVllpBOxl41F0lbPJGgU9Kgpg794rWRnsbjgBq+FgvIrR0q0MyTyZkl+yBm3TQ==@linaro.org X-Google-Smtp-Source: AGHT+IFjoqIgB6sAM7yRtLNNIiXM76gXk4ZMPeKnRkBjSGY9TO41JYnaBKlVfA1T4Crkw6IU8YKB X-Received: by 2002:a05:6214:5892:b0:6c3:54f7:c174 with SMTP id 6a1803df08f44-6c5285024c2mr128498426d6.18.1725903021888; Mon, 09 Sep 2024 10:30:21 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1725903021; cv=none; d=google.com; s=arc-20240605; b=hrv25U7WvlDLykCeRoZV6bceEoP27Jz24IHOpn2F8ziRcvmMDGLDYLvh3aoMJM4hv7 t/POjt3kbxWEQo1GHOUN+Q5HWRIlxlbNDAMuZpgREsgEyUP2bUUuoyYvavZ9PeeZZ6Q/ zMGmc3lGLb2z47x/5dnmxZ7iorbEEen9MGGdWajjtFtxGLf5YTwEYIAd/dA65xeT7y0T dbY9B3YoHAWg9jiYi2eS52oYAYhX7HLSRxYbYnchkWLbkmTTrJ+9ttF6dQv1A2iFtTlH lVw3D4YTOO8Hs4ozuaZyqhWSr2JAsFvQQxHdrdFk2yBWZkriy6Sk9BP1AOmgrCxKDCQC fg4g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=M8RYO3J4teOZwHtJdLjrP3QEdHPNPpBNTIhrL0SkM/Q=; fh=4bMsMJJHDmTQNFavmZaD/iTPOPK/LdH9YFdHoY+StpE=; b=QBX0L0YkOV7RU3PlpAtj3Z8L7Te/rOQMKRkJ2ztApL2iH2gF84z91lUDXJjIYo47y/ FXfL2I0nQdEDJed8le9UTh+6X/Nsk4h3wj54nW0seLNm5JUbmeTUiB9JSpjllnaQlXFf 7UFwO1SYTQLhaLdZ4Iwa9mVFSAfRjSQBtPijKjizldZXG7C8/v5xPp5CPQ3jKmItA+Bj GM+ADsChgxcQXh+SLsoNZktdT4FQNmUEkRlfjk7JSbjrKLXifdLtamnegAD/jE8j/wmU DyY2hR7JogE2cjH7vGTTKfFa0TFsAuaH4dtRakl+f9e2j6yuERUeGxe1KM+1Q2U0r2yW BKsA==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=yQH3o2As; spf=pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom="qemu-devel-bounces+patch=linaro.org@nongnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Return-Path: Received: from lists.gnu.org (lists.gnu.org. [209.51.188.17]) by mx.google.com with ESMTPS id 6a1803df08f44-6c53433cf2asi60677736d6.124.2024.09.09.10.30.21 for (version=TLS1_2 cipher=ECDHE-ECDSA-CHACHA20-POLY1305 bits=256/256); Mon, 09 Sep 2024 10:30:21 -0700 (PDT) Received-SPF: pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=yQH3o2As; spf=pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom="qemu-devel-bounces+patch=linaro.org@nongnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org; dara=neutral header.i=@linaro.org Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1sniCG-0006dR-Kj; Mon, 09 Sep 2024 13:29:04 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1sniC8-0005pF-J6 for qemu-devel@nongnu.org; Mon, 09 Sep 2024 13:28:56 -0400 Received: from mail-pl1-x62f.google.com ([2607:f8b0:4864:20::62f]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1sniC2-00064n-CN for qemu-devel@nongnu.org; Mon, 09 Sep 2024 13:28:56 -0400 Received: by mail-pl1-x62f.google.com with SMTP id d9443c01a7336-2054e22ce3fso39973995ad.2 for ; Mon, 09 Sep 2024 10:28:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1725902928; x=1726507728; darn=nongnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=M8RYO3J4teOZwHtJdLjrP3QEdHPNPpBNTIhrL0SkM/Q=; b=yQH3o2Asw0mIaHiGzmzXGcXF/FVcZdr1rzmbxhnF0/ZOONhueouHtUThGOSVEkETBy TkVBsruMaRng4PVYWOaRkbsMKsLTYFiXIFRgpK1EbUFFazK2H883CPoR9GCw7SvKHtLa GKdlg9pzknKpRlL5xynLaWvO6Zb22ySPdD9SxG3+YgXpoS61G1nnoOyq/wYJnXB8wQUW Lx49clMb+7TWQ2X5Q6+7Q/v4sjYVfKCJunnrdl3ZeBlfO+L4Bs/X5SmggllZgVET7aPh tpTVDAk98OVQEpjyEmTQS5n8qiewfJCWGVLfFc7lsEn/V0Nh0n9PC1/bCsjFfc3JoIS3 x5IQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1725902928; x=1726507728; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=M8RYO3J4teOZwHtJdLjrP3QEdHPNPpBNTIhrL0SkM/Q=; b=OjZQ+oV/HfbYMTHvUNdpQByNeCwLQ1ZWJxL4oOj0INqm7QO/3I1crrPujUXgK5Li47 vo3cgkLN8uIof5jvReVp/KwvYYVeosy2sfqOagcNpgVAQNIJ0pEQ2IdIeCSONd4Q5MOZ cUkgqhB3J64tbBY2IVEHEI8K5dEQmvFE/Q7jM8/66VIvnd4m94mwbShlVqcO1n0szedH ntBQpnUxJAcI4m49msb/wXVWg9be5wFOYeARtoPrBD129qmvmVYSOkEzrApLVv6TC1L9 bIg1XrIibGPQl0UPXHtQ3LJ3lJQfaVY5xBd+9Okxb3NX5+58Pb0i6dvFTfDSBq7oc3T4 4F7w== X-Gm-Message-State: AOJu0YyXrjN11vS25UY4a/Bvclckbj5GXpWrxR7t/zCDLUbpJTCA47Pf uvZw46OmzQh/yC/L0OsFRYWpgaM7ncf6IEbD1oA40kpsI0mA7KhPniV0BF2PKN5ZkCF7iyfGs9o G X-Received: by 2002:a17:902:d4c9:b0:205:6f3c:4a65 with SMTP id d9443c01a7336-206f04c76a0mr122753815ad.2.1725902927001; Mon, 09 Sep 2024 10:28:47 -0700 (PDT) Received: from stoup.. (174-21-81-121.tukw.qwest.net. [174.21.81.121]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-20710e11e02sm36539875ad.14.2024.09.09.10.28.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Sep 2024 10:28:45 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Cc: laurent@vivier.eu, daniel@0x0f.com Subject: [PATCH v3 23/26] target/m68k: Implement packed decimal real loads and stores Date: Mon, 9 Sep 2024 10:28:20 -0700 Message-ID: <20240909172823.649837-24-richard.henderson@linaro.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240909172823.649837-1-richard.henderson@linaro.org> References: <20240909172823.649837-1-richard.henderson@linaro.org> MIME-Version: 1.0 Received-SPF: pass client-ip=2607:f8b0:4864:20::62f; envelope-from=richard.henderson@linaro.org; helo=mail-pl1-x62f.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+patch=linaro.org@nongnu.org Sender: qemu-devel-bounces+patch=linaro.org@nongnu.org Resolves: https://gitlab.com/qemu-project/qemu/-/issues/2488 Signed-off-by: Richard Henderson --- 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 +#include + +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),