diff --git a/NOTICE b/NOTICE index be312e1b..adaa69cb 100644 --- a/NOTICE +++ b/NOTICE @@ -1,39 +1,248 @@ Copyright (c) 2017-2018 AssemblyScript authors. The following authors have all licensed their contributions to AssemblyScript -under the licensing terms detailed in LICENSE. +under the licensing terms detailed in LICENSE: * Daniel Wirtz * Max Graey * Igor Sbitnev * Norton Wang -================================================================================ +Portions of this software are derived from third-party works licensed under +the following terms: -This program includes parts of TypeScript: - - https://github.com/Microsoft/TypeScript +* TypeScript: https://github.com/Microsoft/TypeScript Copyright (c) Microsoft Corporation. All rights reserved. - Apache License, Version 2.0 - https://www.apache.org/licenses/LICENSE-2.0 + Apache License, Version 2.0 (see LICENSE file) -================================================================================ - -This program includes parts of Binaryen: - - https://github.com/WebAssembly/binaryen +* Binaryen: https://github.com/WebAssembly/binaryen Copyright 2015 WebAssembly Community Group participants - Apache License, Version 2.0 - https://www.apache.org/licenses/LICENSE-2.0 + Apache License, Version 2.0 (see LICENSE file) -================================================================================ +* musl: http://www.musl-libc.org -This program includes parts of musl: - - http://www.musl-libc.org + musl as a whole is licensed under the following standard MIT license: + ---------------------------------------------------------------------- Copyright © 2005-2014 Rich Felker, et al. - MIT License - https://opensource.org/licenses/MIT + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + ---------------------------------------------------------------------- + + Authors/contributors include: + + Alex Dowad + Alexander Monakov + Anthony G. Basile + Arvid Picciani + Bobby Bingham + Boris Brezillon + Brent Cook + Chris Spiegel + Clément Vasseur + Daniel Micay + Denys Vlasenko + Emil Renner Berthing + Felix Fietkau + Felix Janda + Gianluca Anzolin + Hauke Mehrtens + Hiltjo Posthuma + Isaac Dunham + Jaydeep Patil + Jens Gustedt + Jeremy Huntwork + Jo-Philipp Wich + Joakim Sindholt + John Spencer + Josiah Worcester + Justin Cormack + Khem Raj + Kylie McClain + Luca Barbato + Luka Perkov + M Farkas-Dyck (Strake) + Mahesh Bodapati + Michael Forney + Natanael Copa + Nicholas J. Kain + orc + Pascal Cuoq + Petr Hosek + Pierre Carrier + Rich Felker + Richard Pennington + Shiz + sin + Solar Designer + Stefan Kristiansson + Szabolcs Nagy + Timo Teräs + Trutz Behn + Valentin Ochs + William Haddon + + Portions of this software are derived from third-party works licensed + under terms compatible with the above MIT license: + + The TRE regular expression implementation (src/regex/reg* and + src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed + under a 2-clause BSD license (license text in the source files). The + included version has been heavily modified by Rich Felker in 2012, in + the interests of size, simplicity, and namespace cleanliness. + + Much of the math library code (src/math/* and src/complex/*) is + Copyright © 1993,2004 Sun Microsystems or + Copyright © 2003-2011 David Schultz or + Copyright © 2003-2009 Steven G. Kargl or + Copyright © 2003-2009 Bruce D. Evans or + Copyright © 2008 Stephen L. Moshier + and labelled as such in comments in the individual source files. All + have been licensed under extremely permissive terms. + + The ARM memcpy code (src/string/arm/memcpy_el.S) is Copyright © 2008 + The Android Open Source Project and is licensed under a two-clause BSD + license. It was taken from Bionic libc, used on Android. + + The implementation of DES for crypt (src/crypt/crypt_des.c) is + Copyright © 1994 David Burren. It is licensed under a BSD license. + + The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was + originally written by Solar Designer and placed into the public + domain. The code also comes with a fallback permissive license for use + in jurisdictions that may not recognize the public domain. + + The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011 + Valentin Ochs and is licensed under an MIT-style license. + + The BSD PRNG implementation (src/prng/random.c) and XSI search API + (src/search/*.c) functions are Copyright © 2011 Szabolcs Nagy and + licensed under following terms: "Permission to use, copy, modify, + and/or distribute this code for any purpose with or without fee is + hereby granted. There is no warranty." + + The x86_64 port was written by Nicholas J. Kain and is licensed under + the standard MIT terms. + + The mips and microblaze ports were originally written by Richard + Pennington for use in the ellcc project. The original code was adapted + by Rich Felker for build system and code conventions during upstream + integration. It is licensed under the standard MIT terms. + + The mips64 port was contributed by Imagination Technologies and is + licensed under the standard MIT terms. + + The powerpc port was also originally written by Richard Pennington, + and later supplemented and integrated by John Spencer. It is licensed + under the standard MIT terms. + + All other files which have no copyright comments are original works + produced specifically for use as part of this library, written either + by Rich Felker, the main author of the library, or by one or more + contibutors listed above. Details on authorship of individual files + can be found in the git version control history of the project. The + omission of copyright and license comments in each file is in the + interest of source tree size. + + In addition, permission is hereby granted for all public header files + (include/* and arch/*/bits/*) and crt files intended to be linked into + applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit + the copyright notice and permission notice otherwise required by the + license, and to use these files without any requirement of + attribution. These files include substantial contributions from: + + Bobby Bingham + John Spencer + Nicholas J. Kain + Rich Felker + Richard Pennington + Stefan Kristiansson + Szabolcs Nagy + + all of whom have explicitly granted such permission. + + This file previously contained text expressing a belief that most of + the files covered by the above exception were sufficiently trivial not + to be subject to copyright, resulting in confusion over whether it + negated the permissions granted in the license. In the spirit of + permissive licensing, and of not having licensing issues being an + obstacle to adoption, that text has been removed. + +* V8: https://developers.google.com/v8/ + + This license applies to all parts of V8 that are not externally + maintained libraries. The externally maintained libraries used by V8 + are: + + - PCRE test suite, located in + test/mjsunit/third_party/regexp-pcre/regexp-pcre.js. This is based on the + test suite from PCRE-7.3, which is copyrighted by the University + of Cambridge and Google, Inc. The copyright notice and license + are embedded in regexp-pcre.js. + + - Layout tests, located in test/mjsunit/third_party/object-keys. These are + based on layout tests from webkit.org which are copyrighted by + Apple Computer, Inc. and released under a 3-clause BSD license. + + - Strongtalk assembler, the basis of the files assembler-arm-inl.h, + assembler-arm.cc, assembler-arm.h, assembler-ia32-inl.h, + assembler-ia32.cc, assembler-ia32.h, assembler-x64-inl.h, + assembler-x64.cc, assembler-x64.h, assembler-mips-inl.h, + assembler-mips.cc, assembler-mips.h, assembler.cc and assembler.h. + This code is copyrighted by Sun Microsystems Inc. and released + under a 3-clause BSD license. + + - Valgrind client API header, located at third_party/valgrind/valgrind.h + This is release under the BSD license. + + These libraries have their own licenses; we recommend you read them, + as their terms may differ from the terms below. + + Further license information can be found in LICENSE files located in + sub-directories. + + Copyright 2014, the V8 project authors. All rights reserved. + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/bin/asc.js b/bin/asc.js index dc3c7b5a..eb39fb6d 100644 --- a/bin/asc.js +++ b/bin/asc.js @@ -363,9 +363,12 @@ exports.main = function main(argv, options, callback) { assemblyscript.setImportTable(compilerOptions, !!args.importTable); assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0); assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null); - assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath"); - // Add or override global aliases if specified + // Initialize default aliases + assemblyscript.setGlobalAlias(compilerOptions, "Math", "NativeMath"); + assemblyscript.setGlobalAlias(compilerOptions, "Mathf", "NativeMathf"); + + // Add or override aliases if specified var aliases = args.use; if (aliases != null) { if (typeof aliases === "string") aliases = aliases.split(","); diff --git a/scripts/hexfloat.html b/scripts/hexfloat.html index 733f899a..d53fdb68 100644 --- a/scripts/hexfloat.html +++ b/scripts/hexfloat.html @@ -10,7 +10,8 @@

- + +

@@ -21,17 +22,19 @@ diff --git a/src/compiler.ts b/src/compiler.ts index a0394344..6a62119f 100644 --- a/src/compiler.ts +++ b/src/compiler.ts @@ -2316,6 +2316,11 @@ export class Compiler extends DiagnosticEmitter { return this.compileExpression(expression.expression, toType, ConversionKind.EXPLICIT); } + private f32ModInstance: Function | null = null; + private f64ModInstance: Function | null = null; + private f32PowInstance: Function | null = null; + private f64PowInstance: Function | null = null; + compileBinaryExpression( expression: BinaryExpression, contextualType: Type, @@ -3078,6 +3083,88 @@ export class Compiler extends DiagnosticEmitter { } break; } + case Token.ASTERISK_ASTERISK_EQUALS: compound = true; + case Token.ASTERISK_ASTERISK: { + leftExpr = this.compileExpressionRetainType( + left, + contextualType, + true // must be wrapped + ); + let instance: Function | null; + + // Mathf.pow if lhs is f32 (result is f32) + if (this.currentType == Type.f32) { + rightExpr = this.compileExpression( + right, + this.currentType + ); + if (!(instance = this.f32PowInstance)) { + let namespace = this.program.elementsLookup.get("Mathf"); + if (!namespace) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Mathf" + ); + expr = module.createUnreachable(); + break; + } + let prototype = namespace.members ? namespace.members.get("pow") : null; + if (!prototype) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Mathf.pow" + ); + expr = module.createUnreachable(); + break; + } + assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE); + this.f32PowInstance = instance = (prototype).resolve(); + } + + // Math.pow otherwise (result is f64) + // TODO: should the result be converted back? + } else { + leftExpr = this.convertExpression( + leftExpr, + this.currentType, + Type.f64, + ConversionKind.IMPLICIT, + left + ); + rightExpr = this.compileExpression( + right, + Type.f64 + ); + if (!(instance = this.f64PowInstance)) { + let namespace = this.program.elementsLookup.get("Math"); + if (!namespace) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Math" + ); + expr = module.createUnreachable(); + break; + } + let prototype = namespace.members ? namespace.members.get("pow") : null; + if (!prototype) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Math.pow" + ); + expr = module.createUnreachable(); + break; + } + assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE); + this.f64PowInstance = instance = (prototype).resolve(); + } + } + if (!(instance && this.compileFunction(instance))) { + expr = module.createUnreachable(); + } else { + expr = this.makeCallDirect(instance, [ leftExpr, rightExpr ]); + } + break; + } case Token.SLASH_EQUALS: compound = true; case Token.SLASH: { leftExpr = this.compileExpressionRetainType( @@ -3269,40 +3356,64 @@ export class Compiler extends DiagnosticEmitter { break; } case TypeKind.F32: { - let fmodPrototype = this.program.elementsLookup.get("fmodf"); - if (!fmodPrototype) { - this.error( - DiagnosticCode.Cannot_find_name_0, - expression.range, "fmod" - ); - expr = module.createUnreachable(); - break; + let instance = this.f32ModInstance; + if (!instance) { + let namespace = this.program.elementsLookup.get("Mathf"); + if (!namespace) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Mathf" + ); + expr = module.createUnreachable(); + break; + } + let prototype = namespace.members ? namespace.members.get("mod") : null; + if (!prototype) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Mathf.mod" + ); + expr = module.createUnreachable(); + break; + } + assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE); + this.f32ModInstance = instance = (prototype).resolve(); } - assert(fmodPrototype.kind == ElementKind.FUNCTION_PROTOTYPE); - let fmodInstance = (fmodPrototype).resolve(); - if (!(fmodInstance && this.compileFunction(fmodInstance))) { + if (!(instance && this.compileFunction(instance))) { expr = module.createUnreachable(); } else { - expr = this.makeCallDirect(fmodInstance, [ leftExpr, rightExpr ]); + expr = this.makeCallDirect(instance, [ leftExpr, rightExpr ]); } break; } case TypeKind.F64: { - let fmodPrototype = this.program.elementsLookup.get("fmod"); - if (!fmodPrototype) { - this.error( - DiagnosticCode.Cannot_find_name_0, - expression.range, "fmod" - ); - expr = module.createUnreachable(); - break; + let instance = this.f64ModInstance; + if (!instance) { + let namespace = this.program.elementsLookup.get("Math"); + if (!namespace) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Math" + ); + expr = module.createUnreachable(); + break; + } + let prototype = namespace.members ? namespace.members.get("mod") : null; + if (!prototype) { + this.error( + DiagnosticCode.Cannot_find_name_0, + expression.range, "Math.mod" + ); + expr = module.createUnreachable(); + break; + } + assert(prototype.kind == ElementKind.FUNCTION_PROTOTYPE); + this.f64ModInstance = instance = (prototype).resolve(); } - assert(fmodPrototype.kind == ElementKind.FUNCTION_PROTOTYPE); - let fmodInstance = (fmodPrototype).resolve(); - if (!(fmodInstance && this.compileFunction(fmodInstance))) { + if (!(instance && this.compileFunction(instance))) { expr = module.createUnreachable(); } else { - expr = this.makeCallDirect(fmodInstance, [ leftExpr, rightExpr ]); + expr = this.makeCallDirect(instance, [ leftExpr, rightExpr ]); } break; } diff --git a/std/assembly.d.ts b/std/assembly.d.ts index 4a84198d..600f7024 100644 --- a/std/assembly.d.ts +++ b/std/assembly.d.ts @@ -135,6 +135,10 @@ declare namespace f32 { export const MAX_SAFE_INTEGER: f32; /** Difference between 1 and the smallest representable value greater than 1. */ export const EPSILON: f32; + /** Returns the floating-point remainder of `x / y` (rounded towards zero). */ + export function mod(x: f32, y: f32): f32; + /** Returns the floating-point remainder of `x / y` (rounded to nearest). */ + export function rem(x: f32, y: f32): f32; } /** Converts any other numeric value to a 64-bit float. */ declare function f64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): f64; @@ -391,7 +395,7 @@ interface IMath { /** Returns the smallest integer greater than or equal to `x`. */ ceil(x: T): T; /** Returns the number of leading zero bits in the 32-bit binary representation of `x`. */ - clz32(x: T): i32; + clz32(x: T): T; /** Returns the cosine (in radians) of `x`. */ cos(x: T): T; /** Returns the hyperbolic cosine of `x`. */ @@ -407,7 +411,7 @@ interface IMath { /** Returns the square root of the sum of squares of its arguments. */ hypot(value1: T, value2: T): T; // TODO: rest /** Returns the result of the C-like 32-bit multiplication of `a` and `b`. */ - imul(a: T, b: T): i32; + imul(a: T, b: T): T; /** Returns the natural logarithm (base e) of `x`. */ log(x: T): T; /** Returns the base 10 logarithm of `x`. */ @@ -442,17 +446,21 @@ interface IMath { trunc(x: T): T; } -interface ISeedRandom { +interface INativeMath extends IMath { /** Seeds the random number generator. */ seedRandom(value: i64): void; + /** Returns the floating-point remainder of `x / y` (rounded towards zero). */ + mod(x: T, y: T): T; + /** Returns the floating-point remainder of `x / y` (rounded to nearest). */ + rem(x: T, y: T): T; } /** Double precision math imported from JavaScript. */ declare const JSMath: IMath; /** Double precision math implemented natively. */ -declare const NativeMath: IMath & ISeedRandom; +declare const NativeMath: INativeMath; /** Single precision math implemented natively. */ -declare const NativeMathf: IMath; +declare const NativeMathf: INativeMath; /** Alias of {@link NativeMath} or {@link JSMath} respectively. Defaults to `NativeMath`. */ declare const Math: IMath; diff --git a/std/assembly/builtins.ts b/std/assembly/builtins.ts index 8fd14497..d62c0f61 100644 --- a/std/assembly/builtins.ts +++ b/std/assembly/builtins.ts @@ -80,25 +80,25 @@ export declare function abort( export declare function i8(value: void): i8; export namespace i8 { export const MIN_VALUE: i8 = -128; - export const MAX_VALUE: i8 = 127; + export const MAX_VALUE: i8 = 127; } export declare function i16(value: void): i16; export namespace i16 { export const MIN_VALUE: i16 = -32768; - export const MAX_VALUE: i16 = 32767; + export const MAX_VALUE: i16 = 32767; } export declare function i32(value: void): i32; export namespace i32 { export const MIN_VALUE: i32 = -2147483648; - export const MAX_VALUE: i32 = 2147483647; + export const MAX_VALUE: i32 = 2147483647; } export declare function i64(value: void): i64; export namespace i64 { export const MIN_VALUE: i64 = -9223372036854775808; - export const MAX_VALUE: i64 = 9223372036854775807; + export const MAX_VALUE: i64 = 9223372036854775807; } export declare function isize(value: void): isize; @@ -151,144 +151,24 @@ export namespace bool { export declare function f32(value: void): f32; export namespace f32 { - export const MIN_VALUE: f32 = -3.40282347e+38; - export const MAX_VALUE: f32 = 3.40282347e+38; - export const MIN_POSITIVE_VALUE: f32 = 1.175494351e-38; + export const MIN_VALUE = reinterpret(0xFF7FFFFF); // -0x1.fffffep+127f + export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f + export const MIN_POSITIVE_VALUE = reinterpret(0x00800000); // 0x1p-126f export const MIN_SAFE_INTEGER: f32 = -16777215; - export const MAX_SAFE_INTEGER: f32 = 16777215; - export const EPSILON: f32 = 1.19209290e-07; + export const MAX_SAFE_INTEGER: f32 = 16777215; + export const EPSILON = reinterpret(0x34000000); // 0x1p-23f } export declare function f64(value: void): f64; export namespace f64 { - export const MIN_VALUE: f64 = -1.7976931348623157e+308; - export const MAX_VALUE: f64 = 1.7976931348623157e+308; - export const MIN_POSITIVE_VALUE: f64 = 2.2250738585072014e-308; + export const MIN_VALUE = reinterpret(0xFFEFFFFFFFFFFFFF); // -0x1.fffffffffffffp+1023 + export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023 + export const MIN_POSITIVE_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022 export const MIN_SAFE_INTEGER: f64 = -9007199254740991; - export const MAX_SAFE_INTEGER: f64 = 9007199254740991; - export const EPSILON: f64 = 2.2204460492503131e-16; + export const MAX_SAFE_INTEGER: f64 = 9007199254740991; + export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52 } export declare const HEAP_BASE: usize; export declare function start(): void; - -export function fmod(x: f64, y: f64): f64 { - // based on musl's implementation of fmod - var ux = reinterpret(x); - var uy = reinterpret(y); - var ex = (ux >> 52 & 0x7ff); - var ey = (uy >> 52 & 0x7ff); - var sx = (ux >> 63); - - if (uy << 1 == 0 || isNaN(y) || ex == 0x7ff) { - return (x * y) / (x * y); - } - if (ux << 1 <= uy << 1) { - if (ux << 1 == uy << 1) return 0 * x; - return x; - } - - // normalize x and y - var i: u64; - if (!ex) { - for (i = ux << 12; !(i >> 63); i <<= 1) --ex; - ux <<= -ex + 1; - } else { - ux &= -1 >> 12; - ux |= 1 << 52; - } - if (!ey) { - for (i = uy << 12; !(i >> 63); i <<= 1) --ey; - uy <<= -ey + 1; - } else { - uy &= -1 >> 12; - uy |= 1 << 52; - } - - // x mod y - for (; ex > ey; ex--) { - i = ux - uy; - if (!(i >> 63)) { - if (!i) return 0 * x; - ux = i; - } - ux <<= 1; - } - i = ux - uy; - if (!(i >> 63)) { - if (!i) return 0 * x; - ux = i; - } - for (; !(ux >> 52); ux <<= 1) --ex; - - // scale result - if (ex > 0) { - ux -= 1 << 52; - ux |= ex << 52; - } else { - ux >>= -ex + 1; - } - ux |= sx << 63; - return reinterpret(ux); -} - -export function fmodf(x: f32, y: f32): f32 { - // based on musl's implementation of fmodf - var ux = reinterpret(x); - var uy = reinterpret(y); - var ex = (ux >> 23 & 0xff); - var ey = (uy >> 23 & 0xff); - var sx = ux & 0x80000000; - - if (uy << 1 == 0 || isNaN(y) || ex == 0xff) { - return (x * y) / (x * y); - } - if (ux << 1 <= uy << 1) { - if (ux << 1 == uy << 1) return 0 * x; - return x; - } - - // normalize x and y - var i: u32; - if (!ex) { - for (i = ux << 9; !(i >> 31); i <<= 1) --ex; - ux <<= -ex + 1; - } else { - ux &= -1 >> 9; - ux |= 1 << 23; - } - if (!ey) { - for (i = uy << 9; !(i >> 31); i <<= 1) --ey; - uy <<= -ey + 1; - } else { - uy &= -1 >> 9; - uy |= 1 << 23; - } - - // x mod y - for (; ex > ey; --ex) { - i = ux - uy; - if (!(i >> 31)) { - if (!i) return 0 * x; - ux = i; - } - ux <<= 1; - } - i = ux - uy; - if (!(i >> 31)) { - if (!i) return 0 * x; - ux = i; - } - for (; !(ux >> 23); ux <<= 1) --ex; - - // scale result - if (ex > 0) { - ux -= 1 << 23; - ux |= ex << 23; - } else { - ux >>= -ex + 1; - } - ux |= sx; - return reinterpret(ux); -} diff --git a/std/assembly/math.ts b/std/assembly/math.ts index 8e53b26f..299bc8ad 100644 --- a/std/assembly/math.ts +++ b/std/assembly/math.ts @@ -19,21 +19,21 @@ export declare namespace JSMath { export function atanh(x: f64): f64; export function cbrt(x: f64): f64; export function ceil(x: f64): f64; - export function clz32(x: f64): i32; + export function clz32(x: f64): f64; export function cos(x: f64): f64; export function cosh(x: f64): f64; export function exp(x: f64): f64; export function expm1(x: f64): f64; export function floor(x: f64): f64; export function fround(x: f64): f32; - export function hypot(value1: f64, value2: f64): f64; // hypot(...values: f64[]): f64; - export function imul(a: f64, b: f64): i32; + export function hypot(value1: f64, value2: f64): f64; // TODO: rest + export function imul(a: f64, b: f64): f64; export function log(x: f64): f64; export function log10(x: f64): f64; export function log1p(x: f64): f64; export function log2(x: f64): f64; - export function max(value1: f64, value2: f64): f64; // max(...values: f64[]): f64; - export function min(value1: f64, value2: f64): f64; // min(...values: f64[]): f64; + export function max(value1: f64, value2: f64): f64; // TODO: rest + export function min(value1: f64, value2: f64): f64; // TODO: rest export function pow(base: f64, exponent: f64): f64; export function random(): f64; export function round(x: f64): f64; @@ -50,273 +50,558 @@ import { abs as builtin_abs, ceil as builtin_ceil, clz as builtin_clz, + copysign as builtin_copysign, floor as builtin_floor, max as builtin_max, min as builtin_min, - nearest as builtin_nearest, sqrt as builtin_sqrt, trunc as builtin_trunc } from "./builtins"; -// NativeMath/NativeMathf.cbrt/exp/log/pow -// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. -// Developed at SunPro, a Sun Microsystems, Inc. business. -// Permission to use, copy, modify, and distribute this -// software is freely granted, provided that this notice -// is preserved. +// SUN COPYRIGHT NOTICE +// +// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. +// Developed at SunPro, a Sun Microsystems, Inc. business. +// Permission to use, copy, modify, and distribute this software +// is freely granted, provided that this notice is preserved. +// +// Applies to all functions marked with a comment referring here. + +// TODO: sin, cos, tan export namespace NativeMath { - export const E = 2.7182818284590452354; - export const LN2 = 0.69314718055994530942; - export const LN10 = 2.30258509299404568402; - export const LOG2E = 1.4426950408889634074; - export const LOG10E = 0.43429448190325182765; - export const PI = 3.14159265358979323846; - export const SQRT1_2 = 0.70710678118654752440; - export const SQRT2 = 1.41421356237309504880; + export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354 + export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942 + export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402 + export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074 + export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765 + export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846 + export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440 + export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880 export function abs(x: f64): f64 { - return builtin_abs(x); + return builtin_abs(x); } - export function acos(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function acosh(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function asin(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function asinh(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function atan(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function atanh(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function atan2(y: f64, x: f64): f64 { - unreachable(); // TOOD - return 0; - } - - export function cbrt(x: f64): f64 { // based on musl's implementation of cbrt + function __R(z: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above const - B1 = 715094163, // B1 = (1023-1023/3-0.03306235651)*2**20 - B2 = 696219795, // B2 = (1023-1023/3-54/3-0.03306235651)*2**20 - // |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). - P0 = 1.87595182427177009643, // 0x3ffe03e6, 0x0f61e692 - P1 = -1.88497979543377169875, // 0xbffe28e0, 0x92f02420 - P2 = 1.621429720105354466140, // 0x3ff9f160, 0x4a49d6c2 - P3 = -0.758397934778766047437, // 0xbfe844cb, 0xbee751d9 - P4 = 0.145996192886612446982, // 0x3fc2b000, 0xd4e4edd7 - Ox1p54 = 18014398509481984.0; + pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01 + pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01 + pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01 + pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02 + pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04 + pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05 + qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00 + qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00 + qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01 + qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02 + var p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5))))); + var q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4))); + return p / q; + } - var __u = reinterpret(x); - var hx = (__u >> 32) & 0x7fffffff; - if (hx >= 0x7ff00000) return x + x; // cbrt(NaN,INF) is itself + export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above + const + pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00 + pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17 + Ox1p_120f = reinterpret(0x03800000); + var hx = (reinterpret(x) >> 32); + var ix = hx & 0x7FFFFFFF; + if (ix >= 0x3FF00000) { + let lx = reinterpret(x); + if ((ix - 0x3FF00000 | lx) == 0) { + if (hx >> 31) return 2 * pio2_hi + Ox1p_120f; + return 0; + } + return 0 / (x - x); + } + if (ix < 0x3FE00000) { + if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f; + return pio2_hi - (x - (pio2_lo - x * __R(x * x))); + } + var s: f64, w: f64, z: f64; + if (hx >> 31) { + z = (1.0 + x) * 0.5; + s = builtin_sqrt(z); + w = __R(z) * s - pio2_lo; + return 2 * (pio2_hi - (s + w)); + } + z = (1.0 - x) * 0.5; + s = builtin_sqrt(z); + var df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000); + var c = (z - df * df) / (s + df); + w = __R(z) * s + c; + return 2 * (df + w); + } - // Rough cbrt to 5 bits: - // cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3) - // where e is integral and >= 0, m is real and in [0, 1), and "/" and - // "%" are integer division and modulus with rounding towards minus - // infinity. The RHS is always >= the LHS and has a maximum relative - // error of about 1 in 16. Adding a bias of -0.03306235651 to the - // (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE - // floating point representation, for finite positive normal values, - // ordinary integer divison of the value in bits magically gives - // almost exactly the RHS of the above provided we first subtract the - // exponent bias (1023 for doubles) and later add it back. We do the - // subtraction virtually to keep e >= 0 so that ordinary integer - // division rounds towards minus infinity; this is also efficient. - if (hx < 0x00100000) { // zero or subnormal? - __u = reinterpret(x * Ox1p54); - hx = (__u >> 32) & 0x7fffffff; - if (hx == 0) return x; // cbrt(0) is itself + export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c + const s = reinterpret(0x3FE62E42FEFA39EF); + var e = reinterpret(x) >> 52 & 0x7FF; + if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1))); + if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1))); + return log(x) + s; + } + + export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above + const + pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00 + pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17 + Ox1p_120f = reinterpret(0x03800000); + var hx = (reinterpret(x) >> 32); + var ix = hx & 0x7FFFFFFF; + if (ix >= 0x3FF00000) { + let lx = reinterpret(x); + if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f; + return 0 / (x - x); + } + if (ix < 0x3FE00000) { + if (ix < 0x3E500000 && ix >= 0x00100000) return x; + return x + x * __R(x * x); + } + var z = (1.0 - builtin_abs(x)) * 0.5; + var s = builtin_sqrt(z); + var r = __R(z); + if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo); + else { + let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000); + let c = (z - f * f) / (s + f); + x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f)); + } + if (hx >> 31) return -x; + return x; + } + + export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c + const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568 + var u = reinterpret(x); + var e = u >> 52 & 0x7FF; + var s = u >> 63; + u &= 0x7FFFFFFFFFFFFFFF; + x = reinterpret(u); + if (e >= 0x3FF + 26) x = log(x) + c; + else if (e >= 0x3FF + 1) x = log(2 * x + 1 / (builtin_sqrt(x * x + 1) + x)); + else if (e >= 0x3FF - 26) x = log1p(x + x * x / (builtin_sqrt(x * x + 1) + 1)); + return s ? -x : x; + } + + export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above + const + atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01 + atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01 + atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01 + atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00 + atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17 + atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17 + atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17 + atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17 + aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01 + aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01 + aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01 + aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01, + aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02 + aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02 + aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02 + aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02 + aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02 + aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02 + aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02 + Ox1p_120f = reinterpret(0x03800000); + var ix = (reinterpret(x) >> 32); + var sign_ = ix >> 31; + ix &= 0x7FFFFFFF; + var z: f64; + if (ix >= 0x44100000) { + if (isNaN(x)) return x; + z = atanhi3 + Ox1p_120f; + return sign_ ? -z : z; + } + var id: i32; + if (ix < 0x3FDC0000) { + if (ix < 0x3E400000) return x; + id = -1; + } else { + x = builtin_abs(x); + if (ix < 0x3FF30000) { + if (ix < 0x3FE60000) { + id = 0; + x = (2.0 * x - 1.0) / (2.0 + x); + } else { + id = 1; + x = (x - 1.0) / (x + 1.0); + } + } else { + if (ix < 0x40038000) { + id = 2; + x = (x - 1.5) / (1.0 + 1.5 * x); + } else { + id = 3; + x = -1.0 / x; + } + } + } + z = x * x; + var w = z * z; + var s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10))))); + var s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9)))); + if (id < 0) return x - x * (s1 + s2); + switch (id) { + case 0: { z = atanhi0 - (x * (s1 + s2) - atanlo0 - x); break; } + case 1: { z = atanhi1 - (x * (s1 + s2) - atanlo1 - x); break; } + case 2: { z = atanhi2 - (x * (s1 + s2) - atanlo2 - x); break; } + case 3: { z = atanhi3 - (x * (s1 + s2) - atanlo3 - x); break; } + default: unreachable(); + } + return sign_ ? -z : z; + } + + export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c + var u = reinterpret(x); + var e = u >> 52 & 0x7FF; + var s = u >> 63; + u &= 0x7FFFFFFFFFFFFFFF; + var y = reinterpret(u); + if (e < 0x3FF - 1) { + if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y)); + } else { + y = 0.5 * log1p(2 * (y / (1 - y))); + } + return s ? -y : y; + } + + export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above + const + pi = reinterpret(0x400921FB54442D18), // 3.1415926535897931160E+00 + pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16 + if (isNaN(x) || isNaN(y)) return x + y; + var u = reinterpret(x); + var ix = (u >> 32); + var lx = u; + u = reinterpret(y); + var iy = (u >> 32); + var ly = u; + if ((ix - 0x3FF00000 | lx) == 0) return atan(y); + var m = ((iy >> 31) & 1) | ((ix >> 30) & 2); + ix = ix & 0x7FFFFFFF; + iy = iy & 0x7FFFFFFF; + if ((iy | ly) == 0) { + switch (m) { + case 0: + case 1: return y; + case 2: return PI; + case 3: return -PI; + } + } + if ((ix | lx) == 0) return m & 1 ? -pi / 2 : pi / 2; + if (ix == 0x7FF00000) { + if (iy == 0x7FF00000) { + switch (m) { + case 0: return pi / 4; + case 1: return -pi / 4; + case 2: return 3 * pi / 4; + case 3: return -3 * pi / 4; + } + } else { + switch (m) { + case 0: return 0.0; + case 1: return -0.0; + case 2: return pi; + case 3: return -pi; + } + } + } + var z: f64; + if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -pi / 2 : pi / 2; + if ((m & 2) && iy + (64 << 20) < ix) z = 0; + else z = atan(builtin_abs(y / x)); + switch (m) { + case 0: return z; + case 1: return -z; + case 2: return pi - (z - pi_lo); + case 3: return (z - pi_lo) - pi; + } + unreachable(); + return 0; + } + + export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above + const + B1 = 715094163, + B2 = 696219795, + P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643 + P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875 + P2 = reinterpret(0x3FF9F1604A49d6C2), // 1.621429720105354466140 + P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437 + P4 = reinterpret(0x3FC2B000d4E4EDD7), // 0.145996192886612446982 + Ox1p54 = reinterpret(0x4350000000000000); + var u = reinterpret(x); + var hx = (u >> 32) & 0x7FFFFFFF; + if (hx >= 0x7FF00000) return x + x; + if (hx < 0x00100000) { + u = reinterpret(x * Ox1p54); + hx = (u >> 32) & 0x7FFFFFFF; + if (hx == 0) return x; hx = hx / 3 + B2; } else { hx = hx / 3 + B1; } - __u &= 1 << 63; - __u |= hx << 32; - var t = reinterpret(__u); - - // New cbrt to 23 bits: - // cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x) - // where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r) - // to within 2**-23.5 when |r - 1| < 1/10. The rough approximation - // has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this - // gives us bounds for r = t**3/x. + u &= 1 << 63; + u |= hx << 32; + var t = reinterpret(u); var r = (t * t) * (t / x); t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4)); - - // Round t away from zero to 23 bits (sloppily except for ensuring that - // the result is larger in magnitude than cbrt(x) but not much more than - // 2 23-bit ulps larger). With rounding towards zero, the error bound - // would be ~5/6 instead of ~4/6. With a maximum error of 2 23-bit ulps - // in the rounded t, the infinite-precision error in the Newton - // approximation barely affects third digit in the final error - // 0.667; the error in the rounded t can be up to about 3 23-bit ulps - // before the final error is larger than 0.667 ulps. - t = reinterpret((reinterpret(t) + 0x80000000) & 0xffffffffc0000000); - - // one step Newton iteration to 53 bits with error < 0.667 ulps - var s = t * t; // t*t is exact - r = x / s; // error <= 0.5 ulps; |r| < |t| - var w = t + t; // t+t is exact - r = (r - t) / (w + r); // r-t is exact; w+r ~= 3*t - t = t + t * r; // error <= 0.5 + 0.5/3 + epsilon + t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000); + var s = t * t; + r = x / s; + var w = t + t; + r = (r - t) / (w + r); + t = t + t * r; return t; } export function ceil(x: f64): f64 { - return builtin_ceil(x); + return builtin_ceil(x); } - export function clz32(x: f64): i32 { - return builtin_clz(x); + export function clz32(x: f64): f64 { + return builtin_clz(x); } - export function cos(x: f64): f64 { - unreachable(); // TODO + export function cos(x: f64): f64 { // TODO + unreachable(); return 0; } - export function cosh(x: f64): f64 { - unreachable(); // TODO - return 0; - } - - export function exp(x: f64): f64 { // based on musl's implementation of exp + function __expo2(x: f64): f64 { // see: musl/src/math/__expo2.c const - ln2hi = 6.93147180369123816490e-01, // 0x3fe62e42, 0xfee00000 - ln2lo = 1.90821492927058770002e-10, // 0x3dea39ef, 0x35793c76 - invln2 = 1.44269504088896338700e+00, // 0x3ff71547, 0x652b82fe - P1 = 1.66666666666666019037e-01, // 0x3FC55555, 0x5555553E - P2 = -2.77777777770155933842e-03, // 0xBF66C16C, 0x16BEBD93 - P3 = 6.61375632143793436117e-05, // 0x3F11566A, 0xAF25DE2C - P4 = -1.65339022054652515390e-06, // 0xBEBBBD41, 0xC5D26BF1 - P5 = 4.13813679705723846039e-08, // 0x3E663769, 0x72BEA4D0 - Ox1p1023 = 8.98846567431157954e+307; + k = 2043, + kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10 + var scale = reinterpret(((0x3FF + k / 2) << 20) << 32); + return exp(x - kln2) * scale * scale; + } + export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c + var u = reinterpret(x); + u &= 0x7FFFFFFFFFFFFFFF; + x = reinterpret(u); + var w = (u >> 32); + var t: f64; + if (w < 0x3FE62E42) { + if (w < 0x3FF00000 - (26 << 20)) return 1; + t = expm1(x); + return 1 + t * t / (2 * (1 + t)); + } + if (w < 0x40862E42) { + t = exp(x); + return 0.5 * (t + 1 / t); + } + t = __expo2(x); + return t; + } + + export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above + const + ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01 + ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10 + invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00 + P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01 + P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03 + P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05 + P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06 + P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08 + overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096 + underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842 + Ox1p1023 = reinterpret(0x7FE0000000000000); var hx = (reinterpret(x) >> 32); - hx &= 0x7fffffff; // high word of |x| - - // special cases - if (hx >= 0x4086232b) { // if |x| >= 708.39... + var sign_ = (hx >> 31); + hx &= 0x7FFFFFFF; + if (hx >= 0x4086232B) { if (isNaN(x)) return x; - if (x > 709.782712893383973096) { - // overflow if x!=inf + if (x > overflow) { x *= Ox1p1023; return x; } - if (x < -708.39641853226410622) { - // underflow if x!=-inf - if (x < -745.13321910194110842) return 0; - } + if (x < underflow) return 0; } - - // argument reduction - var hi: f64, lo: f64; - var k: i32; - if (hx > 0x3fd62e42) { // if |x| > 0.5 ln2 - if (hx >= 0x3ff0a2b2) { // if |x| >= 1.5 ln2 - k = (invln2 * x + copysign(0.5, x)); // was: [0.5, -0.5][sign_]) + var hi: f64, lo: f64 = 0; + var k: i32 = 0; + if (hx > 0x3FD62E42) { + if (hx >= 0x3FF0A2B2) { + k = (invln2 * x + builtin_copysign(0.5, x)); } else { - let sign_ = hx >> 31; k = 1 - sign_ - sign_; } - hi = x - k * ln2hi; // k * ln2hi is exact here + hi = x - k * ln2hi; lo = k * ln2lo; x = hi - lo; - } else if (hx > 0x3e300000) { // if |x| > 2**-28 - k = 0; + } else if (hx > 0x3E300000) { hi = x; - lo = 0; - } else { - // inexact if x != 0 - return 1 + x; - } - - // x is now in primary range + } else return 1.0 + x; var xx = x * x; var c = x - xx * (P1 + xx * (P2 + xx * (P3 + xx * (P4 + xx * P5)))); - var y: f64 = 1 + (x * c / (2 - c) - lo + hi); + var y = 1.0 + (x * c / (2 - c) - lo + hi); if (k == 0) return y; return scalbn(y, k); } - export function expm1(x: f64): f64 { - unreachable(); // TODO - return 0; + export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above + const + o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02 + ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01 + ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10 + invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00 + Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02 + Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03 + Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05 + Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06 + Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07 + Ox1p1023 = reinterpret(0x7FE0000000000000); + var u = reinterpret(x); + var hx = (u >> 32 & 0x7FFFFFFF); + var k = 0, sign_ = (u >> 63); + if (hx >= 0x4043687A) { + if (isNaN(x)) return x; + if (sign_) return -1; + if (x > o_threshold) { + x *= Ox1p1023; + return x; + } + } + var c = 0.0, t: f64; + if (hx > 0x3FD62E42) { + let hi: f64, lo: f64; + if (hx < 0x3FF0A2B2) { + if (!sign_) { + hi = x - ln2_hi; + lo = ln2_lo; + k = 1; + } else { + hi = x + ln2_hi; + lo = -ln2_lo; + k = -1; + } + } else { + k = (invln2 * x + (sign_ ? -0.5 : 0.5)); + t = k; + hi = x - t * ln2_hi; + lo = t * ln2_lo; + } + x = hi - lo; + c = (hi - x) - lo; + } else if (hx < 0x3C900000) return x; + var hfx = 0.5 * x; + var hxs = x * hfx; + var r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5)))); + t = 3.0 - r1 * hfx; + var e = hxs * ((r1 - t) / (6.0 - x * t)); + if (k == 0) return x - (x * e - hxs); + e = x * (e - c) - c; + e -= hxs; + if (k == -1) return 0.5 * (x - e) - 0.5; + if (k == 1) { + if (x < -0.25) return -2.0 * (e - (x + 0.5)); + return 1.0 + 2.0 * (x - e); + } + u = (0x3FF + k) << 52; + var twopk = reinterpret(u); + var y: f64; + if (k < 0 || k > 56) { + y = x - e + 1.0; + if (k == 1024) y = y * 2.0 * Ox1p1023; + else y = y * twopk; + return y - 1.0; + } + u = (0x3FF - k) << 52; + if (k < 20) y = (x - e + (1 - reinterpret(u))) * twopk; + else y = (x - (e + reinterpret(u)) + 1) * twopk; + return y; } export function floor(x: f64): f64 { - return builtin_floor(x); + return builtin_floor(x); } export function fround(x: f64): f32 { return x; } - export function hypot(value1: f64, value2: f64): f64 { // TODO: rest - unreachable(); // TODO - return 0; - } - - export function imul(x: f64, y: f64): i32 { - return x * y; - } - - export function log(x: f64): f64 { // based on musl's implementation of log + export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c const - ln2_hi = 6.93147180369123816490e-01, // 3fe62e42 fee00000 - ln2_lo = 1.90821492927058770002e-10, // 3dea39ef 35793c76 - Lg1 = 6.666666666666735130e-01, // 3FE55555 55555593 - Lg2 = 3.999999999940941908e-01, // 3FD99999 9997FA04 - Lg3 = 2.857142874366239149e-01, // 3FD24924 94229359 - Lg4 = 2.222219843214978396e-01, // 3FCC71C5 1D8E78AF - Lg5 = 1.818357216161805012e-01, // 3FC74664 96CB03DE - Lg6 = 1.531383769920937332e-01, // 3FC39A09 D078C69F - Lg7 = 1.479819860511658591e-01, // 3FC2F112 DF3E5244 - Ox1p54 = 18014398509481984.0; + SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1 + Ox1p700 = reinterpret(0x6BB0000000000000), + Ox1p_700 = reinterpret(0x1430000000000000); + var ux = reinterpret(x); + var uy = reinterpret(y); + ux &= 0x7FFFFFFFFFFFFFFF; + uy &= 0x7FFFFFFFFFFFFFFF; + if (ux < uy) { + let ut = ux; + ux = uy; + uy = ut; + } + var ex = (ux >> 52); + var ey = (uy >> 52); + y = reinterpret(uy); + if (ey == 0x7FF) return y; + x = reinterpret(ux); + if (ex == 0x7FF || uy == 0) return x; + if (ex - ey > 64) return x + y; + var z = 1.0; + if (ex > 0x3FF + 510) { + z = Ox1p700; + x *= Ox1p_700; + y *= Ox1p_700; + } else if (ey < 0x3ff - 450) { + z = Ox1p_700; + x *= Ox1p700; + y *= Ox1p700; + } + var c = x * SPLIT; + var h = x - c + c; + var l = x - h; + var hx = x * x; + var lx = h * h - hx + 2 * h * l + l * l; + c = y * SPLIT; + h = y - c + c; + l = y - h; + var hy = y * y; + var ly = h * h - hy + 2 * h * l + l * l; + return z * builtin_sqrt(ly + lx + hy + hx); + } - var Ux = reinterpret(x); - var hx = (Ux >> 32); + export function imul(x: f64, y: f64): f64 { + return (x * y); + } + + export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above + const + ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01 + ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10 + Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01 + Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01 + Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01 + Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01 + Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01 + Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01 + Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01 + Ox1p54 = reinterpret(0x4350000000000000); + var u = reinterpret(x); + var hx = (u >> 32); var k = 0; if (hx < 0x00100000 || (hx >> 31)) { - if (Ux << 1 == 0) return -1 / (x * x); // log(+-0)=-inf - if (hx >> 31) return (x - x) / 0.0; // log(-#) = NaN - // subnormal number, scale x up + if (u << 1 == 0) return -1 / (x * x); + if (hx >> 31) return (x - x) / 0.0; k -= 54; x *= Ox1p54; - Ux = reinterpret(x); - hx = (Ux >> 32); - } else if (hx >= 0x7ff00000) return x; - else if (hx == 0x3ff00000 && Ux << 32 == 0) return 0; - - // reduce x into [sqrt(2)/2, sqrt(2)] - hx += 0x3ff00000 - 0x3fe6a09e; - k += (hx >> 20) - 0x3ff; - hx = (hx & 0x000fffff) + 0x3fe6a09e; - Ux = hx << 32 | (Ux & 0xffffffff); - x = reinterpret(Ux); - + u = reinterpret(x); + hx = (u >> 32); + } else if (hx >= 0x7FF00000) return x; + else if (hx == 0x3FF00000 && u << 32 == 0) return 0; + hx += 0x3FF00000 - 0x3FE6A09E; + k += (hx >> 20) - 0x3FF; + hx = (hx & 0x000FFFFF) + 0x3FE6A09E; + u = hx << 32 | (u & 0xFFFFFFFF); + x = reinterpret(u); var f = x - 1.0; var hfsq = 0.5 * f * f; var s = f / (2.0 + f); @@ -329,89 +614,218 @@ export namespace NativeMath { return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi; } - export function log10(x: f64): f64 { - // return log(x) / LN10; - unreachable(); // TODO - return 0; + export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above + const + ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01 + ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11 + log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01 + log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13 + Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01 + Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01 + Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01 + Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01 + Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01 + Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01 + Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01 + Ox1p54 = reinterpret(0x4350000000000000); + var u = reinterpret(x); + var hx = (u >> 32); + var k = 0; + if (hx < 0x00100000 || (hx >> 31)) { + if (u << 1 == 0) return -1 / (x * x); + if (hx >> 31) return (x - x) / 0.0; + k -= 54; + x *= Ox1p54; + u = reinterpret(x); + hx = (u >> 32); + } else if (hx >= 0x7ff00000) return x; + else if (hx == 0x3ff00000 && u << 32 == 0) return 0; + hx += 0x3ff00000 - 0x3fe6a09e; + k += (hx >> 20) - 0x3ff; + hx = (hx & 0x000FFFFF) + 0x3FE6A09E; + u = hx << 32 | (u & 0xffffffff); + x = reinterpret(u); + var f = x - 1.0; + var hfsq = 0.5 * f * f; + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + var R = t2 + t1; + var hi = f - hfsq; + u = reinterpret(hi); + u &= 0xFFFFFFFF00000000; + hi = reinterpret(u); + var lo = f - hi - hfsq + s * (hfsq + R); + var val_hi = hi * ivln10hi; + var dk = k; + var y = dk * log10_2hi; + var val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi; + w = y + val_hi; + val_lo += (y - w) + val_hi; + val_hi = w; + return val_lo + val_hi; } - export function log1p(x: f64): f64 { - unreachable(); // TODO - return 0; + export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above + const + ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01 + ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10 + Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01 + Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01 + Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01 + Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01 + Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01 + Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01 + Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01 + var u = reinterpret(x); + var hx = (u >> 32); + var k = 1; + var c = 0.0, f = 0.0; + if (hx < 0x3FDA827A || (hx >> 31)) { + if (hx >= 0xBFF00000) { + if (x == -1) return x / 0.0; + return (x - x) / 0.0; + } + if (hx << 1 < 0x3CA00000 << 1) return x; + if (hx <= 0xBFD2BEC4) { + k = 0; + c = 0; + f = x; + } + } else if (hx >= 0x7FF00000) return x; + if (k) { + u = reinterpret(1 + x); + let hu = (u >> 32); + hu += 0x3FF00000 - 0x3FE6A09E; + k = (hu >> 20) - 0x3FF; + if (k < 54) { + let uf = reinterpret(u); + c = k >= 2 ? 1 - (uf - x) : x - (uf - 1); + c /= uf; + } else c = 0; + hu = (hu & 0x000FFFFF) + 0x3FE6A09E; + u = hu << 32 | (u & 0xFFFFFFFF); + f = reinterpret(u) - 1; + } + var hfsq = 0.5 * f * f; + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + var R = t2 + t1; + var dk = k; + return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi; } - export function log2(x: f64): f64 { - // return log(x) / LN2; - unreachable(); // TODO - return 0; + export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above + const + ivln2hi = reinterpret(0x3ff7154765200000), // 1.44269504072144627571e+00 + ivln2lo = reinterpret(0x3de705fc2eefa200), // 1.67517131648865118353e-10 + Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01 + Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01 + Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01 + Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01 + Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01 + Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01 + Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01 + Ox1p54 = reinterpret(0x4350000000000000); + var u = reinterpret(x); + var hx = (u >> 32); + var k = 0; + if (hx < 0x00100000 || (hx >> 31)) { + if (u << 1 == 0) return -1 / (x * x); + if (hx >> 31) return (x - x) / 0.0; + k -= 54; + x *= Ox1p54; + u = reinterpret(x); + hx = (u >> 32); + } else if (hx >= 0x7FF00000) return x; + else if (hx == 0x3FF00000 && u << 32 == 0) return 0; + hx += 0x3FF00000 - 0x3FE6A09E; + k += (hx >> 20) - 0x3FF; + hx = (hx & 0x000FFFFF) + 0x3FE6A09E; + u = hx << 32 | (u & 0xFFFFFFFF); + x = reinterpret(u); + var f = x - 1.0; + var hfsq = 0.5 * f * f; + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * (Lg4 + w * Lg6)); + var t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7))); + var R = t2 + t1; + var hi = f - hfsq; + u = reinterpret(hi); + u &= 0xFFFFFFFF00000000; + hi = reinterpret(u); + var lo = f - hi - hfsq + s * (hfsq + R); + var val_hi = hi * ivln2hi; + var val_lo = (lo + hi) * ivln2lo + lo * ivln2hi; + var y = k; + w = y + val_hi; + val_lo += (y - w) + val_hi; + val_hi = w; + return val_lo + val_hi; } export function max(value1: f64, value2: f64): f64 { - return builtin_max(value1, value2); + return builtin_max(value1, value2); } export function min(value1: f64, value2: f64): f64 { - return builtin_min(value1, value2); + return builtin_min(value1, value2); } - export function pow(x: f64, y: f64): f64 { // pased on musl's implementation of pow + export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above const - two53 = 9007199254740992.0, // 0x43400000, 0x00000000 - huge = 1.0e+300, - tiny = 1.0e-300, - // poly coefs for (3/2)*(log(x)-2s-2/3*s**3 - L1 = 5.99999999999994648725e-01, // 0x3FE33333, 0x33333303 - L2 = 4.28571428578550184252e-01, // 0x3FDB6DB6, 0xDB6FABFF - L3 = 3.33333329818377432918e-01, // 0x3FD55555, 0x518F264D - L4 = 2.72728123808534006489e-01, // 0x3FD17460, 0xA91D4101 - L5 = 2.30660745775561754067e-01, // 0x3FCD864A, 0x93C9DB65 - L6 = 2.06975017800338417784e-01, // 0x3FCA7E28, 0x4A454EEF - P1 = 1.66666666666666019037e-01, // 0x3FC55555, 0x5555553E - P2 = -2.77777777770155933842e-03, // 0xBF66C16C, 0x16BEBD93 - P3 = 6.61375632143793436117e-05, // 0x3F11566A, 0xAF25DE2C - P4 = -1.65339022054652515390e-06, // 0xBEBBBD41, 0xC5D26BF1 - P5 = 4.13813679705723846039e-08, // 0x3E663769, 0x72BEA4D0 - lg2 = 6.93147180559945286227e-01, // 0x3FE62E42, 0xFEFA39EF - lg2_h = 6.93147182464599609375e-01, // 0x3FE62E43, 0x00000000 - lg2_l = -1.90465429995776804525e-09, // 0xBE205C61, 0x0CA86C39 - ovt = 8.0085662595372944372e-017, // -(1024-log2(ovfl+.5ulp)) - cp = 9.61796693925975554329e-01, // 0x3FEEC709, 0xDC3A03FD =2/(3ln2) - cp_h = 9.61796700954437255859e-01, // 0x3FEEC709, 0xE0000000 =(float)cp - cp_l = -7.02846165095275826516e-09, // 0xBE3E2FE0, 0x145B01F5 =tail of cp_h - ivln2 = 1.44269504088896338700e+00, // 0x3FF71547, 0x652B82FE =1/ln2 - ivln2_h = 1.44269502162933349609e+00, // 0x3FF71547, 0x60000000 =24b 1/ln2 - ivln2_l = 1.92596299112661746887e-0; // 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail - - var __u = reinterpret(x); // EXTRACT_WORDS(hx, lx, x) - var hx = (__u >> 32); - var lx = __u; - - __u = reinterpret(y); // EXTRACT_WORDS(hy, ly, y) - var hy = (__u >> 32); - var ly = __u; - - var ix = hx & 0x7fffffff; - var iy = hy & 0x7fffffff; - - // x**0 = 1, even if x is NaN - if ((iy | ly) == 0) return 1.0; - // 1**y = 1, even if y is NaN - if (hx == 0x3ff00000 && lx == 0) return 1.0; - // NaN if either arg is NaN - if ( - ix > 0x7ff00000 || (ix == 0x7ff00000 && lx != 0) || - iy > 0x7ff00000 || (iy == 0x7ff00000 && ly != 0) + dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01 + dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08 + two53 = reinterpret(0x4340000000000000), // 9007199254740992.0 + huge = reinterpret(0x7E37E43C8800759C), // 1e+300 + tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300 + L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01 + L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01 + L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01 + L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01 + L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01 + L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01 + P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01 + P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03 + P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05 + P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06 + P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08 + lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01 + lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01 + lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09 + ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017 + cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01 + cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01 + cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09 + ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00 + ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00 + ivln2_l = reinterpret(0x3E54AE0BF85DDF44); // 1.92596299112661746887e-08 + var u_ = reinterpret(x); + var hx = (u_ >> 32); + var lx = u_; + u_ = reinterpret(y); + var hy = (u_ >> 32); + var ly = u_; + var ix = hx & 0x7FFFFFFF; + var iy = hy & 0x7FFFFFFF; + if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN + // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN + if ( // NaN if either arg is NaN + ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) || + iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0) ) return x + y; - - // determine if y is an odd int when x < 0 - // yisint = 0 ... y is not an integer - // yisint = 1 ... y is an odd int - // yisint = 2 ... y is an even int var yisint = 0, k: i32; if (hx < 0) { - if (iy >= 0x43400000) yisint = 2; // even integer y - else if (iy >= 0x3ff00000) { - k = (iy >> 20) - 0x3ff; // exponent + if (iy >= 0x43400000) yisint = 2; + else if (iy >= 0x3FF00000) { + k = (iy >> 20) - 0x3FF; if (k > 20) { let jj = ly >> (52 - k); if ((jj << (52 - k)) == ly) yisint = 2 - (jj & 1); @@ -421,154 +835,132 @@ export namespace NativeMath { } } } - - // special value of y if (ly == 0) { - if (iy == 0x7ff00000) { // y is +-inf - if (((ix - 0x3ff00000) | lx) == 0) return 1.0; // (-1)**+-inf is 1 - else if (ix >= 0x3ff00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0 - else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf + if (iy == 0x7FF00000) { // y is +-inf + if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN + else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0 + else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf } - if (iy == 0x3ff00000) { // y is +-1 + if (iy == 0x3FF00000) { if (hy >= 0) return x; return 1 / x; } - if (hy == 0x40000000) return x * x; // y is 2 - if (hy == 0x3fe00000) { // y is 0.5 - if (hx >= 0) return sqrt(x); // x >= +0 + if (hy == 0x40000000) return x * x; + if (hy == 0x3FE00000) { + if (hx >= 0) return builtin_sqrt(x); } } - - var ax = builtin_abs(x), z: f64; - // special value of x + var ax = builtin_abs(x), z: f64; if (lx == 0) { - if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) { // x is +-0,+-inf,+-1 + if (ix == 0x7FF00000 || ix == 0 || ix == 0x3FF00000) { z = ax; - if (hy < 0) z = 1.0 / z; // z = (1/|x|) + if (hy < 0) z = 1.0 / z; if (hx < 0) { - if (((ix - 0x3ff00000) | yisint) == 0) z = (z - z) / (z - z); // (-1)**non-int is NaN - else if (yisint == 1) z = -z; // (x<0)**odd = -(|x|**odd) + if (((ix - 0x3FF00000) | yisint) == 0) z = (z - z) / (z - z); + else if (yisint == 1) z = -z; } return z; } } - - var s = 1.0; // sign of result + var s = 1.0; if (hx < 0) { - if (yisint == 0) return (x - x) / (x - x); // (x<0)**(non-int) is NaN - if (yisint == 1) s = -1.0; // (x<0)**(odd int) + if (yisint == 0) return (x - x) / (x - x); + if (yisint == 1) s = -1.0; } - - // |y| is huge var t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64; var j: i32, n: i32; - if (iy > 0x41e00000) { // if |y| > 2**31 - if (iy > 0x43f00000) { // if |y| > 2**64, must o/uflow - if (ix <= 0x3fefffff) return hy < 0 ? huge * huge : tiny * tiny; - if (ix >= 0x3ff00000) return hy > 0 ? huge * huge : tiny * tiny; + if (iy > 0x41E00000) { + if (iy > 0x43F00000) { + if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny; + if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny; } - // over/underflow if x is not close to one - if (ix < 0x3fefffff) return hy < 0 ? s * huge * huge : s * tiny * tiny; - if (ix > 0x3ff00000) return hy > 0 ? s * huge * huge : s * tiny * tiny; - // now |1-x| is tiny <= 2**-20, suffice to compute - // log(x) by x-x^2/2+x^3/3-x^4/4 - t = ax - 1.0; // t has 20 trailing zeros + if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny; + if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny; + t = ax - 1.0; w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25)); - u = ivln2_h * t; // ivln2_h has 21 sig. bits + u = ivln2_h * t; v = t * ivln2_l - w * ivln2; t1 = u + v; - t1 = reinterpret(reinterpret(t1) & 0xffffffff00000000); // SET_LOW_WORD(t1, 0) + t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000); t2 = v - (t1 - u); } else { let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64; n = 0; - // take care subnormal number if (ix < 0x00100000) { ax *= two53; n -= 53; ix = (reinterpret(ax) >> 32); } - n += (ix >> 20) - 0x3ff; - j = ix & 0x000fffff; - // determine interval - ix = j | 0x3ff00000; // normalize ix - if (j <= 0x3988E) k = 0; // |x|> 20) - 0x3FF; + j = ix & 0x000FFFFF; + ix = j | 0x3FF00000; + if (j <= 0x3988E) k = 0; + else if (j < 0xBB67A) k = 1; else { k = 0; n += 1; ix -= 0x00100000; } - ax = reinterpret(reinterpret(ax) & 0xffffffff | (ix << 32)); // SET_HIGH_WORD(ax, ix) - - // compute ss = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) - let bp = select(1.5, 1.0, k); // bp[k], bp[0]=1.0, bp[1]=1.5 + ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32)); + let bp = select(1.5, 1.0, k); u = ax - bp; v = 1.0 / (ax + bp); ss = u * v; s_h = ss; - s_h = reinterpret(reinterpret(s_h) & 0xffffffff00000000); // SET_LOW_WORD(s_h, 0) - // t_h=ax+bp[k] High - t_h = reinterpret((((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32); // SET_HIGH_WORD + s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000); + t_h = reinterpret((((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32); t_l = ax - (t_h - bp); s_l = v * ((u - s_h * t_h) - s_h * t_l); - // compute log(ax) s2 = ss * ss; r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6))))); r += s_l * (s_h + ss); s2 = s_h * s_h; t_h = 3.0 + s2 + r; - t_h = reinterpret(reinterpret(t_h) & 0xffffffff00000000); // SET_LOW_WORD(t_h, 0) + t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000); t_l = r - ((t_h - 3.0) - s2); - // u+v = ss*(1+...) u = s_h * t_h; v = s_l * t_h + t_l * ss; - // 2/(3log2)*(ss+...) p_h = u + v; - p_h = reinterpret(reinterpret(p_h) & 0xffffffff00000000); // SET_LOW_WORD(p_h, 0) + p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000); p_l = v - (p_h - u); - let z_h = cp_h * p_h; // cp_h+cp_l = 2/(3*log2) - let dp_l = select(1.35003920212974897128e-08, 0.0, k); // dp_l[k] + let z_h = cp_h * p_h; + let dp_l = select(dp_l1, 0.0, k); let z_l = cp_l * p_h + p_l * cp + dp_l; - // log2(ax) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l t = n; - let dp_h = select(5.84962487220764160156e-01, 0.0, k); // dp_h[k] + let dp_h = select(dp_h1, 0.0, k); t1 = ((z_h + z_l) + dp_h) + t; - t1 = reinterpret(reinterpret(t1) & 0xffffffff00000000); // SET_LOW_WORD(t1, 0); + t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000); t2 = z_l - (((t1 - t) - dp_h) - z_h); } - - // split up y into y1+y2 and compute (y1+y2)*(t1+t2) var y1 = y; - y1 = reinterpret(reinterpret(y1) & 0xffffffff00000000); // SET_LOW_WORD(y1, 0) + y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000); p_l = (y - y1) * t1 + y * t2; p_h = y1 * t1; z = p_l + p_h; - __u = reinterpret(z); // EXTRACT_WORDS(j, i, z) ... - j = (__u >> 32); - var i = __u; - if (j >= 0x40900000) { // z >= 1024 - if (((j - 0x40900000) | i) != 0) return s * huge * huge; // if z > 1024, overflow - if (p_l + ovt > z - p_h) return s * huge * huge; // overflow - } else if ((j & 0x7fffffff) >= 0x4090cc00) { // z <= -1075, FIXME: instead of abs(j) use unsigned j - if (((j - 0xc090cc00) | i) != 0) return s * tiny * tiny; // z < -1075, underflow - if (p_l <= z - p_h) return s * tiny * tiny; // underflow + u_ = reinterpret(z); + j = (u_ >> 32); + var i = u_; + if (j >= 0x40900000) { + if (((j - 0x40900000) | i) != 0) return s * huge * huge; + if (p_l + ovt > z - p_h) return s * huge * huge; + } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) { + if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny; + if (p_l <= z - p_h) return s * tiny * tiny; } - // compute 2**(p_h+p_l) - i = j & 0x7fffffff; - k = (i >> 20) - 0x3ff; + i = j & 0x7FFFFFFF; + k = (i >> 20) - 0x3FF; n = 0; - if (i > 0x3fe00000) { // if |z| > 0.5, set n = [z+0.5] + if (i > 0x3FE00000) { n = j + (0x00100000 >> (k + 1)); - k = ((n & 0x7fffffff) >> 20) - 0x3ff; // new k for n + k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF; t = 0.0; - t = reinterpret((n & ~(0x000fffff >> k)) << 32); // SET_HIGH_WORD(t, n & ~(0x000fffff>>k)) - n = ((n & 0x000fffff) | 0x00100000) >> (20 - k); + t = reinterpret((n & ~(0x000FFFFF >> k)) << 32); + n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k); if (j < 0) n = -n; p_h -= t; } t = p_l + p_h; - t = reinterpret(reinterpret(t) & 0xffffffff00000000); // SET_LOW_WORD(t, 0) + t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000); u = t * lg2_h; v = (p_l - (t - p_h)) * lg2 + t * lg2_l; z = u + v; @@ -577,38 +969,13 @@ export namespace NativeMath { t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); r = (z * t1) / (t1 - 2.0) - (w + z * w); z = 1.0 - (r - z); - j = (reinterpret(z) >> 32); // GET_HIGH_WORD(j, z) + j = (reinterpret(z) >> 32); j += n << 20; - if ((j >> 20) <= 0) z = scalbn(z, n); // subnormal output - else z = reinterpret(reinterpret(z) & 0xffffffff | (j << 32)); // SET_HIGH_WORD(z, j) + if ((j >> 20) <= 0) z = scalbn(z, n); + else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32)); return s * z; } - var random_seeded = false; - var random_state0: u64; - var random_state1: u64; - - function murmurHash3(h: u64): u64 { - h ^= h >> 33; - h *= 0xFF51AFD7ED558CCD; - h ^= h >> 33; - h *= 0xC4CEB9FE1A85EC53; - h ^= h >> 33; - return h; - } - - function xorShift128Plus(): u64 { - var s1 = random_state0; - var s0 = random_state1; - random_state0 = s0; - s1 ^= s1 << 23; - s1 ^= s1 >> 17; - s1 ^= s0; - s1 ^= s0 >> 26; - random_state1 = s1; - return s0 + s1; - } - export function seedRandom(value: i64): void { assert(value); random_seeded = true; @@ -616,57 +983,114 @@ export namespace NativeMath { random_state1 = murmurHash3(random_state0); } - export function random(): f64 { // based on V8's implementation - const - kExponentBits = 0x3FF0000000000000, - kMantissaMask = 0x000FFFFFFFFFFFFF; - - if (!random_seeded) unreachable(); - var r = (xorShift128Plus() & kMantissaMask) | kExponentBits; + export function random(): f64 { // see: v8/src/base/random-number-generator.cc + if (!random_seeded) throw new Error("PRNG must be seeded."); + var s1 = random_state0; + var s0 = random_state1; + random_state0 = s0; + s1 ^= s1 << 23; + s1 ^= s1 >> 17; + s1 ^= s0; + s1 ^= s0 >> 26; + random_state1 = s1; + var r = ((s0 + s1) & 0x000FFFFFFFFFFFFF) | 0x3FF0000000000000; return reinterpret(r) - 1; } - export function round(x: f64): f64 { - return builtin_nearest(x); + export function round(x: f64): f64 { // see: musl/src/math/round.c + const toint = 1.0 / f64.EPSILON; + var ux = reinterpret(x); + var e = (ux >> 52 & 0x7ff); + if (e >= 0x3FF + 52) return x; + if (e < 0x3FF - 1) return 0 * x; + var y: f64; + if (ux >> 63) { + // FIXME: JS always rounds fractional 0.5 towards +Infinity + // and there certainly is a smarter way to do this. + y = toint - x - toint + x; + if (y >= 0.5) y = x - y + 1; + else if (y < -0.5) y = x - y - 1; + else y = x - y; + } else { + y = x + toint - toint - x; + if (y > 0.5) y = y + x - 1; + else if (y <= -0.5) y = y + x + 1; + else y = y + x; + } + return y; } export function sign(x: f64): f64 { return x > 0 ? 1 : x < 0 ? -1 : x; } - export function sin(x: f64): f64 { - unreachable(); // TODO + export function sin(x: f64): f64 { // TODO + unreachable(); return 0; } - export function sinh(x: f64): f64 { - unreachable(); // TODO - return 0; + export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c + var u = reinterpret(x); + var h = 0.5; + if (u >> 63) h = -h; + u &= 0x7FFFFFFFFFFFFFFF; + var absx = reinterpret(u); + var w = (u >> 32); + var t: f64; + if (w < 0x40862E42) { + t = expm1(absx); + if (w < 0x3FF00000) { + if (w < 0x3FF00000 - (26 << 20)) return x; + return h * (2 * t - t * t / (t + 1)); + } + return h * (t + t / (t + 1)); + } + t = 2 * h * __expo2(absx); + return t; } export function sqrt(x: f64): f64 { - return builtin_sqrt(x); + return builtin_sqrt(x); } - export function tan(x: f64): f64 { - unreachable(); // TODO + export function tan(x: f64): f64 { // TODO + unreachable(); return 0; } - export function tanh(x: f64): f64 { - unreachable(); // TODO - return 0; + export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c + var u = reinterpret(x); + var sign_ = (u >> 63); + u &= 0x7FFFFFFFFFFFFFFF; + x = reinterpret(u); + var w = (u >> 32); + var t: f64; + if (w > 0x3FE193EA) { + if (w > 0x40340000) { + t = 1 - 0 / x; + } else { + t = expm1(2 * x); + t = 1 - 2 / (t + 2); + } + } else if (w > 0x3FD058AE) { + t = expm1(2 * x); + t = t / (t + 2); + } else if (w >= 0x00100000) { + t = expm1(-2 * x); + t = -t / (t + 2); + } else t = x; + return sign_ ? -t : t; } export function trunc(x: f64): f64 { - return builtin_trunc(x); + return builtin_trunc(x); } - function scalbn(x: f64, n: i32): f64 { // based on musl's implementation of scalbn + /** @internal */ + export function scalbn(x: f64, n: i32): f64 { // see: musl/src/math/scalbn.c const - Ox1p1023 = 8.98846567431157954e+307, - Ox1p_1022 = 2.22507385850720138e-308; - + Ox1p1023 = reinterpret(0x7FE0000000000000), + Ox1p_1022 = reinterpret(0x0010000000000000); var y = x; if (n > 1023) { y *= Ox1p1023; @@ -685,172 +1109,450 @@ export namespace NativeMath { if (n < -1022) n = -1022; } } - return y * reinterpret((0x3ff + n) << 52); + return y * reinterpret((0x3FF + n) << 52); + } + + export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c + var ux = reinterpret(x); + var uy = reinterpret(y); + var ex = (ux >> 52 & 0x7FF); + var ey = (uy >> 52 & 0x7FF); + var sx = (ux >> 63); + if (uy << 1 == 0 || isNaN(y) || ex == 0x7FF) return (x * y) / (x * y); + if (ux << 1 <= uy << 1) { + if (ux << 1 == uy << 1) return 0 * x; + return x; + } + var i: u64; + if (!ex) { + for (i = ux << 12; !(i >> 63); i <<= 1) --ex; + ux <<= -ex + 1; + } else { + ux &= -1 >> 12; + ux |= 1 << 52; + } + if (!ey) { + for (i = uy << 12; !(i >> 63); i <<= 1) --ey; + uy <<= -ey + 1; + } else { + uy &= -1 >> 12; + uy |= 1 << 52; + } + for (; ex > ey; ex--) { + i = ux - uy; + if (!(i >> 63)) { + if (!i) return 0 * x; + ux = i; + } + ux <<= 1; + } + i = ux - uy; + if (!(i >> 63)) { + if (!i) return 0 * x; + ux = i; + } + for (; !(ux >> 52); ux <<= 1) --ex; + if (ex > 0) { + ux -= 1 << 52; + ux |= ex << 52; + } else { + ux >>= -ex + 1; + } + ux |= sx << 63; + return reinterpret(ux); + } + + export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c + var ux = reinterpret(x); + var uy = reinterpret(y); + var ex = (ux >> 52 & 0x7FF); + var ey = (uy >> 52 & 0x7FF); + var sx = (ux >> 63); + var sy = (uy >> 63); + if (uy << 1 == 0 || isNaN(y) || ex == 0x7FF) return (x * y) / (x * y); + if (ux << 1 == 0) return x; + var uxi = ux; + var i: u64; + if (!ex) { + for (i = uxi << 12; i >> 63 == 0; ex--, i <<= 1) {} + uxi <<= -ex + 1; + } else { + uxi &= -1 >> 12; + uxi |= 1 << 52; + } + if (!ey) { + for (i = uy << 12; i >> 63 == 0; ey--, i <<= 1) {} + uy <<= -ey + 1; + } else { + uy &= -1 >> 12; + uy |= 1 << 52; + } + var q: u32 = 0; + do { + if (ex < ey) { + if (ex + 1 == ey) break; // goto end + return x; + } + for (; ex > ey; ex--) { + i = uxi - uy; + if (i >> 63 == 0) { + uxi = i; + ++q; + } + uxi <<= 1; + q <<= 1; + } + i = uxi - uy; + if (i >> 63 == 0) { + uxi = i; + ++q; + } + if (uxi == 0) ex = -60; + else for (; uxi >> 52 == 0; uxi <<= 1, ex--) {} + break; + } while (false); + // end: + if (ex > 0) { + uxi -= 1 << 52; + uxi |= ex << 52; + } else { + uxi >>= -ex + 1; + } + x = reinterpret(uxi); + if (sy) y = -y; + if (ex == ey || (ex + 1 == ey && (2.0 * x > y || (2.0 * x == y && (q % 2))))) { + x -= y; + ++q; + } + q &= 0x7FFFFFFF; + return sx ? -x : x; } } export namespace NativeMathf { - export const E = NativeMath.E; - export const LN2 = NativeMath.LN2; - export const LN10 = NativeMath.LN10; - export const LOG2E = NativeMath.LOG2E; - export const LOG10E = NativeMath.LOG10E; - export const PI = NativeMath.PI; + export const E = NativeMath.E; + export const LN2 = NativeMath.LN2; + export const LN10 = NativeMath.LN10; + export const LOG2E = NativeMath.LOG2E; + export const LOG10E = NativeMath.LOG10E; + export const PI = NativeMath.PI; export const SQRT1_2 = NativeMath.SQRT1_2; - export const SQRT2 = NativeMath.SQRT2; + export const SQRT2 = NativeMath.SQRT2; export function abs(x: f32): f32 { - return builtin_abs(x); + return builtin_abs(x); } - export function acos(x: f32): f32 { - unreachable(); // TOOD - return 0; - } - - export function acosh(x: f32): f32 { - unreachable(); // TODO - return 0; - } - - export function asin(x: f32): f32 { - unreachable(); // TODO - return 0; - } - - export function asinh(x: f32): f32 { - unreachable(); // TODO - return 0; - } - - export function atan(x: f32): f32 { - unreachable(); // TODO - return 0; - } - - export function atanh(x: f32): f32 { - unreachable(); // TODO - return 0; - } - - export function atan2(y: f32, x: f32): f32 { - unreachable(); // TOOD - return 0; - } - - export function cbrt(x: f32): f32 { // based on musl's implementation of cbrtf + function __R(z: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above const - B1 = 709958130, /* B1 = (127-127.0/3-0.03306235651)*2**23 */ - B2 = 642849266, /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */ - Ox1p24f = 16777216.0; + pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f + pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f + pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f + qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f + var p = z * (pS0 + z * (pS1 + z * pS2)); + var q: f32 = 1 + z * qS1; + return p / q; + } - var ux = reinterpret(x); - var hx = ux & 0x7fffffff; - if (hx >= 0x7f800000) return x + x; // cbrt(NaN,INF) is itself + export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above + const + pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f + pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f + Ox1p_120f = reinterpret(0x03800000); + var hx = reinterpret(x); + var ix = hx & 0x7FFFFFFF; + if (ix >= 0x3F800000) { + if (ix == 0x3F800000) { + if (hx >> 31) return 2 * pio2_hi + Ox1p_120f; + return 0; + } + return 0 / (x - x); + } + if (ix < 0x3F000000) { + if (ix <= 0x32800000) return pio2_hi + Ox1p_120f; + return pio2_hi - (x - (pio2_lo - x * __R(x * x))); + } + var z: f32, w: f32, s: f32; + if (hx >> 31) { + z = (1 + x) * 0.5; + s = builtin_sqrt(z); + w = __R(z) * s - pio2_lo; + return 2 * (pio2_hi - (s + w)); + } + z = (1 - x) * 0.5; + s = builtin_sqrt(z); + hx = reinterpret(s); + var df = reinterpret(hx & 0xFFFFF000); + var c = (z - df * df) / (s + df); + w = __R(z) * s + c; + return 2 * (df + w); + } - // rough cbrt to 5 bits - if (hx < 0x00800000) { // zero or subnormal? - if (hx == 0) return x; // cbrt(+-0) is itself - ux = reinterpret(x * Ox1p24f); - hx = ux & 0x7fffffff; + export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c + const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f + var u = reinterpret(x); + var a = u & 0x7FFFFFFF; + if (a < 0x3F800000 + (1 << 23)) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1))); + if (a < 0x3F800000 + (12 << 23)) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1))); + return log(x) + s; + } + + export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above + const + pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f + Ox1p_120f = reinterpret(0x03800000); + var hx = reinterpret(x); + var ix = hx & 0x7FFFFFFF; + if (ix >= 0x3F800000) { + if (ix == 0x3f800000) return x * pio2 + Ox1p_120f; + return 0 / (x - x); + } + if (ix < 0x3F000000) { + if (ix < 0x39800000 && ix >= 0x00800000) return x; + return x + x * __R(x * x); + } + var z: f32 = (1 - builtin_abs(x)) * 0.5; + var s = builtin_sqrt(z); // sic + x = (pio2 - 2 * (s + s * __R(z))); + if (hx >> 31) return -x; + return x; + } + + export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c + const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f + var u = reinterpret(x); + var i = u & 0x7FFFFFFF; + var s = (u >> 31); + u = i; + x = reinterpret(u); + if (i >= 0x3F800000 + (12 << 23)) x = log(x) + c; + else if (i >= 0x3F800000 + (1 << 23)) x = log(2 * x + 1 / (builtin_sqrt(x * x + 1) + x)); + else if (i >= 0x3F800000 - (12 << 23)) x = log1p(x + x * x / (builtin_sqrt(x * x + 1) + 1)); + return s ? -x : x; + } + + export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above + const + atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f + atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f + atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f + atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f + atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f + atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f + atanlo2 = reinterpret(0x33140fB4), // 3.4473217170e-08f + atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f + aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f + aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f + aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f + aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f + aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f + Ox1p_120f = reinterpret(0x03800000); + var ix = reinterpret(x); + var sig = (ix >> 31); + ix &= 0x7FFFFFFF; + var z: f32; + if (ix >= 0x4C800000) { + if (isNaN(x)) return x; + z = atanhi3 + Ox1p_120f; + return sig ? -z : z; + } + var id: i32; + if (ix < 0x3EE00000) { + if (ix < 0x39800000) return x; + id = -1; + } else { + x = builtin_abs(x); + if (ix < 0x3F980000) { + if (ix < 0x3F300000) { + id = 0; + x = (2.0 * x - 1.0) / (2.0 + x); + } else { + id = 1; + x = (x - 1.0) / (x + 1.0); + } + } else { + if (ix < 0x401C0000) { + id = 2; + x = (x - 1.5) / (1.0 + 1.5 * x); + } else { + id = 3; + x = -1.0 / x; + } + } + } + z = x * x; + var w = z * z; + var s1 = z * (aT0 + w * (aT2 + w * aT4)); + var s2 = w * (aT1 + w * aT3); + if (id < 0) return x - x * (s1 + s2); + switch (id) { + case 0: { z = atanhi0 - ((x * (s1 + s2) - atanlo0) - x); break; } + case 1: { z = atanhi1 - ((x * (s1 + s2) - atanlo1) - x); break; } + case 2: { z = atanhi2 - ((x * (s1 + s2) - atanlo2) - x); break; } + case 3: { z = atanhi3 - ((x * (s1 + s2) - atanlo3) - x); break; } + default: unreachable(); + } + return sig ? -z : z; + } + + export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c + var u = reinterpret(x); + var s = (u >> 31); + u &= 0x7FFFFFFF; + var y = reinterpret(u); + if (u < 0x3F800000 - (1 << 23)) { + if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y)); + } else y = 0.5 * log1p(2 * (y / (1 - y))); + return s ? -y : y; + } + + export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above + const + pi = reinterpret(0x40490FDB), // 3.1415927410e+00f + pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f + if (isNaN(x) || isNaN(y)) return x + y; + var ix = reinterpret(x); + var iy = reinterpret(y); + if (ix == 0x3F800000) return atan(y); + var m = (((iy >> 31) & 1) | ((ix >> 30) & 2)); + ix &= 0x7FFFFFFF; + iy &= 0x7FFFFFFF; + if (iy == 0) { + switch (m) { + case 0: + case 1: return y; + case 2: return pi; + case 3: return -pi; + } + } + if (ix == 0) return m & 1 ? -pi / 2 : pi / 2; + if (ix == 0x7F800000) { + if (iy == 0x7F800000) { + switch (m) { + case 0: return pi / 4; + case 1: return -pi / 4; + case 2: return 3 * pi / 4; + case 3: return -3 * pi / 4; + } + } else { + switch (m) { + case 0: return 0; + case 1: return -0; + case 2: return pi; + case 3: return -pi; + } + } + } + if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2; + var z: f32; + if ((m & 2) && iy + (26 << 23) < ix) z = 0.0; + else z = atan(builtin_abs(y / x)); + switch (m) { + case 0: return z; + case 1: return -z; + case 2: return pi - (z - pi_lo); + case 3: return (z - pi_lo) - pi; + } + unreachable(); + return 0; + } + + export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above + const + B1 = 709958130, + B2 = 642849266, + Ox1p24f = reinterpret(0x4B800000); + var u = reinterpret(x); + var hx = u & 0x7FFFFFFF; + if (hx >= 0x7F800000) return x + x; + if (hx < 0x00800000) { + if (hx == 0) return x; + u = reinterpret(x * Ox1p24f); + hx = u & 0x7FFFFFFF; hx = hx / 3 + B2; } else { hx = hx / 3 + B1; } - ux &= 0x80000000; - ux |= hx; - - // First step Newton iteration (solving t*t-x/t == 0) to 16 bits. In - // double precision so that its terms can be arranged for efficiency - // without causing overflow or underflow. - var T = reinterpret(ux); + u &= 0x80000000; + u |= hx; + var T = reinterpret(u); var r = T * T * T; T = T * (x + x + r) / (x + r + r); - - // Second step Newton iteration to 47 bits. In double precision for - // efficiency and accuracy. r = T * T * T; T = T * (x + x + r) / (x + r + r); - - // rounding to 24 bits is perfect in round-to-nearest mode return T; } export function ceil(x: f32): f32 { - return builtin_ceil(x); + return builtin_ceil(x); } - export function clz32(x: f32): i32 { - return builtin_clz(x); + export function clz32(x: f32): f32 { + return builtin_clz(x); } - export function cos(x: f32): f32 { - unreachable(); // TODO + export function cos(x: f32): f32 { // TODO + unreachable(); return 0; } - export function cosh(x: f32): f32 { - unreachable(); // TODO - return 0; + export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c + var u = reinterpret(x); + u &= 0x7FFFFFFF; + x = reinterpret(u); + if (u < 0x3F317217) { + if (u < 0x3F800000 - (12 << 23)) return 1; + let t = expm1(x); + return 1 + t * t / (2 * (1 + t)); + } + if (u < 0x42B17217) { + let t = exp(x); + return 0.5 * (t + 1 / t); + } + return __expo2(x); } export function floor(x: f32): f32 { - return builtin_floor(x); + return builtin_floor(x); } - export function exp(x: f32): f32 { // based on musl's implementation of expf + export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above const - ln2hi = 6.9314575195e-1, // 0x3f317200 - ln2lo = 1.4286067653e-6, // 0x35bfbe8e - invln2 = 1.4426950216e+0, // 0x3fb8aa3b - // Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]: - // |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74 - P1 = 1.6666625440e-1, // 0xaaaa8f.0p-26 - P2 = -2.7667332906e-3, // -0xb55215.0p-32 - Ox1p127f = 1.701411835e+38; - + ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f + ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f + invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f + P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f + P2 = reinterpret(0xBB355215), // -2.7667332906e-3f + Ox1p127f = reinterpret(0x7F000000); var hx = reinterpret(x); - var sign_ = (hx >> 31); // sign bit of x - hx &= 0x7fffffff; // high word of |x| - - // special cases - if (hx >= 0x42aeac50) { // if |x| >= -87.33655f or NaN - if (hx >= 0x42b17218 && !sign_) { // x >= 88.722839f - // overflow + var sign_ = (hx >> 31); + hx &= 0x7FFFFFFF; + if (hx >= 0x42AEAC50) { + if (hx >= 0x42B17218 && !sign_) { x *= Ox1p127f; return x; } - if (sign_) { - // underflow - if (hx >= 0x42cff1b5) { // x <= -103.972084f - return 0; - } - } + if (sign_ && hx >= 0x42CFF1B5) return 0; } - - // argument reduction var hi: f32, lo: f32; var k: i32; - if (hx > 0x3eb17218) { // if |x| > 0.5 ln2 - if (hx > 0x3f851592) { // if |x| > 1.5 ln2 - k = (invln2 * x + copysign(0.5, x)); // was: [0.5, -0.5][sign_]) + if (hx > 0x3EB17218) { + if (hx > 0x3F851592) { + k = (invln2 * x + builtin_copysign(0.5, x)); } else { k = 1 - sign_ - sign_; } - hi = x - k * ln2hi; // k * ln2hi is exact here + hi = x - k * ln2hi; lo = k * ln2lo; x = hi - lo; - } else if (hx > 0x39000000) { // |x| > 2**-14 + } else if (hx > 0x39000000) { k = 0; hi = x; lo = 0; } else { - // raise inexact return 1 + x; } - - // x is now in primary range var xx = x * x; var c = x - xx * (P1 + xx * P2); var y: f32 = 1 + (x * c / (2 - c) - lo + hi); @@ -858,52 +1560,139 @@ export namespace NativeMathf { return scalbn(y, k); } - export function expm1(x: f32): f32 { - unreachable(); // TODO - return 0; + export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above + const + o_threshold = reinterpret(0x42B17180), // 8.8721679688e+01f + ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f + ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f + invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f + Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f + Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f + Ox1p127f = reinterpret(0x7F000000); + var u = reinterpret(x); + var hx = u & 0x7FFFFFFF; + var sign_ = (u >> 31); + if (hx >= 0x4195B844) { + if (hx > 0x7F800000) return x; + if (sign_) return -1; + if (x > o_threshold) { + x *= Ox1p127f; + return x; + } + } + var c: f32 = 0.0, t: f32, k: i32; + if (hx > 0x3EB17218) { + let hi: f32, lo: f32; + if (hx < 0x3F851592) { + if (!sign_) { + hi = x - ln2_hi; + lo = ln2_lo; + k = 1; + } else { + hi = x + ln2_hi; + lo = -ln2_lo; + k = -1; + } + } else { + k = (invln2 * x + (sign_ ? -0.5 : 0.5)); + t = k; + hi = x - t * ln2_hi; + lo = t * ln2_lo; + } + x = hi - lo; + c = (hi - x) - lo; + } else if (hx < 0x33000000) { + return x; + } else k = 0; + var hfx: f32 = 0.5 * x; + var hxs: f32 = x * hfx; + var r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2); + t = 3.0 - r1 * hfx; + var e = hxs * ((r1 - t) / (6.0 - x * t)); + if (k == 0) return x - (x * e - hxs); + e = x * (e - c) - c; + e -= hxs; + if (k == -1) return 0.5 * (x - e) - 0.5; + if (k == 1) { + if (x < -0.25) return -2.0 * (e - (x + 0.5)); + return 1.0 + 2.0 * (x - e); + } + u = (0x7F + k) << 23; + var twopk = reinterpret(u); + var y: f32; + if (k < 0 || k > 56) { + y = x - e + 1.0; + if (k == 128) y = y * 2.0 * Ox1p127f; + else y = y * twopk; + return y - 1.0; + } + u = (0x7F - k) << 23; + if (k < 23) y = (x - e + (1 - reinterpret(u))) * twopk; + else y = (x - (e + reinterpret(u)) + 1) * twopk; + return y; } export function fround(x: f32): f32 { return x; } - export function hypot(value1: f32, value2: f32): f32 { // TODO: rest - unreachable(); // TODO - return 0; - } - - export function imul(x: f32, y: f32): i32 { - return x * y; - } - - export function log(x: f32): f32 { // based on musl's implementaion of logf + export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c const - ln2_hi = 6.9313812256e-01, // 0x3f317180 - ln2_lo = 9.0580006145e-06, // 0x3717f7d1 - Lg1 = 0.66666662693, // 0xaaaaaa.0p-24 - Lg2 = 0.40000972152, // 0xccce13.0p-25 - Lg3 = 0.28498786688, // 0x91e9ee.0p-25 - Lg4 = 0.24279078841, // 0xf89e26.0p-26 - Ox1p25f = 33554432.0; - + Ox1p90f = reinterpret(0x6C800000), + Ox1p_90f = reinterpret(0x12800000); var ux = reinterpret(x); + var uy = reinterpret(y); + ux &= 0x7FFFFFFF; + uy &= 0x7FFFFFFF; + if (ux < uy) { + let ut = ux; + ux = uy; + uy = ut; + } + x = reinterpret(ux); + y = reinterpret(uy); + if (uy == 0xFF << 23) return y; + if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y; + var z: f32 = 1; + if (ux >= (0x7F + 60) << 23) { + z = Ox1p90f; + x *= Ox1p_90f; + y *= Ox1p_90f; + } else if (uy < (0x7F - 60) << 23) { + z = Ox1p_90f; + x *= Ox1p90f; + y *= Ox1p90f; + } + return z * builtin_sqrt((x * x + y * y)); + } + + export function imul(x: f32, y: f32): f32 { + return (x * y); + } + + export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above + const + ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f + ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f + Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f + Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f + Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f + Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f + Ox1p25f = reinterpret(0x4C000000); + var u = reinterpret(x); var k = 0; - if (ux < 0x00800000 || (ux >> 31)) { // x < 2**-126 - if (ux << 1 == 0) return -1 / (x * x); // log(+-0)=-inf - if (ux >> 31) return (x - x) / 0; // log(-#) = NaN - // subnormal number, scale up x + if (u < 0x00800000 || (u >> 31)) { + if (u << 1 == 0) return -1 / (x * x); + if (u >> 31) return (x - x) / 0; k -= 25; x *= Ox1p25f; - ux = reinterpret(x); - } else if (ux >= 0x7f800000) return x; - else if (ux == 0x3f800000) return 0; - - // reduce x into [sqrt(2)/2, sqrt(2)] - ux += 0x3f800000 - 0x3f3504f3; - k += (ux >> 23) - 0x7f; - ux = (ux & 0x007fffff) + 0x3f3504f3; - x = reinterpret(ux); - + u = reinterpret(x); + } else if (u >= 0x7F800000) return x; + else if (u == 0x3F800000) return 0; + u += 0x3F800000 - 0x3F3504F3; + k += (u >> 23) - 0x7F; + u = (u & 0x007FFFFF) + 0x3F3504F3; + x = reinterpret(u); var f = x - 1.0; var s = f / (2.0 + f); var z = s * s; @@ -916,229 +1705,308 @@ export namespace NativeMathf { return s * (hfsq + R) + dk * ln2_lo - hfsq + f + dk * ln2_hi; } - export function log10(x: f32): f32 { - // return log(x) / LN10; - unreachable(); // TODO - return 0; + export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above + const + ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f + ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f + log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f + log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f + Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f + Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f + Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f + Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f + Ox1p25f = reinterpret(0x4C000000); + var ix = reinterpret(x); + var k = 0; + if (ix < 0x00800000 || (ix >> 31)) { + if (ix << 1 == 0) return -1 / (x * x); + if (ix >> 31) return (x - x) / 0.0; + k -= 25; + x *= Ox1p25f; + ix = reinterpret(x); + } else if (ix >= 0x7F800000) return x; + else if (ix == 0x3F800000) return 0; + ix += 0x3F800000 - 0x3F3504F3; + k += (ix >> 23) - 0x7f; + ix = (ix & 0x007FFFFF) + 0x3F3504F3; + x = reinterpret(ix); + var f = x - 1.0; + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * Lg4); + var t2 = z * (Lg1 + w * Lg3); + var R = t2 + t1; + var hfsq: f32 = 0.5 * f * f; + var hi = f - hfsq; + ix = reinterpret(hi); + ix &= 0xFFFFF000; + hi = reinterpret(ix); + var lo = f - hi - hfsq + s * (hfsq + R); + var dk = k; + return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi; } - export function log1p(x: f32): f32 { - unreachable(); // TODO - return 0; + export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above + const + ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01 + ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06 + Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f + Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f + Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f + Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f + var ix = reinterpret(x); + var c: f32 = 0, f: f32 = 0; + var k: i32 = 1; + if (ix < 0x3ED413D0 || (ix >> 31)) { + if (ix >= 0xBF800000) { + if (x == -1) return x / 0.0; + return (x - x) / 0.0; + } + if (ix << 1 < 0x33800000 << 1) return x; + if (ix <= 0xBE95F619) { + k = 0; + c = 0; + f = x; + } + } else if (ix >= 0x7F800000) return x; + if (k) { + let uf: f32 = 1 + x; + let iu = reinterpret(uf); + iu += 0x3F800000 - 0x3F3504F3; + k = (iu >> 23) - 0x7f; + if (k < 25) { + c = k >= 2 ? 1 - (uf - x) : x - (uf - 1); + c /= uf; + } else c = 0; + iu = (iu & 0x007FFFFF) + 0x3F3504F3; + f = reinterpret(iu) - 1; + } + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * Lg4); + var t2 = z * (Lg1 + w * Lg3); + var R = t2 + t1; + var hfsq: f32 = 0.5 * f * f; + var dk = k; + return s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi; } - export function log2(x: f32): f32 { - // return log(x) / LN2; - unreachable(); // TODO - return 0; + export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above + const + ivln2hi = reinterpret(0x3fb8b000), // 1.4428710938e+00f + ivln2lo = reinterpret(0xb9389ad4), // -1.7605285393e-04 + Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f + Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f + Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f + Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f + Ox1p25f = reinterpret(0x4C000000); + var ix = reinterpret(x); + var k: i32 = 0; + if (ix < 0x00800000 || (ix >> 31)) { + if (ix << 1 == 0) return -1 / (x * x); + if (ix >> 31) return (x - x) / 0.0; + k -= 25; + x *= Ox1p25f; + ix = reinterpret(x); + } else if (ix >= 0x7f800000) return x; + else if (ix == 0x3f800000) return 0; + ix += 0x3F800000 - 0x3F3504F3; + k += (ix >> 23) - 0x7F; + ix = (ix & 0x007FFFFF) + 0x3F3504F3; + x = reinterpret(ix); + var f = x - 1.0; + var s = f / (2.0 + f); + var z = s * s; + var w = z * z; + var t1 = w * (Lg2 + w * Lg4); + var t2 = z * (Lg1 + w * Lg3); + var R = t2 + t1; + var hfsq: f32 = 0.5 * f * f; + var hi = f - hfsq; + var u = reinterpret(hi); + u &= 0xFFFFF000; + hi = reinterpret(u); + var lo: f32 = f - hi - hfsq + s * (hfsq + R); + var dk = k; + return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk; } export function max(value1: f32, value2: f32): f32 { - return builtin_max(value1, value2); + return builtin_max(value1, value2); } export function min(value1: f32, value2: f32): f32 { - return builtin_min(value1, value2); + return builtin_min(value1, value2); } - export function pow(x: f32, y: f32): f32 { // based on musl's implementation of powf + export function pow(x: f32, y: f32): f32 { // see: musl/src/math/powf.c and SUN COPYRIGHT NOTICE above const - two24 = 16777216.0, // 0x4b800000 - huge = 1.0e30, - tiny = 1.0e-30, - // poly coefs for (3/2)*(log(x)-2s-2/3*s**3 - L1 = 6.0000002384e-01, // 0x3f19999a - L2 = 4.2857143283e-01, // 0x3edb6db7 - L3 = 3.3333334327e-01, // 0x3eaaaaab - L4 = 2.7272811532e-01, // 0x3e8ba305 - L5 = 2.3066075146e-01, // 0x3e6c3255 - L6 = 2.0697501302e-01, // 0x3e53f142 - P1 = 1.6666667163e-01, // 0x3e2aaaab - P2 = -2.7777778450e-03, // 0xbb360b61 - P3 = 6.6137559770e-05, // 0x388ab355 - P4 = -1.6533901999e-06, // 0xb5ddea0e - P5 = 4.1381369442e-08, // 0x3331bb4c - lg2 = 6.9314718246e-01, // 0x3f317218 - lg2_h = 6.93145752e-01, // 0x3f317200 - lg2_l = 1.42860654e-06, // 0x35bfbe8c - ovt = 4.2995665694e-08, // -(128-log2(ovfl+.5ulp)) - cp = 9.6179670095e-01, // 0x3f76384f =2/(3ln2) - cp_h = 9.6191406250e-01, // 0x3f764000 =12b cp - cp_l = -1.1736857402e-04, // 0xb8f623c6 =tail of cp_h - ivln2 = 1.4426950216e+00, // 0x3fb8aa3b =1/ln2 - ivln2_h = 1.4426879883e+00, // 0x3fb8aa00 =16b 1/ln2 - ivln2_l = 7.0526075433e-06; // 0x36eca570 =1/ln2 tail - - var hx = reinterpret(x); // GET_FLOAT_WORD(hx, x) - var hy = reinterpret(y); // GET_FLOAT_WORD(hy, y) - var ix = hx & 0x7fffffff; - var iy = hy & 0x7fffffff; - - // x**0 = 1, even if x is NaN - if (iy == 0) return 1.0; - // 1**y = 1, even if y is NaN - if (hx == 0x3f800000) return 1.0; - // NaN if either arg is NaN - if (ix > 0x7f800000 || iy > 0x7f800000) return x + y; - - // determine if y is an odd int when x < 0 - // yisint = 0 ... y is not an integer - // yisint = 1 ... y is an odd int - // yisint = 2 ... y is an even int + dp_h1 = reinterpret(0x3F15C000), // 5.84960938e-01f + dp_l1 = reinterpret(0x35D1CFDC), // 1.56322085e-06f + two24 = reinterpret(0x4B800000), // 16777216f + huge = reinterpret(0x7149F2CA), // 1.0e+30f + tiny = reinterpret(0x0DA24260), // 1.0e-30f + L1 = reinterpret(0x3F19999A), // 6.0000002384e-01f + L2 = reinterpret(0x3EDB6DB7), // 4.2857143283e-01f + L3 = reinterpret(0x3EAAAAAB), // 3.3333334327e-01f + L4 = reinterpret(0x3E8bA305), // 2.7272811532e-01f + L5 = reinterpret(0x3E6C3255), // 2.3066075146e-01f + L6 = reinterpret(0x3E53F142), // 2.0697501302e-01f + P1 = reinterpret(0x3E2AAAAB), // 1.6666667163e-01f + P2 = reinterpret(0xBB360B61), // -2.7777778450e-03f + P3 = reinterpret(0x388AB355), // 6.6137559770e-05f + P4 = reinterpret(0xB5DDEA0E), // -1.6533901999e-06f + P5 = reinterpret(0x3331BB4C), // 4.1381369442e-08f + lg2 = reinterpret(0x3F317218), // 6.9314718246e-01f + lg2_h = reinterpret(0x3F317200), // 6.93145752e-01f + lg2_l = reinterpret(0x35BFBE8C), // 1.42860654e-06f + ovt = reinterpret(0x3338AA3C), // 4.2995665694e-08f + cp = reinterpret(0x3F76384F), // 9.6179670095e-01 + cp_h = reinterpret(0x3F764000), // 9.6191406250e-01 + cp_l = reinterpret(0xB8F623C6), // -1.1736857402e-04 + ivln2 = reinterpret(0x3FB8AA3b), // 1.4426950216e+00 + ivln2_h = reinterpret(0x3FB8AA00), // 1.4426879883e+00 + ivln2_l = reinterpret(0x36ECA570); // 7.0526075433e-06 + var hx = reinterpret(x); + var hy = reinterpret(y); + var ix = hx & 0x7FFFFFFF; + var iy = hy & 0x7FFFFFFF; + if (iy == 0) return 1.0; // x**0 = 1, even if x is NaN + // if (hx == 0x3F800000) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN + if (ix > 0x7F800000 || iy > 0x7F800000) return x + y; // NaN if either arg is NaN var yisint = 0, j: i32, k: i32; if (hx < 0) { - if (iy >= 0x4b800000) yisint = 2; // even integer y - else if (iy >= 0x3f800000) { - k = (iy >> 23) - 0x7f; // exponent + if (iy >= 0x4B800000) yisint = 2; + else if (iy >= 0x3F800000) { + k = (iy >> 23) - 0x7F; j = iy >> (23 - k); if ((j << (23 - k)) == iy) yisint = 2 - (j & 1); } } - - // special value of y - if (iy == 0x7f800000) { // y is +-inf - if (ix == 0x3f800000) return 1.0; // (-1)**+-inf is 1 - else if (ix > 0x3f800000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0 + if (iy == 0x7F800000) { // y is +-inf + if (ix == 0x3F800000) return NaN; // C: (-1)**+-inf is 1, JS: NaN + else if (ix > 0x3F800000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0 else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf } - if (iy == 0x3f800000) return hy >= 0 ? x : 1.0 / x; // y is +-1 - if (hy == 0x40000000) return x * x; // y is 2 - if (hy == 0x3f000000) { // y is 0.5 - if (hx >= 0) return builtin_sqrt(x); // x >= +0 + if (iy == 0x3F800000) return hy >= 0 ? x : 1.0 / x; + if (hy == 0x40000000) return x * x; + if (hy == 0x3F000000) { + if (hx >= 0) return builtin_sqrt(x); } - - var ax = builtin_abs(x); - // special value of x + var ax = builtin_abs(x); var z: f32; - if (ix == 0x7f800000 || ix == 0 || ix == 0x3f800000) { // x is +-0,+-inf,+-1 + if (ix == 0x7F800000 || ix == 0 || ix == 0x3F800000) { z = ax; - if (hy < 0) z = 1.0 / z; // z = (1/|x|) + if (hy < 0) z = 1.0 / z; if (hx < 0) { - if (((ix - 0x3f800000) | yisint) == 0) z = (z - z) / (z - z); // (-1)**non-int is NaN - else if (yisint == 1) z = -z; // (x<0)**odd = -(|x|**odd) + if (((ix - 0x3F800000) | yisint) == 0) z = (z - z) / (z - z); + else if (yisint == 1) z = -z; } return z; } - - var sn = 1.0; // sign of result + var sn = 1.0; if (hx < 0) { - if (yisint == 0) return (x - x) / (x - x); // (x<0)**(non-int) is NaN - if (yisint == 1) sn = -1.0; // (x<0)**(odd int) + if (yisint == 0) return (x - x) / (x - x); + if (yisint == 1) sn = -1.0; } - - // |y| is huge var t1: f32, t2: f32, r: f32, s: f32, t: f32, u: f32, v: f32, w: f32, p_h: f32, p_l: f32; var n: i32, is: i32; - if (iy > 0x4d000000) { // if |y| > 2**27 - // over/underflow if x is not close to one - if (ix < 0x3f7ffff8) return hy < 0 ? sn * huge * huge : sn * tiny * tiny; - if (ix > 0x3f800007) return hy > 0 ? sn * huge * huge : sn * tiny * tiny; - // now |1-x| is tiny <= 2**-20, suffice to compute - // log(x) by x-x^2/2+x^3/3-x^4/4 - t = ax - 1; // t has 20 trailing zeros + if (iy > 0x4D000000) { + if (ix < 0x3F7FFFF8) return hy < 0 ? sn * huge * huge : sn * tiny * tiny; + if (ix > 0x3F800007) return hy > 0 ? sn * huge * huge : sn * tiny * tiny; + t = ax - 1; w = (t * t) * (0.5 - t * (0.333333333333 - t * 0.25)); - u = ivln2_h * t; // ivln2_h has 16 sig. bits + u = ivln2_h * t; v = t * ivln2_l - w * ivln2; t1 = u + v; - is = reinterpret(t1); // GET_FLOAT_WORD(is, t1) - t1 = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(t1, is & 0xfffff000) + is = reinterpret(t1); + t1 = reinterpret(is & 0xFFFFF000); t2 = v - (t1 - u); } else { let s2: f32, s_h: f32, s_l: f32, t_h: f32, t_l: f32; n = 0; - // take care subnormal number if (ix < 0x00800000) { ax *= two24; n -= 24; - ix = reinterpret(ax); // GET_FLOAT_WORD(ix, ax) + ix = reinterpret(ax); } - n += (ix >> 23) - 0x7f; - j = ix & 0x007fffff; - // determine interval - ix = j | 0x3f800000; // normalize ix - if (j <= 0x1cc471) k = 0; // |x|> 23) - 0x7F; + j = ix & 0x007FFFFF; + ix = j | 0x3F800000; + if (j <= 0x1CC471) k = 0; + else if (j < 0x5DB3D7) k = 1; else { k = 0; n += 1; ix -= 0x00800000; } - ax = reinterpret(ix); // SET_FLOAT_WORD(ax, ix) - - // compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) - let bp = select(1.5, 1.0, k); // bp[k], [1.0, 1.5] + ax = reinterpret(ix); + let bp = select(1.5, 1.0, k); u = ax - bp; v = 1.0 / (ax + bp); s = u * v; s_h = s; - is = reinterpret(s_h); // GET_FLOAT_WORD(is, s_h) - s_h = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(s_h, is & 0xfffff000) - // t_h=ax+bp[k] High - is = ((ix >> 1) & 0xfffff000) | 0x20000000; - t_h = reinterpret(is + 0x00400000 + (k << 21)); // SET_FLOAT_WORD(t_h, is + 0x00400000 + (k<<21)) + is = reinterpret(s_h); + s_h = reinterpret(is & 0xFFFFF000); + is = ((ix >> 1) & 0xFFFFF000) | 0x20000000; + t_h = reinterpret(is + 0x00400000 + (k << 21)); t_l = ax - (t_h - bp); s_l = v * ((u - s_h * t_h) - s_h * t_l); - // compute log(ax) s2 = s * s; r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6))))); r += s_l * (s_h + s); s2 = s_h * s_h; t_h = 3.0 + s2 + r; - is = reinterpret(t_h); // GET_FLOAT_WORD(is, t_h) - t_h = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(t_h, is & 0xfffff000) + is = reinterpret(t_h); + t_h = reinterpret(is & 0xFFFFF000); t_l = r - ((t_h - 3.0) - s2); - // u+v = s*(1+...) u = s_h * t_h; v = s_l * t_h + t_l * s; - // 2/(3log2)*(s+...) p_h = u + v; - is = reinterpret(p_h); // GET_FLOAT_WORD(is, p_h) - p_h = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(p_h, is & 0xfffff000) + is = reinterpret(p_h); + p_h = reinterpret(is & 0xFFFFF000); p_l = v - (p_h - u); - let z_h = cp_h * p_h; // cp_h+cp_l = 2/(3*log2) - let dp_l = select(1.56322085e-06, 0.0, k); // dp_l[k], [0.0, 1.56322085e-06] + let z_h = cp_h * p_h; + let dp_l = select(dp_l1, 0.0, k); let z_l = cp_l * p_h + p_l * cp + dp_l; - // log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l t = n; - let dp_h = select(5.84960938e-01, 0.0, k); // dp_h[k], [0.0, 5.84960938e-01] + let dp_h = select(dp_h1, 0.0, k); t1 = (((z_h + z_l) + dp_h) + t); - is = reinterpret(t1); // GET_FLOAT_WORD(is, t1) - t1 = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(t1, is & 0xfffff000) + is = reinterpret(t1); + t1 = reinterpret(is & 0xFFFFF000); t2 = z_l - (((t1 - t) - dp_h) - z_h); } - - // split up y into y1+y2 and compute (y1+y2)*(t1+t2) - is = reinterpret(y); // GET_FLOAT_WORD(is, y) - var y1 = reinterpret(is & 0xfffff000); // SET_FLOAT_WORD(y1, is & 0xfffff000) + is = reinterpret(y); + var y1 = reinterpret(is & 0xFFFFF000); p_l = (y - y1) * t1 + y * t2; p_h = y1 * t1; z = p_l + p_h; - j = reinterpret(z); // GET_FLOAT_WORD(j, z) - if (j > 0x43000000) { // if z > 128, overflow + j = reinterpret(z); + if (j > 0x43000000) { return sn * huge * huge; - } else if (j == 0x43000000) { // if z == 128 - if (p_l + ovt > z - p_h) return sn * huge * huge; // overflow - } else if ((j & 0x7fffffff) > 0x43160000) { // z < -150, FIXME: check should be (uint32_t)j > 0xc3160000 - return sn * tiny * tiny; // underflow - } else if (j == 0xc3160000) { // z == -150 - if (p_l <= z - p_h) return sn * tiny * tiny; // underflow + } else if (j == 0x43000000) { + if (p_l + ovt > z - p_h) return sn * huge * huge; + } else if ((j & 0x7FFFFFFF) > 0x43160000) { + return sn * tiny * tiny; + } else if (j == 0xC3160000) { + if (p_l <= z - p_h) return sn * tiny * tiny; } - - // compute 2**(p_h+p_l) - var i = j & 0x7fffffff; - k = (i >> 23) - 0x7f; + var i = j & 0x7FFFFFFF; + k = (i >> 23) - 0x7F; n = 0; - if (i > 0x3f000000) { // if |z| > 0.5, set n = [z+0.5] + if (i > 0x3F000000) { n = j + (0x00800000 >> (k + 1)); - k = ((n & 0x7fffffff) >> 23) - 0x7f; // new k for n - t = reinterpret(n & ~(0x007fffff >> k)); // SET_FLOAT_WORD(t, n & ~(0x007fffff>>k)) - n = ((n & 0x007fffff) | 0x00800000) >> (23 - k); + k = ((n & 0x7FFFFFFF) >> 23) - 0x7F; + t = reinterpret(n & ~(0x007FFFFF >> k)); + n = ((n & 0x007FFFFF) | 0x00800000) >> (23 - k); if (j < 0) n = -n; p_h -= t; } t = p_l + p_h; - is = reinterpret(t); // GET_FLOAT_WORD(is, t) - t = reinterpret(is & 0xffff8000); // SET_FLOAT_WORD(t, is & 0xffff8000); + is = reinterpret(t); + t = reinterpret(is & 0xFFFF8000); u = t * lg2_h; v = (p_l - (t - p_h)) * lg2 + t * lg2_l; z = u + v; @@ -1147,58 +2015,120 @@ export namespace NativeMathf { t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5)))); r = (z * t1) / (t1 - 2.0) - (w + z * w); z = 1.0 - (r - z); - j = reinterpret(z); // GET_FLOAT_WORD(j, z) + j = reinterpret(z); j += n << 23; - if ((j >> 23) <= 0) z = scalbn(z, n); // subnormal output - else z = reinterpret(j); // SET_FLOAT_WORD(z, j) + if ((j >> 23) <= 0) z = scalbn(z, n); + else z = reinterpret(j); return sn * z; } + export function seedRandom(value: i64): void { + NativeMath.seedRandom(value); + } + export function random(): f32 { return NativeMath.random(); } - export function round(x: f32): f32 { - return builtin_nearest(x); + export function round(x: f32): f32 { // see: musl/src/math/roundf.c + const toint = 1.0 / f32.EPSILON; + var ux = reinterpret(x); + var e = (ux >> 23 & 0xff); + if (e >= 0x7F + 23) return x; + if (e < 0x7F - 1) return 0 * x; + var y: f32; + if (ux >> 31) { + // FIXME: JS always rounds fractional 0.5 towards +Infinity + // and there certainly is a smarter way to do this. + y = toint - x - toint + x; + if (y >= 0.5) y = x - y + 1; + else if (y < -0.5) y = x - y - 1; + else y = x - y; + } else { + y = x + toint - toint - x; + if (y > 0.5) y = y + x - 1; + else if (y <= -0.5) y = y + x + 1; + else y = y + x; + } + return y; } export function sign(x: f32): f32 { return x > 0 ? 1 : x < 0 ? -1 : x; } - export function sin(x: f32): f32 { - unreachable(); // TODO + export function sin(x: f32): f32 { // TODO + unreachable(); return 0; } - export function sinh(x: f32): f32 { - unreachable(); // TODO - return 0; + function __expo2(x: f32): f32 { // see: musl/src/math/__expo2f.c + const + k = 235, + kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f + var scale = reinterpret((0x7F + k / 2) << 23); + return exp(x - kln2) * scale * scale; +} + + export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c + var u = reinterpret(x); + var h: f32 = 0.5; + if (u >> 31) h = -h; + u &= 0x7FFFFFFF; + var absx = reinterpret(u); + var t: f32; + if (u < 0x42b17217) { + t = expm1(absx); + if (u < 0x3F800000) { + if (u < 0x3F800000 - (12 << 23)) return x; + return h * (2 * t - t * t / (t + 1)); + } + return h * (t + t / (t + 1)); + } + t = 2 * h * __expo2(absx); + return t; } export function sqrt(x: f32): f32 { - return builtin_sqrt(x); + return builtin_sqrt(x); } - export function tan(x: f32): f32 { - unreachable(); // TODO + export function tan(x: f32): f32 { // TODO + unreachable(); return 0; } - export function tanh(x: f32): f32 { - unreachable(); // TODO - return 0; + export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c + var u = reinterpret(x); + var sig = u >> 31; + u &= 0x7FFFFFFF; + x = reinterpret(u); + var t: f32; + if (u > 0x3F0C9F54) { + if (u > 0x41200000) t = 1 + 0 / x; + else { + t = expm1(2 * x); + t = 1 - 2 / (t + 2); + } + } else if (u > 0x3E82C578) { + t = expm1(2 * x); + t = t / (t + 2); + } else if (u >= 0x00800000) { + t = expm1(-2 * x); + t = -t / (t + 2); + } else t = x; + return sig ? -t : t; } export function trunc(x: f32): f32 { - return builtin_trunc(x); + return builtin_trunc(x); } - function scalbn(x: f32, n: i32): f32 { // based on musl's implementation of scalbnf + /** @internal */ + export function scalbn(x: f32, n: i32): f32 { // see: musl/src/math/scalbnf.c const - Ox1p127f = 1.701411835e+38, - Ox1p_126f = 1.175494351e-38; - + Ox1p127f = reinterpret(0x7F000000), + Ox1p_126f = reinterpret(0x00800000); var y = x; if (n > 127) { y *= Ox1p127f; @@ -1217,6 +2147,135 @@ export namespace NativeMathf { if (n < -126) n = -126; } } - return y * reinterpret((0x7f + n) << 23); + return y * reinterpret((0x7F + n) << 23); + } + + export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c + var ux = reinterpret(x); + var uy = reinterpret(y); + var ex = (ux >> 23 & 0xFF); + var ey = (uy >> 23 & 0xFF); + var sx = ux & 0x80000000; + if (uy << 1 == 0 || isNaN(y) || ex == 0xFF) return (x * y) / (x * y); + if (ux << 1 <= uy << 1) { + if (ux << 1 == uy << 1) return 0 * x; + return x; + } + var i: u32; + if (!ex) { + for (i = ux << 9; !(i >> 31); i <<= 1) --ex; + ux <<= -ex + 1; + } else { + ux &= -1 >> 9; + ux |= 1 << 23; + } + if (!ey) { + for (i = uy << 9; !(i >> 31); i <<= 1) --ey; + uy <<= -ey + 1; + } else { + uy &= -1 >> 9; + uy |= 1 << 23; + } + for (; ex > ey; --ex) { + i = ux - uy; + if (!(i >> 31)) { + if (!i) return 0 * x; + ux = i; + } + ux <<= 1; + } + i = ux - uy; + if (!(i >> 31)) { + if (!i) return 0 * x; + ux = i; + } + for (; !(ux >> 23); ux <<= 1) --ex; + if (ex > 0) { + ux -= 1 << 23; + ux |= ex << 23; + } else { + ux >>= -ex + 1; + } + ux |= sx; + return reinterpret(ux); + } + + export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c + var ux = reinterpret(x); + var uy = reinterpret(y); + var ex = (ux >> 23 & 0xFF); + var ey = (uy >> 23 & 0xFF); + var sx = (ux >> 31); + var sy = (uy >> 31); + var i: u32; + var uxi = ux; + if (uy << 1 == 0 || isNaN(y) || ex == 0xFF) return (x * y) / (x * y); + if (ux << 1 == 0) return x; + if (!ex) { + for (i = uxi << 9; i >> 31 == 0; ex--, i <<= 1) {} + uxi <<= -ex + 1; + } else { + uxi &= -1 >> 9; + uxi |= 1 << 23; + } + if (!ey) { + for (i = uy << 9; i >> 31 == 0; ey--, i <<= 1) {} + uy <<= -ey + 1; + } else { + uy &= -1 >> 9; + uy |= 1 << 23; + } + var q = 0; + do { + if (ex < ey) { + if (ex + 1 == ey) break; // goto end + return x; + } + for (; ex > ey; ex--) { + i = uxi - uy; + if (i >> 31 == 0) { + uxi = i; + q++; + } + uxi <<= 1; + q <<= 1; + } + i = uxi - uy; + if (i >> 31 == 0) { + uxi = i; + q++; + } + if (uxi == 0) ex = -30; + else for (; uxi >> 23 == 0; uxi <<= 1, ex--) {} + break; + } while (false); + // end + if (ex > 0) { + uxi -= 1 << 23; + uxi |= ex << 23; + } else { + uxi >>= -ex + 1; + } + x = reinterpret(uxi); + if (sy) y = -y; + if (ex == ey || (ex + 1 == ey && (2 * x > y || (2 * x == y && (q % 2))))) { + x -= y; + q++; + } + q &= 0x7FFFFFFF; + return sx ? -x : x; } } + +var random_seeded = false; +var random_state0: u64; +var random_state1: u64; + +function murmurHash3(h: u64): u64 { + h ^= h >> 33; + h *= 0xFF51AFD7ED558CCD; + h ^= h >> 33; + h *= 0xC4CEB9FE1A85EC53; + h ^= h >> 33; + return h; +} diff --git a/std/assembly/string.ts b/std/assembly/string.ts index a0bc9086..0c52d2c1 100644 --- a/std/assembly/string.ts +++ b/std/assembly/string.ts @@ -444,6 +444,7 @@ function parse(str: String, radix: i32 = 0): T { return sign * num; } +// FIXME: naive implementation export function parseFloat(str: String): f64 { var len: i32 = str.length; if (!len) { diff --git a/tests/compiler.js b/tests/compiler.js index ea587985..8c9b5633 100644 --- a/tests/compiler.js +++ b/tests/compiler.js @@ -113,7 +113,7 @@ tests.forEach(filename => { let exports = new WebAssembly.Instance(new WebAssembly.Module(stdout.toBuffer()), { env: { abort: function(msg, file, line, column) { - // TODO + console.log("abort called at " + line + ":" + column); }, externalFunction: function() { }, externalConstant: 1, @@ -124,6 +124,9 @@ tests.forEach(filename => { externalFunction: function() { }, externalConstant: 2 }, + JSOp: { + mod: function(a, b) { return a % b; } + }, JSMath: Math }); }); diff --git a/tests/compiler/binary.optimized.wat b/tests/compiler/binary.optimized.wat index 36d9f7cf..978ed2aa 100644 --- a/tests/compiler/binary.optimized.wat +++ b/tests/compiler/binary.optimized.wat @@ -1,4 +1,8 @@ (module + (type $FFF (func (param f64 f64) (result f64))) + (type $FiF (func (param f64 i32) (result f64))) + (type $fff (func (param f32 f32) (result f32))) + (type $fif (func (param f32 i32) (result f32))) (type $v (func)) (global $binary/b (mut i32) (i32.const 0)) (global $binary/i (mut i32) (i32.const 0)) @@ -8,7 +12,3521 @@ (memory $0 1) (export "memory" (memory $0)) (start $start) - (func $start (; 0 ;) (type $v) + (func "$(lib)/math/NativeMath.scalbn" (; 0 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $1) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 1 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 f64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 f64) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 i32) + (local $14 f64) + (local $15 i32) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 i64) + (block $folding-inner1 + (block $folding-inner0 + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (set_local $5 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (i32.or + (tee_local $10 + (i32.and + (tee_local $11 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (tee_local $6 + (i32.wrap/i64 + (get_local $19) + ) + ) + ) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.gt_s + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $13) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.gt_s + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1128267776) + ) + (set_local $15 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1072693248) + ) + (if + (i32.gt_s + (tee_local $8 + (i32.sub + (i32.shr_s + (get_local $10) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (i32.const 20) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + (get_local $6) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_s + (get_local $10) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + (get_local $10) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $13) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (get_local $1) + (f64.const 0) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + (return + (select + (f64.const 0) + (f64.neg + (get_local $1) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (return + (f64.const nan:0x8000000000000) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $4) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eqz + (get_local $13) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (i32.eqz + (get_local $5) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.eq + (get_local $5) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + (set_local $2 + (f64.div + (f64.const 1) + (get_local $2) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $15) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $2 + (f64.div + (f64.sub + (get_local $2) + (get_local $2) + ) + (f64.sub + (get_local $2) + (get_local $2) + ) + ) + ) + ) + ) + (return + (get_local $2) + ) + ) + ) + ) + (set_local $12 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (block + (if + (i32.eqz + (get_local $15) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $12 + (f64.const -1) + ) + ) + ) + ) + (set_local $2 + (if (result f64) + (i32.gt_s + (get_local $10) + (i32.const 1105199104) + ) + (block (result f64) + (if + (i32.gt_s + (get_local $10) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (f64.mul + (tee_local $3 + (f64.sub + (get_local $2) + (f64.const 1) + ) + ) + (get_local $3) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $3) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $3) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $3) + ) + ) + (tee_local $17 + (f64.sub + (f64.mul + (get_local $3) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $0) + (f64.const 1.4426950408889634) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $17) + (f64.sub + (get_local $9) + (get_local $16) + ) + ) + ) + (block (result f64) + (set_local $4 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1048576) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 53) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.mul + (get_local $2) + (f64.const 9007199254740992) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $5 + (i32.or + (tee_local $6 + (i32.and + (get_local $5) + (i32.const 1048575) + ) + ) + (i32.const 1072693248) + ) + ) + (set_local $8 + (if (result i32) + (i32.le_s + (get_local $6) + (i32.const 235662) + ) + (i32.const 0) + (if (result i32) + (i32.lt_s + (get_local $6) + (i32.const 767610) + ) + (i32.const 1) + (block (result i32) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1048576) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (tee_local $18 + (f64.mul + (tee_local $16 + (f64.sub + (tee_local $2 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $5) + ) + (i64.const 32) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $8) + ) + ) + ) + ) + (tee_local $17 + (f64.div + (f64.const 1) + (f64.add + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $2 + (f64.sub + (get_local $2) + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $5) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $8) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $2 + (f64.sub + (tee_local $2 + (f64.add + (f64.mul + (f64.mul + (tee_local $14 + (f64.mul + (get_local $18) + (get_local $18) + ) + ) + (get_local $14) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $14) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (tee_local $0 + (f64.mul + (get_local $17) + (f64.sub + (f64.sub + (get_local $16) + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (f64.mul + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (f64.add + (get_local $3) + (get_local $18) + ) + ) + ) + ) + (f64.sub + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.const 3) + (tee_local $14 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (get_local $2) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 3) + ) + (get_local $14) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.add + (tee_local $18 + (f64.mul + (f64.const 0.9617967009544373) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (get_local $0) + (get_local $9) + ) + (f64.mul + (get_local $2) + (get_local $18) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + ) + (tee_local $2 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $0) + ) + (f64.mul + (f64.sub + (get_local $17) + (f64.sub + (get_local $0) + (get_local $16) + ) + ) + (f64.const 0.9617966939259756) + ) + ) + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $8) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $8) + ) + ) + ) + (tee_local $3 + (f64.convert_s/i32 + (get_local $4) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $2) + (f64.sub + (f64.sub + (f64.sub + (get_local $9) + (get_local $3) + ) + (get_local $0) + ) + (get_local $18) + ) + ) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (tee_local $2 + (f64.add + (tee_local $1 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $1) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $9) + ) + (f64.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $9) + ) + ) + ) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (if + (i32.ge_s + (get_local $6) + (i32.const 1083179008) + ) + (br_if $folding-inner1 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const 1083179008) + ) + (get_local $13) + ) + (f64.gt + (f64.add + (get_local $1) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (br_if $folding-inner0 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const -1064252416) + ) + (get_local $13) + ) + (f64.le + (get_local $1) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $8 + (i32.sub + (i32.shr_s + (tee_local $13 + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $4 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $13) + (i32.const 1071644672) + ) + (block + (set_local $8 + (i32.sub + (i32.shr_s + (i32.and + (tee_local $4 + (i32.add + (get_local $6) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $4) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $8) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.shr_s + (i32.or + (i32.and + (get_local $4) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.const 0) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + ) + (set_local $0 + (f64.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + (return + (f64.mul + (get_local $12) + (tee_local $2 + (if (result f64) + (i32.le_s + (i32.shr_s + (tee_local $6 + (i32.add + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.sub + (f64.const 1) + (f64.sub + (f64.sub + (f64.div + (f64.mul + (tee_local $2 + (f64.add + (tee_local $16 + (f64.mul + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (get_local $1) + (get_local $0) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 0.6931471824645996) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (f64.sub + (get_local $3) + (get_local $0) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $3) + (f64.const -1.904654299957768e-09) + ) + ) + ) + ) + ) + (tee_local $9 + (f64.sub + (get_local $2) + (f64.mul + (tee_local $3 + (f64.mul + (get_local $2) + (get_local $2) + ) + ) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $3) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $3) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $3) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $3) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.sub + (get_local $9) + (f64.const 2) + ) + ) + (f64.add + (tee_local $0 + (f64.sub + (get_local $17) + (f64.sub + (get_local $2) + (get_local $16) + ) + ) + ) + (f64.mul + (get_local $2) + (get_local $0) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.shl + (get_local $4) + (i32.const 20) + ) + ) + ) + (i32.const 20) + ) + (i32.const 0) + ) + (call "$(lib)/math/NativeMath.scalbn" + (get_local $2) + (get_local $4) + ) + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 32) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 2 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (block $folding-inner0 + (set_local $4 + (i32.and + (i32.shr_u + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (i32.shr_u + (tee_local $5 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.and + (if (result i32) + (tee_local $3 + (i32.eqz + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (get_local $3) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $3) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + (block + (br_if $folding-inner0 + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $8 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (set_local $2 + (if (result i32) + (get_local $4) + (i32.or + (i32.and + (get_local $2) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i32.shl + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + ) + ) + ) + (set_local $5 + (if (result i32) + (get_local $6) + (i32.or + (i32.and + (get_local $5) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $5) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i32.shl + (get_local $5) + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $6) + ) + (block + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (return + (f32.reinterpret/i32 + (i32.or + (tee_local $2 + (select + (i32.or + (i32.sub + (get_local $2) + (i32.const 8388608) + ) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + (i32.shr_u + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + ) + ) + (get_local $8) + ) + ) + ) + ) + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 3 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (get_local $1) + (i32.const 127) + ) + (i32.const 23) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.pow" (; 4 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 f32) + (local $3 f32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f32) + (local $9 f32) + (local $10 i32) + (local $11 i32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (local $15 i32) + (local $16 f32) + (block $folding-inner1 + (block $folding-inner0 + (set_local $5 + (i32.and + (tee_local $15 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (tee_local $10 + (i32.and + (tee_local $11 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 2147483647) + ) + ) + ) + (return + (f32.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.gt_s + (get_local $5) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.gt_s + (get_local $10) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1266679808) + ) + (set_local $4 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1065353216) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_s + (get_local $10) + (i32.sub + (i32.const 23) + (tee_local $6 + (i32.sub + (i32.shr_s + (get_local $10) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + ) + ) + (i32.sub + (i32.const 23) + (get_local $6) + ) + ) + (get_local $10) + ) + (set_local $4 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + (return + (f32.const nan:0x400000) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1065353216) + ) + (return + (select + (get_local $1) + (f32.const 0) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + (return + (select + (f32.const 0) + (f32.neg + (get_local $1) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1065353216) + ) + (return + (select + (get_local $0) + (f32.div + (f32.const 1) + (get_local $0) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1073741824) + ) + (return + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1056964608) + ) + (if + (i32.ge_s + (get_local $15) + (i32.const 0) + ) + (return + (f32.sqrt + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (f32.abs + (get_local $0) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.and + (if (result i32) + (tee_local $6 + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.eqz + (get_local $5) + ) + ) + (i32.const 1) + ) + ) + (get_local $6) + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + (set_local $2 + (f32.div + (f32.const 1) + (get_local $2) + ) + ) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1065353216) + ) + (get_local $4) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1) + ) + (set_local $2 + (f32.neg + (get_local $2) + ) + ) + ) + (set_local $2 + (f32.div + (f32.sub + (get_local $2) + (get_local $2) + ) + (f32.sub + (get_local $2) + (get_local $2) + ) + ) + ) + ) + ) + (return + (get_local $2) + ) + ) + ) + (set_local $9 + (f32.const 1) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (block + (if + (i32.eqz + (get_local $4) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1) + ) + (set_local $9 + (f32.const -1) + ) + ) + ) + ) + (set_local $2 + (if (result f32) + (i32.gt_s + (get_local $10) + (i32.const 1291845632) + ) + (block (result f32) + (if + (i32.lt_s + (get_local $5) + (i32.const 1065353208) + ) + (return + (select + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1065353223) + ) + (return + (select + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (set_local $0 + (f32.mul + (f32.mul + (tee_local $3 + (f32.sub + (get_local $2) + (f32.const 1) + ) + ) + (get_local $3) + ) + (f32.sub + (f32.const 0.5) + (f32.mul + (get_local $3) + (f32.sub + (f32.const 0.3333333432674408) + (f32.mul + (get_local $3) + (f32.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (tee_local $13 + (f32.mul + (f32.const 1.44268798828125) + (get_local $3) + ) + ) + (tee_local $14 + (f32.sub + (f32.mul + (get_local $3) + (f32.const 7.052607543300837e-06) + ) + (f32.mul + (get_local $0) + (f32.const 1.4426950216293335) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.sub + (get_local $14) + (f32.sub + (get_local $8) + (get_local $13) + ) + ) + ) + (block (result f32) + (set_local $4 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 8388608) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 24) + ) + ) + (set_local $5 + (i32.reinterpret/f32 + (f32.mul + (get_local $2) + (f32.const 16777216) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $5 + (i32.or + (tee_local $7 + (i32.and + (get_local $5) + (i32.const 8388607) + ) + ) + (i32.const 1065353216) + ) + ) + (set_local $6 + (if (result i32) + (i32.le_s + (get_local $7) + (i32.const 1885297) + ) + (i32.const 0) + (if (result i32) + (i32.lt_s + (get_local $7) + (i32.const 6140887) + ) + (i32.const 1) + (block (result i32) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 8388608) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (tee_local $16 + (f32.mul + (tee_local $13 + (f32.sub + (tee_local $2 + (f32.reinterpret/i32 + (get_local $5) + ) + ) + (tee_local $0 + (select + (f32.const 1.5) + (f32.const 1) + (get_local $6) + ) + ) + ) + ) + (tee_local $14 + (f32.div + (f32.const 1) + (f32.add + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (set_local $2 + (f32.sub + (get_local $2) + (f32.sub + (tee_local $8 + (f32.reinterpret/i32 + (i32.add + (i32.add + (i32.or + (i32.and + (i32.shr_s + (get_local $5) + (i32.const 1) + ) + (i32.const -4096) + ) + (i32.const 536870912) + ) + (i32.const 4194304) + ) + (i32.shl + (get_local $6) + (i32.const 21) + ) + ) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $2 + (f32.sub + (tee_local $2 + (f32.add + (f32.mul + (f32.mul + (tee_local $12 + (f32.mul + (get_local $16) + (get_local $16) + ) + ) + (get_local $12) + ) + (f32.add + (f32.const 0.6000000238418579) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.4285714328289032) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.3333333432674408) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.2727281153202057) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.23066075146198273) + (f32.mul + (get_local $12) + (f32.const 0.20697501301765442) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (tee_local $0 + (f32.mul + (get_local $14) + (f32.sub + (f32.sub + (get_local $13) + (f32.mul + (get_local $3) + (get_local $8) + ) + ) + (f32.mul + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (f32.add + (get_local $3) + (get_local $16) + ) + ) + ) + ) + (f32.sub + (f32.sub + (tee_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (f32.add + (f32.const 3) + (tee_local $12 + (f32.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (get_local $2) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.const 3) + ) + (get_local $12) + ) + ) + ) + (set_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (f32.add + (f32.add + (tee_local $16 + (f32.mul + (f32.const 0.9619140625) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (tee_local $13 + (f32.mul + (get_local $3) + (get_local $8) + ) + ) + (tee_local $14 + (f32.add + (f32.mul + (get_local $0) + (get_local $8) + ) + (f32.mul + (get_local $2) + (get_local $16) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + ) + ) + (tee_local $2 + (f32.add + (f32.add + (f32.mul + (f32.const -1.1736857413779944e-04) + (get_local $0) + ) + (f32.mul + (f32.sub + (get_local $14) + (f32.sub + (get_local $0) + (get_local $13) + ) + ) + (f32.const 0.9617967009544373) + ) + ) + (select + (f32.const 1.5632208487659227e-06) + (f32.const 0) + (get_local $6) + ) + ) + ) + ) + (tee_local $0 + (select + (f32.const 0.5849609375) + (f32.const 0) + (get_local $6) + ) + ) + ) + (tee_local $3 + (f32.convert_s/i32 + (get_local $4) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.sub + (get_local $2) + (f32.sub + (f32.sub + (f32.sub + (get_local $8) + (get_local $3) + ) + (get_local $0) + ) + (get_local $16) + ) + ) + ) + ) + ) + (br_if $folding-inner1 + (i32.gt_s + (tee_local $7 + (i32.reinterpret/f32 + (tee_local $2 + (f32.add + (tee_local $1 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (get_local $1) + ) + (i32.const -4096) + ) + ) + ) + ) + (get_local $8) + ) + (f32.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (tee_local $0 + (f32.mul + (get_local $0) + (get_local $8) + ) + ) + ) + ) + ) + ) + (i32.const 1124073472) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1124073472) + ) + (br_if $folding-inner1 + (f32.gt + (f32.add + (get_local $1) + (f32.const 4.299566569443414e-08) + ) + (f32.sub + (get_local $2) + (get_local $0) + ) + ) + ) + (if + (i32.gt_s + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + (i32.const 1125515264) + ) + (br $folding-inner0) + (if + (i32.eq + (get_local $7) + (i32.const -1021968384) + ) + (br_if $folding-inner0 + (f32.le + (get_local $1) + (f32.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.shr_s + (tee_local $15 + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $4 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $15) + (i32.const 1056964608) + ) + (block + (set_local $6 + (i32.sub + (i32.shr_s + (i32.and + (tee_local $4 + (i32.add + (get_local $7) + (i32.shr_s + (i32.const 8388608) + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (i32.and + (get_local $4) + (i32.xor + (i32.shr_s + (i32.const 8388607) + (get_local $6) + ) + (i32.const -1) + ) + ) + ) + ) + (set_local $4 + (i32.shr_s + (i32.or + (i32.and + (get_local $4) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (i32.sub + (i32.const 23) + (get_local $6) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + ) + (set_local $0 + (f32.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + (return + (f32.mul + (get_local $9) + (tee_local $2 + (if (result f32) + (i32.le_s + (i32.shr_s + (tee_local $7 + (i32.add + (i32.reinterpret/f32 + (tee_local $2 + (f32.sub + (f32.const 1) + (f32.sub + (f32.sub + (f32.div + (f32.mul + (tee_local $2 + (f32.add + (tee_local $13 + (f32.mul + (tee_local $3 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (get_local $1) + (get_local $0) + ) + ) + (i32.const -32768) + ) + ) + ) + (f32.const 0.693145751953125) + ) + ) + (tee_local $14 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (f32.sub + (get_local $3) + (get_local $0) + ) + ) + (f32.const 0.6931471824645996) + ) + (f32.mul + (get_local $3) + (f32.const 1.4286065379565116e-06) + ) + ) + ) + ) + ) + (tee_local $8 + (f32.sub + (get_local $2) + (f32.mul + (tee_local $3 + (f32.mul + (get_local $2) + (get_local $2) + ) + ) + (f32.add + (f32.const 0.1666666716337204) + (f32.mul + (get_local $3) + (f32.add + (f32.const -2.7777778450399637e-03) + (f32.mul + (get_local $3) + (f32.add + (f32.const 6.61375597701408e-05) + (f32.mul + (get_local $3) + (f32.add + (f32.const -1.6533901998627698e-06) + (f32.mul + (get_local $3) + (f32.const 4.138136944220605e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f32.sub + (get_local $8) + (f32.const 2) + ) + ) + (f32.add + (tee_local $0 + (f32.sub + (get_local $14) + (f32.sub + (get_local $2) + (get_local $13) + ) + ) + ) + (f32.mul + (get_local $2) + (get_local $0) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + (i32.const 23) + ) + (i32.const 0) + ) + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $2) + (get_local $4) + ) + (f32.reinterpret/i32 + (get_local $7) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 5 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 f64) + (block $folding-inner0 + (set_local $3 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $5 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i64.eq + (i64.shl + (get_local $5) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $7) + (f64.ne + (tee_local $8 + (get_local $1) + ) + (get_local $8) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.eq + (get_local $3) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.le_u + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + (block + (br_if $folding-inner0 + (i64.eq + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + ) + (set_local $2 + (if (result i64) + (get_local $3) + (i64.or + (i64.and + (get_local $2) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $4 + (i64.shl + (get_local $2) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eqz + (i64.shr_u + (get_local $4) + (i64.const 63) + ) + ) + (block + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (set_local $4 + (i64.shl + (get_local $4) + (i64.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i64.shl + (get_local $2) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (set_local $5 + (if (result i64) + (get_local $6) + (i64.or + (i64.and + (get_local $5) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $4 + (i64.shl + (get_local $5) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eqz + (i64.shr_u + (get_local $4) + (i64.const 63) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $4 + (i64.shl + (get_local $4) + (i64.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i64.shl + (get_local $5) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + ) + (loop $continue|2 + (if + (i32.gt_s + (get_local $3) + (get_local $6) + ) + (block + (if + (i64.eqz + (i64.shr_u + (tee_local $4 + (i64.sub + (get_local $2) + (get_local $5) + ) + ) + (i64.const 63) + ) + ) + (block + (br_if $folding-inner0 + (i64.eqz + (get_local $4) + ) + ) + (set_local $2 + (get_local $4) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + (if + (i64.eqz + (i64.shr_u + (tee_local $4 + (i64.sub + (get_local $2) + (get_local $5) + ) + ) + (i64.const 63) + ) + ) + (block + (br_if $folding-inner0 + (i64.eqz + (get_local $4) + ) + ) + (set_local $2 + (get_local $4) + ) + ) + ) + (loop $continue|3 + (if + (i64.eqz + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + (block + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (return + (f64.reinterpret/i64 + (i64.or + (tee_local $2 + (select + (i64.or + (i64.sub + (get_local $2) + (i64.const 4503599627370496) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 52) + ) + ) + (i64.shr_u + (get_local $2) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + ) + (i32.gt_s + (get_local $3) + (i32.const 0) + ) + ) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 63) + ) + ) + ) + ) + ) + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + (func $start (; 6 ;) (type $v) (drop (i32.div_s (get_global $binary/i) @@ -21,6 +3539,14 @@ (i32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) (set_global $binary/b (i32.lt_s (get_global $binary/i) @@ -81,6 +3607,16 @@ (i32.const 1) ) ) + (set_global $binary/i + (i32.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/i (i32.shl (get_global $binary/i) @@ -183,6 +3719,14 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) (set_global $binary/b (i64.lt_s (get_global $binary/I) @@ -249,6 +3793,16 @@ (i64.const 1) ) ) + (set_global $binary/I + (i64.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/I (i64.shl (get_global $binary/I) @@ -345,6 +3899,18 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/b (f32.lt (get_global $binary/f) @@ -405,6 +3971,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/f (f32.add (get_global $binary/f) @@ -423,6 +4001,30 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/b (f64.lt (get_global $binary/F) @@ -483,6 +4085,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/F (f64.add (get_global $binary/F) @@ -501,5 +4115,17 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) ) ) diff --git a/tests/compiler/binary.ts b/tests/compiler/binary.ts index 74398742..694f0486 100644 --- a/tests/compiler/binary.ts +++ b/tests/compiler/binary.ts @@ -13,6 +13,7 @@ i - 1; i * 1; i / 1; i % 1; +i ** 1; i << 1; i >> 1; i >>> 1; @@ -31,6 +32,7 @@ i = i - 1; i = i * 1; i = i / 1; i = i % 1; +i = (i ** 1); i = i << 1; i = i >> 1; i = i >>> 1; @@ -42,6 +44,7 @@ i += 1; i -= 1; i *= 1; i %= 1; +// i **= 1; i <<= 1; i >>= 1; i >>>= 1; @@ -62,6 +65,7 @@ I - 1; I * 1; I / 1; I % 1; +I ** 1; I << 1; I >> 1; I >>> 1; @@ -80,6 +84,7 @@ I = I - 1; I = I * 1; I = I / 1; I = I % 1; +I = (I ** 1); I = I << 1; I = I >> 1; I = I >>> 1; @@ -91,6 +96,7 @@ I += 1; I -= 1; I *= 1; I %= 1; +// I **= 1; I <<= 1; I >>= 1; I >>>= 1; @@ -110,7 +116,8 @@ f + 1; f - 1; f * 1; f / 1; -// f % 1; +f % 1; +f ** 1; b = f < 1; b = f > 1; @@ -122,12 +129,14 @@ f = f + 1; f = f - 1; f = f * 1; f = f / 1; -// f = f % 1; +f = f % 1; +f = f ** 1; f += 1; f -= 1; f *= 1; -// f %= 1; +f %= 1; +f **= 1; var F: f64 = 0; @@ -141,7 +150,8 @@ F + 1; F - 1; F * 1; F / 1; -// f % 1; +F % 1; +F ** 1; b = F < 1; b = F > 1; @@ -153,9 +163,11 @@ F = F + 1; F = F - 1; F = F * 1; F = F / 1; -// F = F % 1; +F = F % 1; +F = F ** 1; F += 1; F -= 1; F *= 1; -// F %= 1; +F %= 1; +F **= 1; diff --git a/tests/compiler/binary.untouched.wat b/tests/compiler/binary.untouched.wat index 1e29f213..312ae778 100644 --- a/tests/compiler/binary.untouched.wat +++ b/tests/compiler/binary.untouched.wat @@ -1,4 +1,10 @@ (module + (type $FFF (func (param f64 f64) (result f64))) + (type $F (func (result f64))) + (type $FiF (func (param f64 i32) (result f64))) + (type $fff (func (param f32 f32) (result f32))) + (type $f (func (result f32))) + (type $fif (func (param f32 i32) (result f32))) (type $v (func)) (global $binary/b (mut i32) (i32.const 0)) (global $binary/i (mut i32) (i32.const 0)) @@ -9,7 +15,4048 @@ (memory $0 1) (export "memory" (memory $0)) (start $start) - (func $start (; 0 ;) (type $v) + (func "$(lib)/math/NativeMath.scalbn" (; 0 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.const 52) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 1 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 f64) + (local $20 f64) + (local $21 f64) + (local $22 f64) + (local $23 f64) + (local $24 i32) + (local $25 i32) + (local $26 f64) + (local $27 f64) + (local $28 f64) + (local $29 f64) + (local $30 f64) + (local $31 f64) + (local $32 f64) + (local $33 f64) + (local $34 f64) + (local $35 f64) + (local $36 f64) + (local $37 f64) + (local $38 i32) + (nop) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $7 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (set_local $8 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (i32.or + (get_local $8) + (get_local $6) + ) + (i32.const 0) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.gt_s + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $4) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.gt_s + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $10 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1128267776) + ) + (set_local $10 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1072693248) + ) + (block + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $8) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $11) + (i32.const 20) + ) + (block + (set_local $9 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + (get_local $6) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (set_local $9 + (i32.shr_s + (get_local $8) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + (get_local $8) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $4) + ) + (i32.const 0) + ) + (return + (f64.const nan:0x8000000000000) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (get_local $1) + (f64.const 0) + ) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (f64.const 0) + (f64.neg + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (set_local $13 + (get_local $12) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.const 1) + (get_local $13) + ) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $10) + ) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.sub + (get_local $13) + (get_local $13) + ) + (f64.sub + (get_local $13) + (get_local $13) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $13 + (f64.neg + (get_local $13) + ) + ) + ) + ) + ) + (return + (get_local $13) + ) + ) + ) + ) + (set_local $14 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 0) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $14 + (f64.const -1) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_s + (get_local $8) + (i32.const 1105199104) + ) + (block + (if + (i32.gt_s + (get_local $8) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (set_local $20 + (f64.sub + (get_local $12) + (f64.const 1) + ) + ) + (set_local $23 + (f64.mul + (f64.mul + (get_local $20) + (get_local $20) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $20) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $20) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $21 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $20) + ) + ) + (set_local $22 + (f64.sub + (f64.mul + (get_local $20) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $23) + (f64.const 1.4426950408889634) + ) + ) + ) + (set_local $15 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $22) + (f64.sub + (get_local $15) + (get_local $21) + ) + ) + ) + ) + (block + (nop) + (set_local $25 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1048576) + ) + (block + (set_local $12 + (f64.mul + (get_local $12) + (f64.const 9007199254740992) + ) + ) + (set_local $25 + (i32.sub + (get_local $25) + (i32.const 53) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.sub + (i32.shr_s + (get_local $7) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $24 + (i32.and + (get_local $7) + (i32.const 1048575) + ) + ) + (set_local $7 + (i32.or + (get_local $24) + (i32.const 1072693248) + ) + ) + (if + (i32.le_s + (get_local $24) + (i32.const 235662) + ) + (set_local $11 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 767610) + ) + (set_local $11 + (i32.const 1) + ) + (block + (set_local $11 + (i32.const 0) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.const 1) + ) + ) + (set_local $7 + (i32.sub + (get_local $7) + (i32.const 1048576) + ) + ) + ) + ) + ) + (set_local $12 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 32) + ) + ) + ) + ) + (set_local $32 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $11) + ) + ) + (set_local $21 + (f64.sub + (get_local $12) + (get_local $32) + ) + ) + (set_local $22 + (f64.div + (f64.const 1) + (f64.add + (get_local $12) + (get_local $32) + ) + ) + ) + (set_local $26 + (f64.mul + (get_local $21) + (get_local $22) + ) + ) + (set_local $28 + (get_local $26) + ) + (set_local $28 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $28) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $7) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $11) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $12) + (f64.sub + (get_local $30) + (get_local $32) + ) + ) + ) + (set_local $29 + (f64.mul + (get_local $22) + (f64.sub + (f64.sub + (get_local $21) + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (f64.mul + (get_local $28) + (get_local $31) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $26) + (get_local $26) + ) + ) + (set_local $19 + (f64.mul + (f64.mul + (get_local $27) + (get_local $27) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $27) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.add + (get_local $19) + (f64.mul + (get_local $29) + (f64.add + (get_local $28) + (get_local $26) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $28) + (get_local $28) + ) + ) + (set_local $30 + (f64.add + (f64.add + (f64.const 3) + (get_local $27) + ) + (get_local $19) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $30) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $19) + (f64.sub + (f64.sub + (get_local $30) + (f64.const 3) + ) + (get_local $27) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (get_local $29) + (get_local $30) + ) + (f64.mul + (get_local $31) + (get_local $26) + ) + ) + ) + (set_local $17 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $17 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $17) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.sub + (get_local $22) + (f64.sub + (get_local $17) + (get_local $21) + ) + ) + ) + (set_local $33 + (f64.mul + (f64.const 0.9617967009544373) + (get_local $17) + ) + ) + (set_local $34 + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $35 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $17) + ) + (f64.mul + (get_local $18) + (f64.const 0.9617966939259756) + ) + ) + (get_local $34) + ) + ) + (set_local $20 + (f64.convert_s/i32 + (get_local $25) + ) + ) + (set_local $36 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $15 + (f64.add + (f64.add + (f64.add + (get_local $33) + (get_local $35) + ) + (get_local $36) + ) + (get_local $20) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $35) + (f64.sub + (f64.sub + (f64.sub + (get_local $15) + (get_local $20) + ) + (get_local $36) + ) + (get_local $33) + ) + ) + ) + ) + ) + (set_local $37 + (get_local $1) + ) + (set_local $37 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $37) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (get_local $37) + ) + (get_local $15) + ) + (f64.mul + (get_local $1) + (get_local $16) + ) + ) + ) + (set_local $17 + (f64.mul + (get_local $37) + (get_local $15) + ) + ) + (set_local $13 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $38 + (i32.wrap/i64 + (get_local $2) + ) + ) + (if + (i32.ge_s + (get_local $24) + (i32.const 1083179008) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const 1083179008) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + (if + (f64.gt + (f64.add + (get_local $18) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const -1064252416) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (if + (f64.le + (get_local $18) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (set_local $38 + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $38) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $25 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $38) + (i32.const 1071644672) + ) + (block + (set_local $25 + (i32.add + (get_local $24) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $11) + (i32.const 1) + ) + ) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (i32.and + (get_local $25) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $20 + (f64.const 0) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $25) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $11) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $25 + (i32.shr_s + (i32.or + (i32.and + (get_local $25) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 0) + ) + (set_local $25 + (i32.sub + (i32.const 0) + (get_local $25) + ) + ) + ) + (set_local $17 + (f64.sub + (get_local $17) + (get_local $20) + ) + ) + ) + ) + (set_local $20 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $20) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $20) + (f64.const 0.6931471824645996) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (f64.sub + (get_local $18) + (f64.sub + (get_local $20) + (get_local $17) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $20) + (f64.const -1.904654299957768e-09) + ) + ) + ) + (set_local $13 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $23 + (f64.sub + (get_local $22) + (f64.sub + (get_local $13) + (get_local $21) + ) + ) + ) + (set_local $20 + (f64.mul + (get_local $13) + (get_local $13) + ) + ) + (set_local $15 + (f64.sub + (get_local $13) + (f64.mul + (get_local $20) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $20) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $20) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $20) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $20) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.sub + (f64.div + (f64.mul + (get_local $13) + (get_local $15) + ) + (f64.sub + (get_local $15) + (f64.const 2) + ) + ) + (f64.add + (get_local $23) + (f64.mul + (get_local $13) + (get_local $23) + ) + ) + ) + ) + (set_local $13 + (f64.sub + (f64.const 1) + (f64.sub + (get_local $19) + (get_local $13) + ) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 32) + ) + ) + ) + (set_local $24 + (i32.add + (get_local $24) + (i32.shl + (get_local $25) + (i32.const 20) + ) + ) + ) + (if + (i32.le_s + (i32.shr_s + (get_local $24) + (i32.const 20) + ) + (i32.const 0) + ) + (set_local $13 + (call "$(lib)/math/NativeMath.scalbn" + (get_local $13) + (get_local $25) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $24) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 2 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (local $9 i32) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $5 + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.and + (if (result i32) + (tee_local $8 + (i32.eq + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 0) + ) + ) + (get_local $8) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $8) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $9 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $2 + (i32.and + (get_local $2) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $9 + (i32.shl + (get_local $3) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $3 + (i32.and + (get_local $3) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $3 + (i32.or + (get_local $3) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (block $break|2 + (nop) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + ) + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $2 + (i32.sub + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (get_local $6) + ) + ) + (return + (f32.reinterpret/i32 + (get_local $2) + ) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 3 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (i32.const 127) + (get_local $1) + ) + (i32.const 23) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.pow" (; 4 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (local $15 f32) + (local $16 f32) + (local $17 f32) + (local $18 f32) + (local $19 f32) + (local $20 f32) + (local $21 f32) + (local $22 f32) + (local $23 i32) + (local $24 i32) + (local $25 f32) + (local $26 f32) + (local $27 f32) + (local $28 f32) + (local $29 f32) + (local $30 f32) + (local $31 f32) + (local $32 f32) + (local $33 f32) + (local $34 f32) + (local $35 f32) + (local $36 i32) + (nop) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (get_local $2) + (i32.const 2147483647) + ) + ) + (set_local $5 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 0) + ) + (return + (f32.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.gt_s + (get_local $4) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.gt_s + (get_local $5) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $7 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1266679808) + ) + (set_local $7 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1065353216) + ) + (block + (set_local $9 + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $8 + (i32.shr_s + (get_local $5) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $8) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + (get_local $5) + ) + (set_local $7 + (i32.sub + (i32.const 2) + (i32.and + (get_local $8) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1065353216) + ) + (return + (f32.const nan:0x400000) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 1065353216) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (get_local $1) + (f32.const 0) + ) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (f32.const 0) + (f32.neg + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (get_local $0) + (f32.div + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1073741824) + ) + (return + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1056964608) + ) + (if + (i32.ge_s + (get_local $2) + (i32.const 0) + ) + (return + (f32.sqrt + (get_local $0) + ) + ) + ) + ) + (set_local $10 + (f32.abs + (get_local $0) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.and + (if (result i32) + (tee_local $6 + (i32.eq + (get_local $4) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.eq + (get_local $4) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $6) + (i32.eq + (get_local $4) + (i32.const 1065353216) + ) + ) + (i32.const 1) + ) + (block + (set_local $11 + (get_local $10) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (set_local $11 + (f32.div + (f32.const 1) + (get_local $11) + ) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $4) + (i32.const 1065353216) + ) + (get_local $7) + ) + (i32.const 0) + ) + (set_local $11 + (f32.div + (f32.sub + (get_local $11) + (get_local $11) + ) + (f32.sub + (get_local $11) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1) + ) + (set_local $11 + (f32.neg + (get_local $11) + ) + ) + ) + ) + ) + (return + (get_local $11) + ) + ) + ) + (set_local $12 + (f32.const 1) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $7) + (i32.const 0) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1) + ) + (set_local $12 + (f32.const -1) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_s + (get_local $5) + (i32.const 1291845632) + ) + (block + (if + (i32.lt_s + (get_local $4) + (i32.const 1065353208) + ) + (return + (if (result f32) + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 1065353223) + ) + (return + (if (result f32) + (i32.gt_s + (get_local $3) + (i32.const 0) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + (set_local $17 + (f32.sub + (get_local $10) + (f32.const 1) + ) + ) + (set_local $20 + (f32.mul + (f32.mul + (get_local $17) + (get_local $17) + ) + (f32.sub + (f32.const 0.5) + (f32.mul + (get_local $17) + (f32.sub + (f32.const 0.3333333432674408) + (f32.mul + (get_local $17) + (f32.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $18 + (f32.mul + (f32.const 1.44268798828125) + (get_local $17) + ) + ) + (set_local $19 + (f32.sub + (f32.mul + (get_local $17) + (f32.const 7.052607543300837e-06) + ) + (f32.mul + (get_local $20) + (f32.const 1.4426950216293335) + ) + ) + ) + (set_local $13 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $13) + ) + ) + (set_local $13 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $14 + (f32.sub + (get_local $19) + (f32.sub + (get_local $13) + (get_local $18) + ) + ) + ) + ) + (block + (nop) + (set_local $23 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 8388608) + ) + (block + (set_local $10 + (f32.mul + (get_local $10) + (f32.const 16777216) + ) + ) + (set_local $23 + (i32.sub + (get_local $23) + (i32.const 24) + ) + ) + (set_local $4 + (i32.reinterpret/f32 + (get_local $10) + ) + ) + ) + ) + (set_local $23 + (i32.add + (get_local $23) + (i32.sub + (i32.shr_s + (get_local $4) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $8 + (i32.and + (get_local $4) + (i32.const 8388607) + ) + ) + (set_local $4 + (i32.or + (get_local $8) + (i32.const 1065353216) + ) + ) + (if + (i32.le_s + (get_local $8) + (i32.const 1885297) + ) + (set_local $9 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $8) + (i32.const 6140887) + ) + (set_local $9 + (i32.const 1) + ) + (block + (set_local $9 + (i32.const 0) + ) + (set_local $23 + (i32.add + (get_local $23) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 8388608) + ) + ) + ) + ) + ) + (set_local $10 + (f32.reinterpret/i32 + (get_local $4) + ) + ) + (set_local $30 + (select + (f32.const 1.5) + (f32.const 1) + (get_local $9) + ) + ) + (set_local $18 + (f32.sub + (get_local $10) + (get_local $30) + ) + ) + (set_local $19 + (f32.div + (f32.const 1) + (f32.add + (get_local $10) + (get_local $30) + ) + ) + ) + (set_local $16 + (f32.mul + (get_local $18) + (get_local $19) + ) + ) + (set_local $26 + (get_local $16) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $26) + ) + ) + (set_local $26 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $24 + (i32.or + (i32.and + (i32.shr_s + (get_local $4) + (i32.const 1) + ) + (i32.const -4096) + ) + (i32.const 536870912) + ) + ) + (set_local $28 + (f32.reinterpret/i32 + (i32.add + (i32.add + (get_local $24) + (i32.const 4194304) + ) + (i32.shl + (get_local $9) + (i32.const 21) + ) + ) + ) + ) + (set_local $29 + (f32.sub + (get_local $10) + (f32.sub + (get_local $28) + (get_local $30) + ) + ) + ) + (set_local $27 + (f32.mul + (get_local $19) + (f32.sub + (f32.sub + (get_local $18) + (f32.mul + (get_local $26) + (get_local $28) + ) + ) + (f32.mul + (get_local $26) + (get_local $29) + ) + ) + ) + ) + (set_local $25 + (f32.mul + (get_local $16) + (get_local $16) + ) + ) + (set_local $15 + (f32.mul + (f32.mul + (get_local $25) + (get_local $25) + ) + (f32.add + (f32.const 0.6000000238418579) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.4285714328289032) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.3333333432674408) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.2727281153202057) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.23066075146198273) + (f32.mul + (get_local $25) + (f32.const 0.20697501301765442) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $15 + (f32.add + (get_local $15) + (f32.mul + (get_local $27) + (f32.add + (get_local $26) + (get_local $16) + ) + ) + ) + ) + (set_local $25 + (f32.mul + (get_local $26) + (get_local $26) + ) + ) + (set_local $28 + (f32.add + (f32.add + (f32.const 3) + (get_local $25) + ) + (get_local $15) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $28) + ) + ) + (set_local $28 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $29 + (f32.sub + (get_local $15) + (f32.sub + (f32.sub + (get_local $28) + (f32.const 3) + ) + (get_local $25) + ) + ) + ) + (set_local $18 + (f32.mul + (get_local $26) + (get_local $28) + ) + ) + (set_local $19 + (f32.add + (f32.mul + (get_local $27) + (get_local $28) + ) + (f32.mul + (get_local $29) + (get_local $16) + ) + ) + ) + (set_local $21 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $21) + ) + ) + (set_local $21 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $22 + (f32.sub + (get_local $19) + (f32.sub + (get_local $21) + (get_local $18) + ) + ) + ) + (set_local $31 + (f32.mul + (f32.const 0.9619140625) + (get_local $21) + ) + ) + (set_local $32 + (select + (f32.const 1.5632208487659227e-06) + (f32.const 0) + (get_local $9) + ) + ) + (set_local $33 + (f32.add + (f32.add + (f32.mul + (f32.const -1.1736857413779944e-04) + (get_local $21) + ) + (f32.mul + (get_local $22) + (f32.const 0.9617967009544373) + ) + ) + (get_local $32) + ) + ) + (set_local $17 + (f32.convert_s/i32 + (get_local $23) + ) + ) + (set_local $34 + (select + (f32.const 0.5849609375) + (f32.const 0) + (get_local $9) + ) + ) + (set_local $13 + (f32.add + (f32.add + (f32.add + (get_local $31) + (get_local $33) + ) + (get_local $34) + ) + (get_local $17) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $13) + ) + ) + (set_local $13 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $14 + (f32.sub + (get_local $33) + (f32.sub + (f32.sub + (f32.sub + (get_local $13) + (get_local $17) + ) + (get_local $34) + ) + (get_local $31) + ) + ) + ) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $35 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $22 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (get_local $35) + ) + (get_local $13) + ) + (f32.mul + (get_local $1) + (get_local $14) + ) + ) + ) + (set_local $21 + (f32.mul + (get_local $35) + (get_local $13) + ) + ) + (set_local $11 + (f32.add + (get_local $22) + (get_local $21) + ) + ) + (set_local $8 + (i32.reinterpret/f32 + (get_local $11) + ) + ) + (if + (i32.gt_s + (get_local $8) + (i32.const 1124073472) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const 1124073472) + ) + (if + (f32.gt + (f32.add + (get_local $22) + (f32.const 4.299566569443414e-08) + ) + (f32.sub + (get_local $11) + (get_local $21) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + ) + (if + (i32.gt_s + (i32.and + (get_local $8) + (i32.const 2147483647) + ) + (i32.const 1125515264) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const -1021968384) + ) + (if + (f32.le + (get_local $22) + (f32.sub + (get_local $11) + (get_local $21) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (get_local $8) + (i32.const 2147483647) + ) + ) + (set_local $9 + (i32.sub + (i32.shr_s + (get_local $36) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $23 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $36) + (i32.const 1056964608) + ) + (block + (set_local $23 + (i32.add + (get_local $8) + (i32.shr_s + (i32.const 8388608) + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + (set_local $9 + (i32.sub + (i32.shr_s + (i32.and + (get_local $23) + (i32.const 2147483647) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $17 + (f32.reinterpret/i32 + (i32.and + (get_local $23) + (i32.xor + (i32.shr_s + (i32.const 8388607) + (get_local $9) + ) + (i32.const -1) + ) + ) + ) + ) + (set_local $23 + (i32.shr_s + (i32.or + (i32.and + (get_local $23) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + ) + (if + (i32.lt_s + (get_local $8) + (i32.const 0) + ) + (set_local $23 + (i32.sub + (i32.const 0) + (get_local $23) + ) + ) + ) + (set_local $21 + (f32.sub + (get_local $21) + (get_local $17) + ) + ) + ) + ) + (set_local $17 + (f32.add + (get_local $22) + (get_local $21) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $17) + ) + ) + (set_local $17 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -32768) + ) + ) + ) + (set_local $18 + (f32.mul + (get_local $17) + (f32.const 0.693145751953125) + ) + ) + (set_local $19 + (f32.add + (f32.mul + (f32.sub + (get_local $22) + (f32.sub + (get_local $17) + (get_local $21) + ) + ) + (f32.const 0.6931471824645996) + ) + (f32.mul + (get_local $17) + (f32.const 1.4286065379565116e-06) + ) + ) + ) + (set_local $11 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $20 + (f32.sub + (get_local $19) + (f32.sub + (get_local $11) + (get_local $18) + ) + ) + ) + (set_local $17 + (f32.mul + (get_local $11) + (get_local $11) + ) + ) + (set_local $13 + (f32.sub + (get_local $11) + (f32.mul + (get_local $17) + (f32.add + (f32.const 0.1666666716337204) + (f32.mul + (get_local $17) + (f32.add + (f32.const -2.7777778450399637e-03) + (f32.mul + (get_local $17) + (f32.add + (f32.const 6.61375597701408e-05) + (f32.mul + (get_local $17) + (f32.add + (f32.const -1.6533901998627698e-06) + (f32.mul + (get_local $17) + (f32.const 4.138136944220605e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $15 + (f32.sub + (f32.div + (f32.mul + (get_local $11) + (get_local $13) + ) + (f32.sub + (get_local $13) + (f32.const 2) + ) + ) + (f32.add + (get_local $20) + (f32.mul + (get_local $11) + (get_local $20) + ) + ) + ) + ) + (set_local $11 + (f32.sub + (f32.const 1) + (f32.sub + (get_local $15) + (get_local $11) + ) + ) + ) + (set_local $8 + (i32.reinterpret/f32 + (get_local $11) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.shl + (get_local $23) + (i32.const 23) + ) + ) + ) + (if + (i32.le_s + (i32.shr_s + (get_local $8) + (i32.const 23) + ) + (i32.const 0) + ) + (set_local $11 + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $11) + (get_local $23) + ) + ) + (set_local $11 + (f32.reinterpret/i32 + (get_local $8) + ) + ) + ) + (return + (f32.mul + (get_local $12) + (get_local $11) + ) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 5 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f64) + (local $8 i32) + (local $9 i64) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.and + (if (result i32) + (tee_local $8 + (i64.eq + (i64.shl + (get_local $3) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $8) + (f64.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $8) + (i32.eq + (get_local $4) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.le_u + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $9 + (i64.shl + (get_local $2) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i64.shl + (get_local $9) + (i64.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $2 + (i64.and + (get_local $2) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $9 + (i64.shl + (get_local $3) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $9 + (i64.shl + (get_local $9) + (i64.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i64.shl + (get_local $3) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $3 + (i64.and + (get_local $3) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $3 + (i64.or + (get_local $3) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (block $break|2 + (nop) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $9 + (i64.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (if + (i64.eqz + (get_local $9) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + ) + (set_local $9 + (i64.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (if + (i64.eqz + (get_local $9) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i64.eqz + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $2 + (i64.sub + (get_local $2) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 52) + ) + ) + ) + ) + (set_local $2 + (i64.shr_u + (get_local $2) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 63) + ) + ) + ) + (return + (f64.reinterpret/i64 + (get_local $2) + ) + ) + ) + (func $start (; 6 ;) (type $v) (drop (i32.lt_s (get_global $binary/i) @@ -76,6 +4123,14 @@ (i32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) (drop (i32.shl (get_global $binary/i) @@ -178,6 +4233,16 @@ (i32.const 1) ) ) + (set_global $binary/i + (i32.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/i (i32.shl (get_global $binary/i) @@ -340,6 +4405,14 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) (drop (i64.shl (get_global $binary/I) @@ -442,6 +4515,16 @@ (i64.const 1) ) ) + (set_global $binary/I + (i64.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/I (i64.shl (get_global $binary/I) @@ -598,6 +4681,18 @@ (f32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/b (f32.lt (get_global $binary/f) @@ -658,6 +4753,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/f (f32.add (get_global $binary/f) @@ -676,6 +4783,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (drop (f64.lt (get_global $binary/F) @@ -736,6 +4855,18 @@ (f64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/b (f64.lt (get_global $binary/F) @@ -796,6 +4927,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/F (f64.add (get_global $binary/F) @@ -814,5 +4957,17 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) ) ) diff --git a/tests/compiler/builtins.optimized.wat b/tests/compiler/builtins.optimized.wat index 67020a45..56b95aec 100644 --- a/tests/compiler/builtins.optimized.wat +++ b/tests/compiler/builtins.optimized.wat @@ -1,8 +1,6 @@ (module (type $iiiiv (func (param i32 i32 i32 i32))) (type $v (func)) - (type $FFF (func (param f64 f64) (result f64))) - (type $fff (func (param f32 f32) (result f32))) (import "env" "abort" (func $abort (param i32 i32 i32 i32))) (global $builtins/b (mut i32) (i32.const 0)) (global $builtins/i (mut i32) (i32.const 0)) @@ -21,731 +19,7 @@ (func $builtins/test (; 1 ;) (type $v) (nop) ) - (func $fmod (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) - (local $2 i64) - (local $3 i32) - (local $4 i64) - (local $5 i64) - (local $6 i32) - (local $7 i32) - (local $8 f64) - (block $folding-inner0 - (set_local $3 - (i32.wrap/i64 - (i64.and - (i64.shr_u - (tee_local $2 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (i64.const 52) - ) - (i64.const 2047) - ) - ) - ) - (set_local $6 - (i32.wrap/i64 - (i64.and - (i64.shr_u - (tee_local $5 - (i64.reinterpret/f64 - (get_local $1) - ) - ) - (i64.const 52) - ) - (i64.const 2047) - ) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $7 - (i32.and - (if (result i32) - (tee_local $7 - (i64.eq - (i64.shl - (get_local $5) - (i64.const 1) - ) - (i64.const 0) - ) - ) - (get_local $7) - (f64.ne - (tee_local $8 - (get_local $1) - ) - (get_local $8) - ) - ) - (i32.const 1) - ) - ) - (get_local $7) - (i32.eq - (get_local $3) - (i32.const 2047) - ) - ) - (i32.const 1) - ) - (return - (f64.div - (f64.mul - (get_local $0) - (get_local $1) - ) - (f64.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i64.le_u - (i64.shl - (get_local $2) - (i64.const 1) - ) - (i64.shl - (get_local $5) - (i64.const 1) - ) - ) - (block - (br_if $folding-inner0 - (i64.eq - (i64.shl - (get_local $2) - (i64.const 1) - ) - (i64.shl - (get_local $5) - (i64.const 1) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (set_local $7 - (i32.wrap/i64 - (i64.shr_u - (get_local $2) - (i64.const 63) - ) - ) - ) - (set_local $2 - (if (result i64) - (get_local $3) - (i64.or - (i64.and - (get_local $2) - (i64.const 4503599627370495) - ) - (i64.const 4503599627370496) - ) - (block (result i64) - (set_local $4 - (i64.shl - (get_local $2) - (i64.const 12) - ) - ) - (loop $continue|0 - (if - (i64.eqz - (i64.shr_u - (get_local $4) - (i64.const 63) - ) - ) - (block - (set_local $3 - (i32.sub - (get_local $3) - (i32.const 1) - ) - ) - (set_local $4 - (i64.shl - (get_local $4) - (i64.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - (i64.shl - (get_local $2) - (i64.extend_u/i32 - (i32.sub - (i32.const 1) - (get_local $3) - ) - ) - ) - ) - ) - ) - (set_local $5 - (if (result i64) - (get_local $6) - (i64.or - (i64.and - (get_local $5) - (i64.const 4503599627370495) - ) - (i64.const 4503599627370496) - ) - (block (result i64) - (set_local $4 - (i64.shl - (get_local $5) - (i64.const 12) - ) - ) - (loop $continue|1 - (if - (i64.eqz - (i64.shr_u - (get_local $4) - (i64.const 63) - ) - ) - (block - (set_local $6 - (i32.sub - (get_local $6) - (i32.const 1) - ) - ) - (set_local $4 - (i64.shl - (get_local $4) - (i64.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - (i64.shl - (get_local $5) - (i64.extend_u/i32 - (i32.sub - (i32.const 1) - (get_local $6) - ) - ) - ) - ) - ) - ) - (loop $continue|2 - (if - (i32.gt_s - (get_local $3) - (get_local $6) - ) - (block - (if - (i64.eqz - (i64.shr_u - (tee_local $4 - (i64.sub - (get_local $2) - (get_local $5) - ) - ) - (i64.const 63) - ) - ) - (block - (br_if $folding-inner0 - (i64.eqz - (get_local $4) - ) - ) - (set_local $2 - (get_local $4) - ) - ) - ) - (set_local $2 - (i64.shl - (get_local $2) - (i64.const 1) - ) - ) - (set_local $3 - (i32.sub - (get_local $3) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - (if - (i64.eqz - (i64.shr_u - (tee_local $4 - (i64.sub - (get_local $2) - (get_local $5) - ) - ) - (i64.const 63) - ) - ) - (block - (br_if $folding-inner0 - (i64.eqz - (get_local $4) - ) - ) - (set_local $2 - (get_local $4) - ) - ) - ) - (loop $continue|3 - (if - (i64.eqz - (i64.shr_u - (get_local $2) - (i64.const 52) - ) - ) - (block - (set_local $3 - (i32.sub - (get_local $3) - (i32.const 1) - ) - ) - (set_local $2 - (i64.shl - (get_local $2) - (i64.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - (return - (f64.reinterpret/i64 - (i64.or - (tee_local $2 - (select - (i64.or - (i64.sub - (get_local $2) - (i64.const 4503599627370496) - ) - (i64.shl - (i64.extend_u/i32 - (get_local $3) - ) - (i64.const 52) - ) - ) - (i64.shr_u - (get_local $2) - (i64.extend_u/i32 - (i32.sub - (i32.const 1) - (get_local $3) - ) - ) - ) - (i32.gt_s - (get_local $3) - (i32.const 0) - ) - ) - ) - (i64.shl - (i64.extend_u/i32 - (get_local $7) - ) - (i64.const 63) - ) - ) - ) - ) - ) - (f64.mul - (f64.const 0) - (get_local $0) - ) - ) - (func $fmodf (; 3 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 f32) - (local $8 i32) - (block $folding-inner0 - (set_local $4 - (i32.and - (i32.shr_u - (tee_local $2 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $6 - (i32.and - (i32.shr_u - (tee_local $5 - (i32.reinterpret/f32 - (get_local $1) - ) - ) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.and - (if (result i32) - (tee_local $3 - (i32.eqz - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - ) - (get_local $3) - (f32.ne - (tee_local $7 - (get_local $1) - ) - (get_local $7) - ) - ) - (i32.const 1) - ) - ) - (get_local $3) - (i32.eq - (get_local $4) - (i32.const 255) - ) - ) - (i32.const 1) - ) - (return - (f32.div - (f32.mul - (get_local $0) - (get_local $1) - ) - (f32.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i32.le_u - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - (block - (br_if $folding-inner0 - (i32.eq - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (set_local $8 - (i32.and - (get_local $2) - (i32.const -2147483648) - ) - ) - (set_local $2 - (if (result i32) - (get_local $4) - (i32.or - (i32.and - (get_local $2) - (i32.const 8388607) - ) - (i32.const 8388608) - ) - (block (result i32) - (set_local $3 - (i32.shl - (get_local $2) - (i32.const 9) - ) - ) - (loop $continue|0 - (if - (i32.eqz - (i32.shr_u - (get_local $3) - (i32.const 31) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - (i32.shl - (get_local $2) - (i32.sub - (i32.const 1) - (get_local $4) - ) - ) - ) - ) - ) - (set_local $5 - (if (result i32) - (get_local $6) - (i32.or - (i32.and - (get_local $5) - (i32.const 8388607) - ) - (i32.const 8388608) - ) - (block (result i32) - (set_local $3 - (i32.shl - (get_local $5) - (i32.const 9) - ) - ) - (loop $continue|1 - (if - (i32.eqz - (i32.shr_u - (get_local $3) - (i32.const 31) - ) - ) - (block - (set_local $6 - (i32.sub - (get_local $6) - (i32.const 1) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - (i32.shl - (get_local $5) - (i32.sub - (i32.const 1) - (get_local $6) - ) - ) - ) - ) - ) - (loop $continue|2 - (if - (i32.gt_s - (get_local $4) - (get_local $6) - ) - (block - (if - (i32.eqz - (i32.shr_u - (tee_local $3 - (i32.sub - (get_local $2) - (get_local $5) - ) - ) - (i32.const 31) - ) - ) - (block - (br_if $folding-inner0 - (i32.eqz - (get_local $3) - ) - ) - (set_local $2 - (get_local $3) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - (if - (i32.eqz - (i32.shr_u - (tee_local $3 - (i32.sub - (get_local $2) - (get_local $5) - ) - ) - (i32.const 31) - ) - ) - (block - (br_if $folding-inner0 - (i32.eqz - (get_local $3) - ) - ) - (set_local $2 - (get_local $3) - ) - ) - ) - (loop $continue|3 - (if - (i32.eqz - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - (return - (f32.reinterpret/i32 - (i32.or - (tee_local $2 - (select - (i32.or - (i32.sub - (get_local $2) - (i32.const 8388608) - ) - (i32.shl - (get_local $4) - (i32.const 23) - ) - ) - (i32.shr_u - (get_local $2) - (i32.sub - (i32.const 1) - (get_local $4) - ) - ) - (i32.gt_s - (get_local $4) - (i32.const 0) - ) - ) - ) - (get_local $8) - ) - ) - ) - ) - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - (func $start (; 4 ;) (type $v) + (func $start (; 2 ;) (type $v) (local $0 f32) (local $1 f64) (local $2 i32) @@ -1566,209 +840,5 @@ (unreachable) ) ) - (if - (f64.eq - (tee_local $1 - (call $fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - ) - ) - (get_local $1) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 295) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f64.ne - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 296) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 2) - ) - (f64.const 1.2) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 297) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 3.7) - ) - (f64.const 1.8) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 298) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.eq - (tee_local $0 - (call $fmodf - (f32.const 1) - (f32.const nan:0x400000) - ) - ) - (get_local $0) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 300) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.ne - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 301) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 2) - ) - (f32.const 1.2000000476837158) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 302) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 3.700000047683716) - ) - (f32.const 1.7999999523162842) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 303) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f64.ne - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 305) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.ne - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 306) - (i32.const 0) - ) - (unreachable) - ) - ) ) ) diff --git a/tests/compiler/builtins.ts b/tests/compiler/builtins.ts index e2b13476..0aad14c5 100644 --- a/tests/compiler/builtins.ts +++ b/tests/compiler/builtins.ts @@ -292,21 +292,6 @@ assert(f64.MIN_SAFE_INTEGER == -9007199254740991); assert(f64.MAX_SAFE_INTEGER == 9007199254740991); assert(f64.EPSILON == 2.2204460492503131e-16); -assert(isNaN(fmod(1, NaN))); -assert(fmod(1.5, 1.0) == 0.5); // exactly 0.5 (as in C) -assert(fmod(9.2, 2.0) - 1.2 < f64.EPSILON); // not exactly 1.2 (as in C) -assert(fmod(9.2, 3.7) - 1.8 < f64.EPSILON); // not exactly 1.8 (as in C) - -assert(isNaN(fmodf(1, NaN))); -assert(fmodf(1.5, 1.0) == 0.5); -assert(fmodf(9.2, 2.0) - 1.2 < f32.EPSILON); -assert(fmodf(9.2, 3.7) - 1.8 < f32.EPSILON); - -assert(1.5 % 1.0 == 0.5); // should implicitly call fmod -assert(1.5 % 1.0 == 0.5); // should implicitly call fmodf - -import { - isNaN as isItNaN -} from "builtins"; - +// should be importable +import { isNaN as isItNaN } from "builtins"; isItNaN(1); diff --git a/tests/compiler/builtins.untouched.wat b/tests/compiler/builtins.untouched.wat index 775a2812..b8850cca 100644 --- a/tests/compiler/builtins.untouched.wat +++ b/tests/compiler/builtins.untouched.wat @@ -2,8 +2,8 @@ (type $iiiiv (func (param i32 i32 i32 i32))) (type $i (func (result i32))) (type $v (func)) - (type $FFF (func (param f64 f64) (result f64))) - (type $fff (func (param f32 f32) (result f32))) + (type $f (func (result f32))) + (type $F (func (result f64))) (import "env" "abort" (func $abort (param i32 i32 i32 i32))) (global $builtins/b (mut i32) (i32.const 0)) (global $builtins/i (mut i32) (i32.const 0)) @@ -23,898 +23,7 @@ (start $start) (func $builtins/test (; 1 ;) (type $v) ) - (func $fmod (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) - (local $2 i64) - (local $3 i64) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 f64) - (local $8 i32) - (local $9 i64) - (set_local $2 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (set_local $3 - (i64.reinterpret/f64 - (get_local $1) - ) - ) - (set_local $4 - (i32.wrap/i64 - (i64.and - (i64.shr_u - (get_local $2) - (i64.const 52) - ) - (i64.const 2047) - ) - ) - ) - (set_local $5 - (i32.wrap/i64 - (i64.and - (i64.shr_u - (get_local $3) - (i64.const 52) - ) - (i64.const 2047) - ) - ) - ) - (set_local $6 - (i32.wrap/i64 - (i64.shr_u - (get_local $2) - (i64.const 63) - ) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $8 - (i32.and - (if (result i32) - (tee_local $8 - (i64.eq - (i64.shl - (get_local $3) - (i64.const 1) - ) - (i64.const 0) - ) - ) - (get_local $8) - (f64.ne - (tee_local $7 - (get_local $1) - ) - (get_local $7) - ) - ) - (i32.const 1) - ) - ) - (get_local $8) - (i32.eq - (get_local $4) - (i32.const 2047) - ) - ) - (i32.const 1) - ) - (return - (f64.div - (f64.mul - (get_local $0) - (get_local $1) - ) - (f64.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i64.le_u - (i64.shl - (get_local $2) - (i64.const 1) - ) - (i64.shl - (get_local $3) - (i64.const 1) - ) - ) - (block - (if - (i64.eq - (i64.shl - (get_local $2) - (i64.const 1) - ) - (i64.shl - (get_local $3) - (i64.const 1) - ) - ) - (return - (f64.mul - (f64.const 0) - (get_local $0) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (nop) - (if - (i32.eqz - (get_local $4) - ) - (block - (block $break|0 - (set_local $9 - (i64.shl - (get_local $2) - (i64.const 12) - ) - ) - (loop $continue|0 - (if - (i64.eqz - (i64.shr_u - (get_local $9) - (i64.const 63) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $9 - (i64.shl - (get_local $9) - (i64.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - ) - (set_local $2 - (i64.shl - (get_local $2) - (i64.extend_u/i32 - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - ) - (block - (set_local $2 - (i64.and - (get_local $2) - (i64.shr_u - (i64.const -1) - (i64.const 12) - ) - ) - ) - (set_local $2 - (i64.or - (get_local $2) - (i64.shl - (i64.const 1) - (i64.const 52) - ) - ) - ) - ) - ) - (if - (i32.eqz - (get_local $5) - ) - (block - (block $break|1 - (set_local $9 - (i64.shl - (get_local $3) - (i64.const 12) - ) - ) - (loop $continue|1 - (if - (i64.eqz - (i64.shr_u - (get_local $9) - (i64.const 63) - ) - ) - (block - (set_local $5 - (i32.sub - (get_local $5) - (i32.const 1) - ) - ) - (set_local $9 - (i64.shl - (get_local $9) - (i64.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - ) - (set_local $3 - (i64.shl - (get_local $3) - (i64.extend_u/i32 - (i32.add - (i32.sub - (i32.const 0) - (get_local $5) - ) - (i32.const 1) - ) - ) - ) - ) - ) - (block - (set_local $3 - (i64.and - (get_local $3) - (i64.shr_u - (i64.const -1) - (i64.const 12) - ) - ) - ) - (set_local $3 - (i64.or - (get_local $3) - (i64.shl - (i64.const 1) - (i64.const 52) - ) - ) - ) - ) - ) - (block $break|2 - (nop) - (loop $continue|2 - (if - (i32.gt_s - (get_local $4) - (get_local $5) - ) - (block - (block - (set_local $9 - (i64.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i64.eqz - (i64.shr_u - (get_local $9) - (i64.const 63) - ) - ) - (block - (if - (i64.eqz - (get_local $9) - ) - (return - (f64.mul - (f64.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (set_local $2 - (i64.shl - (get_local $2) - (i64.const 1) - ) - ) - ) - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - ) - (set_local $9 - (i64.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i64.eqz - (i64.shr_u - (get_local $9) - (i64.const 63) - ) - ) - (block - (if - (i64.eqz - (get_local $9) - ) - (return - (f64.mul - (f64.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (block $break|3 - (nop) - (loop $continue|3 - (if - (i64.eqz - (i64.shr_u - (get_local $2) - (i64.const 52) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $2 - (i64.shl - (get_local $2) - (i64.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - ) - (if - (i32.gt_s - (get_local $4) - (i32.const 0) - ) - (block - (set_local $2 - (i64.sub - (get_local $2) - (i64.shl - (i64.const 1) - (i64.const 52) - ) - ) - ) - (set_local $2 - (i64.or - (get_local $2) - (i64.shl - (i64.extend_u/i32 - (get_local $4) - ) - (i64.const 52) - ) - ) - ) - ) - (set_local $2 - (i64.shr_u - (get_local $2) - (i64.extend_u/i32 - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - ) - (set_local $2 - (i64.or - (get_local $2) - (i64.shl - (i64.extend_u/i32 - (get_local $6) - ) - (i64.const 63) - ) - ) - ) - (return - (f64.reinterpret/i64 - (get_local $2) - ) - ) - ) - (func $fmodf (; 3 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 f32) - (local $8 i32) - (local $9 i32) - (set_local $2 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (set_local $3 - (i32.reinterpret/f32 - (get_local $1) - ) - ) - (set_local $4 - (i32.and - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $5 - (i32.and - (i32.shr_u - (get_local $3) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $6 - (i32.and - (get_local $2) - (i32.const -2147483648) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $8 - (i32.and - (if (result i32) - (tee_local $8 - (i32.eq - (i32.shl - (get_local $3) - (i32.const 1) - ) - (i32.const 0) - ) - ) - (get_local $8) - (f32.ne - (tee_local $7 - (get_local $1) - ) - (get_local $7) - ) - ) - (i32.const 1) - ) - ) - (get_local $8) - (i32.eq - (get_local $4) - (i32.const 255) - ) - ) - (i32.const 1) - ) - (return - (f32.div - (f32.mul - (get_local $0) - (get_local $1) - ) - (f32.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i32.le_u - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (block - (if - (i32.eq - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (nop) - (if - (i32.eqz - (get_local $4) - ) - (block - (block $break|0 - (set_local $9 - (i32.shl - (get_local $2) - (i32.const 9) - ) - ) - (loop $continue|0 - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $9 - (i32.shl - (get_local $9) - (i32.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - (block - (set_local $2 - (i32.and - (get_local $2) - (i32.shr_u - (i32.const -1) - (i32.const 9) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - ) - ) - (if - (i32.eqz - (get_local $5) - ) - (block - (block $break|1 - (set_local $9 - (i32.shl - (get_local $3) - (i32.const 9) - ) - ) - (loop $continue|1 - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (set_local $5 - (i32.sub - (get_local $5) - (i32.const 1) - ) - ) - (set_local $9 - (i32.shl - (get_local $9) - (i32.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.add - (i32.sub - (i32.const 0) - (get_local $5) - ) - (i32.const 1) - ) - ) - ) - ) - (block - (set_local $3 - (i32.and - (get_local $3) - (i32.shr_u - (i32.const -1) - (i32.const 9) - ) - ) - ) - (set_local $3 - (i32.or - (get_local $3) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - ) - ) - (block $break|2 - (nop) - (loop $continue|2 - (if - (i32.gt_s - (get_local $4) - (get_local $5) - ) - (block - (block - (set_local $9 - (i32.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (if - (i32.eqz - (get_local $9) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - ) - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - ) - (set_local $9 - (i32.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (if - (i32.eqz - (get_local $9) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (block $break|3 - (nop) - (loop $continue|3 - (if - (i32.eqz - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - ) - (if - (i32.gt_s - (get_local $4) - (i32.const 0) - ) - (block - (set_local $2 - (i32.sub - (get_local $2) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (i32.shl - (get_local $4) - (i32.const 23) - ) - ) - ) - ) - (set_local $2 - (i32.shr_u - (get_local $2) - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (get_local $6) - ) - ) - (return - (f32.reinterpret/i32 - (get_local $2) - ) - ) - ) - (func $start (; 4 ;) (type $v) + (func $start (; 2 ;) (type $v) (local $0 i32) (local $1 i32) (local $2 i64) @@ -3167,222 +2276,6 @@ (unreachable) ) ) - (if - (i32.eqz - (f64.ne - (tee_local $5 - (call $fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - ) - ) - (get_local $5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 295) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.eq - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 296) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 2) - ) - (f64.const 1.2) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 297) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 3.7) - ) - (f64.const 1.8) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 298) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.ne - (tee_local $4 - (call $fmodf - (f32.const 1) - (f32.const nan:0x400000) - ) - ) - (get_local $4) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 300) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.eq - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 301) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 2) - ) - (f32.const 1.2000000476837158) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 302) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 3.700000047683716) - ) - (f32.const 1.7999999523162842) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 303) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.eq - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 305) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.eq - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 4) - (i32.const 306) - (i32.const 0) - ) - (unreachable) - ) - ) (drop (f64.ne (tee_local $5 diff --git a/tests/compiler/showcase.optimized.wat b/tests/compiler/showcase.optimized.wat index 1dbb852a..c4cce693 100644 --- a/tests/compiler/showcase.optimized.wat +++ b/tests/compiler/showcase.optimized.wat @@ -1,7 +1,9 @@ (module - (type $iiiiv (func (param i32 i32 i32 i32))) (type $FFF (func (param f64 f64) (result f64))) + (type $FiF (func (param f64 i32) (result f64))) (type $fff (func (param f32 f32) (result f32))) + (type $fif (func (param f32 i32) (result f32))) + (type $iiiiv (func (param i32 i32 i32 i32))) (type $ii (func (param i32) (result i32))) (type $iii (func (param i32 i32) (result i32))) (type $v (func)) @@ -59,7 +61,3149 @@ (export "anExportedFunction" (func $showcase/anExportedFunction)) (export "memory" (memory $0)) (start $start) - (func $fmod (; 1 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func "$(lib)/math/NativeMath.scalbn" (; 1 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $1) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 f64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 f64) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 i32) + (local $14 f64) + (local $15 i32) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 i64) + (block $folding-inner1 + (block $folding-inner0 + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (set_local $5 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (i32.or + (tee_local $10 + (i32.and + (tee_local $11 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (tee_local $6 + (i32.wrap/i64 + (get_local $19) + ) + ) + ) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.gt_s + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $13) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.gt_s + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1128267776) + ) + (set_local $15 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1072693248) + ) + (if + (i32.gt_s + (tee_local $8 + (i32.sub + (i32.shr_s + (get_local $10) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (i32.const 20) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + (get_local $6) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_s + (get_local $10) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + (get_local $10) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $13) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (get_local $1) + (f64.const 0) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + (return + (select + (f64.const 0) + (f64.neg + (get_local $1) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (return + (f64.const nan:0x8000000000000) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $4) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eqz + (get_local $13) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (i32.eqz + (get_local $5) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.eq + (get_local $5) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + (set_local $2 + (f64.div + (f64.const 1) + (get_local $2) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $15) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $2 + (f64.div + (f64.sub + (get_local $2) + (get_local $2) + ) + (f64.sub + (get_local $2) + (get_local $2) + ) + ) + ) + ) + ) + (return + (get_local $2) + ) + ) + ) + ) + (set_local $12 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (block + (if + (i32.eqz + (get_local $15) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $12 + (f64.const -1) + ) + ) + ) + ) + (set_local $2 + (if (result f64) + (i32.gt_s + (get_local $10) + (i32.const 1105199104) + ) + (block (result f64) + (if + (i32.gt_s + (get_local $10) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (f64.mul + (tee_local $3 + (f64.sub + (get_local $2) + (f64.const 1) + ) + ) + (get_local $3) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $3) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $3) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $3) + ) + ) + (tee_local $17 + (f64.sub + (f64.mul + (get_local $3) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $0) + (f64.const 1.4426950408889634) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $17) + (f64.sub + (get_local $9) + (get_local $16) + ) + ) + ) + (block (result f64) + (set_local $4 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1048576) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 53) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.mul + (get_local $2) + (f64.const 9007199254740992) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $5 + (i32.or + (tee_local $6 + (i32.and + (get_local $5) + (i32.const 1048575) + ) + ) + (i32.const 1072693248) + ) + ) + (set_local $8 + (if (result i32) + (i32.le_s + (get_local $6) + (i32.const 235662) + ) + (i32.const 0) + (if (result i32) + (i32.lt_s + (get_local $6) + (i32.const 767610) + ) + (i32.const 1) + (block (result i32) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1048576) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (tee_local $18 + (f64.mul + (tee_local $16 + (f64.sub + (tee_local $2 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $5) + ) + (i64.const 32) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $8) + ) + ) + ) + ) + (tee_local $17 + (f64.div + (f64.const 1) + (f64.add + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $2 + (f64.sub + (get_local $2) + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $5) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $8) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $2 + (f64.sub + (tee_local $2 + (f64.add + (f64.mul + (f64.mul + (tee_local $14 + (f64.mul + (get_local $18) + (get_local $18) + ) + ) + (get_local $14) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $14) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (tee_local $0 + (f64.mul + (get_local $17) + (f64.sub + (f64.sub + (get_local $16) + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (f64.mul + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (f64.add + (get_local $3) + (get_local $18) + ) + ) + ) + ) + (f64.sub + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.const 3) + (tee_local $14 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (get_local $2) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 3) + ) + (get_local $14) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.add + (tee_local $18 + (f64.mul + (f64.const 0.9617967009544373) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (get_local $0) + (get_local $9) + ) + (f64.mul + (get_local $2) + (get_local $18) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + ) + (tee_local $2 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $0) + ) + (f64.mul + (f64.sub + (get_local $17) + (f64.sub + (get_local $0) + (get_local $16) + ) + ) + (f64.const 0.9617966939259756) + ) + ) + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $8) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $8) + ) + ) + ) + (tee_local $3 + (f64.convert_s/i32 + (get_local $4) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $2) + (f64.sub + (f64.sub + (f64.sub + (get_local $9) + (get_local $3) + ) + (get_local $0) + ) + (get_local $18) + ) + ) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (tee_local $2 + (f64.add + (tee_local $1 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $1) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $9) + ) + (f64.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $9) + ) + ) + ) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (if + (i32.ge_s + (get_local $6) + (i32.const 1083179008) + ) + (br_if $folding-inner1 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const 1083179008) + ) + (get_local $13) + ) + (f64.gt + (f64.add + (get_local $1) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (br_if $folding-inner0 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const -1064252416) + ) + (get_local $13) + ) + (f64.le + (get_local $1) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $8 + (i32.sub + (i32.shr_s + (tee_local $13 + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $4 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $13) + (i32.const 1071644672) + ) + (block + (set_local $8 + (i32.sub + (i32.shr_s + (i32.and + (tee_local $4 + (i32.add + (get_local $6) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $4) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $8) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.shr_s + (i32.or + (i32.and + (get_local $4) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.const 0) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + ) + (set_local $0 + (f64.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + (return + (f64.mul + (get_local $12) + (tee_local $2 + (if (result f64) + (i32.le_s + (i32.shr_s + (tee_local $6 + (i32.add + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.sub + (f64.const 1) + (f64.sub + (f64.sub + (f64.div + (f64.mul + (tee_local $2 + (f64.add + (tee_local $16 + (f64.mul + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (get_local $1) + (get_local $0) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 0.6931471824645996) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (f64.sub + (get_local $3) + (get_local $0) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $3) + (f64.const -1.904654299957768e-09) + ) + ) + ) + ) + ) + (tee_local $9 + (f64.sub + (get_local $2) + (f64.mul + (tee_local $3 + (f64.mul + (get_local $2) + (get_local $2) + ) + ) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $3) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $3) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $3) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $3) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.sub + (get_local $9) + (f64.const 2) + ) + ) + (f64.add + (tee_local $0 + (f64.sub + (get_local $17) + (f64.sub + (get_local $2) + (get_local $16) + ) + ) + ) + (f64.mul + (get_local $2) + (get_local $0) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.shl + (get_local $4) + (i32.const 20) + ) + ) + ) + (i32.const 20) + ) + (i32.const 0) + ) + (call "$(lib)/math/NativeMath.scalbn" + (get_local $2) + (get_local $4) + ) + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 32) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 3 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (block $folding-inner0 + (set_local $4 + (i32.and + (i32.shr_u + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (i32.shr_u + (tee_local $5 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.and + (if (result i32) + (tee_local $3 + (i32.eqz + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (get_local $3) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $3) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + (block + (br_if $folding-inner0 + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $8 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (set_local $2 + (if (result i32) + (get_local $4) + (i32.or + (i32.and + (get_local $2) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i32.shl + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + ) + ) + ) + (set_local $5 + (if (result i32) + (get_local $6) + (i32.or + (i32.and + (get_local $5) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $5) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i32.shl + (get_local $5) + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $6) + ) + (block + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (return + (f32.reinterpret/i32 + (i32.or + (tee_local $2 + (select + (i32.or + (i32.sub + (get_local $2) + (i32.const 8388608) + ) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + (i32.shr_u + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + ) + ) + (get_local $8) + ) + ) + ) + ) + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 4 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (get_local $1) + (i32.const 127) + ) + (i32.const 23) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.pow" (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 f32) + (local $3 f32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f32) + (local $9 f32) + (local $10 i32) + (local $11 i32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (local $15 i32) + (local $16 f32) + (block $folding-inner1 + (block $folding-inner0 + (set_local $5 + (i32.and + (tee_local $15 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (tee_local $10 + (i32.and + (tee_local $11 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 2147483647) + ) + ) + ) + (return + (f32.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.gt_s + (get_local $5) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.gt_s + (get_local $10) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1266679808) + ) + (set_local $4 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1065353216) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_s + (get_local $10) + (i32.sub + (i32.const 23) + (tee_local $6 + (i32.sub + (i32.shr_s + (get_local $10) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + ) + ) + (i32.sub + (i32.const 23) + (get_local $6) + ) + ) + (get_local $10) + ) + (set_local $4 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + (return + (f32.const nan:0x400000) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1065353216) + ) + (return + (select + (get_local $1) + (f32.const 0) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + (return + (select + (f32.const 0) + (f32.neg + (get_local $1) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1065353216) + ) + (return + (select + (get_local $0) + (f32.div + (f32.const 1) + (get_local $0) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1073741824) + ) + (return + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1056964608) + ) + (if + (i32.ge_s + (get_local $15) + (i32.const 0) + ) + (return + (f32.sqrt + (get_local $0) + ) + ) + ) + ) + (set_local $2 + (f32.abs + (get_local $0) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.and + (if (result i32) + (tee_local $6 + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.eqz + (get_local $5) + ) + ) + (i32.const 1) + ) + ) + (get_local $6) + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + (set_local $2 + (f32.div + (f32.const 1) + (get_local $2) + ) + ) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1065353216) + ) + (get_local $4) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1) + ) + (set_local $2 + (f32.neg + (get_local $2) + ) + ) + ) + (set_local $2 + (f32.div + (f32.sub + (get_local $2) + (get_local $2) + ) + (f32.sub + (get_local $2) + (get_local $2) + ) + ) + ) + ) + ) + (return + (get_local $2) + ) + ) + ) + (set_local $9 + (f32.const 1) + ) + (if + (i32.lt_s + (get_local $15) + (i32.const 0) + ) + (block + (if + (i32.eqz + (get_local $4) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1) + ) + (set_local $9 + (f32.const -1) + ) + ) + ) + ) + (set_local $2 + (if (result f32) + (i32.gt_s + (get_local $10) + (i32.const 1291845632) + ) + (block (result f32) + (if + (i32.lt_s + (get_local $5) + (i32.const 1065353208) + ) + (return + (select + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1065353223) + ) + (return + (select + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (set_local $0 + (f32.mul + (f32.mul + (tee_local $3 + (f32.sub + (get_local $2) + (f32.const 1) + ) + ) + (get_local $3) + ) + (f32.sub + (f32.const 0.5) + (f32.mul + (get_local $3) + (f32.sub + (f32.const 0.3333333432674408) + (f32.mul + (get_local $3) + (f32.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (tee_local $13 + (f32.mul + (f32.const 1.44268798828125) + (get_local $3) + ) + ) + (tee_local $14 + (f32.sub + (f32.mul + (get_local $3) + (f32.const 7.052607543300837e-06) + ) + (f32.mul + (get_local $0) + (f32.const 1.4426950216293335) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.sub + (get_local $14) + (f32.sub + (get_local $8) + (get_local $13) + ) + ) + ) + (block (result f32) + (set_local $4 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 8388608) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 24) + ) + ) + (set_local $5 + (i32.reinterpret/f32 + (f32.mul + (get_local $2) + (f32.const 16777216) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $5 + (i32.or + (tee_local $7 + (i32.and + (get_local $5) + (i32.const 8388607) + ) + ) + (i32.const 1065353216) + ) + ) + (set_local $6 + (if (result i32) + (i32.le_s + (get_local $7) + (i32.const 1885297) + ) + (i32.const 0) + (if (result i32) + (i32.lt_s + (get_local $7) + (i32.const 6140887) + ) + (i32.const 1) + (block (result i32) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 8388608) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (tee_local $16 + (f32.mul + (tee_local $13 + (f32.sub + (tee_local $2 + (f32.reinterpret/i32 + (get_local $5) + ) + ) + (tee_local $0 + (select + (f32.const 1.5) + (f32.const 1) + (get_local $6) + ) + ) + ) + ) + (tee_local $14 + (f32.div + (f32.const 1) + (f32.add + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (set_local $2 + (f32.sub + (get_local $2) + (f32.sub + (tee_local $8 + (f32.reinterpret/i32 + (i32.add + (i32.add + (i32.or + (i32.and + (i32.shr_s + (get_local $5) + (i32.const 1) + ) + (i32.const -4096) + ) + (i32.const 536870912) + ) + (i32.const 4194304) + ) + (i32.shl + (get_local $6) + (i32.const 21) + ) + ) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $2 + (f32.sub + (tee_local $2 + (f32.add + (f32.mul + (f32.mul + (tee_local $12 + (f32.mul + (get_local $16) + (get_local $16) + ) + ) + (get_local $12) + ) + (f32.add + (f32.const 0.6000000238418579) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.4285714328289032) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.3333333432674408) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.2727281153202057) + (f32.mul + (get_local $12) + (f32.add + (f32.const 0.23066075146198273) + (f32.mul + (get_local $12) + (f32.const 0.20697501301765442) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (tee_local $0 + (f32.mul + (get_local $14) + (f32.sub + (f32.sub + (get_local $13) + (f32.mul + (get_local $3) + (get_local $8) + ) + ) + (f32.mul + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (f32.add + (get_local $3) + (get_local $16) + ) + ) + ) + ) + (f32.sub + (f32.sub + (tee_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (f32.add + (f32.const 3) + (tee_local $12 + (f32.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (get_local $2) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.const 3) + ) + (get_local $12) + ) + ) + ) + (set_local $8 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (f32.add + (f32.add + (tee_local $16 + (f32.mul + (f32.const 0.9619140625) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (tee_local $13 + (f32.mul + (get_local $3) + (get_local $8) + ) + ) + (tee_local $14 + (f32.add + (f32.mul + (get_local $0) + (get_local $8) + ) + (f32.mul + (get_local $2) + (get_local $16) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + ) + ) + (tee_local $2 + (f32.add + (f32.add + (f32.mul + (f32.const -1.1736857413779944e-04) + (get_local $0) + ) + (f32.mul + (f32.sub + (get_local $14) + (f32.sub + (get_local $0) + (get_local $13) + ) + ) + (f32.const 0.9617967009544373) + ) + ) + (select + (f32.const 1.5632208487659227e-06) + (f32.const 0) + (get_local $6) + ) + ) + ) + ) + (tee_local $0 + (select + (f32.const 0.5849609375) + (f32.const 0) + (get_local $6) + ) + ) + ) + (tee_local $3 + (f32.convert_s/i32 + (get_local $4) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.sub + (get_local $2) + (f32.sub + (f32.sub + (f32.sub + (get_local $8) + (get_local $3) + ) + (get_local $0) + ) + (get_local $16) + ) + ) + ) + ) + ) + (br_if $folding-inner1 + (i32.gt_s + (tee_local $7 + (i32.reinterpret/f32 + (tee_local $2 + (f32.add + (tee_local $1 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (get_local $1) + ) + (i32.const -4096) + ) + ) + ) + ) + (get_local $8) + ) + (f32.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (tee_local $0 + (f32.mul + (get_local $0) + (get_local $8) + ) + ) + ) + ) + ) + ) + (i32.const 1124073472) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1124073472) + ) + (br_if $folding-inner1 + (f32.gt + (f32.add + (get_local $1) + (f32.const 4.299566569443414e-08) + ) + (f32.sub + (get_local $2) + (get_local $0) + ) + ) + ) + (if + (i32.gt_s + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + (i32.const 1125515264) + ) + (br $folding-inner0) + (if + (i32.eq + (get_local $7) + (i32.const -1021968384) + ) + (br_if $folding-inner0 + (f32.le + (get_local $1) + (f32.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.shr_s + (tee_local $15 + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $4 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $15) + (i32.const 1056964608) + ) + (block + (set_local $6 + (i32.sub + (i32.shr_s + (i32.and + (tee_local $4 + (i32.add + (get_local $7) + (i32.shr_s + (i32.const 8388608) + (i32.add + (get_local $6) + (i32.const 1) + ) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (i32.and + (get_local $4) + (i32.xor + (i32.shr_s + (i32.const 8388607) + (get_local $6) + ) + (i32.const -1) + ) + ) + ) + ) + (set_local $4 + (i32.shr_s + (i32.or + (i32.and + (get_local $4) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (i32.sub + (i32.const 23) + (get_local $6) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 0) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + ) + (set_local $0 + (f32.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + (return + (f32.mul + (get_local $9) + (tee_local $2 + (if (result f32) + (i32.le_s + (i32.shr_s + (tee_local $7 + (i32.add + (i32.reinterpret/f32 + (tee_local $2 + (f32.sub + (f32.const 1) + (f32.sub + (f32.sub + (f32.div + (f32.mul + (tee_local $2 + (f32.add + (tee_local $13 + (f32.mul + (tee_local $3 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.add + (get_local $1) + (get_local $0) + ) + ) + (i32.const -32768) + ) + ) + ) + (f32.const 0.693145751953125) + ) + ) + (tee_local $14 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (f32.sub + (get_local $3) + (get_local $0) + ) + ) + (f32.const 0.6931471824645996) + ) + (f32.mul + (get_local $3) + (f32.const 1.4286065379565116e-06) + ) + ) + ) + ) + ) + (tee_local $8 + (f32.sub + (get_local $2) + (f32.mul + (tee_local $3 + (f32.mul + (get_local $2) + (get_local $2) + ) + ) + (f32.add + (f32.const 0.1666666716337204) + (f32.mul + (get_local $3) + (f32.add + (f32.const -2.7777778450399637e-03) + (f32.mul + (get_local $3) + (f32.add + (f32.const 6.61375597701408e-05) + (f32.mul + (get_local $3) + (f32.add + (f32.const -1.6533901998627698e-06) + (f32.mul + (get_local $3) + (f32.const 4.138136944220605e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f32.sub + (get_local $8) + (f32.const 2) + ) + ) + (f32.add + (tee_local $0 + (f32.sub + (get_local $14) + (f32.sub + (get_local $2) + (get_local $13) + ) + ) + ) + (f32.mul + (get_local $2) + (get_local $0) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + (i32.const 23) + ) + (i32.const 0) + ) + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $2) + (get_local $4) + ) + (f32.reinterpret/i32 + (get_local $7) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + (f32.mul + (f32.mul + (get_local $9) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 6 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 i64) (local $3 i32) (local $4 i64) @@ -431,383 +3575,31 @@ (get_local $0) ) ) - (func $fmodf (; 2 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 f32) - (local $8 i32) - (block $folding-inner0 - (set_local $4 - (i32.and - (i32.shr_u - (tee_local $2 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $6 - (i32.and - (i32.shr_u - (tee_local $5 - (i32.reinterpret/f32 - (get_local $1) - ) - ) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.and - (if (result i32) - (tee_local $3 - (i32.eqz - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - ) - (get_local $3) - (f32.ne - (tee_local $7 - (get_local $1) - ) - (get_local $7) - ) - ) - (i32.const 1) - ) - ) - (get_local $3) - (i32.eq - (get_local $4) - (i32.const 255) - ) - ) - (i32.const 1) - ) - (return - (f32.div - (f32.mul - (get_local $0) - (get_local $1) - ) - (f32.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i32.le_u - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - (block - (br_if $folding-inner0 - (i32.eq - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $5) - (i32.const 1) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (set_local $8 - (i32.and - (get_local $2) - (i32.const -2147483648) - ) - ) - (set_local $2 - (if (result i32) - (get_local $4) - (i32.or - (i32.and - (get_local $2) - (i32.const 8388607) - ) - (i32.const 8388608) - ) - (block (result i32) - (set_local $3 - (i32.shl - (get_local $2) - (i32.const 9) - ) - ) - (loop $continue|0 - (if - (i32.eqz - (i32.shr_u - (get_local $3) - (i32.const 31) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - (i32.shl - (get_local $2) - (i32.sub - (i32.const 1) - (get_local $4) - ) - ) - ) - ) - ) - (set_local $5 - (if (result i32) - (get_local $6) - (i32.or - (i32.and - (get_local $5) - (i32.const 8388607) - ) - (i32.const 8388608) - ) - (block (result i32) - (set_local $3 - (i32.shl - (get_local $5) - (i32.const 9) - ) - ) - (loop $continue|1 - (if - (i32.eqz - (i32.shr_u - (get_local $3) - (i32.const 31) - ) - ) - (block - (set_local $6 - (i32.sub - (get_local $6) - (i32.const 1) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - (i32.shl - (get_local $5) - (i32.sub - (i32.const 1) - (get_local $6) - ) - ) - ) - ) - ) - (loop $continue|2 - (if - (i32.gt_s - (get_local $4) - (get_local $6) - ) - (block - (if - (i32.eqz - (i32.shr_u - (tee_local $3 - (i32.sub - (get_local $2) - (get_local $5) - ) - ) - (i32.const 31) - ) - ) - (block - (br_if $folding-inner0 - (i32.eqz - (get_local $3) - ) - ) - (set_local $2 - (get_local $3) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - (if - (i32.eqz - (i32.shr_u - (tee_local $3 - (i32.sub - (get_local $2) - (get_local $5) - ) - ) - (i32.const 31) - ) - ) - (block - (br_if $folding-inner0 - (i32.eqz - (get_local $3) - ) - ) - (set_local $2 - (get_local $3) - ) - ) - ) - (loop $continue|3 - (if - (i32.eqz - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - (return - (f32.reinterpret/i32 - (i32.or - (tee_local $2 - (select - (i32.or - (i32.sub - (get_local $2) - (i32.const 8388608) - ) - (i32.shl - (get_local $4) - (i32.const 23) - ) - ) - (i32.shr_u - (get_local $2) - (i32.sub - (i32.const 1) - (get_local $4) - ) - ) - (i32.gt_s - (get_local $4) - (i32.const 0) - ) - ) - ) - (get_local $8) - ) - ) - ) - ) - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - (func $showcase/ANamespace.aNamespacedFunction (; 3 ;) (type $ii) (param $0 i32) (result i32) + (func $showcase/ANamespace.aNamespacedFunction (; 7 ;) (type $ii) (param $0 i32) (result i32) (get_local $0) ) - (func $showcase/addGeneric (; 4 ;) (type $iii) (param $0 i32) (param $1 i32) (result i32) + (func $showcase/addGeneric (; 8 ;) (type $iii) (param $0 i32) (param $1 i32) (result i32) (i32.add (get_local $0) (get_local $1) ) ) - (func $showcase/addGeneric (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func $showcase/addGeneric (; 9 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (f32.add (get_local $0) (get_local $1) ) ) - (func $showcase/addGeneric (; 6 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func $showcase/addGeneric (; 10 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (f64.add (get_local $0) (get_local $1) ) ) - (func $showcase/anExportedFunction (; 7 ;) (type $v) + (func $showcase/anExportedFunction (; 11 ;) (type $v) (nop) ) - (func $memcpy/memcpy (; 8 ;) (type $iiii) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $memcpy/memcpy (; 12 ;) (type $iiii) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) (local $4 i32) (local $5 i32) @@ -2390,18 +5182,18 @@ ) (get_local $5) ) - (func $showcase/ADerivedClass#set:aWildAccessorAppears (; 9 ;) (type $ifv) (param $0 i32) (param $1 f32) + (func $showcase/ADerivedClass#set:aWildAccessorAppears (; 13 ;) (type $ifv) (param $0 i32) (param $1 f32) (f32.store offset=4 (get_local $0) (get_local $1) ) ) - (func $showcase/ADerivedClass#get:aWildAccessorAppears (; 10 ;) (type $if) (param $0 i32) (result f32) + (func $showcase/ADerivedClass#get:aWildAccessorAppears (; 14 ;) (type $if) (param $0 i32) (result f32) (f32.load offset=4 (get_local $0) ) ) - (func $start (; 11 ;) (type $v) + (func $start (; 15 ;) (type $v) (local $0 f64) (local $1 f32) (local $2 i32) @@ -2810,6 +5602,14 @@ (i32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) (set_global $binary/b (i32.lt_s (get_global $binary/i) @@ -2870,6 +5670,16 @@ (i32.const 1) ) ) + (set_global $binary/i + (i32.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/i (i32.shl (get_global $binary/i) @@ -2972,6 +5782,14 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) (set_global $binary/b (i64.lt_s (get_global $binary/I) @@ -3038,6 +5856,16 @@ (i64.const 1) ) ) + (set_global $binary/I + (i64.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/I (i64.shl (get_global $binary/I) @@ -3134,6 +5962,18 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/b (f32.lt (get_global $binary/f) @@ -3194,6 +6034,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/f (f32.add (get_global $binary/f) @@ -3212,6 +6064,30 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/b (f64.lt (get_global $binary/F) @@ -3272,6 +6148,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/F (f64.add (get_global $binary/F) @@ -3290,6 +6178,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (if (i32.eqz (tee_local $2 @@ -4265,210 +7165,6 @@ (unreachable) ) ) - (if - (f64.eq - (tee_local $0 - (call $fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - ) - ) - (get_local $0) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 295) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f64.ne - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 296) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 2) - ) - (f64.const 1.2) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 297) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 3.7) - ) - (f64.const 1.8) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 298) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.eq - (tee_local $1 - (call $fmodf - (f32.const 1) - (f32.const nan:0x400000) - ) - ) - (get_local $1) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 300) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.ne - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 301) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 2) - ) - (f32.const 1.2000000476837158) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 302) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 3.700000047683716) - ) - (f32.const 1.7999999523162842) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 303) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f64.ne - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 305) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (f32.ne - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 306) - (i32.const 0) - ) - (unreachable) - ) - ) (if (i32.ne (call $showcase/ANamespace.aNamespacedFunction diff --git a/tests/compiler/showcase.untouched.wat b/tests/compiler/showcase.untouched.wat index 8582e03d..e94dcc3a 100644 --- a/tests/compiler/showcase.untouched.wat +++ b/tests/compiler/showcase.untouched.wat @@ -1,8 +1,12 @@ (module + (type $FFF (func (param f64 f64) (result f64))) + (type $F (func (result f64))) + (type $FiF (func (param f64 i32) (result f64))) + (type $fff (func (param f32 f32) (result f32))) + (type $f (func (result f32))) + (type $fif (func (param f32 i32) (result f32))) (type $iiiiv (func (param i32 i32 i32 i32))) (type $i (func (result i32))) - (type $FFF (func (param f64 f64) (result f64))) - (type $fff (func (param f32 f32) (result f32))) (type $ii (func (param i32) (result i32))) (type $iii (func (param i32 i32) (result i32))) (type $v (func)) @@ -67,7 +71,3593 @@ (export "anExportedFunction" (func $showcase/anExportedFunction)) (export "memory" (memory $0)) (start $start) - (func $fmod (; 1 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func "$(lib)/math/NativeMath.scalbn" (; 1 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.const 52) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 f64) + (local $20 f64) + (local $21 f64) + (local $22 f64) + (local $23 f64) + (local $24 i32) + (local $25 i32) + (local $26 f64) + (local $27 f64) + (local $28 f64) + (local $29 f64) + (local $30 f64) + (local $31 f64) + (local $32 f64) + (local $33 f64) + (local $34 f64) + (local $35 f64) + (local $36 f64) + (local $37 f64) + (local $38 i32) + (nop) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $7 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (set_local $8 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (i32.or + (get_local $8) + (get_local $6) + ) + (i32.const 0) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.gt_s + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $4) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.gt_s + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $10 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1128267776) + ) + (set_local $10 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1072693248) + ) + (block + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $8) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $11) + (i32.const 20) + ) + (block + (set_local $9 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + (get_local $6) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (set_local $9 + (i32.shr_s + (get_local $8) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + (get_local $8) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $4) + ) + (i32.const 0) + ) + (return + (f64.const nan:0x8000000000000) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (get_local $1) + (f64.const 0) + ) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (f64.const 0) + (f64.neg + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (set_local $13 + (get_local $12) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.const 1) + (get_local $13) + ) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $10) + ) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.sub + (get_local $13) + (get_local $13) + ) + (f64.sub + (get_local $13) + (get_local $13) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $13 + (f64.neg + (get_local $13) + ) + ) + ) + ) + ) + (return + (get_local $13) + ) + ) + ) + ) + (set_local $14 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 0) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $14 + (f64.const -1) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_s + (get_local $8) + (i32.const 1105199104) + ) + (block + (if + (i32.gt_s + (get_local $8) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (set_local $20 + (f64.sub + (get_local $12) + (f64.const 1) + ) + ) + (set_local $23 + (f64.mul + (f64.mul + (get_local $20) + (get_local $20) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $20) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $20) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $21 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $20) + ) + ) + (set_local $22 + (f64.sub + (f64.mul + (get_local $20) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $23) + (f64.const 1.4426950408889634) + ) + ) + ) + (set_local $15 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $22) + (f64.sub + (get_local $15) + (get_local $21) + ) + ) + ) + ) + (block + (nop) + (set_local $25 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1048576) + ) + (block + (set_local $12 + (f64.mul + (get_local $12) + (f64.const 9007199254740992) + ) + ) + (set_local $25 + (i32.sub + (get_local $25) + (i32.const 53) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.sub + (i32.shr_s + (get_local $7) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $24 + (i32.and + (get_local $7) + (i32.const 1048575) + ) + ) + (set_local $7 + (i32.or + (get_local $24) + (i32.const 1072693248) + ) + ) + (if + (i32.le_s + (get_local $24) + (i32.const 235662) + ) + (set_local $11 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 767610) + ) + (set_local $11 + (i32.const 1) + ) + (block + (set_local $11 + (i32.const 0) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.const 1) + ) + ) + (set_local $7 + (i32.sub + (get_local $7) + (i32.const 1048576) + ) + ) + ) + ) + ) + (set_local $12 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 32) + ) + ) + ) + ) + (set_local $32 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $11) + ) + ) + (set_local $21 + (f64.sub + (get_local $12) + (get_local $32) + ) + ) + (set_local $22 + (f64.div + (f64.const 1) + (f64.add + (get_local $12) + (get_local $32) + ) + ) + ) + (set_local $26 + (f64.mul + (get_local $21) + (get_local $22) + ) + ) + (set_local $28 + (get_local $26) + ) + (set_local $28 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $28) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $7) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $11) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $12) + (f64.sub + (get_local $30) + (get_local $32) + ) + ) + ) + (set_local $29 + (f64.mul + (get_local $22) + (f64.sub + (f64.sub + (get_local $21) + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (f64.mul + (get_local $28) + (get_local $31) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $26) + (get_local $26) + ) + ) + (set_local $19 + (f64.mul + (f64.mul + (get_local $27) + (get_local $27) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $27) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.add + (get_local $19) + (f64.mul + (get_local $29) + (f64.add + (get_local $28) + (get_local $26) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $28) + (get_local $28) + ) + ) + (set_local $30 + (f64.add + (f64.add + (f64.const 3) + (get_local $27) + ) + (get_local $19) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $30) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $19) + (f64.sub + (f64.sub + (get_local $30) + (f64.const 3) + ) + (get_local $27) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (get_local $29) + (get_local $30) + ) + (f64.mul + (get_local $31) + (get_local $26) + ) + ) + ) + (set_local $17 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $17 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $17) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.sub + (get_local $22) + (f64.sub + (get_local $17) + (get_local $21) + ) + ) + ) + (set_local $33 + (f64.mul + (f64.const 0.9617967009544373) + (get_local $17) + ) + ) + (set_local $34 + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $35 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $17) + ) + (f64.mul + (get_local $18) + (f64.const 0.9617966939259756) + ) + ) + (get_local $34) + ) + ) + (set_local $20 + (f64.convert_s/i32 + (get_local $25) + ) + ) + (set_local $36 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $15 + (f64.add + (f64.add + (f64.add + (get_local $33) + (get_local $35) + ) + (get_local $36) + ) + (get_local $20) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $35) + (f64.sub + (f64.sub + (f64.sub + (get_local $15) + (get_local $20) + ) + (get_local $36) + ) + (get_local $33) + ) + ) + ) + ) + ) + (set_local $37 + (get_local $1) + ) + (set_local $37 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $37) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (get_local $37) + ) + (get_local $15) + ) + (f64.mul + (get_local $1) + (get_local $16) + ) + ) + ) + (set_local $17 + (f64.mul + (get_local $37) + (get_local $15) + ) + ) + (set_local $13 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $38 + (i32.wrap/i64 + (get_local $2) + ) + ) + (if + (i32.ge_s + (get_local $24) + (i32.const 1083179008) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const 1083179008) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + (if + (f64.gt + (f64.add + (get_local $18) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const -1064252416) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (if + (f64.le + (get_local $18) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (set_local $38 + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $38) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $25 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $38) + (i32.const 1071644672) + ) + (block + (set_local $25 + (i32.add + (get_local $24) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $11) + (i32.const 1) + ) + ) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (i32.and + (get_local $25) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $20 + (f64.const 0) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $25) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $11) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $25 + (i32.shr_s + (i32.or + (i32.and + (get_local $25) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 0) + ) + (set_local $25 + (i32.sub + (i32.const 0) + (get_local $25) + ) + ) + ) + (set_local $17 + (f64.sub + (get_local $17) + (get_local $20) + ) + ) + ) + ) + (set_local $20 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $20) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $20) + (f64.const 0.6931471824645996) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (f64.sub + (get_local $18) + (f64.sub + (get_local $20) + (get_local $17) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $20) + (f64.const -1.904654299957768e-09) + ) + ) + ) + (set_local $13 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $23 + (f64.sub + (get_local $22) + (f64.sub + (get_local $13) + (get_local $21) + ) + ) + ) + (set_local $20 + (f64.mul + (get_local $13) + (get_local $13) + ) + ) + (set_local $15 + (f64.sub + (get_local $13) + (f64.mul + (get_local $20) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $20) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $20) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $20) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $20) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.sub + (f64.div + (f64.mul + (get_local $13) + (get_local $15) + ) + (f64.sub + (get_local $15) + (f64.const 2) + ) + ) + (f64.add + (get_local $23) + (f64.mul + (get_local $13) + (get_local $23) + ) + ) + ) + ) + (set_local $13 + (f64.sub + (f64.const 1) + (f64.sub + (get_local $19) + (get_local $13) + ) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 32) + ) + ) + ) + (set_local $24 + (i32.add + (get_local $24) + (i32.shl + (get_local $25) + (i32.const 20) + ) + ) + ) + (if + (i32.le_s + (i32.shr_s + (get_local $24) + (i32.const 20) + ) + (i32.const 0) + ) + (set_local $13 + (call "$(lib)/math/NativeMath.scalbn" + (get_local $13) + (get_local $25) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $24) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 3 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (local $9 i32) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $5 + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.and + (if (result i32) + (tee_local $8 + (i32.eq + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 0) + ) + ) + (get_local $8) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $8) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $9 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $2 + (i32.and + (get_local $2) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $9 + (i32.shl + (get_local $3) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $3 + (i32.and + (get_local $3) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $3 + (i32.or + (get_local $3) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (block $break|2 + (nop) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + ) + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $2 + (i32.sub + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (get_local $6) + ) + ) + (return + (f32.reinterpret/i32 + (get_local $2) + ) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 4 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (i32.const 127) + (get_local $1) + ) + (i32.const 23) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.pow" (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (local $15 f32) + (local $16 f32) + (local $17 f32) + (local $18 f32) + (local $19 f32) + (local $20 f32) + (local $21 f32) + (local $22 f32) + (local $23 i32) + (local $24 i32) + (local $25 f32) + (local $26 f32) + (local $27 f32) + (local $28 f32) + (local $29 f32) + (local $30 f32) + (local $31 f32) + (local $32 f32) + (local $33 f32) + (local $34 f32) + (local $35 f32) + (local $36 i32) + (nop) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (get_local $2) + (i32.const 2147483647) + ) + ) + (set_local $5 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 0) + ) + (return + (f32.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.gt_s + (get_local $4) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.gt_s + (get_local $5) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $7 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1266679808) + ) + (set_local $7 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1065353216) + ) + (block + (set_local $9 + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $8 + (i32.shr_s + (get_local $5) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $8) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + (get_local $5) + ) + (set_local $7 + (i32.sub + (i32.const 2) + (i32.and + (get_local $8) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1065353216) + ) + (return + (f32.const nan:0x400000) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 1065353216) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (get_local $1) + (f32.const 0) + ) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (f32.const 0) + (f32.neg + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1065353216) + ) + (return + (if (result f32) + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (get_local $0) + (f32.div + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1073741824) + ) + (return + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1056964608) + ) + (if + (i32.ge_s + (get_local $2) + (i32.const 0) + ) + (return + (f32.sqrt + (get_local $0) + ) + ) + ) + ) + (set_local $10 + (f32.abs + (get_local $0) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.and + (if (result i32) + (tee_local $6 + (i32.eq + (get_local $4) + (i32.const 2139095040) + ) + ) + (get_local $6) + (i32.eq + (get_local $4) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $6) + (i32.eq + (get_local $4) + (i32.const 1065353216) + ) + ) + (i32.const 1) + ) + (block + (set_local $11 + (get_local $10) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (set_local $11 + (f32.div + (f32.const 1) + (get_local $11) + ) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $4) + (i32.const 1065353216) + ) + (get_local $7) + ) + (i32.const 0) + ) + (set_local $11 + (f32.div + (f32.sub + (get_local $11) + (get_local $11) + ) + (f32.sub + (get_local $11) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1) + ) + (set_local $11 + (f32.neg + (get_local $11) + ) + ) + ) + ) + ) + (return + (get_local $11) + ) + ) + ) + (set_local $12 + (f32.const 1) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $7) + (i32.const 0) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $7) + (i32.const 1) + ) + (set_local $12 + (f32.const -1) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_s + (get_local $5) + (i32.const 1291845632) + ) + (block + (if + (i32.lt_s + (get_local $4) + (i32.const 1065353208) + ) + (return + (if (result f32) + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 1065353223) + ) + (return + (if (result f32) + (i32.gt_s + (get_local $3) + (i32.const 0) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + (set_local $17 + (f32.sub + (get_local $10) + (f32.const 1) + ) + ) + (set_local $20 + (f32.mul + (f32.mul + (get_local $17) + (get_local $17) + ) + (f32.sub + (f32.const 0.5) + (f32.mul + (get_local $17) + (f32.sub + (f32.const 0.3333333432674408) + (f32.mul + (get_local $17) + (f32.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $18 + (f32.mul + (f32.const 1.44268798828125) + (get_local $17) + ) + ) + (set_local $19 + (f32.sub + (f32.mul + (get_local $17) + (f32.const 7.052607543300837e-06) + ) + (f32.mul + (get_local $20) + (f32.const 1.4426950216293335) + ) + ) + ) + (set_local $13 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $13) + ) + ) + (set_local $13 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $14 + (f32.sub + (get_local $19) + (f32.sub + (get_local $13) + (get_local $18) + ) + ) + ) + ) + (block + (nop) + (set_local $23 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 8388608) + ) + (block + (set_local $10 + (f32.mul + (get_local $10) + (f32.const 16777216) + ) + ) + (set_local $23 + (i32.sub + (get_local $23) + (i32.const 24) + ) + ) + (set_local $4 + (i32.reinterpret/f32 + (get_local $10) + ) + ) + ) + ) + (set_local $23 + (i32.add + (get_local $23) + (i32.sub + (i32.shr_s + (get_local $4) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $8 + (i32.and + (get_local $4) + (i32.const 8388607) + ) + ) + (set_local $4 + (i32.or + (get_local $8) + (i32.const 1065353216) + ) + ) + (if + (i32.le_s + (get_local $8) + (i32.const 1885297) + ) + (set_local $9 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $8) + (i32.const 6140887) + ) + (set_local $9 + (i32.const 1) + ) + (block + (set_local $9 + (i32.const 0) + ) + (set_local $23 + (i32.add + (get_local $23) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 8388608) + ) + ) + ) + ) + ) + (set_local $10 + (f32.reinterpret/i32 + (get_local $4) + ) + ) + (set_local $30 + (select + (f32.const 1.5) + (f32.const 1) + (get_local $9) + ) + ) + (set_local $18 + (f32.sub + (get_local $10) + (get_local $30) + ) + ) + (set_local $19 + (f32.div + (f32.const 1) + (f32.add + (get_local $10) + (get_local $30) + ) + ) + ) + (set_local $16 + (f32.mul + (get_local $18) + (get_local $19) + ) + ) + (set_local $26 + (get_local $16) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $26) + ) + ) + (set_local $26 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $24 + (i32.or + (i32.and + (i32.shr_s + (get_local $4) + (i32.const 1) + ) + (i32.const -4096) + ) + (i32.const 536870912) + ) + ) + (set_local $28 + (f32.reinterpret/i32 + (i32.add + (i32.add + (get_local $24) + (i32.const 4194304) + ) + (i32.shl + (get_local $9) + (i32.const 21) + ) + ) + ) + ) + (set_local $29 + (f32.sub + (get_local $10) + (f32.sub + (get_local $28) + (get_local $30) + ) + ) + ) + (set_local $27 + (f32.mul + (get_local $19) + (f32.sub + (f32.sub + (get_local $18) + (f32.mul + (get_local $26) + (get_local $28) + ) + ) + (f32.mul + (get_local $26) + (get_local $29) + ) + ) + ) + ) + (set_local $25 + (f32.mul + (get_local $16) + (get_local $16) + ) + ) + (set_local $15 + (f32.mul + (f32.mul + (get_local $25) + (get_local $25) + ) + (f32.add + (f32.const 0.6000000238418579) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.4285714328289032) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.3333333432674408) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.2727281153202057) + (f32.mul + (get_local $25) + (f32.add + (f32.const 0.23066075146198273) + (f32.mul + (get_local $25) + (f32.const 0.20697501301765442) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $15 + (f32.add + (get_local $15) + (f32.mul + (get_local $27) + (f32.add + (get_local $26) + (get_local $16) + ) + ) + ) + ) + (set_local $25 + (f32.mul + (get_local $26) + (get_local $26) + ) + ) + (set_local $28 + (f32.add + (f32.add + (f32.const 3) + (get_local $25) + ) + (get_local $15) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $28) + ) + ) + (set_local $28 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $29 + (f32.sub + (get_local $15) + (f32.sub + (f32.sub + (get_local $28) + (f32.const 3) + ) + (get_local $25) + ) + ) + ) + (set_local $18 + (f32.mul + (get_local $26) + (get_local $28) + ) + ) + (set_local $19 + (f32.add + (f32.mul + (get_local $27) + (get_local $28) + ) + (f32.mul + (get_local $29) + (get_local $16) + ) + ) + ) + (set_local $21 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $21) + ) + ) + (set_local $21 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $22 + (f32.sub + (get_local $19) + (f32.sub + (get_local $21) + (get_local $18) + ) + ) + ) + (set_local $31 + (f32.mul + (f32.const 0.9619140625) + (get_local $21) + ) + ) + (set_local $32 + (select + (f32.const 1.5632208487659227e-06) + (f32.const 0) + (get_local $9) + ) + ) + (set_local $33 + (f32.add + (f32.add + (f32.mul + (f32.const -1.1736857413779944e-04) + (get_local $21) + ) + (f32.mul + (get_local $22) + (f32.const 0.9617967009544373) + ) + ) + (get_local $32) + ) + ) + (set_local $17 + (f32.convert_s/i32 + (get_local $23) + ) + ) + (set_local $34 + (select + (f32.const 0.5849609375) + (f32.const 0) + (get_local $9) + ) + ) + (set_local $13 + (f32.add + (f32.add + (f32.add + (get_local $31) + (get_local $33) + ) + (get_local $34) + ) + (get_local $17) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $13) + ) + ) + (set_local $13 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $14 + (f32.sub + (get_local $33) + (f32.sub + (f32.sub + (f32.sub + (get_local $13) + (get_local $17) + ) + (get_local $34) + ) + (get_local $31) + ) + ) + ) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $35 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -4096) + ) + ) + ) + (set_local $22 + (f32.add + (f32.mul + (f32.sub + (get_local $1) + (get_local $35) + ) + (get_local $13) + ) + (f32.mul + (get_local $1) + (get_local $14) + ) + ) + ) + (set_local $21 + (f32.mul + (get_local $35) + (get_local $13) + ) + ) + (set_local $11 + (f32.add + (get_local $22) + (get_local $21) + ) + ) + (set_local $8 + (i32.reinterpret/f32 + (get_local $11) + ) + ) + (if + (i32.gt_s + (get_local $8) + (i32.const 1124073472) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const 1124073472) + ) + (if + (f32.gt + (f32.add + (get_local $22) + (f32.const 4.299566569443414e-08) + ) + (f32.sub + (get_local $11) + (get_local $21) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1000000015047466219876688e6) + ) + (f32.const 1000000015047466219876688e6) + ) + ) + ) + (if + (i32.gt_s + (i32.and + (get_local $8) + (i32.const 2147483647) + ) + (i32.const 1125515264) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const -1021968384) + ) + (if + (f32.le + (get_local $22) + (f32.sub + (get_local $11) + (get_local $21) + ) + ) + (return + (f32.mul + (f32.mul + (get_local $12) + (f32.const 1.0000000031710769e-30) + ) + (f32.const 1.0000000031710769e-30) + ) + ) + ) + ) + ) + ) + ) + (set_local $36 + (i32.and + (get_local $8) + (i32.const 2147483647) + ) + ) + (set_local $9 + (i32.sub + (i32.shr_s + (get_local $36) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $23 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $36) + (i32.const 1056964608) + ) + (block + (set_local $23 + (i32.add + (get_local $8) + (i32.shr_s + (i32.const 8388608) + (i32.add + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + (set_local $9 + (i32.sub + (i32.shr_s + (i32.and + (get_local $23) + (i32.const 2147483647) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (set_local $17 + (f32.reinterpret/i32 + (i32.and + (get_local $23) + (i32.xor + (i32.shr_s + (i32.const 8388607) + (get_local $9) + ) + (i32.const -1) + ) + ) + ) + ) + (set_local $23 + (i32.shr_s + (i32.or + (i32.and + (get_local $23) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (i32.sub + (i32.const 23) + (get_local $9) + ) + ) + ) + (if + (i32.lt_s + (get_local $8) + (i32.const 0) + ) + (set_local $23 + (i32.sub + (i32.const 0) + (get_local $23) + ) + ) + ) + (set_local $21 + (f32.sub + (get_local $21) + (get_local $17) + ) + ) + ) + ) + (set_local $17 + (f32.add + (get_local $22) + (get_local $21) + ) + ) + (set_local $24 + (i32.reinterpret/f32 + (get_local $17) + ) + ) + (set_local $17 + (f32.reinterpret/i32 + (i32.and + (get_local $24) + (i32.const -32768) + ) + ) + ) + (set_local $18 + (f32.mul + (get_local $17) + (f32.const 0.693145751953125) + ) + ) + (set_local $19 + (f32.add + (f32.mul + (f32.sub + (get_local $22) + (f32.sub + (get_local $17) + (get_local $21) + ) + ) + (f32.const 0.6931471824645996) + ) + (f32.mul + (get_local $17) + (f32.const 1.4286065379565116e-06) + ) + ) + ) + (set_local $11 + (f32.add + (get_local $18) + (get_local $19) + ) + ) + (set_local $20 + (f32.sub + (get_local $19) + (f32.sub + (get_local $11) + (get_local $18) + ) + ) + ) + (set_local $17 + (f32.mul + (get_local $11) + (get_local $11) + ) + ) + (set_local $13 + (f32.sub + (get_local $11) + (f32.mul + (get_local $17) + (f32.add + (f32.const 0.1666666716337204) + (f32.mul + (get_local $17) + (f32.add + (f32.const -2.7777778450399637e-03) + (f32.mul + (get_local $17) + (f32.add + (f32.const 6.61375597701408e-05) + (f32.mul + (get_local $17) + (f32.add + (f32.const -1.6533901998627698e-06) + (f32.mul + (get_local $17) + (f32.const 4.138136944220605e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $15 + (f32.sub + (f32.div + (f32.mul + (get_local $11) + (get_local $13) + ) + (f32.sub + (get_local $13) + (f32.const 2) + ) + ) + (f32.add + (get_local $20) + (f32.mul + (get_local $11) + (get_local $20) + ) + ) + ) + ) + (set_local $11 + (f32.sub + (f32.const 1) + (f32.sub + (get_local $15) + (get_local $11) + ) + ) + ) + (set_local $8 + (i32.reinterpret/f32 + (get_local $11) + ) + ) + (set_local $8 + (i32.add + (get_local $8) + (i32.shl + (get_local $23) + (i32.const 23) + ) + ) + ) + (if + (i32.le_s + (i32.shr_s + (get_local $8) + (i32.const 23) + ) + (i32.const 0) + ) + (set_local $11 + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $11) + (get_local $23) + ) + ) + (set_local $11 + (f32.reinterpret/i32 + (get_local $8) + ) + ) + ) + (return + (f32.mul + (get_local $12) + (get_local $11) + ) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 6 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 i64) (local $3 i64) (local $4 i32) @@ -522,448 +4112,12 @@ ) ) ) - (func $fmodf (; 2 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 f32) - (local $8 i32) - (local $9 i32) - (set_local $2 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (set_local $3 - (i32.reinterpret/f32 - (get_local $1) - ) - ) - (set_local $4 - (i32.and - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $5 - (i32.and - (i32.shr_u - (get_local $3) - (i32.const 23) - ) - (i32.const 255) - ) - ) - (set_local $6 - (i32.and - (get_local $2) - (i32.const -2147483648) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $8 - (i32.and - (if (result i32) - (tee_local $8 - (i32.eq - (i32.shl - (get_local $3) - (i32.const 1) - ) - (i32.const 0) - ) - ) - (get_local $8) - (f32.ne - (tee_local $7 - (get_local $1) - ) - (get_local $7) - ) - ) - (i32.const 1) - ) - ) - (get_local $8) - (i32.eq - (get_local $4) - (i32.const 255) - ) - ) - (i32.const 1) - ) - (return - (f32.div - (f32.mul - (get_local $0) - (get_local $1) - ) - (f32.mul - (get_local $0) - (get_local $1) - ) - ) - ) - ) - (if - (i32.le_u - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (block - (if - (i32.eq - (i32.shl - (get_local $2) - (i32.const 1) - ) - (i32.shl - (get_local $3) - (i32.const 1) - ) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (return - (get_local $0) - ) - ) - ) - (nop) - (if - (i32.eqz - (get_local $4) - ) - (block - (block $break|0 - (set_local $9 - (i32.shl - (get_local $2) - (i32.const 9) - ) - ) - (loop $continue|0 - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $9 - (i32.shl - (get_local $9) - (i32.const 1) - ) - ) - (br $continue|0) - ) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - (block - (set_local $2 - (i32.and - (get_local $2) - (i32.shr_u - (i32.const -1) - (i32.const 9) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - ) - ) - (if - (i32.eqz - (get_local $5) - ) - (block - (block $break|1 - (set_local $9 - (i32.shl - (get_local $3) - (i32.const 9) - ) - ) - (loop $continue|1 - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (set_local $5 - (i32.sub - (get_local $5) - (i32.const 1) - ) - ) - (set_local $9 - (i32.shl - (get_local $9) - (i32.const 1) - ) - ) - (br $continue|1) - ) - ) - ) - ) - (set_local $3 - (i32.shl - (get_local $3) - (i32.add - (i32.sub - (i32.const 0) - (get_local $5) - ) - (i32.const 1) - ) - ) - ) - ) - (block - (set_local $3 - (i32.and - (get_local $3) - (i32.shr_u - (i32.const -1) - (i32.const 9) - ) - ) - ) - (set_local $3 - (i32.or - (get_local $3) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - ) - ) - (block $break|2 - (nop) - (loop $continue|2 - (if - (i32.gt_s - (get_local $4) - (get_local $5) - ) - (block - (block - (set_local $9 - (i32.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (if - (i32.eqz - (get_local $9) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - ) - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (br $continue|2) - ) - ) - ) - ) - (set_local $9 - (i32.sub - (get_local $2) - (get_local $3) - ) - ) - (if - (i32.eqz - (i32.shr_u - (get_local $9) - (i32.const 31) - ) - ) - (block - (if - (i32.eqz - (get_local $9) - ) - (return - (f32.mul - (f32.const 0) - (get_local $0) - ) - ) - ) - (set_local $2 - (get_local $9) - ) - ) - ) - (block $break|3 - (nop) - (loop $continue|3 - (if - (i32.eqz - (i32.shr_u - (get_local $2) - (i32.const 23) - ) - ) - (block - (set_local $4 - (i32.sub - (get_local $4) - (i32.const 1) - ) - ) - (set_local $2 - (i32.shl - (get_local $2) - (i32.const 1) - ) - ) - (br $continue|3) - ) - ) - ) - ) - (if - (i32.gt_s - (get_local $4) - (i32.const 0) - ) - (block - (set_local $2 - (i32.sub - (get_local $2) - (i32.shl - (i32.const 1) - (i32.const 23) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (i32.shl - (get_local $4) - (i32.const 23) - ) - ) - ) - ) - (set_local $2 - (i32.shr_u - (get_local $2) - (i32.add - (i32.sub - (i32.const 0) - (get_local $4) - ) - (i32.const 1) - ) - ) - ) - ) - (set_local $2 - (i32.or - (get_local $2) - (get_local $6) - ) - ) - (return - (f32.reinterpret/i32 - (get_local $2) - ) - ) - ) - (func $showcase/ANamespace.aNamespacedFunction (; 3 ;) (type $ii) (param $0 i32) (result i32) + (func $showcase/ANamespace.aNamespacedFunction (; 7 ;) (type $ii) (param $0 i32) (result i32) (return (get_local $0) ) ) - (func $showcase/addGeneric (; 4 ;) (type $iii) (param $0 i32) (param $1 i32) (result i32) + (func $showcase/addGeneric (; 8 ;) (type $iii) (param $0 i32) (param $1 i32) (result i32) (return (i32.add (get_local $0) @@ -971,7 +4125,7 @@ ) ) ) - (func $showcase/addGeneric (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func $showcase/addGeneric (; 9 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (return (f32.add (get_local $0) @@ -979,7 +4133,7 @@ ) ) ) - (func $showcase/addGeneric (; 6 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func $showcase/addGeneric (; 10 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (return (f64.add (get_local $0) @@ -987,9 +4141,9 @@ ) ) ) - (func $showcase/anExportedFunction (; 7 ;) (type $v) + (func $showcase/anExportedFunction (; 11 ;) (type $v) ) - (func $memcpy/memcpy (; 8 ;) (type $iiii) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $memcpy/memcpy (; 12 ;) (type $iiii) (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) (local $4 i32) (local $5 i32) @@ -2795,20 +5949,20 @@ (get_local $3) ) ) - (func $showcase/ADerivedClass#set:aWildAccessorAppears (; 9 ;) (type $ifv) (param $0 i32) (param $1 f32) + (func $showcase/ADerivedClass#set:aWildAccessorAppears (; 13 ;) (type $ifv) (param $0 i32) (param $1 f32) (f32.store offset=4 (get_local $0) (get_local $1) ) ) - (func $showcase/ADerivedClass#get:aWildAccessorAppears (; 10 ;) (type $if) (param $0 i32) (result f32) + (func $showcase/ADerivedClass#get:aWildAccessorAppears (; 14 ;) (type $if) (param $0 i32) (result f32) (return (f32.load offset=4 (get_local $0) ) ) ) - (func $start (; 11 ;) (type $v) + (func $start (; 15 ;) (type $v) (local $0 i32) (local $1 i64) (local $2 f32) @@ -3408,6 +6562,14 @@ (i32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) (drop (i32.shl (get_global $binary/i) @@ -3510,6 +6672,16 @@ (i32.const 1) ) ) + (set_global $binary/i + (i32.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i32 + (get_global $binary/i) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/i (i32.shl (get_global $binary/i) @@ -3672,6 +6844,14 @@ (i64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) (drop (i64.shl (get_global $binary/I) @@ -3774,6 +6954,16 @@ (i64.const 1) ) ) + (set_global $binary/I + (i64.trunc_s/f64 + (call "$(lib)/math/NativeMath.pow" + (f64.convert_s/i64 + (get_global $binary/I) + ) + (f64.const 1) + ) + ) + ) (set_global $binary/I (i64.shl (get_global $binary/I) @@ -3930,6 +7120,18 @@ (f32.const 1) ) ) + (drop + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/b (f32.lt (get_global $binary/f) @@ -3990,6 +7192,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (set_global $binary/f (f32.add (get_global $binary/f) @@ -4008,6 +7222,18 @@ (f32.const 1) ) ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.mod" + (get_global $binary/f) + (f32.const 1) + ) + ) + (set_global $binary/f + (call "$(lib)/math/NativeMathf.pow" + (get_global $binary/f) + (f32.const 1) + ) + ) (drop (f64.lt (get_global $binary/F) @@ -4068,6 +7294,18 @@ (f64.const 1) ) ) + (drop + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (drop + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/b (f64.lt (get_global $binary/F) @@ -4128,6 +7366,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (set_global $binary/F (f64.add (get_global $binary/F) @@ -4146,6 +7396,18 @@ (f64.const 1) ) ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.mod" + (get_global $binary/F) + (f64.const 1) + ) + ) + (set_global $binary/F + (call "$(lib)/math/NativeMath.pow" + (get_global $binary/F) + (f64.const 1) + ) + ) (drop (if (result i32) (i32.const 0) @@ -6668,222 +9930,6 @@ (unreachable) ) ) - (if - (i32.eqz - (f64.ne - (tee_local $3 - (call $fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - ) - ) - (get_local $3) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 295) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.eq - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 296) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 2) - ) - (f64.const 1.2) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 297) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.lt - (f64.sub - (call $fmod - (f64.const 9.2) - (f64.const 3.7) - ) - (f64.const 1.8) - ) - (f64.const 2.220446049250313e-16) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 298) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.ne - (tee_local $2 - (call $fmodf - (f32.const 1) - (f32.const nan:0x400000) - ) - ) - (get_local $2) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 300) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.eq - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 301) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 2) - ) - (f32.const 1.2000000476837158) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 302) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.lt - (f32.sub - (call $fmodf - (f32.const 9.199999809265137) - (f32.const 3.700000047683716) - ) - (f32.const 1.7999999523162842) - ) - (f32.const 1.1920928955078125e-07) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 303) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f64.eq - (call $fmod - (f64.const 1.5) - (f64.const 1) - ) - (f64.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 305) - (i32.const 0) - ) - (unreachable) - ) - ) - (if - (i32.eqz - (f32.eq - (call $fmodf - (f32.const 1.5) - (f32.const 1) - ) - (f32.const 0.5) - ) - ) - (block - (call $abort - (i32.const 0) - (i32.const 28) - (i32.const 306) - (i32.const 0) - ) - (unreachable) - ) - ) (drop (f64.ne (tee_local $3 diff --git a/tests/compiler/std/libm.optimized.wat b/tests/compiler/std/libm.optimized.wat new file mode 100644 index 00000000..c5a0d192 --- /dev/null +++ b/tests/compiler/std/libm.optimized.wat @@ -0,0 +1,6050 @@ +(module + (type $FF (func (param f64) (result f64))) + (type $FFF (func (param f64 f64) (result f64))) + (type $FiF (func (param f64 i32) (result f64))) + (type $Ff (func (param f64) (result f32))) + (global $std/libm/E f64 (f64.const 2.718281828459045)) + (global $std/libm/LN10 f64 (f64.const 2.302585092994046)) + (global $std/libm/LN2 f64 (f64.const 0.6931471805599453)) + (global $std/libm/LOG10E f64 (f64.const 0.4342944819032518)) + (global $std/libm/LOG2E f64 (f64.const 1.4426950408889634)) + (global $std/libm/PI f64 (f64.const 3.141592653589793)) + (global $std/libm/SQRT1_2 f64 (f64.const 0.7071067811865476)) + (global $std/libm/SQRT2 f64 (f64.const 1.4142135623730951)) + (memory $0 1) + (export "E" (global $std/libm/E)) + (export "LN10" (global $std/libm/LN10)) + (export "LN2" (global $std/libm/LN2)) + (export "LOG10E" (global $std/libm/LOG10E)) + (export "LOG2E" (global $std/libm/LOG2E)) + (export "PI" (global $std/libm/PI)) + (export "SQRT1_2" (global $std/libm/SQRT1_2)) + (export "SQRT2" (global $std/libm/SQRT2)) + (export "abs" (func $std/libm/abs)) + (export "acos" (func $std/libm/acos)) + (export "acosh" (func $std/libm/acosh)) + (export "asin" (func $std/libm/asin)) + (export "asinh" (func $std/libm/asinh)) + (export "atan" (func $std/libm/atan)) + (export "atanh" (func $std/libm/atanh)) + (export "atan2" (func $std/libm/atan2)) + (export "cbrt" (func $std/libm/cbrt)) + (export "ceil" (func $std/libm/ceil)) + (export "clz32" (func $std/libm/clz32)) + (export "cos" (func $std/libm/cos)) + (export "cosh" (func $std/libm/cosh)) + (export "exp" (func $std/libm/exp)) + (export "expm1" (func $std/libm/expm1)) + (export "floor" (func $std/libm/floor)) + (export "fround" (func $std/libm/fround)) + (export "hypot" (func $std/libm/hypot)) + (export "imul" (func $std/libm/imul)) + (export "log" (func $std/libm/log)) + (export "log10" (func $std/libm/log10)) + (export "log1p" (func $std/libm/log1p)) + (export "log2" (func $std/libm/log2)) + (export "max" (func $std/libm/max)) + (export "min" (func $std/libm/min)) + (export "pow" (func $std/libm/pow)) + (export "round" (func $std/libm/round)) + (export "sign" (func $std/libm/sign)) + (export "sin" (func $std/libm/cos)) + (export "sinh" (func $std/libm/sinh)) + (export "sqrt" (func $std/libm/sqrt)) + (export "tan" (func $std/libm/cos)) + (export "tanh" (func $std/libm/tanh)) + (export "trunc" (func $std/libm/trunc)) + (export "memory" (memory $0)) + (func "$(lib)/math/NativeMath.abs" (; 0 ;) (type $FF) (param $0 f64) (result f64) + (f64.abs + (get_local $0) + ) + ) + (func $std/libm/abs (; 1 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.abs" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.__R" (; 2 ;) (type $FF) (param $0 f64) (result f64) + (f64.div + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.16666666666666666) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.3255658186224009) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.20121253213486293) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.04005553450067941) + (f64.mul + (get_local $0) + (f64.add + (f64.const 7.915349942898145e-04) + (f64.mul + (get_local $0) + (f64.const 3.479331075960212e-05) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (f64.const 1) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.403394911734414) + (f64.mul + (get_local $0) + (f64.add + (f64.const 2.0209457602335057) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.6882839716054533) + (f64.mul + (get_local $0) + (f64.const 0.07703815055590194) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.acos" (; 3 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 i32) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (tee_local $4 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1072693248) + ) + (block + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + ) + (block + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 1012924416) + ) + (return + (f64.const 1.5707963267948966) + ) + ) + (return + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (get_local $0) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f64.mul + (f64.const 2) + (f64.sub + (f64.const 1.5707963267948966) + (f64.add + (tee_local $1 + (f64.sqrt + (tee_local $0 + (f64.mul + (f64.add + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + ) + ) + (f64.sub + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $0) + ) + (get_local $1) + ) + (f64.const 6.123233995736766e-17) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.const 2) + (f64.add + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (tee_local $1 + (f64.sqrt + (tee_local $0 + (f64.mul + (f64.sub + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.add + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $0) + ) + (get_local $1) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (f64.add + (get_local $1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (func $std/libm/acos (; 4 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.acos" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.log1p" (; 5 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 i64) + (local $8 f64) + (set_local $2 + (i32.const 1) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1071284858) + ) + ) + (get_local $6) + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $3) + (i32.const -1074790400) + ) + (block + (if + (f64.eq + (get_local $0) + (f64.const -1) + ) + (return + (f64.div + (get_local $0) + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 2034237440) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $3) + (i32.const -1076707644) + ) + (block + (set_local $2 + (i32.const 0) + ) + (set_local $1 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $2) + (block + (set_local $5 + (if (result f64) + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.shr_u + (tee_local $6 + (i32.add + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (i32.const 54) + ) + (f64.div + (select + (f64.sub + (f64.const 1) + (f64.sub + (tee_local $1 + (f64.reinterpret/i64 + (get_local $7) + ) + ) + (get_local $0) + ) + ) + (f64.sub + (get_local $0) + (f64.sub + (get_local $1) + (f64.const 1) + ) + ) + (i32.ge_s + (get_local $2) + (i32.const 2) + ) + ) + (get_local $1) + ) + (f64.const 0) + ) + ) + (set_local $1 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $6) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $7) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $4 + (f64.div + (get_local $1) + (f64.add + (f64.const 2) + (get_local $1) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $8) + ) + ) + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $4) + (f64.add + (tee_local $4 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $1) + ) + (get_local $1) + ) + ) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (f64.mul + (tee_local $0 + (f64.convert_s/i32 + (get_local $2) + ) + ) + (f64.const 1.9082149292705877e-10) + ) + (get_local $5) + ) + ) + (get_local $4) + ) + (get_local $1) + ) + (f64.mul + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + ) + (func "$(lib)/math/NativeMath.log" (; 6 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 f64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $5) + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $3) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 54) + ) + ) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.eq + (get_local $1) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $3) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $5) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $4 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $1) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $3) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $4) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $7 + (f64.div + (get_local $4) + (f64.add + (f64.const 2) + (get_local $4) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $8) + ) + ) + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $2) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (get_local $6) + ) + (get_local $4) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $2) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (func "$(lib)/math/NativeMath.acosh" (; 7 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (if + (i64.lt_u + (tee_local $1 + (i64.and + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (i64.const 1024) + ) + (return + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sqrt + (f64.add + (f64.mul + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.const 1049) + ) + (return + (call "$(lib)/math/NativeMath.log" + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (get_local $0) + (f64.sqrt + (f64.sub + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (func $std/libm/acosh (; 8 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.acosh" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.asin" (; 9 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1072693248) + ) + (block + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + ) + (return + (f64.add + (f64.mul + (get_local $0) + (f64.const 1.5707963267948966) + ) + (f64.const 7.52316384526264e-37) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $2) + (i32.const 1045430272) + ) + ) + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (get_local $3) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f64.sqrt + (tee_local $1 + (f64.mul + (f64.sub + (f64.const 1) + (f64.abs + (get_local $0) + ) + ) + (f64.const 0.5) + ) + ) + ) + ) + (set_local $4 + (call "$(lib)/math/NativeMath.__R" + (get_local $1) + ) + ) + (set_local $0 + (if (result f64) + (i32.ge_u + (get_local $2) + (i32.const 1072640819) + ) + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.mul + (f64.const 2) + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (get_local $4) + ) + ) + ) + (f64.const 6.123233995736766e-17) + ) + ) + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $4) + ) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (f64.const 2) + (f64.div + (f64.sub + (get_local $1) + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const -4294967296) + ) + ) + ) + (get_local $1) + ) + ) + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (f64.sub + (f64.const 0.7853981633974483) + (f64.mul + (f64.const 2) + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (get_local $0) + ) + (func $std/libm/asin (; 10 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.asin" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.asinh" (; 11 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (set_local $1 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (i64.and + (get_local $2) + (i64.const 9223372036854775807) + ) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 1049) + ) + (set_local $0 + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 1024) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 997) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (get_local $0) + (f64.div + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (i64.ne + (get_local $3) + (i64.const 0) + ) + ) + ) + (func $std/libm/asinh (; 12 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.asinh" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.atan" (; 13 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i32) + (local $4 i32) + (set_local $4 + (i32.shr_u + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (i32.const 1141899264) + ) + (block + (if + (f64.ne + (tee_local $1 + (get_local $0) + ) + (get_local $1) + ) + (return + (get_local $0) + ) + ) + (return + (select + (f64.neg + (tee_local $1 + (f64.const 1.5707963267948966) + ) + ) + (get_local $1) + (get_local $4) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $3) + (i32.const 1071382528) + ) + (block + (if + (i32.lt_u + (get_local $3) + (i32.const 1044381696) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f64.abs + (get_local $0) + ) + ) + (set_local $0 + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1072889856) + ) + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1072037888) + ) + (block (result f64) + (set_local $3 + (i32.const 0) + ) + (f64.div + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (f64.const 2) + (get_local $0) + ) + ) + ) + (block (result f64) + (set_local $3 + (i32.const 1) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.add + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1073971200) + ) + (block (result f64) + (set_local $3 + (i32.const 2) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.const 1.5) + ) + (f64.add + (f64.const 1) + (f64.mul + (f64.const 1.5) + (get_local $0) + ) + ) + ) + ) + (block (result f64) + (set_local $3 + (i32.const 3) + ) + (f64.div + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.mul + (tee_local $1 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (get_local $1) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.3333333333333293) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.14285714272503466) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.09090887133436507) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.06661073137387531) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.049768779946159324) + (f64.mul + (get_local $2) + (f64.const 0.016285820115365782) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.19999999999876483) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.11111110405462356) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.0769187620504483) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.058335701337905735) + (f64.mul + (get_local $2) + (f64.const -0.036531572744216916) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (block $tablify|0 + (br_table $case0|0 $case1|0 $case2|0 $case3|0 $tablify|0 + (get_local $3) + ) + ) + (br $case4|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.4636476090008061) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 2.2698777452961687e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 3.061616997868383e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.982793723247329) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 1.3903311031230998e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 6.123233995736766e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (unreachable) + ) + (select + (f64.neg + (get_local $1) + ) + (get_local $1) + (get_local $4) + ) + ) + (func $std/libm/atan (; 14 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.atanh" (; 15 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (set_local $2 + (i64.and + (i64.shr_u + (tee_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + ) + (if + (i64.lt_u + (get_local $2) + (i64.const 1022) + ) + (if + (i64.ge_u + (get_local $2) + (i64.const 991) + ) + (set_local $0 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.mul + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $0) + ) + (f64.sub + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.mul + (f64.const 2) + (f64.div + (get_local $0) + (f64.sub + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (i64.ne + (get_local $3) + (i64.const 0) + ) + ) + ) + (func $std/libm/atanh (; 16 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.atanh" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.atan2" (; 17 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 f64) + (local $7 i64) + (local $8 i32) + (block $folding-inner0 + (if + (i32.and + (if (result i32) + (tee_local $2 + (f64.ne + (tee_local $6 + (get_local $1) + ) + (get_local $6) + ) + ) + (get_local $2) + (f64.ne + (tee_local $6 + (get_local $0) + ) + (get_local $6) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $8 + (i32.wrap/i64 + (get_local $7) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $3) + (i32.const 1072693248) + ) + (get_local $8) + ) + ) + (return + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + ) + (set_local $5 + (i32.or + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (i32.or + (tee_local $4 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (i32.wrap/i64 + (get_local $7) + ) + ) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (if + (i32.eqz + (i32.or + (i32.eqz + (tee_local $2 + (get_local $5) + ) + ) + (i32.eq + (get_local $2) + (i32.const 1) + ) + ) + ) + (block + (br_if $case2|0 + (i32.eq + (get_local $2) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $2) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const -3.141592653589793) + ) + ) + ) + (br_if $folding-inner0 + (i32.eqz + (i32.or + (get_local $3) + (get_local $8) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 2146435072) + ) + (if + (i32.eq + (get_local $4) + (i32.const 2146435072) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (block $tablify|0 + (br_table $case0|1 $case1|1 $case2|1 $case3|1 $tablify|0 + (get_local $5) + ) + ) + (br $break|1) + ) + (return + (f64.const 0.7853981633974483) + ) + ) + (return + (f64.const -0.7853981633974483) + ) + ) + (return + (f64.const 2.356194490192345) + ) + ) + (return + (f64.const -2.356194490192345) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (block $tablify|00 + (br_table $case0|2 $case1|2 $case2|2 $case3|2 $tablify|00 + (get_local $5) + ) + ) + (br $break|2) + ) + (return + (f64.const 0) + ) + ) + (return + (f64.const -0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const -3.141592653589793) + ) + ) + ) + ) + (br_if $folding-inner0 + (i32.and + (if (result i32) + (tee_local $2 + (i32.lt_u + (i32.add + (get_local $3) + (i32.const 67108864) + ) + (get_local $4) + ) + ) + (get_local $2) + (i32.eq + (get_local $4) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (set_local $0 + (if (result f64) + (if (result i32) + (tee_local $2 + (i32.and + (get_local $5) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $4) + (i32.const 67108864) + ) + (get_local $3) + ) + (get_local $2) + ) + (f64.const 0) + (call "$(lib)/math/NativeMath.atan" + (f64.abs + (f64.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (block $tablify|01 + (br_table $case0|3 $case1|3 $case2|3 $case3|3 $tablify|01 + (get_local $5) + ) + ) + (br $break|3) + ) + (return + (get_local $0) + ) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (return + (f64.sub + (f64.const 3.141592653589793) + (f64.sub + (get_local $0) + (f64.const 1.2246467991473532e-16) + ) + ) + ) + ) + (return + (f64.sub + (f64.sub + (get_local $0) + (f64.const 1.2246467991473532e-16) + ) + (f64.const 3.141592653589793) + ) + ) + ) + (unreachable) + ) + (select + (f64.const -1.5707963267948966) + (f64.const 1.5707963267948966) + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + (func $std/libm/atan2 (; 18 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.atan2" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.cbrt" (; 19 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i32) + (local $4 i64) + (if + (i32.ge_u + (tee_local $3 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 2146435072) + ) + (return + (f64.add + (get_local $0) + (get_local $0) + ) + ) + ) + (set_local $3 + (if (result i32) + (i32.lt_u + (get_local $3) + (i32.const 1048576) + ) + (block (result i32) + (if + (i32.eqz + (tee_local $3 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + ) + (return + (get_local $0) + ) + ) + (i32.add + (i32.div_u + (get_local $3) + (i32.const 3) + ) + (i32.const 696219795) + ) + ) + (i32.add + (i32.div_u + (get_local $3) + (i32.const 3) + ) + (i32.const 715094163) + ) + ) + ) + (set_local $2 + (f64.mul + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.or + (i64.and + (get_local $4) + (i64.const -9223372036854775808) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 32) + ) + ) + ) + ) + (get_local $1) + ) + (f64.div + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $2 + (f64.div + (f64.sub + (tee_local $2 + (f64.div + (get_local $0) + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.add + (i64.reinterpret/f64 + (f64.mul + (get_local $1) + (f64.add + (f64.add + (f64.const 1.87595182427177) + (f64.mul + (get_local $2) + (f64.add + (f64.const -1.8849797954337717) + (f64.mul + (get_local $2) + (f64.const 1.6214297201053545) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.mul + (get_local $2) + (get_local $2) + ) + (get_local $2) + ) + (f64.add + (f64.const -0.758397934778766) + (f64.mul + (get_local $2) + (f64.const 0.14599619288661245) + ) + ) + ) + ) + ) + ) + (i64.const 2147483648) + ) + (i64.const -1073741824) + ) + ) + ) + (get_local $1) + ) + ) + ) + (get_local $1) + ) + (f64.add + (f64.add + (get_local $1) + (get_local $1) + ) + (get_local $2) + ) + ) + ) + (f64.add + (get_local $1) + (f64.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (func $std/libm/cbrt (; 20 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.cbrt" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.ceil" (; 21 ;) (type $FF) (param $0 f64) (result f64) + (f64.ceil + (get_local $0) + ) + ) + (func $std/libm/ceil (; 22 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.ceil" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.clz32" (; 23 ;) (type $FF) (param $0 f64) (result f64) + (f64.convert_s/i32 + (i32.clz + (i32.trunc_s/f64 + (get_local $0) + ) + ) + ) + ) + (func $std/libm/clz32 (; 24 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.clz32" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.cos" (; 25 ;) (type $FF) (param $0 f64) (result f64) + (unreachable) + ) + (func $std/libm/cos (; 26 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.cos" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.expm1" (; 27 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 f64) + (set_local $7 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + (i64.const 2147483647) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $6) + (i64.const 63) + ) + ) + ) + (if + (i32.ge_u + (get_local $7) + (i32.const 1078159482) + ) + (block + (if + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $5) + (return + (f64.const -1) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (return + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $7) + (i32.const 1071001154) + ) + (block + (if + (i32.lt_u + (get_local $7) + (i32.const 1072734898) + ) + (set_local $3 + (if (result f64) + (get_local $5) + (block (result f64) + (set_local $1 + (f64.const -1.9082149292705877e-10) + ) + (set_local $2 + (i32.const -1) + ) + (f64.add + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (block (result f64) + (set_local $1 + (f64.const 1.9082149292705877e-10) + ) + (set_local $2 + (i32.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (block + (set_local $3 + (f64.sub + (get_local $0) + (f64.mul + (tee_local $1 + (f64.convert_s/i32 + (tee_local $2 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (select + (f64.const -0.5) + (f64.const 0.5) + (get_local $5) + ) + ) + ) + ) + ) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (set_local $8 + (f64.sub + (f64.sub + (get_local $3) + (tee_local $0 + (f64.sub + (get_local $3) + (get_local $1) + ) + ) + ) + (get_local $1) + ) + ) + ) + (if + (i32.lt_u + (get_local $7) + (i32.const 1016070144) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $1 + (f64.sub + (f64.const 3) + (f64.mul + (tee_local $3 + (f64.add + (f64.const 1) + (f64.mul + (tee_local $4 + (f64.mul + (get_local $0) + (tee_local $1 + (f64.mul + (f64.const 0.5) + (get_local $0) + ) + ) + ) + ) + (f64.add + (f64.const -0.03333333333333313) + (f64.mul + (get_local $4) + (f64.add + (f64.const 1.5873015872548146e-03) + (f64.mul + (get_local $4) + (f64.add + (f64.const -7.93650757867488e-05) + (f64.mul + (get_local $4) + (f64.add + (f64.const 4.008217827329362e-06) + (f64.mul + (get_local $4) + (f64.const -2.0109921818362437e-07) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $1) + ) + ) + ) + (set_local $1 + (f64.mul + (get_local $4) + (f64.div + (f64.sub + (get_local $3) + (get_local $1) + ) + (f64.sub + (f64.const 6) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $2) + ) + (return + (f64.sub + (get_local $0) + (f64.sub + (f64.mul + (get_local $0) + (get_local $1) + ) + (get_local $4) + ) + ) + ) + ) + (set_local $1 + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.sub + (get_local $1) + (get_local $8) + ) + ) + (get_local $8) + ) + (get_local $4) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const -1) + ) + (return + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + (f64.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 1) + ) + (block + (if + (f64.lt + (get_local $0) + (f64.const -0.25) + ) + (return + (f64.mul + (f64.const -2) + (f64.sub + (get_local $1) + (f64.add + (get_local $0) + (f64.const 0.5) + ) + ) + ) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + ) + (get_local $5) + (i32.gt_s + (get_local $2) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + ) + (return + (f64.sub + (tee_local $0 + (select + (f64.mul + (f64.mul + (get_local $0) + (f64.const 2) + ) + (f64.const 8988465674311579538646525e283) + ) + (f64.mul + (get_local $0) + (get_local $3) + ) + (i32.eq + (get_local $2) + (i32.const 1024) + ) + ) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $6 + (i64.shl + (i64.sub + (i64.const 1023) + (i64.extend_u/i32 + (get_local $2) + ) + ) + (i64.const 52) + ) + ) + (tee_local $0 + (select + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.sub + (f64.const 1) + (f64.reinterpret/i64 + (get_local $6) + ) + ) + ) + (get_local $3) + ) + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (f64.add + (get_local $1) + (f64.reinterpret/i64 + (get_local $6) + ) + ) + ) + (f64.const 1) + ) + (get_local $3) + ) + (i32.lt_s + (get_local $2) + (i32.const 20) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.scalbn" (; 28 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $1) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.exp" (; 29 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 f64) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (set_local $4 + (i32.shr_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (i32.const 1082532651) + ) + (block + (if + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + (return + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (return + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + ) + (if + (f64.lt + (get_local $0) + (f64.const -745.1332191019411) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1071001154) + ) + (set_local $0 + (f64.sub + (tee_local $2 + (f64.sub + (get_local $0) + (f64.mul + (f64.convert_s/i32 + (tee_local $3 + (if (result i32) + (i32.ge_u + (get_local $1) + (i32.const 1072734898) + ) + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (f64.copysign + (f64.const 0.5) + (get_local $0) + ) + ) + ) + (i32.sub + (i32.sub + (i32.const 1) + (get_local $4) + ) + (get_local $4) + ) + ) + ) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (tee_local $5 + (f64.mul + (f64.convert_s/i32 + (get_local $3) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1043333120) + ) + (set_local $2 + (get_local $0) + ) + (return + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $0 + (f64.add + (f64.const 1) + (f64.add + (f64.sub + (f64.div + (f64.mul + (get_local $0) + (tee_local $0 + (f64.sub + (get_local $0) + (f64.mul + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $0) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $0) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $0) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.sub + (f64.const 2) + (get_local $0) + ) + ) + (get_local $5) + ) + (get_local $2) + ) + ) + ) + (if + (i32.eqz + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (call "$(lib)/math/NativeMath.scalbn" + (get_local $0) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.__expo2" (; 30 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (f64.mul + (f64.mul + (call "$(lib)/math/NativeMath.exp" + (f64.sub + (get_local $0) + (f64.const 1416.0996898839683) + ) + ) + (tee_local $1 + (f64.const 2247116418577894884661631e283) + ) + ) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.cosh" (; 31 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i64) + (set_local $0 + (f64.reinterpret/i64 + (tee_local $2 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.lt_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (i32.const 1072049730) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 1045430272) + ) + (return + (f64.const 1) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.div + (f64.mul + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + (get_local $0) + ) + (f64.mul + (f64.const 2) + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1082535490) + ) + (return + (f64.mul + (f64.const 0.5) + (f64.add + (tee_local $0 + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $0) + ) + ) + (func $std/libm/cosh (; 32 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.cosh" + (get_local $0) + ) + ) + (func $std/libm/exp (; 33 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + (func $std/libm/expm1 (; 34 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.floor" (; 35 ;) (type $FF) (param $0 f64) (result f64) + (f64.floor + (get_local $0) + ) + ) + (func $std/libm/floor (; 36 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.floor" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.fround" (; 37 ;) (type $Ff) (param $0 f64) (result f32) + (f32.demote/f64 + (get_local $0) + ) + ) + (func $std/libm/fround (; 38 ;) (type $Ff) (param $0 f64) (result f32) + (call "$(lib)/math/NativeMath.fround" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.hypot" (; 39 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 f64) + (local $4 i64) + (local $5 i64) + (local $6 f64) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i32) + (local $11 f64) + (if + (i64.lt_u + (tee_local $5 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 9223372036854775807) + ) + ) + (tee_local $4 + (i64.and + (i64.reinterpret/f64 + (get_local $1) + ) + (i64.const 9223372036854775807) + ) + ) + ) + (block + (set_local $9 + (get_local $5) + ) + (set_local $5 + (get_local $4) + ) + (set_local $4 + (get_local $9) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (get_local $4) + ) + ) + (if + (i32.eq + (tee_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 52) + ) + ) + ) + (i32.const 2047) + ) + (return + (get_local $1) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $5) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $10 + (i32.eq + (tee_local $8 + (i32.wrap/i64 + (i64.shr_u + (get_local $5) + (i64.const 52) + ) + ) + ) + (i32.const 2047) + ) + ) + (get_local $10) + (i64.eq + (get_local $4) + (i64.const 0) + ) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (if + (i32.gt_s + (i32.sub + (get_local $8) + (get_local $7) + ) + (i32.const 64) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $6 + (f64.const 1) + ) + (if + (i32.gt_s + (get_local $8) + (i32.const 1533) + ) + (block + (set_local $6 + (f64.const 5260135901548373507240989e186) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 1.90109156629516e-211) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.90109156629516e-211) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 573) + ) + (block + (set_local $6 + (f64.const 1.90109156629516e-211) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 5260135901548373507240989e186) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 5260135901548373507240989e186) + ) + ) + ) + ) + ) + (set_local $3 + (f64.sub + (get_local $0) + (tee_local $2 + (f64.add + (f64.sub + (get_local $0) + (tee_local $2 + (f64.mul + (get_local $0) + (f64.const 134217729) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (set_local $11 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $2) + (get_local $2) + ) + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (get_local $3) + ) + ) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (set_local $3 + (f64.sub + (get_local $1) + (tee_local $2 + (f64.add + (f64.sub + (get_local $1) + (tee_local $2 + (f64.mul + (get_local $1) + (f64.const 134217729) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (f64.mul + (get_local $6) + (f64.sqrt + (f64.add + (f64.add + (f64.add + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $2) + (get_local $2) + ) + (tee_local $1 + (f64.mul + (get_local $1) + (get_local $1) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (get_local $3) + ) + ) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (get_local $11) + ) + (get_local $1) + ) + (get_local $0) + ) + ) + ) + ) + (func $std/libm/hypot (; 40 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.hypot" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.imul" (; 41 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (f64.convert_s/i32 + (i32.mul + (i32.trunc_s/f64 + (get_local $0) + ) + (i32.trunc_s/f64 + (get_local $1) + ) + ) + ) + ) + (func $std/libm/imul (; 42 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.imul" + (get_local $0) + (get_local $1) + ) + ) + (func $std/libm/log (; 43 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.log10" (; 44 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $5) + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $4) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $4) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $5) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $1 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $4) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $7 + (f64.div + (get_local $1) + (f64.add + (f64.const 2) + (get_local $1) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $8) + ) + ) + (set_local $9 + (f64.mul + (tee_local $10 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (f64.const 0.30102999566361177) + ) + ) + (f64.add + (f64.add + (f64.add + (f64.add + (f64.mul + (get_local $10) + (f64.const 3.694239077158931e-13) + ) + (f64.mul + (f64.add + (tee_local $0 + (f64.add + (f64.sub + (f64.sub + (get_local $1) + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.sub + (get_local $1) + (get_local $6) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $1) + ) + (f64.const 2.5082946711645275e-11) + ) + ) + (f64.mul + (get_local $0) + (f64.const 0.4342944818781689) + ) + ) + (f64.add + (f64.sub + (get_local $9) + (tee_local $0 + (f64.add + (get_local $9) + (tee_local $1 + (f64.mul + (get_local $1) + (f64.const 0.4342944818781689) + ) + ) + ) + ) + ) + (get_local $1) + ) + ) + (get_local $0) + ) + ) + (func $std/libm/log10 (; 45 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.log10" + (get_local $0) + ) + ) + (func $std/libm/log1p (; 46 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.log1p" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.log2" (; 47 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 i64) + (local $7 f64) + (local $8 i32) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.lt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $8) + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $6) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 54) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $6) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $8) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.sub + (i32.shr_u + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $3 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $3) + ) + ) + (set_local $1 + (f64.mul + (tee_local $0 + (f64.mul + (tee_local $7 + (f64.div + (get_local $3) + (f64.add + (f64.const 2) + (get_local $3) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $0) + ) + ) + (set_local $4 + (f64.add + (f64.sub + (f64.sub + (get_local $3) + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.sub + (get_local $3) + (get_local $4) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $4) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $4) + (f64.add + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $1) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $1) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $1 + (f64.add + (tee_local $7 + (f64.convert_s/i32 + (get_local $5) + ) + ) + (tee_local $0 + (f64.mul + (get_local $3) + (f64.const 1.4426950407214463) + ) + ) + ) + ) + (f64.add + (f64.add + (f64.add + (f64.mul + (f64.add + (get_local $4) + (get_local $3) + ) + (f64.const 1.6751713164886512e-10) + ) + (f64.mul + (get_local $4) + (f64.const 1.4426950407214463) + ) + ) + (f64.add + (f64.sub + (get_local $7) + (get_local $1) + ) + (get_local $0) + ) + ) + (get_local $1) + ) + ) + (func $std/libm/log2 (; 48 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.log2" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.max" (; 49 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (f64.max + (get_local $0) + (get_local $1) + ) + ) + (func $std/libm/max (; 50 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.max" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.min" (; 51 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (f64.min + (get_local $0) + (get_local $1) + ) + ) + (func $std/libm/min (; 52 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.min" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 53 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 f64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 f64) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 i32) + (local $14 f64) + (local $15 i32) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 i64) + (block $folding-inner1 + (block $folding-inner0 + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (set_local $5 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (i32.or + (tee_local $10 + (i32.and + (tee_local $11 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (tee_local $6 + (i32.wrap/i64 + (get_local $19) + ) + ) + ) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.gt_s + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $13) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.gt_s + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1128267776) + ) + (set_local $15 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $10) + (i32.const 1072693248) + ) + (if + (i32.gt_s + (tee_local $8 + (i32.sub + (i32.shr_s + (get_local $10) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (i32.const 20) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 52) + (get_local $8) + ) + ) + (get_local $6) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (if + (i32.eq + (i32.shl + (tee_local $7 + (i32.shr_s + (get_local $10) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + (get_local $10) + ) + (set_local $15 + (i32.sub + (i32.const 2) + (i32.and + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $6) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 2146435072) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $13) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (get_local $1) + (f64.const 0) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + (return + (select + (f64.const 0) + (f64.neg + (get_local $1) + ) + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (return + (f64.const nan:0x8000000000000) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $11) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $11) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $4) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eqz + (get_local $13) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + ) + (get_local $7) + (i32.eqz + (get_local $5) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.eq + (get_local $5) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + (set_local $2 + (f64.div + (f64.const 1) + (get_local $2) + ) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (if + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $15) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $2 + (f64.div + (f64.sub + (get_local $2) + (get_local $2) + ) + (f64.sub + (get_local $2) + (get_local $2) + ) + ) + ) + ) + ) + (return + (get_local $2) + ) + ) + ) + ) + (set_local $12 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 0) + ) + (block + (if + (i32.eqz + (get_local $15) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $15) + (i32.const 1) + ) + (set_local $12 + (f64.const -1) + ) + ) + ) + ) + (set_local $2 + (if (result f64) + (i32.gt_s + (get_local $10) + (i32.const 1105199104) + ) + (block (result f64) + (if + (i32.gt_s + (get_local $10) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.const inf) + (f64.const 0) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1072693247) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.lt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $5) + (i32.const 1072693248) + ) + (return + (select + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + (i32.gt_s + (get_local $11) + (i32.const 0) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (f64.mul + (tee_local $3 + (f64.sub + (get_local $2) + (f64.const 1) + ) + ) + (get_local $3) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $3) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $3) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $3) + ) + ) + (tee_local $17 + (f64.sub + (f64.mul + (get_local $3) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $0) + (f64.const 1.4426950408889634) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $17) + (f64.sub + (get_local $9) + (get_local $16) + ) + ) + ) + (block (result f64) + (set_local $4 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 1048576) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 53) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.mul + (get_local $2) + (f64.const 9007199254740992) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $4 + (i32.add + (get_local $4) + (i32.sub + (i32.shr_s + (get_local $5) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $5 + (i32.or + (tee_local $6 + (i32.and + (get_local $5) + (i32.const 1048575) + ) + ) + (i32.const 1072693248) + ) + ) + (set_local $8 + (if (result i32) + (i32.le_s + (get_local $6) + (i32.const 235662) + ) + (i32.const 0) + (if (result i32) + (i32.lt_s + (get_local $6) + (i32.const 767610) + ) + (i32.const 1) + (block (result i32) + (set_local $4 + (i32.add + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1048576) + ) + ) + (i32.const 0) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (tee_local $18 + (f64.mul + (tee_local $16 + (f64.sub + (tee_local $2 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $5) + ) + (i64.const 32) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $8) + ) + ) + ) + ) + (tee_local $17 + (f64.div + (f64.const 1) + (f64.add + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $2 + (f64.sub + (get_local $2) + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $5) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $8) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (get_local $0) + ) + ) + ) + (set_local $2 + (f64.sub + (tee_local $2 + (f64.add + (f64.mul + (f64.mul + (tee_local $14 + (f64.mul + (get_local $18) + (get_local $18) + ) + ) + (get_local $14) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $14) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $14) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (tee_local $0 + (f64.mul + (get_local $17) + (f64.sub + (f64.sub + (get_local $16) + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (f64.mul + (get_local $3) + (get_local $2) + ) + ) + ) + ) + (f64.add + (get_local $3) + (get_local $18) + ) + ) + ) + ) + (f64.sub + (f64.sub + (tee_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.const 3) + (tee_local $14 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (get_local $2) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 3) + ) + (get_local $14) + ) + ) + ) + (set_local $9 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (f64.add + (f64.add + (tee_local $18 + (f64.mul + (f64.const 0.9617967009544373) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (tee_local $16 + (f64.mul + (get_local $3) + (get_local $9) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (get_local $0) + (get_local $9) + ) + (f64.mul + (get_local $2) + (get_local $18) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + ) + (tee_local $2 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $0) + ) + (f64.mul + (f64.sub + (get_local $17) + (f64.sub + (get_local $0) + (get_local $16) + ) + ) + (f64.const 0.9617966939259756) + ) + ) + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $8) + ) + ) + ) + ) + (tee_local $0 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $8) + ) + ) + ) + (tee_local $3 + (f64.convert_s/i32 + (get_local $4) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.sub + (get_local $2) + (f64.sub + (f64.sub + (f64.sub + (get_local $9) + (get_local $3) + ) + (get_local $0) + ) + (get_local $18) + ) + ) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (tee_local $19 + (i64.reinterpret/f64 + (tee_local $2 + (f64.add + (tee_local $1 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (tee_local $0 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $1) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $9) + ) + (f64.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $9) + ) + ) + ) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $13 + (i32.wrap/i64 + (get_local $19) + ) + ) + (if + (i32.ge_s + (get_local $6) + (i32.const 1083179008) + ) + (br_if $folding-inner1 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const 1083179008) + ) + (get_local $13) + ) + (f64.gt + (f64.add + (get_local $1) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (br_if $folding-inner0 + (i32.or + (i32.or + (i32.sub + (get_local $6) + (i32.const -1064252416) + ) + (get_local $13) + ) + (f64.le + (get_local $1) + (f64.sub + (get_local $2) + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $8 + (i32.sub + (i32.shr_s + (tee_local $13 + (i32.and + (get_local $6) + (i32.const 2147483647) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $4 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $13) + (i32.const 1071644672) + ) + (block + (set_local $8 + (i32.sub + (i32.shr_s + (i32.and + (tee_local $4 + (i32.add + (get_local $6) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $8) + (i32.const 1) + ) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $4) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $8) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.shr_s + (i32.or + (i32.and + (get_local $4) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $8) + ) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.const 0) + ) + (set_local $4 + (i32.sub + (i32.const 0) + (get_local $4) + ) + ) + ) + (set_local $0 + (f64.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + (return + (f64.mul + (get_local $12) + (tee_local $2 + (if (result f64) + (i32.le_s + (i32.shr_s + (tee_local $6 + (i32.add + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (tee_local $2 + (f64.sub + (f64.const 1) + (f64.sub + (f64.sub + (f64.div + (f64.mul + (tee_local $2 + (f64.add + (tee_local $16 + (f64.mul + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.add + (get_local $1) + (get_local $0) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.const 0.6931471824645996) + ) + ) + (tee_local $17 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (f64.sub + (get_local $3) + (get_local $0) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $3) + (f64.const -1.904654299957768e-09) + ) + ) + ) + ) + ) + (tee_local $9 + (f64.sub + (get_local $2) + (f64.mul + (tee_local $3 + (f64.mul + (get_local $2) + (get_local $2) + ) + ) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $3) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $3) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $3) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $3) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.sub + (get_local $9) + (f64.const 2) + ) + ) + (f64.add + (tee_local $0 + (f64.sub + (get_local $17) + (f64.sub + (get_local $2) + (get_local $16) + ) + ) + ) + (f64.mul + (get_local $2) + (get_local $0) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.shl + (get_local $4) + (i32.const 20) + ) + ) + ) + (i32.const 20) + ) + (i32.const 0) + ) + (call "$(lib)/math/NativeMath.scalbn" + (get_local $2) + (get_local $4) + ) + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $2) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 32) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (f64.mul + (f64.mul + (get_local $12) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + (func $std/libm/pow (; 54 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (call "$(lib)/math/NativeMath.pow" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.round" (; 55 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i64) + (local $3 i32) + (if + (i32.ge_s + (tee_local $3 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (i32.const 1075) + ) + (return + (get_local $0) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 1022) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (tee_local $1 + (if (result f64) + (i64.ne + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + (i64.const 0) + ) + (if (result f64) + (f64.ge + (tee_local $1 + (f64.add + (f64.sub + (f64.sub + (f64.const 4503599627370496) + (get_local $0) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (f64.const 0.5) + ) + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + (select + (f64.sub + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.lt + (get_local $1) + (f64.const -0.5) + ) + ) + ) + (if (result f64) + (f64.gt + (tee_local $1 + (f64.sub + (f64.sub + (f64.add + (get_local $0) + (f64.const 4503599627370496) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (f64.const 0.5) + ) + (f64.sub + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.const 1) + ) + (select + (f64.add + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.le + (get_local $1) + (f64.const -0.5) + ) + ) + ) + ) + ) + ) + (func $std/libm/round (; 56 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.round" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.sign" (; 57 ;) (type $FF) (param $0 f64) (result f64) + (select + (f64.const 1) + (select + (f64.const -1) + (get_local $0) + (f64.lt + (get_local $0) + (f64.const 0) + ) + ) + (f64.gt + (get_local $0) + (f64.const 0) + ) + ) + ) + (func $std/libm/sign (; 58 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.sign" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.sinh" (; 59 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i64) + (local $4 i32) + (set_local $2 + (f64.const 0.5) + ) + (if + (i64.ne + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 63) + ) + (i64.const 0) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (tee_local $3 + (i64.and + (get_local $3) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.lt_u + (tee_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $3) + (i64.const 32) + ) + ) + ) + (i32.const 1082535490) + ) + (block + (set_local $1 + (call "$(lib)/math/NativeMath.expm1" + (get_local $1) + ) + ) + (if + (i32.lt_u + (get_local $4) + (i32.const 1072693248) + ) + (block + (if + (i32.lt_u + (get_local $4) + (i32.const 1045430272) + ) + (return + (get_local $0) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.sub + (f64.mul + (f64.const 2) + (get_local $1) + ) + (f64.div + (f64.mul + (get_local $1) + (get_local $1) + ) + (f64.add + (get_local $1) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.add + (get_local $1) + (f64.div + (get_local $1) + (f64.add + (get_local $1) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $1) + ) + ) + ) + (func $std/libm/sinh (; 60 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.sinh" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.sqrt" (; 61 ;) (type $FF) (param $0 f64) (result f64) + (f64.sqrt + (get_local $0) + ) + ) + (func $std/libm/sqrt (; 62 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.sqrt" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.tanh" (; 63 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (tee_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 63) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (tee_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.gt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (i32.const 1071748074) + ) + (set_local $0 + (if (result f64) + (i32.gt_u + (get_local $2) + (i32.const 1077149696) + ) + (f64.sub + (f64.const 1) + (f64.div + (f64.const 0) + (get_local $0) + ) + ) + (f64.sub + (f64.const 1) + (f64.div + (f64.const 2) + (f64.add + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + (f64.const 2) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1070618798) + ) + (set_local $0 + (f64.div + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (f64.add + (get_local $0) + (f64.const 2) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (set_local $0 + (f64.div + (f64.neg + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const -2) + (get_local $0) + ) + ) + ) + ) + (f64.add + (get_local $0) + (f64.const 2) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (get_local $3) + ) + ) + (func $std/libm/tanh (; 64 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.tanh" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMath.trunc" (; 65 ;) (type $FF) (param $0 f64) (result f64) + (f64.trunc + (get_local $0) + ) + ) + (func $std/libm/trunc (; 66 ;) (type $FF) (param $0 f64) (result f64) + (call "$(lib)/math/NativeMath.trunc" + (get_local $0) + ) + ) +) diff --git a/tests/compiler/std/libm.ts b/tests/compiler/std/libm.ts new file mode 100644 index 00000000..6b1c62b6 --- /dev/null +++ b/tests/compiler/std/libm.ts @@ -0,0 +1,144 @@ +export const E = Math.E; +export const LN10 = Math.LN10; +export const LN2 = Math.LN2; +export const LOG10E = Math.LOG10E; +export const LOG2E = Math.LOG2E; +export const PI = Math.PI; +export const SQRT1_2 = Math.SQRT1_2; +export const SQRT2 = Math.SQRT2; + +export function abs(x: f64): f64 { + return Math.abs(x); +} + +export function acos(x: f64): f64 { + return Math.acos(x); +} + +export function acosh(x: f64): f64 { + return Math.acosh(x); +} + +export function asin(x: f64): f64 { + return Math.asin(x); +} + +export function asinh(x: f64): f64 { + return Math.asinh(x); +} + +export function atan(x: f64): f64 { + return Math.atan(x); +} + +export function atanh(x: f64): f64 { + return Math.atanh(x); +} + +export function atan2(y: f64, x: f64): f64 { + return Math.atan2(y, x); +} + +export function cbrt(x: f64): f64 { + return Math.cbrt(x); +} + +export function ceil(x: f64): f64 { + return Math.ceil(x); +} + +export function clz32(x: f64): f64 { + return Math.clz32(x); +} + +export function cos(x: f64): f64 { + return Math.cos(x); +} + +export function cosh(x: f64): f64 { + return Math.cosh(x); +} + +export function exp(x: f64): f64 { + return Math.exp(x); +} + +export function expm1(x: f64): f64 { + return Math.expm1(x); +} + +export function floor(x: f64): f64 { + return Math.floor(x); +} + +export function fround(x: f64): f32 { + return Math.fround(x); +} + +export function hypot(a: f64, b: f64): f64 { + return Math.hypot(a, b); +} + +export function imul(a: f64, b: f64): f64 { + return Math.imul(a, b); +} + +export function log(x: f64): f64 { + return Math.log(x); +} + +export function log10(x: f64): f64 { + return Math.log10(x); +} + +export function log1p(x: f64): f64 { + return Math.log1p(x); +} + +export function log2(x: f64): f64 { + return Math.log2(x); +} + +export function max(a: f64, b: f64): f64 { + return Math.max(a, b); +} + +export function min(a: f64, b: f64): f64 { + return Math.min(a, b); +} + +export function pow(x: f64, y: f64): f64 { + return Math.pow(x, y); +} + +export function round(x: f64): f64 { + return Math.round(x); +} + +export function sign(x: f64): f64 { + return Math.sign(x); +} + +export function sin(x: f64): f64 { + return Math.sin(x); +} + +export function sinh(x: f64): f64 { + return Math.sinh(x); +} + +export function sqrt(x: f64): f64 { + return Math.sqrt(x); +} + +export function tan(x: f64): f64 { + return Math.tan(x); +} + +export function tanh(x: f64): f64 { + return Math.tanh(x); +} + +export function trunc(x: f64): f64 { + return Math.trunc(x); +} diff --git a/tests/compiler/std/libm.untouched.wat b/tests/compiler/std/libm.untouched.wat new file mode 100644 index 00000000..8b1db308 --- /dev/null +++ b/tests/compiler/std/libm.untouched.wat @@ -0,0 +1,7194 @@ +(module + (type $F (func (result f64))) + (type $FF (func (param f64) (result f64))) + (type $f (func (result f32))) + (type $FFF (func (param f64 f64) (result f64))) + (type $i (func (result i32))) + (type $FiF (func (param f64 i32) (result f64))) + (type $Ff (func (param f64) (result f32))) + (global $std/libm/E f64 (f64.const 2.718281828459045)) + (global $std/libm/LN10 f64 (f64.const 2.302585092994046)) + (global $std/libm/LN2 f64 (f64.const 0.6931471805599453)) + (global $std/libm/LOG10E f64 (f64.const 0.4342944819032518)) + (global $std/libm/LOG2E f64 (f64.const 1.4426950408889634)) + (global $std/libm/PI f64 (f64.const 3.141592653589793)) + (global $std/libm/SQRT1_2 f64 (f64.const 0.7071067811865476)) + (global $std/libm/SQRT2 f64 (f64.const 1.4142135623730951)) + (global $HEAP_BASE i32 (i32.const 4)) + (memory $0 1) + (export "E" (global $std/libm/E)) + (export "LN10" (global $std/libm/LN10)) + (export "LN2" (global $std/libm/LN2)) + (export "LOG10E" (global $std/libm/LOG10E)) + (export "LOG2E" (global $std/libm/LOG2E)) + (export "PI" (global $std/libm/PI)) + (export "SQRT1_2" (global $std/libm/SQRT1_2)) + (export "SQRT2" (global $std/libm/SQRT2)) + (export "abs" (func $std/libm/abs)) + (export "acos" (func $std/libm/acos)) + (export "acosh" (func $std/libm/acosh)) + (export "asin" (func $std/libm/asin)) + (export "asinh" (func $std/libm/asinh)) + (export "atan" (func $std/libm/atan)) + (export "atanh" (func $std/libm/atanh)) + (export "atan2" (func $std/libm/atan2)) + (export "cbrt" (func $std/libm/cbrt)) + (export "ceil" (func $std/libm/ceil)) + (export "clz32" (func $std/libm/clz32)) + (export "cos" (func $std/libm/cos)) + (export "cosh" (func $std/libm/cosh)) + (export "exp" (func $std/libm/exp)) + (export "expm1" (func $std/libm/expm1)) + (export "floor" (func $std/libm/floor)) + (export "fround" (func $std/libm/fround)) + (export "hypot" (func $std/libm/hypot)) + (export "imul" (func $std/libm/imul)) + (export "log" (func $std/libm/log)) + (export "log10" (func $std/libm/log10)) + (export "log1p" (func $std/libm/log1p)) + (export "log2" (func $std/libm/log2)) + (export "max" (func $std/libm/max)) + (export "min" (func $std/libm/min)) + (export "pow" (func $std/libm/pow)) + (export "round" (func $std/libm/round)) + (export "sign" (func $std/libm/sign)) + (export "sin" (func $std/libm/sin)) + (export "sinh" (func $std/libm/sinh)) + (export "sqrt" (func $std/libm/sqrt)) + (export "tan" (func $std/libm/tan)) + (export "tanh" (func $std/libm/tanh)) + (export "trunc" (func $std/libm/trunc)) + (export "memory" (memory $0)) + (func "$(lib)/math/NativeMath.abs" (; 0 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.abs + (get_local $0) + ) + ) + ) + (func $std/libm/abs (; 1 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.abs" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.__R" (; 2 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (nop) + (set_local $1 + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.16666666666666666) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.3255658186224009) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.20121253213486293) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.04005553450067941) + (f64.mul + (get_local $0) + (f64.add + (f64.const 7.915349942898145e-04) + (f64.mul + (get_local $0) + (f64.const 3.479331075960212e-05) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.add + (f64.const 1) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.403394911734414) + (f64.mul + (get_local $0) + (f64.add + (f64.const 2.0209457602335057) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.6882839716054533) + (f64.mul + (get_local $0) + (f64.const 0.07703815055590194) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.div + (get_local $1) + (get_local $2) + ) + ) + ) + (func "$(lib)/math/NativeMath.acos" (; 3 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072693248) + ) + (block + (set_local $3 + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (get_local $3) + ) + (i32.const 0) + ) + (block + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.add + (f64.mul + (f64.const 2) + (f64.const 1.5707963267948966) + ) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 1012924416) + ) + (return + (f64.add + (f64.const 1.5707963267948966) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (get_local $0) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (nop) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (block + (set_local $6 + (f64.mul + (f64.add + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + (set_local $4 + (f64.sqrt + (get_local $6) + ) + ) + (set_local $5 + (f64.sub + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $6) + ) + (get_local $4) + ) + (f64.const 6.123233995736766e-17) + ) + ) + (return + (f64.mul + (f64.const 2) + (f64.sub + (f64.const 1.5707963267948966) + (f64.add + (get_local $4) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.sub + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + (set_local $4 + (f64.sqrt + (get_local $6) + ) + ) + (set_local $7 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $4) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $8 + (f64.div + (f64.sub + (get_local $6) + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (f64.add + (get_local $4) + (get_local $7) + ) + ) + ) + (set_local $5 + (f64.add + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $6) + ) + (get_local $4) + ) + (get_local $8) + ) + ) + (return + (f64.mul + (f64.const 2) + (f64.add + (get_local $7) + (get_local $5) + ) + ) + ) + ) + (func $std/libm/acos (; 4 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.acos" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.log1p" (; 5 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (block + (set_local $4 + (f64.const 0) + ) + (set_local $5 + (f64.const 0) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (get_local $2) + (i32.const 1071284858) + ) + ) + (get_local $6) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $2) + (i32.const -1074790400) + ) + (block + (if + (f64.eq + (get_local $0) + (f64.const -1) + ) + (return + (f64.div + (get_local $0) + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (i32.const 1017118720) + (i32.const 1) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $2) + (i32.const -1076707644) + ) + (block + (set_local $3 + (i32.const 0) + ) + (set_local $4 + (f64.const 0) + ) + (set_local $5 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $3) + (block + (set_local $1 + (i64.reinterpret/f64 + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.shr_u + (get_local $6) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 54) + ) + (block + (set_local $7 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (if (result f64) + (i32.ge_s + (get_local $3) + (i32.const 2) + ) + (f64.sub + (f64.const 1) + (f64.sub + (get_local $7) + (get_local $0) + ) + ) + (f64.sub + (get_local $0) + (f64.sub + (get_local $7) + (f64.const 1) + ) + ) + ) + ) + (set_local $4 + (f64.div + (get_local $4) + (get_local $7) + ) + ) + ) + (set_local $4 + (f64.const 0) + ) + ) + (set_local $6 + (i32.add + (i32.and + (get_local $6) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $5 + (f64.sub + (f64.reinterpret/i64 + (get_local $1) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $8 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $9 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (get_local $9) + ) + ) + (set_local $11 + (f64.mul + (get_local $10) + (get_local $10) + ) + ) + (set_local $12 + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $11) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $13 + (f64.mul + (get_local $10) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $11) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $14 + (f64.add + (get_local $13) + (get_local $12) + ) + ) + (set_local $15 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (return + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $9) + (f64.add + (get_local $8) + (get_local $14) + ) + ) + (f64.add + (f64.mul + (get_local $15) + (f64.const 1.9082149292705877e-10) + ) + (get_local $4) + ) + ) + (get_local $8) + ) + (get_local $5) + ) + (f64.mul + (get_local $15) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.log" (; 6 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 i32) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_s + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (get_local $3) + ) + (return + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $13) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (get_local $6) + ) + (get_local $5) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $13) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.acosh" (; 7 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (nop) + (set_local $1 + (i64.and + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.add + (i64.const 1023) + (i64.const 1) + ) + ) + (return + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sqrt + (f64.add + (f64.mul + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.add + (i64.const 1023) + (i64.const 26) + ) + ) + (return + (call "$(lib)/math/NativeMath.log" + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (get_local $0) + (f64.sqrt + (f64.sub + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + ) + (func $std/libm/acosh (; 8 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.acosh" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.asin" (; 9 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072693248) + ) + (block + (set_local $3 + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (get_local $3) + ) + (i32.const 0) + ) + (return + (f64.add + (f64.mul + (get_local $0) + (f64.const 1.5707963267948966) + ) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $2) + (i32.const 1045430272) + ) + ) + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (get_local $3) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.sub + (f64.const 1) + (f64.abs + (get_local $0) + ) + ) + (f64.const 0.5) + ) + ) + (set_local $5 + (f64.sqrt + (get_local $4) + ) + ) + (set_local $6 + (call "$(lib)/math/NativeMath.__R" + (get_local $4) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072640819) + ) + (set_local $0 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.mul + (f64.const 2) + (f64.add + (get_local $5) + (f64.mul + (get_local $5) + (get_local $6) + ) + ) + ) + (f64.const 6.123233995736766e-17) + ) + ) + ) + (block + (set_local $7 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $5) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $8 + (f64.div + (f64.sub + (get_local $4) + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (f64.add + (get_local $5) + (get_local $7) + ) + ) + ) + (set_local $0 + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.const 1.5707963267948966) + ) + (f64.sub + (f64.sub + (f64.mul + (f64.mul + (f64.const 2) + (get_local $5) + ) + (get_local $6) + ) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (f64.const 2) + (get_local $8) + ) + ) + ) + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.const 1.5707963267948966) + ) + (f64.mul + (f64.const 2) + (get_local $7) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + (func $std/libm/asin (; 10 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.asin" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.asinh" (; 11 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.add + (i64.const 1023) + (i64.const 26) + ) + ) + (set_local $0 + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.add + (i64.const 1023) + (i64.const 1) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 26) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (get_local $0) + (f64.div + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f64) + (i64.ne + (get_local $3) + (i64.const 0) + ) + (f64.neg + (get_local $0) + ) + (get_local $0) + ) + ) + ) + (func $std/libm/asinh (; 12 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.asinh" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.atan" (; 13 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 i32) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (nop) + (if + (i32.ge_u + (get_local $1) + (i32.const 1141899264) + ) + (block + (if + (f64.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (f64.add + (f64.const 1.5707963267948966) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $1) + (i32.const 1071382528) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 1044381696) + ) + (return + (get_local $0) + ) + ) + (set_local $5 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1072889856) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1072037888) + ) + (block + (set_local $5 + (i32.const 0) + ) + (set_local $0 + (f64.div + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (f64.const 2) + (get_local $0) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 1) + ) + (set_local $0 + (f64.div + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.add + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1073971200) + ) + (block + (set_local $5 + (i32.const 2) + ) + (set_local $0 + (f64.div + (f64.sub + (get_local $0) + (f64.const 1.5) + ) + (f64.add + (f64.const 1) + (f64.mul + (f64.const 1.5) + (get_local $0) + ) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 3) + ) + (set_local $0 + (f64.div + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $6 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (set_local $7 + (f64.mul + (get_local $3) + (f64.add + (f64.const 0.3333333333333293) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.14285714272503466) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.09090887133436507) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.06661073137387531) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.049768779946159324) + (f64.mul + (get_local $6) + (f64.const 0.016285820115365782) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.19999999999876483) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.11111110405462356) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.0769187620504483) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.058335701337905735) + (f64.mul + (get_local $6) + (f64.const -0.036531572744216916) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $9 + (get_local $5) + ) + (br_if $case0|0 + (i32.eq + (get_local $9) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $9) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $9) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $9) + (i32.const 3) + ) + ) + (br $case4|0) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.4636476090008061) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 2.2698777452961687e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 3.061616997868383e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.982793723247329) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 1.3903311031230998e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 6.123233995736766e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (unreachable) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + (func $std/libm/atan (; 14 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.atanh" (; 15 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (local $4 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $4 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (if + (i64.lt_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 1) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 32) + ) + ) + (set_local $4 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.mul + (f64.const 2) + (get_local $4) + ) + (f64.div + (f64.mul + (f64.mul + (f64.const 2) + (get_local $4) + ) + (get_local $4) + ) + (f64.sub + (f64.const 1) + (get_local $4) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.mul + (f64.const 2) + (f64.div + (get_local $4) + (f64.sub + (f64.const 1) + (get_local $4) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f64) + (i64.ne + (get_local $3) + (i64.const 0) + ) + (f64.neg + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (func $std/libm/atanh (; 16 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.atanh" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.atan2" (; 17 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 f64) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $3 + (f64.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + ) + (get_local $3) + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $4 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (get_local $4) + ) + ) + (set_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 32) + ) + ) + ) + (set_local $8 + (i32.wrap/i64 + (get_local $4) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $6) + ) + (i32.const 0) + ) + (return + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + ) + (set_local $9 + (i32.or + (i32.and + (i32.shr_u + (get_local $7) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.and + (i32.shr_u + (get_local $5) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $5 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (set_local $7 + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (i32.or + (get_local $7) + (get_local $8) + ) + (i32.const 0) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $3 + (get_local $9) + ) + (br_if $case0|0 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.neg + (f64.const 3.141592653589793) + ) + ) + ) + ) + (if + (i32.eq + (i32.or + (get_local $5) + (get_local $6) + ) + (i32.const 0) + ) + (return + (if (result f64) + (i32.and + (get_local $9) + (i32.const 1) + ) + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 2) + ) + (f64.div + (f64.const 3.141592653589793) + (f64.const 2) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + (if + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (set_local $3 + (get_local $9) + ) + (br_if $case0|1 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|1 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|1 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|1 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|1) + ) + (return + (f64.div + (f64.const 3.141592653589793) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.mul + (f64.const 3) + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.mul + (f64.const -3) + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (set_local $3 + (get_local $9) + ) + (br_if $case0|2 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|2 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|2 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|2 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|2) + ) + (return + (f64.const 0) + ) + ) + (return + (f64.const -0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.neg + (f64.const 3.141592653589793) + ) + ) + ) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (i32.add + (get_local $5) + (i32.shl + (i32.const 64) + (i32.const 20) + ) + ) + (get_local $7) + ) + ) + (get_local $3) + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + (return + (if (result f64) + (i32.and + (get_local $9) + (i32.const 1) + ) + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 2) + ) + (f64.div + (f64.const 3.141592653589793) + (f64.const 2) + ) + ) + ) + ) + (if + (if (result i32) + (tee_local $3 + (i32.and + (get_local $9) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $7) + (i32.shl + (i32.const 64) + (i32.const 20) + ) + ) + (get_local $5) + ) + (get_local $3) + ) + (set_local $10 + (f64.const 0) + ) + (set_local $10 + (call "$(lib)/math/NativeMath.atan" + (f64.abs + (f64.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (set_local $3 + (get_local $9) + ) + (br_if $case0|3 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|3 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|3 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|3 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|3) + ) + (return + (get_local $10) + ) + ) + (return + (f64.neg + (get_local $10) + ) + ) + ) + (return + (f64.sub + (f64.const 3.141592653589793) + (f64.sub + (get_local $10) + (f64.const 1.2246467991473532e-16) + ) + ) + ) + ) + (return + (f64.sub + (f64.sub + (get_local $10) + (f64.const 1.2246467991473532e-16) + ) + (f64.const 3.141592653589793) + ) + ) + ) + (unreachable) + (return + (f64.const 0) + ) + ) + (func $std/libm/atan2 (; 18 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.atan2" + (get_local $0) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.cbrt" (; 19 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (f64.add + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + (block + (set_local $1 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (set_local $2 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 696219795) + ) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 715094163) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.shl + (i64.const 1) + (i64.const 63) + ) + ) + ) + (set_local $1 + (i64.or + (get_local $1) + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (get_local $3) + (get_local $3) + ) + (f64.div + (get_local $3) + (get_local $0) + ) + ) + ) + (set_local $3 + (f64.mul + (get_local $3) + (f64.add + (f64.add + (f64.const 1.87595182427177) + (f64.mul + (get_local $4) + (f64.add + (f64.const -1.8849797954337717) + (f64.mul + (get_local $4) + (f64.const 1.6214297201053545) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.mul + (get_local $4) + (get_local $4) + ) + (get_local $4) + ) + (f64.add + (f64.const -0.758397934778766) + (f64.mul + (get_local $4) + (f64.const 0.14599619288661245) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.add + (i64.reinterpret/f64 + (get_local $3) + ) + (i64.const 2147483648) + ) + (i64.const -1073741824) + ) + ) + ) + (set_local $5 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (set_local $4 + (f64.div + (get_local $0) + (get_local $5) + ) + ) + (set_local $6 + (f64.add + (get_local $3) + (get_local $3) + ) + ) + (set_local $4 + (f64.div + (f64.sub + (get_local $4) + (get_local $3) + ) + (f64.add + (get_local $6) + (get_local $4) + ) + ) + ) + (set_local $3 + (f64.add + (get_local $3) + (f64.mul + (get_local $3) + (get_local $4) + ) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/libm/cbrt (; 20 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.cbrt" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.ceil" (; 21 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.ceil + (get_local $0) + ) + ) + ) + (func $std/libm/ceil (; 22 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.ceil" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.clz32" (; 23 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.convert_s/i32 + (i32.clz + (i32.trunc_s/f64 + (get_local $0) + ) + ) + ) + ) + ) + (func $std/libm/clz32 (; 24 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.clz32" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.cos" (; 25 ;) (type $FF) (param $0 f64) (result f64) + (unreachable) + (return + (f64.const 0) + ) + ) + (func $std/libm/cos (; 26 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.cos" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.expm1" (; 27 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 i32) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + (i64.const 2147483647) + ) + ) + ) + (block + (set_local $3 + (i32.const 0) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1078159482) + ) + (block + (if + (f64.ne + (tee_local $5 + (get_local $0) + ) + (get_local $5) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $4) + (return + (f64.const -1) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (block + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + (return + (get_local $0) + ) + ) + ) + ) + ) + (set_local $6 + (f64.const 0) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1071001154) + ) + (block + (nop) + (if + (i32.lt_u + (get_local $2) + (i32.const 1072734898) + ) + (if + (i32.eqz + (get_local $4) + ) + (block + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (set_local $8 + (f64.const 1.9082149292705877e-10) + ) + (set_local $3 + (i32.const 1) + ) + ) + (block + (set_local $5 + (f64.add + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (set_local $8 + (f64.neg + (f64.const 1.9082149292705877e-10) + ) + ) + (set_local $3 + (i32.const -1) + ) + ) + ) + (block + (set_local $3 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (if (result f64) + (get_local $4) + (f64.const -0.5) + (f64.const 0.5) + ) + ) + ) + ) + (set_local $7 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.mul + (get_local $7) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (set_local $0 + (f64.sub + (get_local $5) + (get_local $8) + ) + ) + (set_local $6 + (f64.sub + (f64.sub + (get_local $5) + (get_local $0) + ) + (get_local $8) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1016070144) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $9 + (f64.mul + (f64.const 0.5) + (get_local $0) + ) + ) + (set_local $10 + (f64.mul + (get_local $0) + (get_local $9) + ) + ) + (set_local $11 + (f64.add + (f64.const 1) + (f64.mul + (get_local $10) + (f64.add + (f64.const -0.03333333333333313) + (f64.mul + (get_local $10) + (f64.add + (f64.const 1.5873015872548146e-03) + (f64.mul + (get_local $10) + (f64.add + (f64.const -7.93650757867488e-05) + (f64.mul + (get_local $10) + (f64.add + (f64.const 4.008217827329362e-06) + (f64.mul + (get_local $10) + (f64.const -2.0109921818362437e-07) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $7 + (f64.sub + (f64.const 3) + (f64.mul + (get_local $11) + (get_local $9) + ) + ) + ) + (set_local $12 + (f64.mul + (get_local $10) + (f64.div + (f64.sub + (get_local $11) + (get_local $7) + ) + (f64.sub + (f64.const 6) + (f64.mul + (get_local $0) + (get_local $7) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.sub + (f64.mul + (get_local $0) + (get_local $12) + ) + (get_local $10) + ) + ) + ) + ) + (set_local $12 + (f64.sub + (f64.mul + (get_local $0) + (f64.sub + (get_local $12) + (get_local $6) + ) + ) + (get_local $6) + ) + ) + (set_local $12 + (f64.sub + (get_local $12) + (get_local $10) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const -1) + ) + (return + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.sub + (get_local $0) + (get_local $12) + ) + ) + (f64.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1) + ) + (block + (if + (f64.lt + (get_local $0) + (f64.const -0.25) + ) + (return + (f64.mul + (f64.const -2) + (f64.sub + (get_local $12) + (f64.add + (get_local $0) + (f64.const 0.5) + ) + ) + ) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (get_local $12) + ) + ) + ) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $3) + ) + ) + (i64.const 52) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $15 + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + ) + (get_local $15) + (i32.gt_s + (get_local $3) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $14 + (f64.add + (f64.sub + (get_local $0) + (get_local $12) + ) + (f64.const 1) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1024) + ) + (set_local $14 + (f64.mul + (f64.mul + (get_local $14) + (f64.const 2) + ) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $14 + (f64.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (return + (f64.sub + (get_local $14) + (f64.const 1) + ) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.sub + (i64.const 1023) + (i64.extend_u/i32 + (get_local $3) + ) + ) + (i64.const 52) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 20) + ) + (set_local $14 + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (get_local $12) + ) + (f64.sub + (f64.const 1) + (f64.reinterpret/i64 + (get_local $1) + ) + ) + ) + (get_local $13) + ) + ) + (set_local $14 + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (f64.add + (get_local $12) + (f64.reinterpret/i64 + (get_local $1) + ) + ) + ) + (f64.const 1) + ) + (get_local $13) + ) + ) + ) + (return + (get_local $14) + ) + ) + (func "$(lib)/math/NativeMath.scalbn" (; 28 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.const 52) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.exp" (; 29 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 1082532651) + ) + (block + (if + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (block + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + (return + (get_local $0) + ) + ) + ) + (if + (f64.lt + (get_local $0) + (f64.const -745.1332191019411) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $5 + (f64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1071001154) + ) + (block + (if + (i32.ge_u + (get_local $1) + (i32.const 1072734898) + ) + (set_local $6 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (f64.copysign + (f64.const 0.5) + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.sub + (i32.const 1) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + (set_local $4 + (f64.sub + (get_local $0) + (f64.mul + (f64.convert_s/i32 + (get_local $6) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $5 + (f64.mul + (f64.convert_s/i32 + (get_local $6) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (set_local $0 + (f64.sub + (get_local $4) + (get_local $5) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1043333120) + ) + (set_local $4 + (get_local $0) + ) + (return + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $7 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $8 + (f64.sub + (get_local $0) + (f64.mul + (get_local $7) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $7) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $7) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $7) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $7) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $9 + (f64.add + (f64.const 1) + (f64.add + (f64.sub + (f64.div + (f64.mul + (get_local $0) + (get_local $8) + ) + (f64.sub + (f64.const 2) + (get_local $8) + ) + ) + (get_local $5) + ) + (get_local $4) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (return + (get_local $9) + ) + ) + (return + (call "$(lib)/math/NativeMath.scalbn" + (get_local $9) + (get_local $6) + ) + ) + ) + (func "$(lib)/math/NativeMath.__expo2" (; 30 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (nop) + (set_local $1 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.shl + (i32.add + (i32.const 1023) + (i32.div_u + (i32.const 2043) + (i32.const 2) + ) + ) + (i32.const 20) + ) + ) + (i64.const 32) + ) + ) + ) + (return + (f64.mul + (f64.mul + (call "$(lib)/math/NativeMath.exp" + (f64.sub + (get_local $0) + (f64.const 1416.0996898839683) + ) + ) + (get_local $1) + ) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.cosh" (; 31 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $2) + (i32.const 1072049730) + ) + (block + (if + (i32.lt_u + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.shl + (i32.const 26) + (i32.const 20) + ) + ) + ) + (return + (f64.const 1) + ) + ) + (set_local $3 + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.div + (f64.mul + (get_local $3) + (get_local $3) + ) + (f64.mul + (f64.const 2) + (f64.add + (f64.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1082535490) + ) + (block + (set_local $3 + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + (return + (f64.mul + (f64.const 0.5) + (f64.add + (get_local $3) + (f64.div + (f64.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (set_local $3 + (call "$(lib)/math/NativeMath.__expo2" + (get_local $0) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/libm/cosh (; 32 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.cosh" + (get_local $0) + ) + ) + ) + (func $std/libm/exp (; 33 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + ) + (func $std/libm/expm1 (; 34 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.floor" (; 35 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.floor + (get_local $0) + ) + ) + ) + (func $std/libm/floor (; 36 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.floor" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.fround" (; 37 ;) (type $Ff) (param $0 f64) (result f32) + (return + (f32.demote/f64 + (get_local $0) + ) + ) + ) + (func $std/libm/fround (; 38 ;) (type $Ff) (param $0 f64) (result f32) + (return + (call "$(lib)/math/NativeMath.fround" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.hypot" (; 39 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (nop) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $2 + (i64.and + (get_local $2) + (i64.const 9223372036854775807) + ) + ) + (set_local $3 + (i64.and + (get_local $3) + (i64.const 9223372036854775807) + ) + ) + (if + (i64.lt_u + (get_local $2) + (get_local $3) + ) + (block + (set_local $4 + (get_local $2) + ) + (set_local $2 + (get_local $3) + ) + (set_local $3 + (get_local $4) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (get_local $3) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 2047) + ) + (return + (get_local $1) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $2) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2047) + ) + ) + (get_local $7) + (i64.eq + (get_local $3) + (i64.const 0) + ) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (if + (i32.gt_s + (i32.sub + (get_local $5) + (get_local $6) + ) + (i32.const 64) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $8 + (f64.const 1) + ) + (if + (i32.gt_s + (get_local $5) + (i32.add + (i32.const 1023) + (i32.const 510) + ) + ) + (block + (set_local $8 + (f64.const 5260135901548373507240989e186) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 1.90109156629516e-211) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.90109156629516e-211) + ) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.sub + (i32.const 1023) + (i32.const 450) + ) + ) + (block + (set_local $8 + (f64.const 1.90109156629516e-211) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 5260135901548373507240989e186) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 5260135901548373507240989e186) + ) + ) + ) + ) + ) + (set_local $9 + (f64.mul + (get_local $0) + (f64.const 134217729) + ) + ) + (set_local $10 + (f64.add + (f64.sub + (get_local $0) + (get_local $9) + ) + (get_local $9) + ) + ) + (set_local $11 + (f64.sub + (get_local $0) + (get_local $10) + ) + ) + (set_local $12 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $13 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $10) + (get_local $10) + ) + (get_local $12) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $10) + ) + (get_local $11) + ) + ) + (f64.mul + (get_local $11) + (get_local $11) + ) + ) + ) + (set_local $9 + (f64.mul + (get_local $1) + (f64.const 134217729) + ) + ) + (set_local $10 + (f64.add + (f64.sub + (get_local $1) + (get_local $9) + ) + (get_local $9) + ) + ) + (set_local $11 + (f64.sub + (get_local $1) + (get_local $10) + ) + ) + (set_local $14 + (f64.mul + (get_local $1) + (get_local $1) + ) + ) + (set_local $15 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $10) + (get_local $10) + ) + (get_local $14) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $10) + ) + (get_local $11) + ) + ) + (f64.mul + (get_local $11) + (get_local $11) + ) + ) + ) + (return + (f64.mul + (get_local $8) + (f64.sqrt + (f64.add + (f64.add + (f64.add + (get_local $15) + (get_local $13) + ) + (get_local $14) + ) + (get_local $12) + ) + ) + ) + ) + ) + (func $std/libm/hypot (; 40 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.hypot" + (get_local $0) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.imul" (; 41 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (f64.convert_s/i32 + (i32.mul + (i32.trunc_s/f64 + (get_local $0) + ) + (i32.trunc_s/f64 + (get_local $1) + ) + ) + ) + ) + ) + (func $std/libm/imul (; 42 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.imul" + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/libm/log (; 43 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.log10" (; 44 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (f64.sub + (get_local $5) + (get_local $6) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const -4294967296) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $14 + (f64.add + (f64.sub + (f64.sub + (get_local $5) + (get_local $13) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + ) + ) + (set_local $15 + (f64.mul + (get_local $13) + (f64.const 0.4342944818781689) + ) + ) + (set_local $16 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $17 + (f64.mul + (get_local $16) + (f64.const 0.30102999566361177) + ) + ) + (set_local $18 + (f64.add + (f64.add + (f64.mul + (get_local $16) + (f64.const 3.694239077158931e-13) + ) + (f64.mul + (f64.add + (get_local $14) + (get_local $13) + ) + (f64.const 2.5082946711645275e-11) + ) + ) + (f64.mul + (get_local $14) + (f64.const 0.4342944818781689) + ) + ) + ) + (set_local $9 + (f64.add + (get_local $17) + (get_local $15) + ) + ) + (set_local $18 + (f64.add + (get_local $18) + (f64.add + (f64.sub + (get_local $17) + (get_local $9) + ) + (get_local $15) + ) + ) + ) + (set_local $15 + (get_local $9) + ) + (return + (f64.add + (get_local $18) + (get_local $15) + ) + ) + ) + (func $std/libm/log10 (; 45 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.log10" + (get_local $0) + ) + ) + ) + (func $std/libm/log1p (; 46 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.log1p" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.log2" (; 47 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (f64.sub + (get_local $5) + (get_local $6) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const -4294967296) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $14 + (f64.add + (f64.sub + (f64.sub + (get_local $5) + (get_local $13) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + ) + ) + (set_local $15 + (f64.mul + (get_local $13) + (f64.const 1.4426950407214463) + ) + ) + (set_local $16 + (f64.add + (f64.mul + (f64.add + (get_local $14) + (get_local $13) + ) + (f64.const 1.6751713164886512e-10) + ) + (f64.mul + (get_local $14) + (f64.const 1.4426950407214463) + ) + ) + ) + (set_local $17 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $9 + (f64.add + (get_local $17) + (get_local $15) + ) + ) + (set_local $16 + (f64.add + (get_local $16) + (f64.add + (f64.sub + (get_local $17) + (get_local $9) + ) + (get_local $15) + ) + ) + ) + (set_local $15 + (get_local $9) + ) + (return + (f64.add + (get_local $16) + (get_local $15) + ) + ) + ) + (func $std/libm/log2 (; 48 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.log2" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.max" (; 49 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (f64.max + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/libm/max (; 50 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.max" + (get_local $0) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.min" (; 51 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (f64.min + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/libm/min (; 52 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.min" + (get_local $0) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.pow" (; 53 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (local $19 f64) + (local $20 f64) + (local $21 f64) + (local $22 f64) + (local $23 f64) + (local $24 i32) + (local $25 i32) + (local $26 f64) + (local $27 f64) + (local $28 f64) + (local $29 f64) + (local $30 f64) + (local $31 f64) + (local $32 f64) + (local $33 f64) + (local $34 f64) + (local $35 f64) + (local $36 f64) + (local $37 f64) + (local $38 i32) + (nop) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $4 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (get_local $2) + ) + ) + (set_local $7 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (set_local $8 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (i32.or + (get_local $8) + (get_local $6) + ) + (i32.const 0) + ) + (return + (f64.const 1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.gt_s + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $4) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.gt_s + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + ) + (i32.ne + (get_local $6) + (i32.const 0) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $10 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1128267776) + ) + (set_local $10 + (i32.const 2) + ) + (if + (i32.ge_s + (get_local $8) + (i32.const 1072693248) + ) + (block + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $8) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $11) + (i32.const 20) + ) + (block + (set_local $9 + (i32.shr_u + (get_local $6) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 52) + (get_local $11) + ) + ) + (get_local $6) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (set_local $9 + (i32.shr_s + (get_local $8) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $9) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + (get_local $8) + ) + (set_local $10 + (i32.sub + (i32.const 2) + (i32.and + (get_local $9) + (i32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $8) + (i32.const 2146435072) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $4) + ) + (i32.const 0) + ) + (return + (f64.const nan:0x8000000000000) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (get_local $1) + (f64.const 0) + ) + ) + (return + (if (result f64) + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (f64.const 0) + (f64.neg + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $8) + (i32.const 1072693248) + ) + (block + (if + (i32.ge_s + (get_local $5) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (return + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1073741824) + ) + (return + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 1071644672) + ) + (if + (i32.ge_s + (get_local $3) + (i32.const 0) + ) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.eq + (get_local $7) + (i32.const 1072693248) + ) + ) + (i32.const 1) + ) + (block + (set_local $13 + (get_local $12) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.const 1) + (get_local $13) + ) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $7) + (i32.const 1072693248) + ) + (get_local $10) + ) + (i32.const 0) + ) + (set_local $13 + (f64.div + (f64.sub + (get_local $13) + (get_local $13) + ) + (f64.sub + (get_local $13) + (get_local $13) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $13 + (f64.neg + (get_local $13) + ) + ) + ) + ) + ) + (return + (get_local $13) + ) + ) + ) + ) + (set_local $14 + (f64.const 1) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (block + (if + (i32.eq + (get_local $10) + (i32.const 0) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.eq + (get_local $10) + (i32.const 1) + ) + (set_local $14 + (f64.const -1) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_s + (get_local $8) + (i32.const 1105199104) + ) + (block + (if + (i32.gt_s + (get_local $8) + (i32.const 1139802112) + ) + (block + (if + (i32.le_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.ge_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.const 1.e+300) + (f64.const 1.e+300) + ) + (f64.mul + (f64.const 1e-300) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1072693247) + ) + (return + (if (result f64) + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $7) + (i32.const 1072693248) + ) + (return + (if (result f64) + (i32.gt_s + (get_local $5) + (i32.const 0) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + (set_local $20 + (f64.sub + (get_local $12) + (f64.const 1) + ) + ) + (set_local $23 + (f64.mul + (f64.mul + (get_local $20) + (get_local $20) + ) + (f64.sub + (f64.const 0.5) + (f64.mul + (get_local $20) + (f64.sub + (f64.const 0.3333333333333333) + (f64.mul + (get_local $20) + (f64.const 0.25) + ) + ) + ) + ) + ) + ) + (set_local $21 + (f64.mul + (f64.const 1.4426950216293335) + (get_local $20) + ) + ) + (set_local $22 + (f64.sub + (f64.mul + (get_local $20) + (f64.const 1.9259629911266175e-08) + ) + (f64.mul + (get_local $23) + (f64.const 1.4426950408889634) + ) + ) + ) + (set_local $15 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $22) + (f64.sub + (get_local $15) + (get_local $21) + ) + ) + ) + ) + (block + (nop) + (set_local $25 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 1048576) + ) + (block + (set_local $12 + (f64.mul + (get_local $12) + (f64.const 9007199254740992) + ) + ) + (set_local $25 + (i32.sub + (get_local $25) + (i32.const 53) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.sub + (i32.shr_s + (get_local $7) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $24 + (i32.and + (get_local $7) + (i32.const 1048575) + ) + ) + (set_local $7 + (i32.or + (get_local $24) + (i32.const 1072693248) + ) + ) + (if + (i32.le_s + (get_local $24) + (i32.const 235662) + ) + (set_local $11 + (i32.const 0) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 767610) + ) + (set_local $11 + (i32.const 1) + ) + (block + (set_local $11 + (i32.const 0) + ) + (set_local $25 + (i32.add + (get_local $25) + (i32.const 1) + ) + ) + (set_local $7 + (i32.sub + (get_local $7) + (i32.const 1048576) + ) + ) + ) + ) + ) + (set_local $12 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $12) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 32) + ) + ) + ) + ) + (set_local $32 + (select + (f64.const 1.5) + (f64.const 1) + (get_local $11) + ) + ) + (set_local $21 + (f64.sub + (get_local $12) + (get_local $32) + ) + ) + (set_local $22 + (f64.div + (f64.const 1) + (f64.add + (get_local $12) + (get_local $32) + ) + ) + ) + (set_local $26 + (f64.mul + (get_local $21) + (get_local $22) + ) + ) + (set_local $28 + (get_local $26) + ) + (set_local $28 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $28) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.add + (i32.or + (i32.shr_s + (get_local $7) + (i32.const 1) + ) + (i32.const 536870912) + ) + (i32.const 524288) + ) + (i32.shl + (get_local $11) + (i32.const 18) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $12) + (f64.sub + (get_local $30) + (get_local $32) + ) + ) + ) + (set_local $29 + (f64.mul + (get_local $22) + (f64.sub + (f64.sub + (get_local $21) + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (f64.mul + (get_local $28) + (get_local $31) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $26) + (get_local $26) + ) + ) + (set_local $19 + (f64.mul + (f64.mul + (get_local $27) + (get_local $27) + ) + (f64.add + (f64.const 0.5999999999999946) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.4285714285785502) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.33333332981837743) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.272728123808534) + (f64.mul + (get_local $27) + (f64.add + (f64.const 0.23066074577556175) + (f64.mul + (get_local $27) + (f64.const 0.20697501780033842) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.add + (get_local $19) + (f64.mul + (get_local $29) + (f64.add + (get_local $28) + (get_local $26) + ) + ) + ) + ) + (set_local $27 + (f64.mul + (get_local $28) + (get_local $28) + ) + ) + (set_local $30 + (f64.add + (f64.add + (f64.const 3) + (get_local $27) + ) + (get_local $19) + ) + ) + (set_local $30 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $30) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $31 + (f64.sub + (get_local $19) + (f64.sub + (f64.sub + (get_local $30) + (f64.const 3) + ) + (get_local $27) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $28) + (get_local $30) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (get_local $29) + (get_local $30) + ) + (f64.mul + (get_local $31) + (get_local $26) + ) + ) + ) + (set_local $17 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $17 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $17) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.sub + (get_local $22) + (f64.sub + (get_local $17) + (get_local $21) + ) + ) + ) + (set_local $33 + (f64.mul + (f64.const 0.9617967009544373) + (get_local $17) + ) + ) + (set_local $34 + (select + (f64.const 1.350039202129749e-08) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $35 + (f64.add + (f64.add + (f64.mul + (f64.const -7.028461650952758e-09) + (get_local $17) + ) + (f64.mul + (get_local $18) + (f64.const 0.9617966939259756) + ) + ) + (get_local $34) + ) + ) + (set_local $20 + (f64.convert_s/i32 + (get_local $25) + ) + ) + (set_local $36 + (select + (f64.const 0.5849624872207642) + (f64.const 0) + (get_local $11) + ) + ) + (set_local $15 + (f64.add + (f64.add + (f64.add + (get_local $33) + (get_local $35) + ) + (get_local $36) + ) + (get_local $20) + ) + ) + (set_local $15 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $15) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $16 + (f64.sub + (get_local $35) + (f64.sub + (f64.sub + (f64.sub + (get_local $15) + (get_local $20) + ) + (get_local $36) + ) + (get_local $33) + ) + ) + ) + ) + ) + (set_local $37 + (get_local $1) + ) + (set_local $37 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $37) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $18 + (f64.add + (f64.mul + (f64.sub + (get_local $1) + (get_local $37) + ) + (get_local $15) + ) + (f64.mul + (get_local $1) + (get_local $16) + ) + ) + ) + (set_local $17 + (f64.mul + (get_local $37) + (get_local $15) + ) + ) + (set_local $13 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $2 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (set_local $38 + (i32.wrap/i64 + (get_local $2) + ) + ) + (if + (i32.ge_s + (get_local $24) + (i32.const 1083179008) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const 1083179008) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + (if + (f64.gt + (f64.add + (get_local $18) + (f64.const 8.008566259537294e-17) + ) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1.e+300) + ) + (f64.const 1.e+300) + ) + ) + ) + ) + (if + (i32.ge_s + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + (i32.const 1083231232) + ) + (block + (if + (i32.ne + (i32.or + (i32.sub + (get_local $24) + (i32.const -1064252416) + ) + (get_local $38) + ) + (i32.const 0) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + (if + (f64.le + (get_local $18) + (f64.sub + (get_local $13) + (get_local $17) + ) + ) + (return + (f64.mul + (f64.mul + (get_local $14) + (f64.const 1e-300) + ) + (f64.const 1e-300) + ) + ) + ) + ) + ) + ) + (set_local $38 + (i32.and + (get_local $24) + (i32.const 2147483647) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (get_local $38) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $25 + (i32.const 0) + ) + (if + (i32.gt_s + (get_local $38) + (i32.const 1071644672) + ) + (block + (set_local $25 + (i32.add + (get_local $24) + (i32.shr_s + (i32.const 1048576) + (i32.add + (get_local $11) + (i32.const 1) + ) + ) + ) + ) + (set_local $11 + (i32.sub + (i32.shr_s + (i32.and + (get_local $25) + (i32.const 2147483647) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (set_local $20 + (f64.const 0) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.and + (get_local $25) + (i32.xor + (i32.shr_s + (i32.const 1048575) + (get_local $11) + ) + (i32.const -1) + ) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $25 + (i32.shr_s + (i32.or + (i32.and + (get_local $25) + (i32.const 1048575) + ) + (i32.const 1048576) + ) + (i32.sub + (i32.const 20) + (get_local $11) + ) + ) + ) + (if + (i32.lt_s + (get_local $24) + (i32.const 0) + ) + (set_local $25 + (i32.sub + (i32.const 0) + (get_local $25) + ) + ) + ) + (set_local $17 + (f64.sub + (get_local $17) + (get_local $20) + ) + ) + ) + ) + (set_local $20 + (f64.add + (get_local $18) + (get_local $17) + ) + ) + (set_local $20 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $20) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $21 + (f64.mul + (get_local $20) + (f64.const 0.6931471824645996) + ) + ) + (set_local $22 + (f64.add + (f64.mul + (f64.sub + (get_local $18) + (f64.sub + (get_local $20) + (get_local $17) + ) + ) + (f64.const 0.6931471805599453) + ) + (f64.mul + (get_local $20) + (f64.const -1.904654299957768e-09) + ) + ) + ) + (set_local $13 + (f64.add + (get_local $21) + (get_local $22) + ) + ) + (set_local $23 + (f64.sub + (get_local $22) + (f64.sub + (get_local $13) + (get_local $21) + ) + ) + ) + (set_local $20 + (f64.mul + (get_local $13) + (get_local $13) + ) + ) + (set_local $15 + (f64.sub + (get_local $13) + (f64.mul + (get_local $20) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $20) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $20) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $20) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $20) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $19 + (f64.sub + (f64.div + (f64.mul + (get_local $13) + (get_local $15) + ) + (f64.sub + (get_local $15) + (f64.const 2) + ) + ) + (f64.add + (get_local $23) + (f64.mul + (get_local $13) + (get_local $23) + ) + ) + ) + ) + (set_local $13 + (f64.sub + (f64.const 1) + (f64.sub + (get_local $19) + (get_local $13) + ) + ) + ) + (set_local $24 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 32) + ) + ) + ) + (set_local $24 + (i32.add + (get_local $24) + (i32.shl + (get_local $25) + (i32.const 20) + ) + ) + ) + (if + (i32.le_s + (i32.shr_s + (get_local $24) + (i32.const 20) + ) + (i32.const 0) + ) + (set_local $13 + (call "$(lib)/math/NativeMath.scalbn" + (get_local $13) + (get_local $25) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (i64.or + (i64.and + (i64.reinterpret/f64 + (get_local $13) + ) + (i64.const 4294967295) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $24) + ) + (i64.const 32) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (func $std/libm/pow (; 54 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.pow" + (get_local $0) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.round" (; 55 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.ge_s + (get_local $2) + (i32.add + (i32.const 1023) + (i32.const 52) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.sub + (i32.const 1023) + (i32.const 1) + ) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (nop) + (if + (i64.ne + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $3 + (f64.add + (f64.sub + (f64.sub + (f64.const 4503599627370496) + (get_local $0) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (if + (f64.ge + (get_local $3) + (f64.const 0.5) + ) + (set_local $3 + (f64.add + (f64.sub + (get_local $0) + (get_local $3) + ) + (f64.const 1) + ) + ) + (if + (f64.lt + (get_local $3) + (f64.const -0.5) + ) + (set_local $3 + (f64.sub + (f64.sub + (get_local $0) + (get_local $3) + ) + (f64.const 1) + ) + ) + (set_local $3 + (f64.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.sub + (f64.add + (get_local $0) + (f64.const 4503599627370496) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $3) + (f64.const 0.5) + ) + (set_local $3 + (f64.sub + (f64.add + (get_local $3) + (get_local $0) + ) + (f64.const 1) + ) + ) + (if + (f64.le + (get_local $3) + (f64.const -0.5) + ) + (set_local $3 + (f64.add + (f64.add + (get_local $3) + (get_local $0) + ) + (f64.const 1) + ) + ) + (set_local $3 + (f64.add + (get_local $3) + (get_local $0) + ) + ) + ) + ) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/libm/round (; 56 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.round" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.sign" (; 57 ;) (type $FF) (param $0 f64) (result f64) + (return + (if (result f64) + (f64.gt + (get_local $0) + (f64.const 0) + ) + (f64.const 1) + (if (result f64) + (f64.lt + (get_local $0) + (f64.const 0) + ) + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + (func $std/libm/sign (; 58 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.sign" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.sin" (; 59 ;) (type $FF) (param $0 f64) (result f64) + (unreachable) + (return + (f64.const 0) + ) + ) + (func $std/libm/sin (; 60 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.sin" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.sinh" (; 61 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 f64) + (local $3 f64) + (local $4 i32) + (local $5 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (f64.const 0.5) + ) + (if + (i64.ne + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + (i64.const 0) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $4) + (i32.const 1082535490) + ) + (block + (set_local $5 + (call "$(lib)/math/NativeMath.expm1" + (get_local $3) + ) + ) + (if + (i32.lt_u + (get_local $4) + (i32.const 1072693248) + ) + (block + (if + (i32.lt_u + (get_local $4) + (i32.sub + (i32.const 1072693248) + (i32.shl + (i32.const 26) + (i32.const 20) + ) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.sub + (f64.mul + (f64.const 2) + (get_local $5) + ) + (f64.div + (f64.mul + (get_local $5) + (get_local $5) + ) + (f64.add + (get_local $5) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.add + (get_local $5) + (f64.div + (get_local $5) + (f64.add + (get_local $5) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (set_local $5 + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $3) + ) + ) + ) + (return + (get_local $5) + ) + ) + (func $std/libm/sinh (; 62 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.sinh" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.sqrt" (; 63 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + (func $std/libm/sqrt (; 64 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.sqrt" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.tan" (; 65 ;) (type $FF) (param $0 f64) (result f64) + (unreachable) + (return + (f64.const 0) + ) + ) + (func $std/libm/tan (; 66 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.tan" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.tanh" (; 67 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.gt_u + (get_local $3) + (i32.const 1071748074) + ) + (if + (i32.gt_u + (get_local $3) + (i32.const 1077149696) + ) + (set_local $4 + (f64.sub + (f64.const 1) + (f64.div + (f64.const 0) + (get_local $0) + ) + ) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.sub + (f64.const 1) + (f64.div + (f64.const 2) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $3) + (i32.const 1070618798) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.div + (get_local $4) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 1048576) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const -2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.div + (f64.neg + (get_local $4) + ) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + (set_local $4 + (get_local $0) + ) + ) + ) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (func $std/libm/tanh (; 68 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.tanh" + (get_local $0) + ) + ) + ) + (func "$(lib)/math/NativeMath.trunc" (; 69 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.trunc + (get_local $0) + ) + ) + ) + (func $std/libm/trunc (; 70 ;) (type $FF) (param $0 f64) (result f64) + (return + (call "$(lib)/math/NativeMath.trunc" + (get_local $0) + ) + ) + ) +) diff --git a/tests/compiler/std/math.optimized.wat b/tests/compiler/std/math.optimized.wat index 21008faa..81ce3ec1 100644 --- a/tests/compiler/std/math.optimized.wat +++ b/tests/compiler/std/math.optimized.wat @@ -1,34 +1,8720 @@ (module - (type $iiiiv (func (param i32 i32 i32 i32))) - (type $FFFFiv (func (param f64 f64 f64 f64 i32))) - (type $FFF (func (param f64 f64) (result f64))) - (type $FFFiv (func (param f64 f64 f64 i32))) - (type $ffffiv (func (param f32 f32 f32 f32 i32))) - (type $fff (func (param f32 f32) (result f32))) - (type $fffiv (func (param f32 f32 f32 i32))) - (type $FF (func (param f64) (result f64))) (type $F (func (result f64))) - (type $ff (func (param f32) (result f32))) + (type $iiiiv (func (param i32 i32 i32 i32))) + (type $f (func (result f32))) + (type $FFFii (func (param f64 f64 f64 i32) (result i32))) + (type $FFFF (func (param f64 f64 f64) (result f64))) + (type $Fi (func (param f64) (result i32))) (type $FiF (func (param f64 i32) (result f64))) + (type $Fv (func (param f64))) + (type $fffii (func (param f32 f32 f32 i32) (result i32))) + (type $ffff (func (param f32 f32 f32) (result f32))) + (type $fi (func (param f32) (result i32))) (type $fif (func (param f32 i32) (result f32))) + (type $FiFFii (func (param f64 i32 f64 f64 i32) (result i32))) + (type $fiffii (func (param f32 i32 f32 f32 i32) (result i32))) + (type $FF (func (param f64) (result f64))) + (type $ff (func (param f32) (result f32))) + (type $FFFFii (func (param f64 f64 f64 f64 i32) (result i32))) + (type $FFF (func (param f64 f64) (result f64))) + (type $ffffii (func (param f32 f32 f32 f32 i32) (result i32))) + (type $fff (func (param f32 f32) (result f32))) (type $Iv (func (param i64))) (type $II (func (param i64) (result i64))) - (type $I (func (result i64))) (type $v (func)) (import "env" "abort" (func $abort (param i32 i32 i32 i32))) - (import "JSMath" "log" (func $(lib)/math/JSMath.log (param f64) (result f64))) - (import "JSMath" "exp" (func $(lib)/math/JSMath.exp (param f64) (result f64))) + (import "JSMath" "E" (global $(lib)/math/JSMath.E f64)) + (import "env" "logf" (func $std/math/logf (param f64))) + (import "JSMath" "LN2" (global $(lib)/math/JSMath.LN2 f64)) + (import "JSMath" "LN10" (global $(lib)/math/JSMath.LN10 f64)) + (import "JSMath" "LOG2E" (global $(lib)/math/JSMath.LOG2E f64)) + (import "JSMath" "PI" (global $(lib)/math/JSMath.PI f64)) + (import "JSMath" "SQRT1_2" (global $(lib)/math/JSMath.SQRT1_2 f64)) + (import "JSMath" "SQRT2" (global $(lib)/math/JSMath.SQRT2 f64)) + (import "JSMath" "abs" (func $(lib)/math/JSMath.abs (param f64) (result f64))) + (import "JSMath" "acos" (func $(lib)/math/JSMath.acos (param f64) (result f64))) + (import "JSMath" "acosh" (func $(lib)/math/JSMath.acosh (param f64) (result f64))) + (import "JSMath" "asin" (func $(lib)/math/JSMath.asin (param f64) (result f64))) + (import "JSMath" "asinh" (func $(lib)/math/JSMath.asinh (param f64) (result f64))) + (import "JSMath" "atan" (func $(lib)/math/JSMath.atan (param f64) (result f64))) + (import "JSMath" "atanh" (func $(lib)/math/JSMath.atanh (param f64) (result f64))) + (import "JSMath" "atan2" (func $(lib)/math/JSMath.atan2 (param f64 f64) (result f64))) (import "JSMath" "cbrt" (func $(lib)/math/JSMath.cbrt (param f64) (result f64))) + (import "JSMath" "ceil" (func $(lib)/math/JSMath.ceil (param f64) (result f64))) + (import "JSMath" "cosh" (func $(lib)/math/JSMath.cosh (param f64) (result f64))) + (import "JSMath" "exp" (func $(lib)/math/JSMath.exp (param f64) (result f64))) + (import "JSMath" "expm1" (func $(lib)/math/JSMath.expm1 (param f64) (result f64))) + (import "JSMath" "floor" (func $(lib)/math/JSMath.floor (param f64) (result f64))) + (import "JSMath" "hypot" (func $(lib)/math/JSMath.hypot (param f64 f64) (result f64))) + (import "JSMath" "log" (func $(lib)/math/JSMath.log (param f64) (result f64))) + (import "JSMath" "log10" (func $(lib)/math/JSMath.log10 (param f64) (result f64))) + (import "JSMath" "log1p" (func $(lib)/math/JSMath.log1p (param f64) (result f64))) + (import "JSMath" "log2" (func $(lib)/math/JSMath.log2 (param f64) (result f64))) + (import "JSMath" "max" (func $(lib)/math/JSMath.max (param f64 f64) (result f64))) + (import "JSMath" "min" (func $(lib)/math/JSMath.min (param f64 f64) (result f64))) + (import "JSOp" "mod" (func $std/math/JSOp.mod (param f64 f64) (result f64))) + (import "JSMath" "pow" (func $(lib)/math/JSMath.pow (param f64 f64) (result f64))) (import "JSMath" "random" (func $(lib)/math/JSMath.random (result f64))) - (global "$(lib)/math/NativeMath.random_seeded" (mut i32) (i32.const 0)) - (global "$(lib)/math/NativeMath.random_state0" (mut i64) (i64.const 0)) - (global "$(lib)/math/NativeMath.random_state1" (mut i64) (i64.const 0)) + (import "JSMath" "sign" (func $(lib)/math/JSMath.sign (param f64) (result f64))) + (import "JSMath" "sinh" (func $(lib)/math/JSMath.sinh (param f64) (result f64))) + (import "JSMath" "sqrt" (func $(lib)/math/JSMath.sqrt (param f64) (result f64))) + (import "JSMath" "tanh" (func $(lib)/math/JSMath.tanh (param f64) (result f64))) + (import "JSMath" "trunc" (func $(lib)/math/JSMath.trunc (param f64) (result f64))) + (global "$(lib)/math/random_seeded" (mut i32) (i32.const 0)) + (global "$(lib)/math/random_state0" (mut i64) (i64.const 0)) + (global "$(lib)/math/random_state1" (mut i64) (i64.const 0)) (memory $0 1) (data (i32.const 4) "\0b\00\00\00s\00t\00d\00/\00m\00a\00t\00h\00.\00t\00s") (data (i32.const 32) "\0d\00\00\00(\00l\00i\00b\00)\00/\00m\00a\00t\00h\00.\00t\00s") (export "memory" (memory $0)) (start $start) - (func $fmod (; 5 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func $std/math/signbit (; 31 ;) (type $Fi) (param $0 f64) (result i32) + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 63) + ) + ) + ) + (func $std/math/eulp (; 32 ;) (type $Fi) (param $0 f64) (result i32) + (local $1 i32) + (if + (i32.eqz + (tee_local $1 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + ) + (i32.add + (get_local $1) + (i32.const -1075) + ) + ) + (func "$(lib)/math/NativeMath.scalbn" (; 33 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $1) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + ) + (func $std/math/ulperr (; 34 ;) (type $FFFF) (param $0 f64) (param $1 f64) (param $2 f64) (result f64) + (local $3 f64) + (local $4 i32) + (if + (i32.and + (if (result i32) + (tee_local $4 + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + ) + (f64.ne + (tee_local $3 + (get_local $1) + ) + (get_local $3) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + (if + (f64.eq + (get_local $0) + (get_local $1) + ) + (block + (if + (i32.eq + (call $std/math/signbit + (get_local $0) + ) + (call $std/math/signbit + (get_local $1) + ) + ) + (return + (get_local $2) + ) + ) + (return + (f64.const inf) + ) + ) + ) + (if + (i32.eqz + (select + (f64.ne + (f64.abs + (tee_local $3 + (get_local $0) + ) + ) + (f64.const inf) + ) + (i32.const 0) + (f64.eq + (get_local $3) + (get_local $3) + ) + ) + ) + (block + (set_local $0 + (f64.copysign + (f64.const 8988465674311579538646525e283) + (get_local $0) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 0.5) + ) + ) + ) + ) + (f64.add + (call "$(lib)/math/NativeMath.scalbn" + (f64.sub + (get_local $0) + (get_local $1) + ) + (i32.sub + (i32.const 0) + (call $std/math/eulp + (get_local $1) + ) + ) + ) + (get_local $2) + ) + ) + (func $std/math/check (; 35 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 f64) + (if + (f64.eq + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (if + (f64.ne + (tee_local $4 + (get_local $1) + ) + (get_local $4) + ) + (return + (f64.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + ) + ) + (if + (f64.ge + (f64.abs + (tee_local $0 + (call $std/math/ulperr + (get_local $0) + (get_local $1) + (get_local $2) + ) + ) + ) + (f64.const 1.5) + ) + (block + (call $std/math/logf + (f64.abs + (get_local $0) + ) + ) + (return + (i32.const 0) + ) + ) + ) + (i32.const 1) + ) + (func $std/math/signbitf (; 36 ;) (type $fi) (param $0 f32) (result i32) + (i32.shr_u + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 31) + ) + ) + (func $std/math/eulpf (; 37 ;) (type $fi) (param $0 f32) (result i32) + (local $1 i32) + (if + (i32.eqz + (tee_local $1 + (i32.and + (i32.shr_u + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1) + ) + ) + ) + (i32.add + (get_local $1) + (i32.const -150) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 38 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (if + (i32.gt_s + (tee_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (if + (i32.lt_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (get_local $1) + (i32.const 127) + ) + (i32.const 23) + ) + ) + ) + ) + (func $std/math/ulperrf (; 39 ;) (type $ffff) (param $0 f32) (param $1 f32) (param $2 f32) (result f32) + (local $3 f32) + (local $4 i32) + (if + (i32.and + (if (result i32) + (tee_local $4 + (f32.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + ) + (f32.ne + (tee_local $3 + (get_local $1) + ) + (get_local $3) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f32.const 0) + ) + ) + (if + (f32.eq + (get_local $0) + (get_local $1) + ) + (block + (if + (i32.eq + (call $std/math/signbitf + (get_local $0) + ) + (call $std/math/signbitf + (get_local $1) + ) + ) + (return + (get_local $2) + ) + ) + (return + (f32.const inf) + ) + ) + ) + (if + (i32.eqz + (select + (f32.ne + (f32.abs + (tee_local $3 + (get_local $0) + ) + ) + (f32.const inf) + ) + (i32.const 0) + (f32.eq + (get_local $3) + (get_local $3) + ) + ) + ) + (block + (set_local $0 + (f32.copysign + (f32.const 1701411834604692317316873e14) + (get_local $0) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 0.5) + ) + ) + ) + ) + (f32.add + (call "$(lib)/math/NativeMathf.scalbn" + (f32.sub + (get_local $0) + (get_local $1) + ) + (i32.sub + (i32.const 0) + (call $std/math/eulpf + (get_local $1) + ) + ) + ) + (get_local $2) + ) + ) + (func $std/math/check (; 40 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (local $4 f32) + (if + (f32.eq + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (if + (f32.ne + (tee_local $4 + (get_local $1) + ) + (get_local $4) + ) + (return + (f32.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + ) + ) + (if + (f32.ge + (f32.abs + (tee_local $0 + (call $std/math/ulperrf + (get_local $0) + (get_local $1) + (get_local $2) + ) + ) + ) + (f32.const 1.5) + ) + (block + (call $std/math/logf + (f64.promote/f32 + (f32.abs + (get_local $0) + ) + ) + ) + (return + (i32.const 0) + ) + ) + ) + (i32.const 1) + ) + (func $std/math/test_scalbn (; 41 ;) (type $FiFFii) (param $0 f64) (param $1 i32) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMath.scalbn" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func $std/math/test_scalbnf (; 42 ;) (type $fiffii) (param $0 f32) (param $1 i32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMath.abs" (; 43 ;) (type $FF) (param $0 f64) (result f64) + (f64.abs + (get_local $0) + ) + ) + (func $std/math/test_abs (; 44 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.abs" (; 45 ;) (type $ff) (param $0 f32) (result f32) + (f32.abs + (get_local $0) + ) + ) + (func $std/math/test_absf (; 46 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.__R" (; 47 ;) (type $FF) (param $0 f64) (result f64) + (f64.div + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.16666666666666666) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.3255658186224009) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.20121253213486293) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.04005553450067941) + (f64.mul + (get_local $0) + (f64.add + (f64.const 7.915349942898145e-04) + (f64.mul + (get_local $0) + (f64.const 3.479331075960212e-05) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (f64.const 1) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.403394911734414) + (f64.mul + (get_local $0) + (f64.add + (f64.const 2.0209457602335057) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.6882839716054533) + (f64.mul + (get_local $0) + (f64.const 0.07703815055590194) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.acos" (; 48 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 i32) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (tee_local $4 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1072693248) + ) + (block + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + ) + (block + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 1012924416) + ) + (return + (f64.const 1.5707963267948966) + ) + ) + (return + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (get_local $0) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f64.mul + (f64.const 2) + (f64.sub + (f64.const 1.5707963267948966) + (f64.add + (tee_local $1 + (f64.sqrt + (tee_local $0 + (f64.mul + (f64.add + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + ) + ) + (f64.sub + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $0) + ) + (get_local $1) + ) + (f64.const 6.123233995736766e-17) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.const 2) + (f64.add + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (tee_local $1 + (f64.sqrt + (tee_local $0 + (f64.mul + (f64.sub + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + ) + ) + ) + (i64.const -4294967296) + ) + ) + ) + (f64.add + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $0) + ) + (get_local $1) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (f64.add + (get_local $1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (func $std/math/test_acos (; 49 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.__R" (; 50 ;) (type $ff) (param $0 f32) (result f32) + (f32.div + (f32.mul + (get_local $0) + (f32.add + (f32.const 0.16666586697101593) + (f32.mul + (get_local $0) + (f32.add + (f32.const -0.04274342209100723) + (f32.mul + (get_local $0) + (f32.const -0.008656363002955914) + ) + ) + ) + ) + ) + (f32.add + (f32.const 1) + (f32.mul + (get_local $0) + (f32.const -0.7066296339035034) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.acos" (; 51 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 i32) + (local $3 f32) + (local $4 i32) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (tee_local $4 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1065353216) + ) + (block + (if + (i32.eq + (get_local $2) + (i32.const 1065353216) + ) + (block + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f32.const 3.141592502593994) + ) + ) + (return + (f32.const 0) + ) + ) + ) + (return + (f32.div + (f32.const 0) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1056964608) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 847249408) + ) + (return + (f32.const 1.570796251296997) + ) + ) + (return + (f32.sub + (f32.const 1.570796251296997) + (f32.sub + (get_local $0) + (f32.sub + (f32.const 7.549789415861596e-08) + (f32.mul + (get_local $0) + (call "$(lib)/math/NativeMathf.__R" + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (return + (f32.mul + (f32.const 2) + (f32.sub + (f32.const 1.570796251296997) + (f32.add + (tee_local $1 + (f32.sqrt + (tee_local $0 + (f32.mul + (f32.add + (f32.const 1) + (get_local $0) + ) + (f32.const 0.5) + ) + ) + ) + ) + (f32.sub + (f32.mul + (call "$(lib)/math/NativeMathf.__R" + (get_local $0) + ) + (get_local $1) + ) + (f32.const 7.549789415861596e-08) + ) + ) + ) + ) + ) + ) + (f32.mul + (f32.const 2) + (f32.add + (tee_local $3 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (tee_local $1 + (f32.sqrt + (tee_local $0 + (f32.mul + (f32.sub + (f32.const 1) + (get_local $0) + ) + (f32.const 0.5) + ) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + (f32.add + (f32.mul + (call "$(lib)/math/NativeMathf.__R" + (get_local $0) + ) + (get_local $1) + ) + (f32.div + (f32.sub + (get_local $0) + (f32.mul + (get_local $3) + (get_local $3) + ) + ) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (func $std/math/test_acosf (; 52 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.log1p" (; 53 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 i64) + (local $8 f64) + (set_local $2 + (i32.const 1) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1071284858) + ) + ) + (get_local $6) + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $3) + (i32.const -1074790400) + ) + (block + (if + (f64.eq + (get_local $0) + (f64.const -1) + ) + (return + (f64.div + (get_local $0) + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 2034237440) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $3) + (i32.const -1076707644) + ) + (block + (set_local $2 + (i32.const 0) + ) + (set_local $1 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $2) + (block + (set_local $5 + (if (result f64) + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.shr_u + (tee_local $6 + (i32.add + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (i32.const 54) + ) + (f64.div + (select + (f64.sub + (f64.const 1) + (f64.sub + (tee_local $1 + (f64.reinterpret/i64 + (get_local $7) + ) + ) + (get_local $0) + ) + ) + (f64.sub + (get_local $0) + (f64.sub + (get_local $1) + (f64.const 1) + ) + ) + (i32.ge_s + (get_local $2) + (i32.const 2) + ) + ) + (get_local $1) + ) + (f64.const 0) + ) + ) + (set_local $1 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $6) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $7) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $4 + (f64.div + (get_local $1) + (f64.add + (f64.const 2) + (get_local $1) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $8) + ) + ) + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $4) + (f64.add + (tee_local $4 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $1) + ) + (get_local $1) + ) + ) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (f64.mul + (tee_local $0 + (f64.convert_s/i32 + (get_local $2) + ) + ) + (f64.const 1.9082149292705877e-10) + ) + (get_local $5) + ) + ) + (get_local $4) + ) + (get_local $1) + ) + (f64.mul + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + ) + (func "$(lib)/math/NativeMath.log" (; 54 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i64) + (local $4 f64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $5) + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $3) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 54) + ) + ) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.eq + (get_local $1) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $3) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $5) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $4 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $1) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $3) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $4) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $7 + (f64.div + (get_local $4) + (f64.add + (f64.const 2) + (get_local $4) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $8) + ) + ) + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $2) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (get_local $6) + ) + (get_local $4) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $2) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (func "$(lib)/math/NativeMath.acosh" (; 55 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (if + (i64.lt_u + (tee_local $1 + (i64.and + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (i64.const 1024) + ) + (return + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sqrt + (f64.add + (f64.mul + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.const 1049) + ) + (return + (call "$(lib)/math/NativeMath.log" + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (get_local $0) + (f64.sqrt + (f64.sub + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (func $std/math/test_acosh (; 56 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.log1p" (; 57 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 i32) + (local $7 f32) + (set_local $2 + (i32.const 1) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (tee_local $3 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 1054086096) + ) + ) + (get_local $6) + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $3) + (i32.const -1082130432) + ) + (block + (if + (f32.eq + (get_local $0) + (f32.const -1) + ) + (return + (f32.div + (get_local $0) + (f32.const 0) + ) + ) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 1728053248) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $3) + (i32.const -1097468391) + ) + (block + (set_local $2 + (i32.const 0) + ) + (set_local $1 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $2) + (block + (set_local $5 + (if (result f32) + (i32.lt_s + (tee_local $2 + (i32.sub + (i32.shr_u + (tee_local $6 + (i32.add + (i32.reinterpret/f32 + (tee_local $1 + (f32.add + (f32.const 1) + (get_local $0) + ) + ) + ) + (i32.const 4913933) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (i32.const 25) + ) + (f32.div + (select + (f32.sub + (f32.const 1) + (f32.sub + (get_local $1) + (get_local $0) + ) + ) + (f32.sub + (get_local $0) + (f32.sub + (get_local $1) + (f32.const 1) + ) + ) + (i32.ge_s + (get_local $2) + (i32.const 2) + ) + ) + (get_local $1) + ) + (f32.const 0) + ) + ) + (set_local $1 + (f32.sub + (f32.reinterpret/i32 + (i32.add + (i32.and + (get_local $6) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (f32.const 1) + ) + ) + ) + ) + (set_local $0 + (f32.mul + (tee_local $7 + (f32.mul + (tee_local $4 + (f32.div + (get_local $1) + (f32.add + (f32.const 2) + (get_local $1) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $7) + ) + ) + (f32.add + (f32.add + (f32.sub + (f32.add + (f32.mul + (get_local $4) + (f32.add + (tee_local $4 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $1) + ) + (get_local $1) + ) + ) + (f32.add + (f32.mul + (get_local $7) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $0) + (f32.const 0.2849878668785095) + ) + ) + ) + (f32.mul + (get_local $0) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $0) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + ) + ) + (f32.add + (f32.mul + (tee_local $0 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (f32.const 9.05800061445916e-06) + ) + (get_local $5) + ) + ) + (get_local $4) + ) + (get_local $1) + ) + (f32.mul + (get_local $0) + (f32.const 0.6931381225585938) + ) + ) + ) + (func "$(lib)/math/NativeMathf.log" (; 58 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 f32) + (local $6 i32) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 8388608) + ) + ) + (get_local $6) + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eqz + (i32.shl + (get_local $1) + (i32.const 1) + ) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_s + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 4913933) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $3 + (f32.mul + (tee_local $5 + (f32.mul + (tee_local $4 + (f32.div + (tee_local $0 + (f32.sub + (f32.reinterpret/i32 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (f32.const 1) + ) + ) + (f32.add + (f32.const 2) + (get_local $0) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $5) + ) + ) + (f32.add + (f32.add + (f32.sub + (f32.add + (f32.mul + (get_local $4) + (f32.add + (tee_local $4 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $0) + ) + (get_local $0) + ) + ) + (f32.add + (f32.mul + (get_local $5) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $3) + (f32.const 0.2849878668785095) + ) + ) + ) + (f32.mul + (get_local $3) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $3) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + ) + ) + (f32.mul + (tee_local $3 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (f32.const 9.05800061445916e-06) + ) + ) + (get_local $4) + ) + (get_local $0) + ) + (f32.mul + (get_local $3) + (f32.const 0.6931381225585938) + ) + ) + ) + (func "$(lib)/math/NativeMathf.acosh" (; 59 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (if + (i32.lt_u + (tee_local $1 + (i32.and + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1073741824) + ) + (return + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.sqrt + (f32.add + (f32.mul + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + (f32.mul + (f32.const 2) + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1166016512) + ) + (return + (call "$(lib)/math/NativeMathf.log" + (f32.sub + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.div + (f32.const 1) + (f32.add + (get_local $0) + (f32.sqrt + (f32.sub + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (f32.add + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (f32.const 0.6931471824645996) + ) + ) + (func $std/math/test_acoshf (; 60 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.asin" (; 61 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1072693248) + ) + (block + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + ) + (return + (f64.add + (f64.mul + (get_local $0) + (f64.const 1.5707963267948966) + ) + (f64.const 7.52316384526264e-37) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $2) + (i32.const 1045430272) + ) + ) + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (get_local $3) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f64.sqrt + (tee_local $1 + (f64.mul + (f64.sub + (f64.const 1) + (f64.abs + (get_local $0) + ) + ) + (f64.const 0.5) + ) + ) + ) + ) + (set_local $4 + (call "$(lib)/math/NativeMath.__R" + (get_local $1) + ) + ) + (set_local $0 + (if (result f64) + (i32.ge_u + (get_local $2) + (i32.const 1072640819) + ) + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.mul + (f64.const 2) + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (get_local $4) + ) + ) + ) + (f64.const 6.123233995736766e-17) + ) + ) + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $4) + ) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (f64.const 2) + (f64.div + (f64.sub + (get_local $1) + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const -4294967296) + ) + ) + ) + (get_local $1) + ) + ) + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (f64.sub + (f64.const 0.7853981633974483) + (f64.mul + (f64.const 2) + (get_local $1) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (get_local $0) + ) + (func $std/math/test_asin (; 62 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.asin" (; 63 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (if + (i32.ge_u + (tee_local $1 + (i32.and + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 1065353216) + ) + (block + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.add + (f32.mul + (get_local $0) + (f32.const 1.5707963705062866) + ) + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (f32.div + (f32.const 0) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1056964608) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $2 + (i32.lt_u + (get_local $1) + (i32.const 964689920) + ) + ) + (i32.ge_u + (get_local $1) + (i32.const 8388608) + ) + (get_local $2) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f32.add + (get_local $0) + (f32.mul + (get_local $0) + (call "$(lib)/math/NativeMathf.__R" + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f32.demote/f64 + (f64.sub + (f64.const 1.5707963705062866) + (f64.mul + (f64.const 2) + (f64.add + (tee_local $3 + (f64.sqrt + (f64.promote/f32 + (tee_local $0 + (f32.mul + (f32.sub + (f32.const 1) + (f32.abs + (get_local $0) + ) + ) + (f32.const 0.5) + ) + ) + ) + ) + ) + (f64.mul + (get_local $3) + (f64.promote/f32 + (call "$(lib)/math/NativeMathf.__R" + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f32.neg + (get_local $0) + ) + ) + ) + (get_local $0) + ) + (func $std/math/test_asinf (; 64 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.asinh" (; 65 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (set_local $1 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (i64.and + (get_local $2) + (i64.const 9223372036854775807) + ) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 1049) + ) + (set_local $0 + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 1024) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i64.ge_u + (get_local $1) + (i64.const 997) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (get_local $0) + (f64.div + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (i64.ne + (get_local $3) + (i64.const 0) + ) + ) + ) + (func $std/math/test_asinh (; 66 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.asinh" (; 67 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (set_local $1 + (i32.and + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 1166016512) + ) + (set_local $0 + (f32.add + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (f32.const 0.6931471824645996) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 1073741824) + ) + (set_local $0 + (call "$(lib)/math/NativeMathf.log" + (f32.add + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.div + (f32.const 1) + (f32.add + (f32.sqrt + (f32.add + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 964689920) + ) + (set_local $0 + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (get_local $0) + (f32.div + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.add + (f32.sqrt + (f32.add + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (select + (f32.neg + (get_local $0) + ) + (get_local $0) + (get_local $2) + ) + ) + (func $std/math/test_asinhf (; 68 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.atan" (; 69 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i32) + (local $4 i32) + (set_local $4 + (i32.shr_u + (tee_local $3 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (i32.const 1141899264) + ) + (block + (if + (f64.ne + (tee_local $1 + (get_local $0) + ) + (get_local $1) + ) + (return + (get_local $0) + ) + ) + (return + (select + (f64.neg + (tee_local $1 + (f64.const 1.5707963267948966) + ) + ) + (get_local $1) + (get_local $4) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $3) + (i32.const 1071382528) + ) + (block + (if + (i32.lt_u + (get_local $3) + (i32.const 1044381696) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f64.abs + (get_local $0) + ) + ) + (set_local $0 + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1072889856) + ) + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1072037888) + ) + (block (result f64) + (set_local $3 + (i32.const 0) + ) + (f64.div + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (f64.const 2) + (get_local $0) + ) + ) + ) + (block (result f64) + (set_local $3 + (i32.const 1) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.add + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + (if (result f64) + (i32.lt_u + (get_local $3) + (i32.const 1073971200) + ) + (block (result f64) + (set_local $3 + (i32.const 2) + ) + (f64.div + (f64.sub + (get_local $0) + (f64.const 1.5) + ) + (f64.add + (f64.const 1) + (f64.mul + (f64.const 1.5) + (get_local $0) + ) + ) + ) + ) + (block (result f64) + (set_local $3 + (i32.const 3) + ) + (f64.div + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.mul + (tee_local $1 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (get_local $1) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.3333333333333293) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.14285714272503466) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.09090887133436507) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.06661073137387531) + (f64.mul + (get_local $2) + (f64.add + (f64.const 0.049768779946159324) + (f64.mul + (get_local $2) + (f64.const 0.016285820115365782) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.19999999999876483) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.11111110405462356) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.0769187620504483) + (f64.mul + (get_local $2) + (f64.add + (f64.const -0.058335701337905735) + (f64.mul + (get_local $2) + (f64.const -0.036531572744216916) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (block $tablify|0 + (br_table $case0|0 $case1|0 $case2|0 $case3|0 $tablify|0 + (get_local $3) + ) + ) + (br $case4|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.4636476090008061) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 2.2698777452961687e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 3.061616997868383e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 0.982793723247329) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 1.3903311031230998e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $1) + (get_local $2) + ) + ) + (f64.const 6.123233995736766e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (unreachable) + ) + (select + (f64.neg + (get_local $1) + ) + (get_local $1) + (get_local $4) + ) + ) + (func $std/math/test_atan (; 70 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.atan" (; 71 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 i32) + (local $3 f32) + (local $4 i32) + (set_local $4 + (i32.shr_u + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $2 + (i32.and + (get_local $2) + (i32.const 2147483647) + ) + ) + (i32.const 1283457024) + ) + (block + (if + (f32.ne + (tee_local $1 + (get_local $0) + ) + (get_local $1) + ) + (return + (get_local $0) + ) + ) + (return + (select + (f32.neg + (tee_local $1 + (f32.const 1.570796251296997) + ) + ) + (get_local $1) + (get_local $4) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1054867456) + ) + (block + (if + (i32.lt_u + (get_local $2) + (i32.const 964689920) + ) + (return + (get_local $0) + ) + ) + (set_local $2 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f32.abs + (get_local $0) + ) + ) + (set_local $0 + (if (result f32) + (i32.lt_u + (get_local $2) + (i32.const 1066926080) + ) + (if (result f32) + (i32.lt_u + (get_local $2) + (i32.const 1060110336) + ) + (block (result f32) + (set_local $2 + (i32.const 0) + ) + (f32.div + (f32.sub + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.const 1) + ) + (f32.add + (f32.const 2) + (get_local $0) + ) + ) + ) + (block (result f32) + (set_local $2 + (i32.const 1) + ) + (f32.div + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.add + (get_local $0) + (f32.const 1) + ) + ) + ) + ) + (if (result f32) + (i32.lt_u + (get_local $2) + (i32.const 1075576832) + ) + (block (result f32) + (set_local $2 + (i32.const 2) + ) + (f32.div + (f32.sub + (get_local $0) + (f32.const 1.5) + ) + (f32.add + (f32.const 1) + (f32.mul + (f32.const 1.5) + (get_local $0) + ) + ) + ) + ) + (block (result f32) + (set_local $2 + (i32.const 3) + ) + (f32.div + (f32.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f32.mul + (tee_local $1 + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + (get_local $1) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.add + (f32.const 0.333333283662796) + (f32.mul + (get_local $3) + (f32.add + (f32.const 0.14253635704517365) + (f32.mul + (get_local $3) + (f32.const 0.06168760731816292) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f32.mul + (get_local $3) + (f32.add + (f32.const -0.19999158382415771) + (f32.mul + (get_local $3) + (f32.const -0.106480173766613) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + (return + (f32.sub + (get_local $0) + (f32.mul + (get_local $0) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (block $tablify|0 + (br_table $case0|0 $case1|0 $case2|0 $case3|0 $tablify|0 + (get_local $2) + ) + ) + (br $case4|0) + ) + (set_local $1 + (f32.sub + (f32.const 0.46364760398864746) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + (f32.const 5.01215824399992e-09) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f32.sub + (f32.const 0.7853981256484985) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + (f32.const 3.774894707930798e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f32.sub + (f32.const 0.9827936887741089) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + (f32.const 3.447321716976148e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (set_local $1 + (f32.sub + (f32.const 1.570796251296997) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $1) + (get_local $3) + ) + ) + (f32.const 7.549789415861596e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + (unreachable) + ) + (select + (f32.neg + (get_local $1) + ) + (get_local $1) + (get_local $4) + ) + ) + (func $std/math/test_atanf (; 72 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.atanh" (; 73 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (set_local $2 + (i64.and + (i64.shr_u + (tee_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + ) + (if + (i64.lt_u + (get_local $2) + (i64.const 1022) + ) + (if + (i64.ge_u + (get_local $2) + (i64.const 991) + ) + (set_local $0 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.mul + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $0) + ) + (f64.sub + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.mul + (f64.const 2) + (f64.div + (get_local $0) + (f64.sub + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (i64.ne + (get_local $3) + (i64.const 0) + ) + ) + ) + (func $std/math/test_atanh (; 74 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.atanh" (; 75 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (set_local $2 + (i32.shr_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 31) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (tee_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1056964608) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 796917760) + ) + (set_local $0 + (f32.mul + (f32.const 0.5) + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.div + (f32.mul + (f32.mul + (f32.const 2) + (get_local $0) + ) + (get_local $0) + ) + (f32.sub + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f32.mul + (f32.const 0.5) + (call "$(lib)/math/NativeMathf.log1p" + (f32.mul + (f32.const 2) + (f32.div + (get_local $0) + (f32.sub + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (select + (f32.neg + (get_local $0) + ) + (get_local $0) + (get_local $2) + ) + ) + (func $std/math/test_atanhf (; 76 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.atan2" (; 77 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 f64) + (local $7 i64) + (local $8 i32) + (block $folding-inner0 + (if + (i32.and + (if (result i32) + (tee_local $2 + (f64.ne + (tee_local $6 + (get_local $1) + ) + (get_local $6) + ) + ) + (get_local $2) + (f64.ne + (tee_local $6 + (get_local $0) + ) + (get_local $6) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 32) + ) + ) + ) + (set_local $8 + (i32.wrap/i64 + (get_local $7) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (tee_local $7 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (if + (i32.eqz + (i32.or + (i32.sub + (get_local $3) + (i32.const 1072693248) + ) + (get_local $8) + ) + ) + (return + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + ) + (set_local $5 + (i32.or + (i32.shr_u + (get_local $4) + (i32.const 31) + ) + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (i32.or + (tee_local $4 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (i32.wrap/i64 + (get_local $7) + ) + ) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (if + (i32.eqz + (i32.or + (i32.eqz + (tee_local $2 + (get_local $5) + ) + ) + (i32.eq + (get_local $2) + (i32.const 1) + ) + ) + ) + (block + (br_if $case2|0 + (i32.eq + (get_local $2) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $2) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const -3.141592653589793) + ) + ) + ) + (br_if $folding-inner0 + (i32.eqz + (i32.or + (get_local $3) + (get_local $8) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 2146435072) + ) + (if + (i32.eq + (get_local $4) + (i32.const 2146435072) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (block $tablify|0 + (br_table $case0|1 $case1|1 $case2|1 $case3|1 $tablify|0 + (get_local $5) + ) + ) + (br $break|1) + ) + (return + (f64.const 0.7853981633974483) + ) + ) + (return + (f64.const -0.7853981633974483) + ) + ) + (return + (f64.const 2.356194490192345) + ) + ) + (return + (f64.const -2.356194490192345) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (block $tablify|00 + (br_table $case0|2 $case1|2 $case2|2 $case3|2 $tablify|00 + (get_local $5) + ) + ) + (br $break|2) + ) + (return + (f64.const 0) + ) + ) + (return + (f64.const -0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.const -3.141592653589793) + ) + ) + ) + ) + (br_if $folding-inner0 + (i32.and + (if (result i32) + (tee_local $2 + (i32.lt_u + (i32.add + (get_local $3) + (i32.const 67108864) + ) + (get_local $4) + ) + ) + (get_local $2) + (i32.eq + (get_local $4) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + ) + (set_local $0 + (if (result f64) + (if (result i32) + (tee_local $2 + (i32.and + (get_local $5) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $4) + (i32.const 67108864) + ) + (get_local $3) + ) + (get_local $2) + ) + (f64.const 0) + (call "$(lib)/math/NativeMath.atan" + (f64.abs + (f64.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (block $tablify|01 + (br_table $case0|3 $case1|3 $case2|3 $case3|3 $tablify|01 + (get_local $5) + ) + ) + (br $break|3) + ) + (return + (get_local $0) + ) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (return + (f64.sub + (f64.const 3.141592653589793) + (f64.sub + (get_local $0) + (f64.const 1.2246467991473532e-16) + ) + ) + ) + ) + (return + (f64.sub + (f64.sub + (get_local $0) + (f64.const 1.2246467991473532e-16) + ) + (f64.const 3.141592653589793) + ) + ) + ) + (unreachable) + ) + (select + (f64.const -1.5707963267948966) + (f64.const 1.5707963267948966) + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + (func $std/math/test_atan2 (; 78 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.atan2" (; 79 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 f32) + (block $folding-inner0 + (if + (i32.and + (if (result i32) + (tee_local $2 + (f32.ne + (tee_local $6 + (get_local $1) + ) + (get_local $6) + ) + ) + (get_local $2) + (f32.ne + (tee_local $6 + (get_local $0) + ) + (get_local $6) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (if + (i32.eq + (tee_local $4 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 1065353216) + ) + (return + (call "$(lib)/math/NativeMathf.atan" + (get_local $0) + ) + ) + ) + (set_local $5 + (i32.or + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $4 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (if + (i32.eqz + (tee_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (if + (i32.eqz + (i32.or + (i32.eqz + (tee_local $2 + (get_local $5) + ) + ) + (i32.eq + (get_local $2) + (i32.const 1) + ) + ) + ) + (block + (br_if $case2|0 + (i32.eq + (get_local $2) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $2) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f32.const 3.1415927410125732) + ) + ) + (return + (f32.const -3.1415927410125732) + ) + ) + ) + (br_if $folding-inner0 + (i32.eqz + (get_local $4) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $3) + (i32.const 2139095040) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (block $tablify|0 + (br_table $case0|1 $case1|1 $case2|1 $case3|1 $tablify|0 + (get_local $5) + ) + ) + (br $break|1) + ) + (return + (f32.const 0.7853981852531433) + ) + ) + (return + (f32.const -0.7853981852531433) + ) + ) + (return + (f32.const 2.356194496154785) + ) + ) + (return + (f32.const -2.356194496154785) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (block $tablify|00 + (br_table $case0|2 $case1|2 $case2|2 $case3|2 $tablify|00 + (get_local $5) + ) + ) + (br $break|2) + ) + (return + (f32.const 0) + ) + ) + (return + (f32.const 0) + ) + ) + (return + (f32.const 3.1415927410125732) + ) + ) + (return + (f32.const -3.1415927410125732) + ) + ) + ) + ) + (br_if $folding-inner0 + (i32.and + (if (result i32) + (tee_local $2 + (i32.lt_u + (i32.add + (get_local $4) + (i32.const 218103808) + ) + (get_local $3) + ) + ) + (get_local $2) + (i32.eq + (get_local $3) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + ) + (set_local $0 + (if (result f32) + (if (result i32) + (tee_local $2 + (i32.and + (get_local $5) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $3) + (i32.const 218103808) + ) + (get_local $4) + ) + (get_local $2) + ) + (f32.const 0) + (call "$(lib)/math/NativeMathf.atan" + (f32.abs + (f32.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (block $tablify|01 + (br_table $case0|3 $case1|3 $case2|3 $case3|3 $tablify|01 + (get_local $5) + ) + ) + (br $break|3) + ) + (return + (get_local $0) + ) + ) + (return + (f32.neg + (get_local $0) + ) + ) + ) + (return + (f32.sub + (f32.const 3.1415927410125732) + (f32.sub + (get_local $0) + (f32.const -8.742277657347586e-08) + ) + ) + ) + ) + (return + (f32.sub + (f32.sub + (get_local $0) + (f32.const -8.742277657347586e-08) + ) + (f32.const 3.1415927410125732) + ) + ) + ) + (unreachable) + ) + (select + (f32.const -1.5707963705062866) + (f32.const 1.5707963705062866) + (i32.and + (get_local $5) + (i32.const 1) + ) + ) + ) + (func $std/math/test_atan2f (; 80 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMath.cbrt" (; 81 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i32) + (local $4 i64) + (if + (i32.ge_u + (tee_local $3 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 2146435072) + ) + (return + (f64.add + (get_local $0) + (get_local $0) + ) + ) + ) + (set_local $3 + (if (result i32) + (i32.lt_u + (get_local $3) + (i32.const 1048576) + ) + (block (result i32) + (if + (i32.eqz + (tee_local $3 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + ) + (return + (get_local $0) + ) + ) + (i32.add + (i32.div_u + (get_local $3) + (i32.const 3) + ) + (i32.const 696219795) + ) + ) + (i32.add + (i32.div_u + (get_local $3) + (i32.const 3) + ) + (i32.const 715094163) + ) + ) + ) + (set_local $2 + (f64.mul + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.or + (i64.and + (get_local $4) + (i64.const -9223372036854775808) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 32) + ) + ) + ) + ) + (get_local $1) + ) + (f64.div + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $2 + (f64.div + (f64.sub + (tee_local $2 + (f64.div + (get_local $0) + (f64.mul + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.add + (i64.reinterpret/f64 + (f64.mul + (get_local $1) + (f64.add + (f64.add + (f64.const 1.87595182427177) + (f64.mul + (get_local $2) + (f64.add + (f64.const -1.8849797954337717) + (f64.mul + (get_local $2) + (f64.const 1.6214297201053545) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.mul + (get_local $2) + (get_local $2) + ) + (get_local $2) + ) + (f64.add + (f64.const -0.758397934778766) + (f64.mul + (get_local $2) + (f64.const 0.14599619288661245) + ) + ) + ) + ) + ) + ) + (i64.const 2147483648) + ) + (i64.const -1073741824) + ) + ) + ) + (get_local $1) + ) + ) + ) + (get_local $1) + ) + (f64.add + (f64.add + (get_local $1) + (get_local $1) + ) + (get_local $2) + ) + ) + ) + (f64.add + (get_local $1) + (f64.mul + (get_local $1) + (get_local $2) + ) + ) + ) + (func $std/math/test_cbrt (; 82 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.cbrt" (; 83 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f64) + (local $2 f64) + (local $3 i32) + (local $4 i32) + (if + (i32.ge_u + (tee_local $3 + (i32.and + (tee_local $4 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (i32.const 2139095040) + ) + (return + (f32.add + (get_local $0) + (get_local $0) + ) + ) + ) + (set_local $3 + (if (result i32) + (i32.lt_u + (get_local $3) + (i32.const 8388608) + ) + (block (result i32) + (if + (i32.eqz + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (i32.add + (i32.div_u + (i32.and + (tee_local $4 + (i32.reinterpret/f32 + (f32.mul + (get_local $0) + (f32.const 16777216) + ) + ) + ) + (i32.const 2147483647) + ) + (i32.const 3) + ) + (i32.const 642849266) + ) + ) + (i32.add + (i32.div_u + (get_local $3) + (i32.const 3) + ) + (i32.const 709958130) + ) + ) + ) + (set_local $2 + (f64.mul + (f64.mul + (tee_local $1 + (f64.promote/f32 + (f32.reinterpret/i32 + (i32.or + (i32.and + (get_local $4) + (i32.const -2147483648) + ) + (get_local $3) + ) + ) + ) + ) + (get_local $1) + ) + (get_local $1) + ) + ) + (set_local $2 + (f64.mul + (f64.mul + (tee_local $1 + (f64.div + (f64.mul + (get_local $1) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (get_local $2) + ) + ) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + (get_local $1) + ) + (get_local $1) + ) + ) + (f32.demote/f64 + (f64.div + (f64.mul + (get_local $1) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (get_local $2) + ) + ) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + ) + (func $std/math/test_cbrtf (; 84 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.ceil" (; 85 ;) (type $FF) (param $0 f64) (result f64) + (f64.ceil + (get_local $0) + ) + ) + (func $std/math/test_ceil (; 86 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.ceil" (; 87 ;) (type $ff) (param $0 f32) (result f32) + (f32.ceil + (get_local $0) + ) + ) + (func $std/math/test_ceilf (; 88 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.expm1" (; 89 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 i64) + (local $7 i32) + (local $8 f64) + (set_local $7 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + (i64.const 2147483647) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $6) + (i64.const 63) + ) + ) + ) + (if + (i32.ge_u + (get_local $7) + (i32.const 1078159482) + ) + (block + (if + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $5) + (return + (f64.const -1) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (return + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $7) + (i32.const 1071001154) + ) + (block + (if + (i32.lt_u + (get_local $7) + (i32.const 1072734898) + ) + (set_local $3 + (if (result f64) + (get_local $5) + (block (result f64) + (set_local $1 + (f64.const -1.9082149292705877e-10) + ) + (set_local $2 + (i32.const -1) + ) + (f64.add + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (block (result f64) + (set_local $1 + (f64.const 1.9082149292705877e-10) + ) + (set_local $2 + (i32.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (block + (set_local $3 + (f64.sub + (get_local $0) + (f64.mul + (tee_local $1 + (f64.convert_s/i32 + (tee_local $2 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (select + (f64.const -0.5) + (f64.const 0.5) + (get_local $5) + ) + ) + ) + ) + ) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (set_local $8 + (f64.sub + (f64.sub + (get_local $3) + (tee_local $0 + (f64.sub + (get_local $3) + (get_local $1) + ) + ) + ) + (get_local $1) + ) + ) + ) + (if + (i32.lt_u + (get_local $7) + (i32.const 1016070144) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $1 + (f64.sub + (f64.const 3) + (f64.mul + (tee_local $3 + (f64.add + (f64.const 1) + (f64.mul + (tee_local $4 + (f64.mul + (get_local $0) + (tee_local $1 + (f64.mul + (f64.const 0.5) + (get_local $0) + ) + ) + ) + ) + (f64.add + (f64.const -0.03333333333333313) + (f64.mul + (get_local $4) + (f64.add + (f64.const 1.5873015872548146e-03) + (f64.mul + (get_local $4) + (f64.add + (f64.const -7.93650757867488e-05) + (f64.mul + (get_local $4) + (f64.add + (f64.const 4.008217827329362e-06) + (f64.mul + (get_local $4) + (f64.const -2.0109921818362437e-07) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $1) + ) + ) + ) + (set_local $1 + (f64.mul + (get_local $4) + (f64.div + (f64.sub + (get_local $3) + (get_local $1) + ) + (f64.sub + (f64.const 6) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $2) + ) + (return + (f64.sub + (get_local $0) + (f64.sub + (f64.mul + (get_local $0) + (get_local $1) + ) + (get_local $4) + ) + ) + ) + ) + (set_local $1 + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.sub + (get_local $1) + (get_local $8) + ) + ) + (get_local $8) + ) + (get_local $4) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const -1) + ) + (return + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + (f64.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 1) + ) + (block + (if + (f64.lt + (get_local $0) + (f64.const -0.25) + ) + (return + (f64.mul + (f64.const -2) + (f64.sub + (get_local $1) + (f64.add + (get_local $0) + (f64.const 0.5) + ) + ) + ) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 1023) + ) + (i64.const 52) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + ) + (get_local $5) + (i32.gt_s + (get_local $2) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + ) + (return + (f64.sub + (tee_local $0 + (select + (f64.mul + (f64.mul + (get_local $0) + (f64.const 2) + ) + (f64.const 8988465674311579538646525e283) + ) + (f64.mul + (get_local $0) + (get_local $3) + ) + (i32.eq + (get_local $2) + (i32.const 1024) + ) + ) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $6 + (i64.shl + (i64.sub + (i64.const 1023) + (i64.extend_u/i32 + (get_local $2) + ) + ) + (i64.const 52) + ) + ) + (tee_local $0 + (select + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.sub + (f64.const 1) + (f64.reinterpret/i64 + (get_local $6) + ) + ) + ) + (get_local $3) + ) + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (f64.add + (get_local $1) + (f64.reinterpret/i64 + (get_local $6) + ) + ) + ) + (f64.const 1) + ) + (get_local $3) + ) + (i32.lt_s + (get_local $2) + (i32.const 20) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.exp" (; 90 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 f64) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (set_local $4 + (i32.shr_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (i32.const 1082532651) + ) + (block + (if + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + (return + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (return + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + ) + (if + (f64.lt + (get_local $0) + (f64.const -745.1332191019411) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1071001154) + ) + (set_local $0 + (f64.sub + (tee_local $2 + (f64.sub + (get_local $0) + (f64.mul + (f64.convert_s/i32 + (tee_local $3 + (if (result i32) + (i32.ge_u + (get_local $1) + (i32.const 1072734898) + ) + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (f64.copysign + (f64.const 0.5) + (get_local $0) + ) + ) + ) + (i32.sub + (i32.sub + (i32.const 1) + (get_local $4) + ) + (get_local $4) + ) + ) + ) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (tee_local $5 + (f64.mul + (f64.convert_s/i32 + (get_local $3) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1043333120) + ) + (set_local $2 + (get_local $0) + ) + (return + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $0 + (f64.add + (f64.const 1) + (f64.add + (f64.sub + (f64.div + (f64.mul + (get_local $0) + (tee_local $0 + (f64.sub + (get_local $0) + (f64.mul + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $0) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $0) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $0) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (f64.sub + (f64.const 2) + (get_local $0) + ) + ) + (get_local $5) + ) + (get_local $2) + ) + ) + ) + (if + (i32.eqz + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (call "$(lib)/math/NativeMath.scalbn" + (get_local $0) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.__expo2" (; 91 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (f64.mul + (f64.mul + (call "$(lib)/math/NativeMath.exp" + (f64.sub + (get_local $0) + (f64.const 1416.0996898839683) + ) + ) + (tee_local $1 + (f64.const 2247116418577894884661631e283) + ) + ) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMath.cosh" (; 92 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i64) + (set_local $0 + (f64.reinterpret/i64 + (tee_local $2 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.lt_u + (tee_local $1 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 32) + ) + ) + ) + (i32.const 1072049730) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 1045430272) + ) + (return + (f64.const 1) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.div + (f64.mul + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + (get_local $0) + ) + (f64.mul + (f64.const 2) + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1082535490) + ) + (return + (f64.mul + (f64.const 0.5) + (f64.add + (tee_local $0 + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $0) + ) + ) + (func $std/math/test_cosh (; 93 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.expm1" (; 94 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (set_local $2 + (i32.and + (tee_local $3 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 2147483647) + ) + ) + (set_local $3 + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1100331076) + ) + (block + (if + (i32.gt_u + (get_local $2) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $3) + (return + (f32.const -1) + ) + ) + (if + (f32.gt + (get_local $0) + (f32.const 88.7216796875) + ) + (return + (f32.mul + (get_local $0) + (f32.const 1701411834604692317316873e14) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1051816472) + ) + (block + (if + (i32.lt_u + (get_local $2) + (i32.const 1065686418) + ) + (set_local $0 + (if (result f32) + (get_local $3) + (block (result f32) + (set_local $1 + (f32.const -9.05800061445916e-06) + ) + (set_local $2 + (i32.const -1) + ) + (f32.add + (get_local $0) + (f32.const 0.6931381225585938) + ) + ) + (block (result f32) + (set_local $1 + (f32.const 9.05800061445916e-06) + ) + (set_local $2 + (i32.const 1) + ) + (f32.sub + (get_local $0) + (f32.const 0.6931381225585938) + ) + ) + ) + ) + (block + (set_local $0 + (f32.sub + (get_local $0) + (f32.mul + (tee_local $1 + (f32.convert_s/i32 + (tee_local $2 + (i32.trunc_s/f32 + (f32.add + (f32.mul + (f32.const 1.4426950216293335) + (get_local $0) + ) + (select + (f32.const -0.5) + (f32.const 0.5) + (get_local $3) + ) + ) + ) + ) + ) + ) + (f32.const 0.6931381225585938) + ) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 9.05800061445916e-06) + ) + ) + ) + ) + (set_local $5 + (f32.sub + (f32.sub + (get_local $0) + (tee_local $0 + (f32.sub + (get_local $0) + (get_local $1) + ) + ) + ) + (get_local $1) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 855638016) + ) + (return + (get_local $0) + ) + (set_local $2 + (i32.const 0) + ) + ) + ) + (set_local $1 + (f32.sub + (f32.const 3) + (f32.mul + (tee_local $6 + (f32.add + (f32.const 1) + (f32.mul + (tee_local $4 + (f32.mul + (get_local $0) + (tee_local $1 + (f32.mul + (f32.const 0.5) + (get_local $0) + ) + ) + ) + ) + (f32.add + (f32.const -0.03333321213722229) + (f32.mul + (get_local $4) + (f32.const 1.5807170420885086e-03) + ) + ) + ) + ) + ) + (get_local $1) + ) + ) + ) + (set_local $1 + (f32.mul + (get_local $4) + (f32.div + (f32.sub + (get_local $6) + (get_local $1) + ) + (f32.sub + (f32.const 6) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $2) + ) + (return + (f32.sub + (get_local $0) + (f32.sub + (f32.mul + (get_local $0) + (get_local $1) + ) + (get_local $4) + ) + ) + ) + ) + (set_local $1 + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.sub + (get_local $1) + (get_local $5) + ) + ) + (get_local $5) + ) + (get_local $4) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const -1) + ) + (return + (f32.sub + (f32.mul + (f32.const 0.5) + (f32.sub + (get_local $0) + (get_local $1) + ) + ) + (f32.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 1) + ) + (block + (if + (f32.lt + (get_local $0) + (f32.const -0.25) + ) + (return + (f32.mul + (f32.const -2) + (f32.sub + (get_local $1) + (f32.add + (get_local $0) + (f32.const 0.5) + ) + ) + ) + ) + ) + (return + (f32.add + (f32.const 1) + (f32.mul + (f32.const 2) + (f32.sub + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f32.reinterpret/i32 + (i32.shl + (i32.add + (get_local $2) + (i32.const 127) + ) + (i32.const 23) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_s + (get_local $2) + (i32.const 0) + ) + ) + (get_local $3) + (i32.gt_s + (get_local $2) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f32.add + (f32.sub + (get_local $0) + (get_local $1) + ) + (f32.const 1) + ) + ) + (return + (f32.sub + (tee_local $0 + (select + (f32.mul + (f32.mul + (get_local $0) + (f32.const 2) + ) + (f32.const 1701411834604692317316873e14) + ) + (f32.mul + (get_local $0) + (get_local $4) + ) + (i32.eq + (get_local $2) + (i32.const 128) + ) + ) + ) + (f32.const 1) + ) + ) + ) + ) + (set_local $3 + (i32.shl + (i32.sub + (i32.const 127) + (get_local $2) + ) + (i32.const 23) + ) + ) + (tee_local $0 + (select + (f32.mul + (f32.add + (f32.sub + (get_local $0) + (get_local $1) + ) + (f32.sub + (f32.const 1) + (f32.reinterpret/i32 + (get_local $3) + ) + ) + ) + (get_local $4) + ) + (f32.mul + (f32.add + (f32.sub + (get_local $0) + (f32.add + (get_local $1) + (f32.reinterpret/i32 + (get_local $3) + ) + ) + ) + (f32.const 1) + ) + (get_local $4) + ) + (i32.lt_s + (get_local $2) + (i32.const 23) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.exp" (; 95 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 i32) + (set_local $2 + (i32.shr_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (tee_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (i32.const 1118743632) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.ge_u + (get_local $1) + (i32.const 1118925336) + ) + ) + (i32.eqz + (get_local $2) + ) + (get_local $5) + ) + (i32.const 1) + ) + (return + (f32.mul + (get_local $0) + (f32.const 1701411834604692317316873e14) + ) + ) + ) + (if + (select + (i32.ge_u + (get_local $1) + (i32.const 1120924085) + ) + (get_local $2) + (get_local $2) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1051816472) + ) + (set_local $0 + (f32.sub + (tee_local $3 + (f32.sub + (get_local $0) + (f32.mul + (f32.convert_s/i32 + (tee_local $1 + (if (result i32) + (i32.gt_u + (get_local $1) + (i32.const 1065686418) + ) + (i32.trunc_s/f32 + (f32.add + (f32.mul + (f32.const 1.4426950216293335) + (get_local $0) + ) + (f32.copysign + (f32.const 0.5) + (get_local $0) + ) + ) + ) + (i32.sub + (i32.sub + (i32.const 1) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + ) + (f32.const 0.693145751953125) + ) + ) + ) + (tee_local $4 + (f32.mul + (f32.convert_s/i32 + (get_local $1) + ) + (f32.const 1.428606765330187e-06) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 956301312) + ) + (block + (set_local $1 + (i32.const 0) + ) + (set_local $3 + (get_local $0) + ) + ) + (return + (f32.add + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $0 + (f32.add + (f32.const 1) + (f32.add + (f32.sub + (f32.div + (f32.mul + (get_local $0) + (tee_local $0 + (f32.sub + (get_local $0) + (f32.mul + (tee_local $0 + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + (f32.add + (f32.const 0.16666625440120697) + (f32.mul + (get_local $0) + (f32.const -2.7667332906275988e-03) + ) + ) + ) + ) + ) + ) + (f32.sub + (f32.const 2) + (get_local $0) + ) + ) + (get_local $4) + ) + (get_local $3) + ) + ) + ) + (if + (i32.eqz + (get_local $1) + ) + (return + (get_local $0) + ) + ) + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $0) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMathf.__expo2" (; 96 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (f32.mul + (f32.mul + (call "$(lib)/math/NativeMathf.exp" + (f32.sub + (get_local $0) + (f32.const 162.88958740234375) + ) + ) + (tee_local $1 + (f32.const 1661534994731144841129758e11) + ) + ) + (get_local $1) + ) + ) + (func "$(lib)/math/NativeMathf.cosh" (; 97 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (set_local $0 + (f32.reinterpret/i32 + (tee_local $1 + (i32.and + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 2147483647) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1060205079) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 964689920) + ) + (return + (f32.const 1) + ) + ) + (return + (f32.add + (f32.const 1) + (f32.div + (f32.mul + (tee_local $0 + (call "$(lib)/math/NativeMathf.expm1" + (get_local $0) + ) + ) + (get_local $0) + ) + (f32.mul + (f32.const 2) + (f32.add + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1118925335) + ) + (return + (f32.mul + (f32.const 0.5) + (f32.add + (tee_local $0 + (call "$(lib)/math/NativeMathf.exp" + (get_local $0) + ) + ) + (f32.div + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + ) + (call "$(lib)/math/NativeMathf.__expo2" + (get_local $0) + ) + ) + (func $std/math/test_coshf (; 98 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func $std/math/test_exp (; 99 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func $std/math/test_expf (; 100 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func $std/math/test_expm1 (; 101 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func $std/math/test_expm1f (; 102 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.floor" (; 103 ;) (type $FF) (param $0 f64) (result f64) + (f64.floor + (get_local $0) + ) + ) + (func $std/math/test_floor (; 104 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.floor" (; 105 ;) (type $ff) (param $0 f32) (result f32) + (f32.floor + (get_local $0) + ) + ) + (func $std/math/test_floorf (; 106 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.hypot" (; 107 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 f64) + (local $4 i64) + (local $5 i64) + (local $6 f64) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i32) + (local $11 f64) + (if + (i64.lt_u + (tee_local $5 + (i64.and + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 9223372036854775807) + ) + ) + (tee_local $4 + (i64.and + (i64.reinterpret/f64 + (get_local $1) + ) + (i64.const 9223372036854775807) + ) + ) + ) + (block + (set_local $9 + (get_local $5) + ) + (set_local $5 + (get_local $4) + ) + (set_local $4 + (get_local $9) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (get_local $4) + ) + ) + (if + (i32.eq + (tee_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 52) + ) + ) + ) + (i32.const 2047) + ) + (return + (get_local $1) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $5) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $10 + (i32.eq + (tee_local $8 + (i32.wrap/i64 + (i64.shr_u + (get_local $5) + (i64.const 52) + ) + ) + ) + (i32.const 2047) + ) + ) + (get_local $10) + (i64.eq + (get_local $4) + (i64.const 0) + ) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (if + (i32.gt_s + (i32.sub + (get_local $8) + (get_local $7) + ) + (i32.const 64) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $6 + (f64.const 1) + ) + (if + (i32.gt_s + (get_local $8) + (i32.const 1533) + ) + (block + (set_local $6 + (f64.const 5260135901548373507240989e186) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 1.90109156629516e-211) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.90109156629516e-211) + ) + ) + ) + (if + (i32.lt_s + (get_local $7) + (i32.const 573) + ) + (block + (set_local $6 + (f64.const 1.90109156629516e-211) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 5260135901548373507240989e186) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 5260135901548373507240989e186) + ) + ) + ) + ) + ) + (set_local $3 + (f64.sub + (get_local $0) + (tee_local $2 + (f64.add + (f64.sub + (get_local $0) + (tee_local $2 + (f64.mul + (get_local $0) + (f64.const 134217729) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (set_local $11 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $2) + (get_local $2) + ) + (tee_local $0 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (get_local $3) + ) + ) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + ) + (set_local $3 + (f64.sub + (get_local $1) + (tee_local $2 + (f64.add + (f64.sub + (get_local $1) + (tee_local $2 + (f64.mul + (get_local $1) + (f64.const 134217729) + ) + ) + ) + (get_local $2) + ) + ) + ) + ) + (f64.mul + (get_local $6) + (f64.sqrt + (f64.add + (f64.add + (f64.add + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $2) + (get_local $2) + ) + (tee_local $1 + (f64.mul + (get_local $1) + (get_local $1) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (get_local $3) + ) + ) + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (get_local $11) + ) + (get_local $1) + ) + (get_local $0) + ) + ) + ) + ) + (func $std/math/test_hypot (; 108 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.hypot" (; 109 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f32) + (if + (i32.lt_u + (tee_local $3 + (i32.and + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 2147483647) + ) + ) + (tee_local $2 + (i32.and + (i32.reinterpret/f32 + (get_local $1) + ) + (i32.const 2147483647) + ) + ) + ) + (block + (set_local $4 + (get_local $3) + ) + (set_local $3 + (get_local $2) + ) + (set_local $2 + (get_local $4) + ) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $3) + ) + ) + (set_local $1 + (f32.reinterpret/i32 + (get_local $2) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 2139095040) + ) + (return + (get_local $1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.and + (if (result i32) + (tee_local $4 + (i32.ge_u + (get_local $3) + (i32.const 2139095040) + ) + ) + (get_local $4) + (i32.eqz + (get_local $2) + ) + ) + (i32.const 1) + ) + ) + (get_local $4) + (i32.ge_u + (i32.sub + (get_local $3) + (get_local $2) + ) + (i32.const 209715200) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $5 + (f32.const 1) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 1568669696) + ) + (block + (set_local $5 + (f32.const 1237940039285380274899124e3) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 8.077935669463161e-28) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 8.077935669463161e-28) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 562036736) + ) + (block + (set_local $5 + (f32.const 8.077935669463161e-28) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 1237940039285380274899124e3) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 1237940039285380274899124e3) + ) + ) + ) + ) + ) + (f32.mul + (get_local $5) + (f32.sqrt + (f32.demote/f64 + (f64.add + (f64.mul + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (f64.mul + (f64.promote/f32 + (get_local $1) + ) + (f64.promote/f32 + (get_local $1) + ) + ) + ) + ) + ) + ) + ) + (func $std/math/test_hypotf (; 110 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func $std/math/test_log (; 111 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func $std/math/test_logf (; 112 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.log10" (; 113 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $5) + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $4) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $4 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $4) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $5) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $1 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $4) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $1) + ) + ) + (set_local $0 + (f64.mul + (tee_local $8 + (f64.mul + (tee_local $7 + (f64.div + (get_local $1) + (f64.add + (f64.const 2) + (get_local $1) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $8) + ) + ) + (set_local $9 + (f64.mul + (tee_local $10 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (f64.const 0.30102999566361177) + ) + ) + (f64.add + (f64.add + (f64.add + (f64.add + (f64.mul + (get_local $10) + (f64.const 3.694239077158931e-13) + ) + (f64.mul + (f64.add + (tee_local $0 + (f64.add + (f64.sub + (f64.sub + (get_local $1) + (tee_local $1 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.sub + (get_local $1) + (get_local $6) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (f64.add + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $0) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $0) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $1) + ) + (f64.const 2.5082946711645275e-11) + ) + ) + (f64.mul + (get_local $0) + (f64.const 0.4342944818781689) + ) + ) + (f64.add + (f64.sub + (get_local $9) + (tee_local $0 + (f64.add + (get_local $9) + (tee_local $1 + (f64.mul + (get_local $1) + (f64.const 0.4342944818781689) + ) + ) + ) + ) + ) + (get_local $1) + ) + ) + (get_local $0) + ) + ) + (func $std/math/test_log10 (; 114 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.log10" (; 115 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 i32) + (local $8 f32) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.lt_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 8388608) + ) + ) + (get_local $7) + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eqz + (i32.shl + (get_local $1) + (i32.const 1) + ) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_u + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 4913933) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $3 + (f32.mul + (tee_local $5 + (f32.mul + (tee_local $4 + (f32.div + (tee_local $0 + (f32.sub + (f32.reinterpret/i32 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (f32.const 1) + ) + ) + (f32.add + (f32.const 2) + (get_local $0) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $5) + ) + ) + (f32.add + (f32.add + (f32.add + (f32.add + (f32.mul + (tee_local $8 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (f32.const 7.903415166765626e-07) + ) + (f32.mul + (f32.add + (tee_local $3 + (f32.add + (f32.sub + (f32.sub + (get_local $0) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.sub + (get_local $0) + (tee_local $6 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $0) + ) + (get_local $0) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + ) + (get_local $6) + ) + (f32.mul + (get_local $4) + (f32.add + (get_local $6) + (f32.add + (f32.mul + (get_local $5) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $3) + (f32.const 0.2849878668785095) + ) + ) + ) + (f32.mul + (get_local $3) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $3) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $0) + ) + (f32.const -3.168997136526741e-05) + ) + ) + (f32.mul + (get_local $3) + (f32.const 0.434326171875) + ) + ) + (f32.mul + (get_local $0) + (f32.const 0.434326171875) + ) + ) + (f32.mul + (get_local $8) + (f32.const 0.3010292053222656) + ) + ) + ) + (func $std/math/test_log10f (; 116 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func $std/math/test_log1p (; 117 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func $std/math/test_log1pf (; 118 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.log2" (; 119 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 i64) + (local $7 f64) + (local $8 i32) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.lt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 32) + ) + ) + ) + (i32.const 1048576) + ) + ) + (get_local $8) + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $6) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 54) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (tee_local $6 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $6) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $8) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.sub + (i32.shr_u + (tee_local $2 + (i32.add + (get_local $2) + (i32.const 614242) + ) + ) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (f64.const 0.5) + (tee_local $3 + (f64.sub + (f64.reinterpret/i64 + (i64.or + (i64.shl + (i64.extend_u/i32 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (i64.const 32) + ) + (i64.and + (get_local $6) + (i64.const 4294967295) + ) + ) + ) + (f64.const 1) + ) + ) + ) + (get_local $3) + ) + ) + (set_local $1 + (f64.mul + (tee_local $0 + (f64.mul + (tee_local $7 + (f64.div + (get_local $3) + (f64.add + (f64.const 2) + (get_local $3) + ) + ) + ) + (get_local $7) + ) + ) + (get_local $0) + ) + ) + (set_local $4 + (f64.add + (f64.sub + (f64.sub + (get_local $3) + (tee_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (f64.sub + (get_local $3) + (get_local $4) + ) + ) + (i64.const -4294967296) + ) + ) + ) + ) + (get_local $4) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $4) + (f64.add + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $1) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $1) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $1) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $1 + (f64.add + (tee_local $7 + (f64.convert_s/i32 + (get_local $5) + ) + ) + (tee_local $0 + (f64.mul + (get_local $3) + (f64.const 1.4426950407214463) + ) + ) + ) + ) + (f64.add + (f64.add + (f64.add + (f64.mul + (f64.add + (get_local $4) + (get_local $3) + ) + (f64.const 1.6751713164886512e-10) + ) + (f64.mul + (get_local $4) + (f64.const 1.4426950407214463) + ) + ) + (f64.add + (f64.sub + (get_local $7) + (get_local $1) + ) + (get_local $0) + ) + ) + (get_local $1) + ) + ) + (func $std/math/test_log2 (; 120 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.log2" (; 121 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 i32) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.lt_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 8388608) + ) + ) + (get_local $7) + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eqz + (i32.shl + (get_local $1) + (i32.const 1) + ) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_u + (tee_local $1 + (i32.add + (get_local $1) + (i32.const 4913933) + ) + ) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $3 + (f32.mul + (tee_local $5 + (f32.mul + (tee_local $4 + (f32.div + (tee_local $0 + (f32.sub + (f32.reinterpret/i32 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (f32.const 1) + ) + ) + (f32.add + (f32.const 2) + (get_local $0) + ) + ) + ) + (get_local $4) + ) + ) + (get_local $5) + ) + ) + (f32.add + (f32.add + (f32.add + (f32.mul + (f32.add + (tee_local $3 + (f32.add + (f32.sub + (f32.sub + (get_local $0) + (tee_local $0 + (f32.reinterpret/i32 + (i32.and + (i32.reinterpret/f32 + (f32.sub + (get_local $0) + (tee_local $6 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $0) + ) + (get_local $0) + ) + ) + ) + ) + (i32.const -4096) + ) + ) + ) + ) + (get_local $6) + ) + (f32.mul + (get_local $4) + (f32.add + (get_local $6) + (f32.add + (f32.mul + (get_local $5) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $3) + (f32.const 0.2849878668785095) + ) + ) + ) + (f32.mul + (get_local $3) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $3) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + ) + ) + ) + ) + (get_local $0) + ) + (f32.const -1.7605285393074155e-04) + ) + (f32.mul + (get_local $3) + (f32.const 1.44287109375) + ) + ) + (f32.mul + (get_local $0) + (f32.const 1.44287109375) + ) + ) + (f32.convert_s/i32 + (get_local $2) + ) + ) + ) + (func $std/math/test_log2f (; 122 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.max" (; 123 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (f64.max + (get_local $0) + (get_local $1) + ) + ) + (func $std/math/test_max (; 124 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.max" (; 125 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (f32.max + (get_local $0) + (get_local $1) + ) + ) + (func $std/math/test_maxf (; 126 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMath.min" (; 127 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (f64.min + (get_local $0) + (get_local $1) + ) + ) + (func $std/math/test_min (; 128 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.min" (; 129 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (f32.min + (get_local $0) + (get_local $1) + ) + ) + (func $std/math/test_minf (; 130 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 131 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 i64) (local $3 i32) (local $4 i64) @@ -400,72 +9086,42 @@ (get_local $0) ) ) - (func $std/math/check (; 6 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (local $4 f64) - (if - (f64.ne - (tee_local $4 - (get_local $1) - ) - (get_local $4) - ) - (if - (f64.eq - (tee_local $4 - (get_local $0) - ) - (get_local $4) - ) - (unreachable) - ) - (if - (f64.ne - (get_local $0) - (get_local $1) - ) - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.eqz - (i32.and - (get_local $3) - (i32.const 1) - ) - ) - ) - (get_local $3) - (f64.gt - (f64.abs - (f64.sub - (get_local $0) - (get_local $1) - ) - ) - (f64.abs - (get_local $2) - ) - ) + (func $std/math/test_mod (; 132 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.mod" + (get_local $0) + (get_local $1) ) - (i32.const 1) + (get_local $2) + (get_local $3) + (get_local $4) ) - (unreachable) ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call $std/math/JSOp.mod + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) ) + (i32.const 1) ) ) - (func $std/math/test_fmod (; 7 ;) (type $FFFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) - (call $std/math/check - (call $fmod - (get_local $0) - (get_local $1) - ) - (get_local $2) - (get_local $3) - (get_local $4) - ) - ) - (func $fmodf (; 8 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func "$(lib)/math/NativeMathf.mod" (; 133 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (local $2 i32) (local $3 i32) (local $4 i32) @@ -817,63 +9473,9 @@ (get_local $0) ) ) - (func $std/math/check (; 9 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (local $4 f32) - (if - (f32.ne - (tee_local $4 - (get_local $1) - ) - (get_local $4) - ) - (if - (f32.eq - (tee_local $4 - (get_local $0) - ) - (get_local $4) - ) - (unreachable) - ) - (if - (f32.ne - (get_local $0) - (get_local $1) - ) - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.eqz - (i32.and - (get_local $3) - (i32.const 1) - ) - ) - ) - (get_local $3) - (f32.gt - (f32.abs - (f32.sub - (get_local $0) - (get_local $1) - ) - ) - (f32.abs - (get_local $2) - ) - ) - ) - (i32.const 1) - ) - (unreachable) - ) - ) - ) - ) - (func $std/math/test_fmodf (; 10 ;) (type $ffffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) + (func $std/math/test_modf (; 134 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) (call $std/math/check - (call $fmodf + (call "$(lib)/math/NativeMathf.mod" (get_local $0) (get_local $1) ) @@ -882,1167 +9484,7 @@ (get_local $4) ) ) - (func "$(lib)/math/NativeMath.log" (; 11 ;) (type $FF) (param $0 f64) (result f64) - (local $1 i32) - (local $2 i32) - (local $3 i64) - (local $4 f64) - (local $5 i32) - (local $6 f64) - (local $7 f64) - (local $8 f64) - (if - (i32.and - (if (result i32) - (tee_local $5 - (i32.lt_u - (tee_local $1 - (i32.wrap/i64 - (i64.shr_u - (tee_local $3 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (i64.const 32) - ) - ) - ) - (i32.const 1048576) - ) - ) - (get_local $5) - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - ) - (i32.const 1) - ) - (block - (if - (i64.eq - (i64.shl - (get_local $3) - (i64.const 1) - ) - (i64.const 0) - ) - (return - (f64.div - (f64.const -1) - (f64.mul - (get_local $0) - (get_local $0) - ) - ) - ) - ) - (if - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - (return - (f64.div - (f64.sub - (get_local $0) - (get_local $0) - ) - (f64.const 0) - ) - ) - ) - (set_local $2 - (i32.sub - (get_local $2) - (i32.const 54) - ) - ) - (set_local $1 - (i32.wrap/i64 - (i64.shr_u - (tee_local $3 - (i64.reinterpret/f64 - (f64.mul - (get_local $0) - (f64.const 18014398509481984) - ) - ) - ) - (i64.const 32) - ) - ) - ) - ) - (if - (i32.ge_u - (get_local $1) - (i32.const 2146435072) - ) - (return - (get_local $0) - ) - (if - (i32.and - (if (result i32) - (tee_local $5 - (i32.eq - (get_local $1) - (i32.const 1072693248) - ) - ) - (i64.eq - (i64.shl - (get_local $3) - (i64.const 32) - ) - (i64.const 0) - ) - (get_local $5) - ) - (i32.const 1) - ) - (return - (f64.const 0) - ) - ) - ) - ) - (set_local $2 - (i32.add - (get_local $2) - (i32.sub - (i32.shr_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 614242) - ) - ) - (i32.const 20) - ) - (i32.const 1023) - ) - ) - ) - (set_local $6 - (f64.mul - (f64.mul - (f64.const 0.5) - (tee_local $4 - (f64.sub - (f64.reinterpret/i64 - (i64.or - (i64.shl - (i64.extend_u/i32 - (i32.add - (i32.and - (get_local $1) - (i32.const 1048575) - ) - (i32.const 1072079006) - ) - ) - (i64.const 32) - ) - (i64.and - (get_local $3) - (i64.const 4294967295) - ) - ) - ) - (f64.const 1) - ) - ) - ) - (get_local $4) - ) - ) - (set_local $0 - (f64.mul - (tee_local $8 - (f64.mul - (tee_local $7 - (f64.div - (get_local $4) - (f64.add - (f64.const 2) - (get_local $4) - ) - ) - ) - (get_local $7) - ) - ) - (get_local $8) - ) - ) - (f64.add - (f64.add - (f64.sub - (f64.add - (f64.mul - (get_local $7) - (f64.add - (get_local $6) - (f64.add - (f64.mul - (get_local $8) - (f64.add - (f64.const 0.6666666666666735) - (f64.mul - (get_local $0) - (f64.add - (f64.const 0.2857142874366239) - (f64.mul - (get_local $0) - (f64.add - (f64.const 0.1818357216161805) - (f64.mul - (get_local $0) - (f64.const 0.14798198605116586) - ) - ) - ) - ) - ) - ) - ) - (f64.mul - (get_local $0) - (f64.add - (f64.const 0.3999999999940942) - (f64.mul - (get_local $0) - (f64.add - (f64.const 0.22222198432149784) - (f64.mul - (get_local $0) - (f64.const 0.15313837699209373) - ) - ) - ) - ) - ) - ) - ) - ) - (f64.mul - (f64.convert_s/i32 - (get_local $2) - ) - (f64.const 1.9082149292705877e-10) - ) - ) - (get_local $6) - ) - (get_local $4) - ) - (f64.mul - (f64.convert_s/i32 - (get_local $2) - ) - (f64.const 0.6931471803691238) - ) - ) - ) - (func $std/math/test_log (; 12 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.log" (; 13 ;) (type $ff) (param $0 f32) (result f32) - (local $1 i32) - (local $2 i32) - (local $3 f32) - (local $4 f32) - (local $5 f32) - (local $6 i32) - (if - (i32.and - (if (result i32) - (tee_local $6 - (i32.lt_u - (tee_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (i32.const 8388608) - ) - ) - (get_local $6) - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - ) - (i32.const 1) - ) - (block - (if - (i32.eqz - (i32.shl - (get_local $1) - (i32.const 1) - ) - ) - (return - (f32.div - (f32.const -1) - (f32.mul - (get_local $0) - (get_local $0) - ) - ) - ) - ) - (if - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - (return - (f32.div - (f32.sub - (get_local $0) - (get_local $0) - ) - (f32.const 0) - ) - ) - ) - (set_local $2 - (i32.sub - (get_local $2) - (i32.const 25) - ) - ) - (set_local $1 - (i32.reinterpret/f32 - (f32.mul - (get_local $0) - (f32.const 33554432) - ) - ) - ) - ) - (if - (i32.ge_u - (get_local $1) - (i32.const 2139095040) - ) - (return - (get_local $0) - ) - (if - (i32.eq - (get_local $1) - (i32.const 1065353216) - ) - (return - (f32.const 0) - ) - ) - ) - ) - (set_local $2 - (i32.add - (get_local $2) - (i32.sub - (i32.shr_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 4913933) - ) - ) - (i32.const 23) - ) - (i32.const 127) - ) - ) - ) - (set_local $3 - (f32.mul - (tee_local $5 - (f32.mul - (tee_local $4 - (f32.div - (tee_local $0 - (f32.sub - (f32.reinterpret/i32 - (i32.add - (i32.and - (get_local $1) - (i32.const 8388607) - ) - (i32.const 1060439283) - ) - ) - (f32.const 1) - ) - ) - (f32.add - (f32.const 2) - (get_local $0) - ) - ) - ) - (get_local $4) - ) - ) - (get_local $5) - ) - ) - (f32.add - (f32.add - (f32.sub - (f32.add - (f32.mul - (get_local $4) - (f32.add - (tee_local $4 - (f32.mul - (f32.mul - (f32.const 0.5) - (get_local $0) - ) - (get_local $0) - ) - ) - (f32.add - (f32.mul - (get_local $5) - (f32.add - (f32.const 0.6666666269302368) - (f32.mul - (get_local $3) - (f32.const 0.2849878668785095) - ) - ) - ) - (f32.mul - (get_local $3) - (f32.add - (f32.const 0.40000972151756287) - (f32.mul - (get_local $3) - (f32.const 0.24279078841209412) - ) - ) - ) - ) - ) - ) - (f32.mul - (tee_local $3 - (f32.convert_s/i32 - (get_local $2) - ) - ) - (f32.const 9.05800061445916e-06) - ) - ) - (get_local $4) - ) - (get_local $0) - ) - (f32.mul - (get_local $3) - (f32.const 0.6931381225585938) - ) - ) - ) - (func $std/math/test_logf (; 14 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.scalbn" (; 15 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) - (local $2 f64) - (set_local $2 - (get_local $0) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 1023) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 8988465674311579538646525e283) - ) - ) - (if - (i32.gt_s - (tee_local $1 - (i32.sub - (get_local $1) - (i32.const 1023) - ) - ) - (i32.const 1023) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 8988465674311579538646525e283) - ) - ) - (if - (i32.gt_s - (tee_local $1 - (i32.sub - (get_local $1) - (i32.const 1023) - ) - ) - (i32.const 1023) - ) - (set_local $1 - (i32.const 1023) - ) - ) - ) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -1022) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 2.2250738585072014e-308) - ) - ) - (if - (i32.lt_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 1022) - ) - ) - (i32.const -1022) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 2.2250738585072014e-308) - ) - ) - (if - (i32.lt_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 1022) - ) - ) - (i32.const -1022) - ) - (set_local $1 - (i32.const -1022) - ) - ) - ) - ) - ) - ) - ) - (f64.mul - (get_local $2) - (f64.reinterpret/i64 - (i64.shl - (i64.add - (i64.extend_u/i32 - (get_local $1) - ) - (i64.const 1023) - ) - (i64.const 52) - ) - ) - ) - ) - (func "$(lib)/math/NativeMath.exp" (; 16 ;) (type $FF) (param $0 f64) (result f64) - (local $1 i32) - (local $2 f64) - (local $3 f64) - (if - (i32.ge_u - (tee_local $1 - (i32.and - (i32.wrap/i64 - (i64.shr_u - (i64.reinterpret/f64 - (get_local $0) - ) - (i64.const 32) - ) - ) - (i32.const 2147483647) - ) - ) - (i32.const 1082532651) - ) - (block - (if - (f64.ne - (tee_local $2 - (get_local $0) - ) - (get_local $2) - ) - (return - (get_local $0) - ) - ) - (if - (f64.gt - (get_local $0) - (f64.const 709.782712893384) - ) - (return - (f64.mul - (get_local $0) - (f64.const 8988465674311579538646525e283) - ) - ) - ) - (if - (f64.lt - (get_local $0) - (f64.const -708.3964185322641) - ) - (if - (f64.lt - (get_local $0) - (f64.const -745.1332191019411) - ) - (return - (f64.const 0) - ) - ) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 1071001154) - ) - (set_local $0 - (f64.sub - (tee_local $2 - (f64.sub - (get_local $0) - (f64.mul - (f64.convert_s/i32 - (tee_local $1 - (if (result i32) - (i32.ge_u - (get_local $1) - (i32.const 1072734898) - ) - (i32.trunc_s/f64 - (f64.add - (f64.mul - (f64.const 1.4426950408889634) - (get_local $0) - ) - (f64.copysign - (f64.const 0.5) - (get_local $0) - ) - ) - ) - (i32.sub - (i32.sub - (i32.const 1) - (tee_local $1 - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - ) - ) - (get_local $1) - ) - ) - ) - ) - (f64.const 0.6931471803691238) - ) - ) - ) - (tee_local $3 - (f64.mul - (f64.convert_s/i32 - (get_local $1) - ) - (f64.const 1.9082149292705877e-10) - ) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 1043333120) - ) - (block - (set_local $1 - (i32.const 0) - ) - (set_local $2 - (get_local $0) - ) - ) - (return - (f64.add - (f64.const 1) - (get_local $0) - ) - ) - ) - ) - (set_local $0 - (f64.add - (f64.const 1) - (f64.add - (f64.sub - (f64.div - (f64.mul - (get_local $0) - (tee_local $0 - (f64.sub - (get_local $0) - (f64.mul - (tee_local $0 - (f64.mul - (get_local $0) - (get_local $0) - ) - ) - (f64.add - (f64.const 0.16666666666666602) - (f64.mul - (get_local $0) - (f64.add - (f64.const -2.7777777777015593e-03) - (f64.mul - (get_local $0) - (f64.add - (f64.const 6.613756321437934e-05) - (f64.mul - (get_local $0) - (f64.add - (f64.const -1.6533902205465252e-06) - (f64.mul - (get_local $0) - (f64.const 4.1381367970572385e-08) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - (f64.sub - (f64.const 2) - (get_local $0) - ) - ) - (get_local $3) - ) - (get_local $2) - ) - ) - ) - (if - (i32.eqz - (get_local $1) - ) - (return - (get_local $0) - ) - ) - (call "$(lib)/math/NativeMath.scalbn" - (get_local $0) - (get_local $1) - ) - ) - (func $std/math/test_exp (; 17 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.scalbn" (; 18 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) - (local $2 f32) - (set_local $2 - (get_local $0) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 127) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1701411834604692317316873e14) - ) - ) - (if - (i32.gt_s - (tee_local $1 - (i32.sub - (get_local $1) - (i32.const 127) - ) - ) - (i32.const 127) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1701411834604692317316873e14) - ) - ) - (if - (i32.gt_s - (tee_local $1 - (i32.sub - (get_local $1) - (i32.const 127) - ) - ) - (i32.const 127) - ) - (set_local $1 - (i32.const 127) - ) - ) - ) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -126) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1.1754943508222875e-38) - ) - ) - (if - (i32.lt_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 126) - ) - ) - (i32.const -126) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1.1754943508222875e-38) - ) - ) - (if - (i32.lt_s - (tee_local $1 - (i32.add - (get_local $1) - (i32.const 126) - ) - ) - (i32.const -126) - ) - (set_local $1 - (i32.const -126) - ) - ) - ) - ) - ) - ) - ) - (f32.mul - (get_local $2) - (f32.reinterpret/i32 - (i32.shl - (i32.add - (get_local $1) - (i32.const 127) - ) - (i32.const 23) - ) - ) - ) - ) - (func "$(lib)/math/NativeMathf.exp" (; 19 ;) (type $ff) (param $0 f32) (result f32) - (local $1 i32) - (local $2 i32) - (local $3 f32) - (local $4 f32) - (local $5 i32) - (set_local $2 - (i32.shr_u - (tee_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (i32.const 31) - ) - ) - (if - (i32.ge_u - (tee_local $1 - (i32.and - (get_local $1) - (i32.const 2147483647) - ) - ) - (i32.const 1118743632) - ) - (block - (if - (i32.and - (if (result i32) - (tee_local $5 - (i32.ge_u - (get_local $1) - (i32.const 1118925336) - ) - ) - (i32.eqz - (get_local $2) - ) - (get_local $5) - ) - (i32.const 1) - ) - (return - (f32.mul - (get_local $0) - (f32.const 1701411834604692317316873e14) - ) - ) - ) - (if - (get_local $2) - (if - (i32.ge_u - (get_local $1) - (i32.const 1120924085) - ) - (return - (f32.const 0) - ) - ) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 1051816472) - ) - (set_local $0 - (f32.sub - (tee_local $3 - (f32.sub - (get_local $0) - (f32.mul - (f32.convert_s/i32 - (tee_local $1 - (if (result i32) - (i32.gt_u - (get_local $1) - (i32.const 1065686418) - ) - (i32.trunc_s/f32 - (f32.add - (f32.mul - (f32.const 1.4426950216293335) - (get_local $0) - ) - (f32.copysign - (f32.const 0.5) - (get_local $0) - ) - ) - ) - (i32.sub - (i32.sub - (i32.const 1) - (get_local $2) - ) - (get_local $2) - ) - ) - ) - ) - (f32.const 0.693145751953125) - ) - ) - ) - (tee_local $4 - (f32.mul - (f32.convert_s/i32 - (get_local $1) - ) - (f32.const 1.428606765330187e-06) - ) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 956301312) - ) - (block - (set_local $1 - (i32.const 0) - ) - (set_local $3 - (get_local $0) - ) - ) - (return - (f32.add - (f32.const 1) - (get_local $0) - ) - ) - ) - ) - (set_local $0 - (f32.add - (f32.const 1) - (f32.add - (f32.sub - (f32.div - (f32.mul - (get_local $0) - (tee_local $0 - (f32.sub - (get_local $0) - (f32.mul - (tee_local $0 - (f32.mul - (get_local $0) - (get_local $0) - ) - ) - (f32.add - (f32.const 0.16666625440120697) - (f32.mul - (get_local $0) - (f32.const -2.7667332906275988e-03) - ) - ) - ) - ) - ) - ) - (f32.sub - (f32.const 2) - (get_local $0) - ) - ) - (get_local $4) - ) - (get_local $3) - ) - ) - ) - (if - (i32.eqz - (get_local $1) - ) - (return - (get_local $0) - ) - ) - (call "$(lib)/math/NativeMathf.scalbn" - (get_local $0) - (get_local $1) - ) - ) - (func $std/math/test_expf (; 20 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.sqrt" (; 21 ;) (type $FF) (param $0 f64) (result f64) - (f64.sqrt - (get_local $0) - ) - ) - (func "$(lib)/math/NativeMath.pow" (; 22 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func "$(lib)/math/NativeMath.pow" (; 135 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 f64) (local $3 f64) (local $4 i32) @@ -2106,7 +9548,7 @@ (i32.const 2147483647) ) ) - (tee_local $7 + (tee_local $6 (i32.wrap/i64 (get_local $19) ) @@ -2120,41 +9562,21 @@ (if (i32.and (if (result i32) - (tee_local $6 - (i32.eq - (get_local $4) - (i32.const 1072693248) - ) - ) - (i32.eqz - (get_local $13) - ) - (get_local $6) - ) - (i32.const 1) - ) - (return - (f64.const 1) - ) - ) - (if - (i32.and - (if (result i32) - (tee_local $6 + (tee_local $7 (i32.and (if (result i32) - (tee_local $6 + (tee_local $7 (i32.and (if (result i32) - (tee_local $6 + (tee_local $7 (i32.gt_s (get_local $5) (i32.const 2146435072) ) ) - (get_local $6) + (get_local $7) (if (result i32) - (tee_local $6 + (tee_local $7 (i32.eq (get_local $5) (i32.const 2146435072) @@ -2164,13 +9586,13 @@ (get_local $13) (i32.const 0) ) - (get_local $6) + (get_local $7) ) ) (i32.const 1) ) ) - (get_local $6) + (get_local $7) (i32.gt_s (get_local $10) (i32.const 2146435072) @@ -2179,19 +9601,19 @@ (i32.const 1) ) ) - (get_local $6) + (get_local $7) (if (result i32) - (tee_local $6 + (tee_local $7 (i32.eq (get_local $10) (i32.const 2146435072) ) ) (i32.ne - (get_local $7) + (get_local $6) (i32.const 0) ) - (get_local $6) + (get_local $7) ) ) (i32.const 1) @@ -2237,9 +9659,9 @@ (if (i32.eq (i32.shl - (tee_local $6 + (tee_local $7 (i32.shr_u - (get_local $7) + (get_local $6) (i32.sub (i32.const 52) (get_local $8) @@ -2251,13 +9673,13 @@ (get_local $8) ) ) - (get_local $7) + (get_local $6) ) (set_local $15 (i32.sub (i32.const 2) (i32.and - (get_local $6) + (get_local $7) (i32.const 1) ) ) @@ -2265,12 +9687,12 @@ ) (if (i32.eqz - (get_local $7) + (get_local $6) ) (if (i32.eq (i32.shl - (tee_local $6 + (tee_local $7 (i32.shr_s (get_local $10) (i32.sub @@ -2290,7 +9712,7 @@ (i32.sub (i32.const 2) (i32.and - (get_local $6) + (get_local $7) (i32.const 1) ) ) @@ -2303,7 +9725,7 @@ ) (if (i32.eqz - (get_local $7) + (get_local $6) ) (block (if @@ -2348,7 +9770,7 @@ ) ) (return - (f64.const 1) + (f64.const nan:0x8000000000000) ) ) ) @@ -2398,7 +9820,7 @@ (i32.const 0) ) (return - (call "$(lib)/math/NativeMath.sqrt" + (f64.sqrt (get_local $0) ) ) @@ -2418,16 +9840,16 @@ (if (i32.and (if (result i32) - (tee_local $6 + (tee_local $7 (i32.and (if (result i32) - (tee_local $6 + (tee_local $7 (i32.eq (get_local $5) (i32.const 2146435072) ) ) - (get_local $6) + (get_local $7) (i32.eqz (get_local $5) ) @@ -2435,7 +9857,7 @@ (i32.const 1) ) ) - (get_local $6) + (get_local $7) (i32.eq (get_local $5) (i32.const 1072693248) @@ -2681,7 +10103,7 @@ (f64.sub (f64.mul (get_local $3) - (f64.const 1.9259629911266174) + (f64.const 1.9259629911266175e-08) ) (f64.mul (get_local $0) @@ -2750,7 +10172,7 @@ ) (set_local $5 (i32.or - (tee_local $7 + (tee_local $6 (i32.and (get_local $5) (i32.const 1048575) @@ -2762,13 +10184,13 @@ (set_local $8 (if (result i32) (i32.le_s - (get_local $7) + (get_local $6) (i32.const 235662) ) (i32.const 0) (if (result i32) (i32.lt_s - (get_local $7) + (get_local $6) (i32.const 767610) ) (i32.const 1) @@ -3077,7 +10499,7 @@ ) ) ) - (set_local $7 + (set_local $6 (i32.wrap/i64 (i64.shr_u (tee_local $19 @@ -3129,14 +10551,14 @@ ) (if (i32.ge_s - (get_local $7) + (get_local $6) (i32.const 1083179008) ) (br_if $folding-inner1 (i32.or (i32.or (i32.sub - (get_local $7) + (get_local $6) (i32.const 1083179008) ) (get_local $13) @@ -3156,7 +10578,7 @@ (if (i32.ge_s (i32.and - (get_local $7) + (get_local $6) (i32.const 2147483647) ) (i32.const 1083231232) @@ -3165,7 +10587,7 @@ (i32.or (i32.or (i32.sub - (get_local $7) + (get_local $6) (i32.const -1064252416) ) (get_local $13) @@ -3186,7 +10608,7 @@ (i32.shr_s (tee_local $13 (i32.and - (get_local $7) + (get_local $6) (i32.const 2147483647) ) ) @@ -3210,7 +10632,7 @@ (i32.and (tee_local $4 (i32.add - (get_local $7) + (get_local $6) (i32.shr_s (i32.const 1048576) (i32.add @@ -3263,7 +10685,7 @@ ) (if (i32.lt_s - (get_local $7) + (get_local $6) (i32.const 0) ) (set_local $4 @@ -3288,7 +10710,7 @@ (if (result f64) (i32.le_s (i32.shr_s - (tee_local $7 + (tee_local $6 (i32.add (i32.wrap/i64 (i64.shr_u @@ -3432,7 +10854,7 @@ ) (i64.shl (i64.extend_u/i32 - (get_local $7) + (get_local $6) ) (i64.const 32) ) @@ -3461,39 +10883,62 @@ (f64.const 1.e+300) ) ) - (func $std/math/test_pow (; 23 ;) (type $FFFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.pow" - (get_local $0) - (get_local $1) + (func $std/math/test_pow (; 136 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.pow" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.const 0) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.pow" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) ) - (get_local $2) - (get_local $3) - (get_local $4) + (i32.const 1) ) ) - (func "$(lib)/math/NativeMathf.pow" (; 24 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func "$(lib)/math/NativeMathf.pow" (; 137 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (local $2 f32) (local $3 f32) (local $4 i32) (local $5 i32) (local $6 i32) - (local $7 f32) - (local $8 i32) + (local $7 i32) + (local $8 f32) (local $9 f32) (local $10 i32) (local $11 i32) (local $12 f32) - (local $13 i32) + (local $13 f32) (local $14 f32) - (local $15 f32) - (local $16 i32) - (local $17 f32) + (local $15 i32) + (local $16 f32) (block $folding-inner1 (block $folding-inner0 (set_local $5 (i32.and - (tee_local $4 + (tee_local $15 (i32.reinterpret/f32 (get_local $0) ) @@ -3518,25 +10963,16 @@ (f32.const 1) ) ) - (if - (i32.eq - (get_local $4) - (i32.const 1065353216) - ) - (return - (f32.const 1) - ) - ) (if (i32.and (if (result i32) - (tee_local $13 + (tee_local $6 (i32.gt_s (get_local $5) (i32.const 2139095040) ) ) - (get_local $13) + (get_local $6) (i32.gt_s (get_local $10) (i32.const 2139095040) @@ -3553,7 +10989,7 @@ ) (if (i32.lt_s - (get_local $4) + (get_local $15) (i32.const 0) ) (if @@ -3561,7 +10997,7 @@ (get_local $10) (i32.const 1266679808) ) - (set_local $16 + (set_local $4 (i32.const 2) ) (if @@ -3572,12 +11008,12 @@ (if (i32.eq (i32.shl - (tee_local $6 + (tee_local $7 (i32.shr_s (get_local $10) (i32.sub (i32.const 23) - (tee_local $8 + (tee_local $6 (i32.sub (i32.shr_s (get_local $10) @@ -3591,16 +11027,16 @@ ) (i32.sub (i32.const 23) - (get_local $8) + (get_local $6) ) ) (get_local $10) ) - (set_local $16 + (set_local $4 (i32.sub (i32.const 2) (i32.and - (get_local $6) + (get_local $7) (i32.const 1) ) ) @@ -3620,7 +11056,7 @@ (i32.const 1065353216) ) (return - (f32.const 1) + (f32.const nan:0x400000) ) (if (i32.gt_s @@ -3690,7 +11126,7 @@ ) (if (i32.ge_s - (get_local $4) + (get_local $15) (i32.const 0) ) (return @@ -3708,16 +11144,16 @@ (if (i32.and (if (result i32) - (tee_local $13 + (tee_local $6 (i32.and (if (result i32) - (tee_local $13 + (tee_local $6 (i32.eq (get_local $5) (i32.const 2139095040) ) ) - (get_local $13) + (get_local $6) (i32.eqz (get_local $5) ) @@ -3725,7 +11161,7 @@ (i32.const 1) ) ) - (get_local $13) + (get_local $6) (i32.eq (get_local $5) (i32.const 1065353216) @@ -3748,7 +11184,7 @@ ) (if (i32.lt_s - (get_local $4) + (get_local $15) (i32.const 0) ) (if @@ -3757,11 +11193,11 @@ (get_local $5) (i32.const 1065353216) ) - (get_local $16) + (get_local $4) ) (if (i32.eq - (get_local $16) + (get_local $4) (i32.const 1) ) (set_local $2 @@ -3794,13 +11230,13 @@ ) (if (i32.lt_s - (get_local $4) + (get_local $15) (i32.const 0) ) (block (if (i32.eqz - (get_local $16) + (get_local $4) ) (return (f32.div @@ -3817,7 +11253,7 @@ ) (if (i32.eq - (get_local $16) + (get_local $4) (i32.const 1) ) (set_local $9 @@ -3915,18 +11351,18 @@ ) ) ) - (set_local $7 + (set_local $8 (f32.reinterpret/i32 (i32.and (i32.reinterpret/f32 (f32.add - (tee_local $14 + (tee_local $13 (f32.mul (f32.const 1.44268798828125) (get_local $3) ) ) - (tee_local $15 + (tee_local $14 (f32.sub (f32.mul (get_local $3) @@ -3945,10 +11381,10 @@ ) ) (f32.sub - (get_local $15) + (get_local $14) (f32.sub - (get_local $7) - (get_local $14) + (get_local $8) + (get_local $13) ) ) ) @@ -3992,7 +11428,7 @@ ) (set_local $5 (i32.or - (tee_local $6 + (tee_local $7 (i32.and (get_local $5) (i32.const 8388607) @@ -4001,16 +11437,16 @@ (i32.const 1065353216) ) ) - (set_local $8 + (set_local $6 (if (result i32) (i32.le_s - (get_local $6) + (get_local $7) (i32.const 1885297) ) (i32.const 0) (if (result i32) (i32.lt_s - (get_local $6) + (get_local $7) (i32.const 6140887) ) (i32.const 1) @@ -4036,9 +11472,9 @@ (f32.reinterpret/i32 (i32.and (i32.reinterpret/f32 - (tee_local $17 + (tee_local $16 (f32.mul - (tee_local $14 + (tee_local $13 (f32.sub (tee_local $2 (f32.reinterpret/i32 @@ -4049,12 +11485,12 @@ (select (f32.const 1.5) (f32.const 1) - (get_local $8) + (get_local $6) ) ) ) ) - (tee_local $15 + (tee_local $14 (f32.div (f32.const 1) (f32.add @@ -4074,7 +11510,7 @@ (f32.sub (get_local $2) (f32.sub - (tee_local $7 + (tee_local $8 (f32.reinterpret/i32 (i32.add (i32.add @@ -4091,7 +11527,7 @@ (i32.const 4194304) ) (i32.shl - (get_local $8) + (get_local $6) (i32.const 21) ) ) @@ -4109,8 +11545,8 @@ (f32.mul (tee_local $12 (f32.mul - (get_local $17) - (get_local $17) + (get_local $16) + (get_local $16) ) ) (get_local $12) @@ -4150,13 +11586,13 @@ (f32.mul (tee_local $0 (f32.mul - (get_local $15) + (get_local $14) (f32.sub (f32.sub - (get_local $14) + (get_local $13) (f32.mul (get_local $3) - (get_local $7) + (get_local $8) ) ) (f32.mul @@ -4168,14 +11604,14 @@ ) (f32.add (get_local $3) - (get_local $17) + (get_local $16) ) ) ) ) (f32.sub (f32.sub - (tee_local $7 + (tee_local $8 (f32.reinterpret/i32 (i32.and (i32.reinterpret/f32 @@ -4202,14 +11638,14 @@ ) ) ) - (set_local $7 + (set_local $8 (f32.reinterpret/i32 (i32.and (i32.reinterpret/f32 (f32.add (f32.add (f32.add - (tee_local $17 + (tee_local $16 (f32.mul (f32.const 0.9619140625) (tee_local $0 @@ -4217,21 +11653,21 @@ (i32.and (i32.reinterpret/f32 (f32.add - (tee_local $14 + (tee_local $13 (f32.mul (get_local $3) - (get_local $7) + (get_local $8) ) ) - (tee_local $15 + (tee_local $14 (f32.add (f32.mul (get_local $0) - (get_local $7) + (get_local $8) ) (f32.mul (get_local $2) - (get_local $17) + (get_local $16) ) ) ) @@ -4252,10 +11688,10 @@ ) (f32.mul (f32.sub - (get_local $15) + (get_local $14) (f32.sub (get_local $0) - (get_local $14) + (get_local $13) ) ) (f32.const 0.9617967009544373) @@ -4264,7 +11700,7 @@ (select (f32.const 1.5632208487659227e-06) (f32.const 0) - (get_local $8) + (get_local $6) ) ) ) @@ -4273,7 +11709,7 @@ (select (f32.const 0.5849609375) (f32.const 0) - (get_local $8) + (get_local $6) ) ) ) @@ -4293,12 +11729,12 @@ (f32.sub (f32.sub (f32.sub - (get_local $7) + (get_local $8) (get_local $3) ) (get_local $0) ) - (get_local $17) + (get_local $16) ) ) ) @@ -4306,7 +11742,7 @@ ) (br_if $folding-inner1 (i32.gt_s - (tee_local $6 + (tee_local $7 (i32.reinterpret/f32 (tee_local $2 (f32.add @@ -4326,7 +11762,7 @@ ) ) ) - (get_local $7) + (get_local $8) ) (f32.mul (get_local $1) @@ -4337,7 +11773,7 @@ (tee_local $0 (f32.mul (get_local $0) - (get_local $7) + (get_local $8) ) ) ) @@ -4349,7 +11785,7 @@ ) (if (i32.eq - (get_local $6) + (get_local $7) (i32.const 1124073472) ) (br_if $folding-inner1 @@ -4367,7 +11803,7 @@ (if (i32.gt_s (i32.and - (get_local $6) + (get_local $7) (i32.const 2147483647) ) (i32.const 1125515264) @@ -4375,7 +11811,7 @@ (br $folding-inner0) (if (i32.eq - (get_local $6) + (get_local $7) (i32.const -1021968384) ) (br_if $folding-inner0 @@ -4390,12 +11826,12 @@ ) ) ) - (set_local $8 + (set_local $6 (i32.sub (i32.shr_s - (tee_local $13 + (tee_local $15 (i32.and - (get_local $6) + (get_local $7) (i32.const 2147483647) ) ) @@ -4409,21 +11845,21 @@ ) (if (i32.gt_s - (get_local $13) + (get_local $15) (i32.const 1056964608) ) (block - (set_local $8 + (set_local $6 (i32.sub (i32.shr_s (i32.and (tee_local $4 (i32.add - (get_local $6) + (get_local $7) (i32.shr_s (i32.const 8388608) (i32.add - (get_local $8) + (get_local $6) (i32.const 1) ) ) @@ -4443,7 +11879,7 @@ (i32.xor (i32.shr_s (i32.const 8388607) - (get_local $8) + (get_local $6) ) (i32.const -1) ) @@ -4461,13 +11897,13 @@ ) (i32.sub (i32.const 23) - (get_local $8) + (get_local $6) ) ) ) (if (i32.lt_s - (get_local $6) + (get_local $7) (i32.const 0) ) (set_local $4 @@ -4492,7 +11928,7 @@ (if (result f32) (i32.le_s (i32.shr_s - (tee_local $6 + (tee_local $7 (i32.add (i32.reinterpret/f32 (tee_local $2 @@ -4504,7 +11940,7 @@ (f32.mul (tee_local $2 (f32.add - (tee_local $14 + (tee_local $13 (f32.mul (tee_local $3 (f32.reinterpret/i32 @@ -4522,7 +11958,7 @@ (f32.const 0.693145751953125) ) ) - (tee_local $15 + (tee_local $14 (f32.add (f32.mul (f32.sub @@ -4542,7 +11978,7 @@ ) ) ) - (tee_local $7 + (tee_local $8 (f32.sub (get_local $2) (f32.mul @@ -4582,17 +12018,17 @@ ) ) (f32.sub - (get_local $7) + (get_local $8) (f32.const 2) ) ) (f32.add (tee_local $0 (f32.sub - (get_local $15) + (get_local $14) (f32.sub (get_local $2) - (get_local $14) + (get_local $13) ) ) ) @@ -4622,7 +12058,7 @@ (get_local $4) ) (f32.reinterpret/i32 - (get_local $6) + (get_local $7) ) ) ) @@ -4647,7 +12083,7 @@ (f32.const 1000000015047466219876688e6) ) ) - (func $std/math/test_powf (; 25 ;) (type $ffffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) + (func $std/math/test_powf (; 138 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) (call $std/math/check (call "$(lib)/math/NativeMathf.pow" (get_local $0) @@ -4658,370 +12094,7 @@ (get_local $4) ) ) - (func "$(lib)/math/NativeMath.cbrt" (; 26 ;) (type $FF) (param $0 f64) (result f64) - (local $1 f64) - (local $2 f64) - (local $3 i32) - (local $4 i64) - (if - (i32.ge_u - (tee_local $3 - (i32.and - (i32.wrap/i64 - (i64.shr_u - (tee_local $4 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (i64.const 32) - ) - ) - (i32.const 2147483647) - ) - ) - (i32.const 2146435072) - ) - (return - (f64.add - (get_local $0) - (get_local $0) - ) - ) - ) - (set_local $3 - (if (result i32) - (i32.lt_u - (get_local $3) - (i32.const 1048576) - ) - (block (result i32) - (if - (i32.eqz - (tee_local $3 - (i32.and - (i32.wrap/i64 - (i64.shr_u - (tee_local $4 - (i64.reinterpret/f64 - (f64.mul - (get_local $0) - (f64.const 18014398509481984) - ) - ) - ) - (i64.const 32) - ) - ) - (i32.const 2147483647) - ) - ) - ) - (return - (get_local $0) - ) - ) - (i32.add - (i32.div_u - (get_local $3) - (i32.const 3) - ) - (i32.const 696219795) - ) - ) - (i32.add - (i32.div_u - (get_local $3) - (i32.const 3) - ) - (i32.const 715094163) - ) - ) - ) - (set_local $2 - (f64.mul - (f64.mul - (tee_local $1 - (f64.reinterpret/i64 - (i64.or - (i64.and - (get_local $4) - (i64.const -9223372036854775808) - ) - (i64.shl - (i64.extend_u/i32 - (get_local $3) - ) - (i64.const 32) - ) - ) - ) - ) - (get_local $1) - ) - (f64.div - (get_local $1) - (get_local $0) - ) - ) - ) - (set_local $2 - (f64.div - (f64.sub - (tee_local $2 - (f64.div - (get_local $0) - (f64.mul - (tee_local $1 - (f64.reinterpret/i64 - (i64.and - (i64.add - (i64.reinterpret/f64 - (f64.mul - (get_local $1) - (f64.add - (f64.add - (f64.const 1.87595182427177) - (f64.mul - (get_local $2) - (f64.add - (f64.const -1.8849797954337717) - (f64.mul - (get_local $2) - (f64.const 1.6214297201053545) - ) - ) - ) - ) - (f64.mul - (f64.mul - (f64.mul - (get_local $2) - (get_local $2) - ) - (get_local $2) - ) - (f64.add - (f64.const -0.758397934778766) - (f64.mul - (get_local $2) - (f64.const 0.14599619288661245) - ) - ) - ) - ) - ) - ) - (i64.const 2147483648) - ) - (i64.const -1073741824) - ) - ) - ) - (get_local $1) - ) - ) - ) - (get_local $1) - ) - (f64.add - (f64.add - (get_local $1) - (get_local $1) - ) - (get_local $2) - ) - ) - ) - (f64.add - (get_local $1) - (f64.mul - (get_local $1) - (get_local $2) - ) - ) - ) - (func $std/math/test_cbrt (; 27 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.cbrt" (; 28 ;) (type $ff) (param $0 f32) (result f32) - (local $1 f64) - (local $2 f64) - (local $3 i32) - (local $4 i32) - (if - (i32.ge_u - (tee_local $3 - (i32.and - (tee_local $4 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (i32.const 2147483647) - ) - ) - (i32.const 2139095040) - ) - (return - (f32.add - (get_local $0) - (get_local $0) - ) - ) - ) - (set_local $3 - (if (result i32) - (i32.lt_u - (get_local $3) - (i32.const 8388608) - ) - (block (result i32) - (if - (i32.eqz - (get_local $3) - ) - (return - (get_local $0) - ) - ) - (i32.add - (i32.div_u - (i32.and - (tee_local $4 - (i32.reinterpret/f32 - (f32.mul - (get_local $0) - (f32.const 16777216) - ) - ) - ) - (i32.const 2147483647) - ) - (i32.const 3) - ) - (i32.const 642849266) - ) - ) - (i32.add - (i32.div_u - (get_local $3) - (i32.const 3) - ) - (i32.const 709958130) - ) - ) - ) - (set_local $2 - (f64.mul - (f64.mul - (tee_local $1 - (f64.promote/f32 - (f32.reinterpret/i32 - (i32.or - (i32.and - (get_local $4) - (i32.const -2147483648) - ) - (get_local $3) - ) - ) - ) - ) - (get_local $1) - ) - (get_local $1) - ) - ) - (set_local $2 - (f64.mul - (f64.mul - (tee_local $1 - (f64.div - (f64.mul - (get_local $1) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (f64.promote/f32 - (get_local $0) - ) - ) - (get_local $2) - ) - ) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (get_local $2) - ) - (get_local $2) - ) - ) - ) - (get_local $1) - ) - (get_local $1) - ) - ) - (f32.demote/f64 - (f64.div - (f64.mul - (get_local $1) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (f64.promote/f32 - (get_local $0) - ) - ) - (get_local $2) - ) - ) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (get_local $2) - ) - (get_local $2) - ) - ) - ) - ) - (func $std/math/test_cbrtf (; 29 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.murmurHash3" (; 30 ;) (type $II) (param $0 i64) (result i64) + (func "$(lib)/math/murmurHash3" (; 139 ;) (type $II) (param $0 i64) (result i64) (i64.xor (tee_local $0 (i64.mul @@ -5052,7 +12125,7 @@ ) ) ) - (func "$(lib)/math/NativeMath.seedRandom" (; 31 ;) (type $Iv) (param $0 i64) + (func "$(lib)/math/NativeMath.seedRandom" (; 140 ;) (type $Iv) (param $0 i64) (if (i64.eqz (get_local $0) @@ -5061,38 +12134,44 @@ (call $abort (i32.const 0) (i32.const 32) - (i32.const 613) + (i32.const 980) (i32.const 4) ) (unreachable) ) ) - (set_global "$(lib)/math/NativeMath.random_seeded" + (set_global "$(lib)/math/random_seeded" (i32.const 1) ) - (set_global "$(lib)/math/NativeMath.random_state0" - (call "$(lib)/math/NativeMath.murmurHash3" + (set_global "$(lib)/math/random_state0" + (call "$(lib)/math/murmurHash3" (get_local $0) ) ) - (set_global "$(lib)/math/NativeMath.random_state1" - (call "$(lib)/math/NativeMath.murmurHash3" - (get_global "$(lib)/math/NativeMath.random_state0") + (set_global "$(lib)/math/random_state1" + (call "$(lib)/math/murmurHash3" + (get_global "$(lib)/math/random_state0") ) ) ) - (func "$(lib)/math/NativeMath.xorShift128Plus" (; 32 ;) (type $I) (result i64) + (func "$(lib)/math/NativeMath.random" (; 141 ;) (type $F) (result f64) (local $0 i64) (local $1 i64) - (set_local $0 - (get_global "$(lib)/math/NativeMath.random_state0") + (if + (i32.eqz + (get_global "$(lib)/math/random_seeded") + ) + (unreachable) ) - (set_global "$(lib)/math/NativeMath.random_state0" + (set_local $0 + (get_global "$(lib)/math/random_state0") + ) + (set_global "$(lib)/math/random_state0" (tee_local $1 - (get_global "$(lib)/math/NativeMath.random_state1") + (get_global "$(lib)/math/random_state1") ) ) - (set_global "$(lib)/math/NativeMath.random_state1" + (set_global "$(lib)/math/random_state1" (tee_local $0 (i64.xor (i64.xor @@ -5120,23 +12199,14 @@ ) ) ) - (i64.add - (get_local $1) - (get_local $0) - ) - ) - (func "$(lib)/math/NativeMath.random" (; 33 ;) (type $F) (result f64) - (if - (i32.eqz - (get_global "$(lib)/math/NativeMath.random_seeded") - ) - (unreachable) - ) (f64.sub (f64.reinterpret/i64 (i64.or (i64.and - (call "$(lib)/math/NativeMath.xorShift128Plus") + (i64.add + (get_local $1) + (get_local $0) + ) (i64.const 4503599627370495) ) (i64.const 4607182418800017408) @@ -5145,3215 +12215,32402 @@ (f64.const 1) ) ) - (func $start (; 34 ;) (type $v) - (local $0 i32) + (func "$(lib)/math/NativeMathf.seedRandom" (; 142 ;) (type $Iv) (param $0 i64) + (call "$(lib)/math/NativeMath.seedRandom" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMathf.random" (; 143 ;) (type $f) (result f32) + (f32.demote/f64 + (call "$(lib)/math/NativeMath.random") + ) + ) + (func "$(lib)/math/NativeMath.round" (; 144 ;) (type $FF) (param $0 f64) (result f64) (local $1 f64) + (local $2 i64) + (local $3 i32) + (if + (i32.ge_s + (tee_local $3 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (i32.const 1075) + ) + (return + (get_local $0) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 1022) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (tee_local $1 + (if (result f64) + (i64.ne + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + (i64.const 0) + ) + (if (result f64) + (f64.ge + (tee_local $1 + (f64.add + (f64.sub + (f64.sub + (f64.const 4503599627370496) + (get_local $0) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (f64.const 0.5) + ) + (f64.add + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + (select + (f64.sub + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (get_local $1) + ) + (f64.lt + (get_local $1) + (f64.const -0.5) + ) + ) + ) + (if (result f64) + (f64.gt + (tee_local $1 + (f64.sub + (f64.sub + (f64.add + (get_local $0) + (f64.const 4503599627370496) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (f64.const 0.5) + ) + (f64.sub + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.const 1) + ) + (select + (f64.add + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (get_local $1) + (get_local $0) + ) + (f64.le + (get_local $1) + (f64.const -0.5) + ) + ) + ) + ) + ) + ) + (func $std/math/test_round (; 145 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMath.round" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMathf.round" (; 146 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) (local $2 i32) - (call $std/math/test_fmod - (f64.const -8.06684839057968) - (f64.const 4.535662560676869) - (f64.const -3.531185829902812) - (f64.const 0) - (i32.const 0) + (local $3 i32) + (if + (i32.ge_s + (tee_local $3 + (i32.and + (i32.shr_u + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (i32.const 150) + ) + (return + (get_local $0) + ) ) - (call $std/math/test_fmod - (f64.const 4.345239849338305) - (f64.const -8.88799136300345) - (f64.const 4.345239849338305) - (f64.const 0) - (i32.const 0) + (if + (i32.lt_s + (get_local $3) + (i32.const 126) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) ) - (call $std/math/test_fmod - (f64.const -8.38143342755525) - (f64.const -2.763607337379588) - (f64.const -0.09061141541648476) - (f64.const 0) - (i32.const 0) + (tee_local $1 + (if (result f32) + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (if (result f32) + (f32.ge + (tee_local $1 + (f32.add + (f32.sub + (f32.sub + (f32.const 8388608) + (get_local $0) + ) + (f32.const 8388608) + ) + (get_local $0) + ) + ) + (f32.const 0.5) + ) + (f32.add + (f32.sub + (get_local $0) + (get_local $1) + ) + (f32.const 1) + ) + (select + (f32.sub + (f32.sub + (get_local $0) + (get_local $1) + ) + (f32.const 1) + ) + (f32.sub + (get_local $0) + (get_local $1) + ) + (f32.lt + (get_local $1) + (f32.const -0.5) + ) + ) + ) + (if (result f32) + (f32.gt + (tee_local $1 + (f32.sub + (f32.sub + (f32.add + (get_local $0) + (f32.const 8388608) + ) + (f32.const 8388608) + ) + (get_local $0) + ) + ) + (f32.const 0.5) + ) + (f32.sub + (f32.add + (get_local $1) + (get_local $0) + ) + (f32.const 1) + ) + (select + (f32.add + (f32.add + (get_local $1) + (get_local $0) + ) + (f32.const 1) + ) + (f32.add + (get_local $1) + (get_local $0) + ) + (f32.le + (get_local $1) + (f32.const -0.5) + ) + ) + ) + ) ) - (call $std/math/test_fmod - (f64.const -6.531673581913484) - (f64.const 4.567535276842744) - (f64.const -1.9641383050707404) - (f64.const 0) - (i32.const 0) + ) + (func $std/math/test_roundf (; 147 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.round" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) ) - (call $std/math/test_fmod - (f64.const 9.267056966972586) - (f64.const 4.811392084359796) - (f64.const 4.45566488261279) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -6.450045556060236) - (f64.const 0.6620717923376739) - (f64.const -0.4913994250211714) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 7.858890253041697) - (f64.const 0.05215452675006225) - (f64.const 0.035711240532359426) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.792054511984896) - (f64.const 7.67640268511754) - (f64.const -0.792054511984896) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0.615702673197924) - (f64.const 2.0119025790324803) - (f64.const 0.615702673197924) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.5587586823609152) - (f64.const 0.03223983060263804) - (f64.const -0.0106815621160685) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) + ) + (func "$(lib)/math/NativeMath.sign" (; 148 ;) (type $FF) (param $0 f64) (result f64) + (select (f64.const 1) - (f64.const 0) - (f64.const 0) + (select + (f64.const -1) + (get_local $0) + (f64.lt + (get_local $0) + (f64.const 0) + ) + ) + (f64.gt + (get_local $0) + (f64.const 0) + ) + ) + ) + (func $std/math/test_sign (; 149 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.sign" (; 150 ;) (type $ff) (param $0 f32) (result f32) + (select + (f32.const 1) + (select + (f32.const -1) + (get_local $0) + (f32.lt + (get_local $0) + (f32.const 0) + ) + ) + (f32.gt + (get_local $0) + (f32.const 0) + ) + ) + ) + (func $std/math/test_signf (; 151 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.rem" (; 152 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i32) + (local $3 i64) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i64) + (local $9 i64) + (local $10 f64) + (local $11 i32) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $9 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $8 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.and + (if (result i32) + (tee_local $4 + (i64.eq + (i64.shl + (get_local $8) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $4) + (f64.ne + (tee_local $10 + (get_local $1) + ) + (get_local $10) + ) + ) + (i32.const 1) + ) + ) + (get_local $4) + (i32.eq + (get_local $2) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.eq + (i64.shl + (get_local $9) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (get_local $9) + ) + (set_local $3 + (if (result i64) + (get_local $2) + (i64.or + (i64.and + (get_local $3) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $5 + (i64.shl + (get_local $3) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eq + (i64.shr_u + (get_local $5) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 1) + ) + ) + (set_local $5 + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i64.shl + (get_local $3) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $2) + ) + ) + ) + ) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $8) + (i64.const 63) + ) + ) + ) + (set_local $8 + (if (result i64) + (get_local $6) + (i64.or + (i64.and + (get_local $8) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $5 + (i64.shl + (get_local $8) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eq + (i64.shr_u + (get_local $5) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $5 + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i64.shl + (get_local $8) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + ) + (set_local $11 + (i32.wrap/i64 + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + ) + (block $break|2 + (loop $continue|2 + (if + (i32.lt_s + (get_local $2) + (get_local $6) + ) + (block + (br_if $break|2 + (i32.eq + (i32.add + (get_local $2) + (i32.const 1) + ) + (get_local $6) + ) + ) + (return + (get_local $0) + ) + ) + ) + (loop $continue|3 + (if + (i32.gt_s + (get_local $2) + (get_local $6) + ) + (block + (if + (i64.eq + (i64.shr_u + (tee_local $5 + (i64.sub + (get_local $3) + (get_local $8) + ) + ) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $3 + (get_local $5) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (set_local $3 + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (set_local $7 + (i32.shl + (get_local $7) + (i32.const 1) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (if + (i64.eq + (i64.shr_u + (tee_local $5 + (i64.sub + (get_local $3) + (get_local $8) + ) + ) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $3 + (get_local $5) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (if + (i64.eq + (get_local $3) + (i64.const 0) + ) + (set_local $2 + (i32.const -60) + ) + (loop $continue|4 + (if + (i64.eq + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + (i64.const 0) + ) + (block + (set_local $3 + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|4) + ) + ) + ) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (tee_local $3 + (select + (i64.or + (i64.sub + (get_local $3) + (i64.const 4503599627370496) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 52) + ) + ) + (i64.shr_u + (get_local $3) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $2) + ) + ) + ) + (i32.gt_s + (get_local $2) + (i32.const 0) + ) + ) + ) + ) + ) + (if + (get_local $4) + (set_local $1 + (f64.neg + (get_local $1) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (get_local $6) + ) + ) + (get_local $4) + (if (result i32) + (tee_local $4 + (i32.eq + (i32.add + (get_local $2) + (i32.const 1) + ) + (get_local $6) + ) + ) + (if (result i32) + (tee_local $4 + (f64.gt + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (get_local $4) + (if (result i32) + (tee_local $4 + (f64.eq + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (i32.and + (get_local $7) + (i32.const 1) + ) + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + (set_local $7 + (i32.add + (get_local $7) + (i32.const 1) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (get_local $11) + ) + ) + (func $std/math/test_rem (; 153 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMath.rem" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMathf.rem" (; 154 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f32) + (local $9 i32) + (local $10 i32) + (set_local $3 + (i32.and + (i32.shr_u + (tee_local $5 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (i32.shr_u + (tee_local $7 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $4 + (get_local $5) + ) + (if + (i32.and + (if (result i32) + (tee_local $2 + (i32.and + (if (result i32) + (tee_local $2 + (i32.eqz + (i32.shl + (get_local $7) + (i32.const 1) + ) + ) + ) + (get_local $2) + (f32.ne + (tee_local $8 + (get_local $1) + ) + (get_local $8) + ) + ) + (i32.const 1) + ) + ) + (get_local $2) + (i32.eq + (get_local $3) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.eqz + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + (return + (get_local $0) + ) + ) + (set_local $4 + (if (result i32) + (get_local $3) + (i32.or + (i32.and + (get_local $4) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $2 + (i32.shl + (get_local $4) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (block + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i32.shl + (get_local $4) + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + ) + ) + ) + (set_local $9 + (i32.shr_u + (get_local $7) + (i32.const 31) + ) + ) + (set_local $7 + (if (result i32) + (get_local $6) + (i32.or + (i32.and + (get_local $7) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $2 + (i32.shl + (get_local $7) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i32.shl + (get_local $7) + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + (set_local $10 + (i32.shr_u + (get_local $5) + (i32.const 31) + ) + ) + (set_local $5 (i32.const 0) ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) + (block $break|2 + (loop $continue|2 + (if + (i32.lt_s + (get_local $3) + (get_local $6) + ) + (block + (br_if $break|2 + (i32.eq + (i32.add + (get_local $3) + (i32.const 1) + ) + (get_local $6) + ) + ) + (return + (get_local $0) + ) + ) + ) + (loop $continue|3 + (if + (i32.gt_s + (get_local $3) + (get_local $6) + ) + (block + (if + (i32.eqz + (i32.shr_u + (tee_local $2 + (i32.sub + (get_local $4) + (get_local $7) + ) + ) + (i32.const 31) + ) + ) + (block + (set_local $4 + (get_local $2) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (set_local $4 + (i32.shl + (get_local $4) + (i32.const 1) + ) + ) + (set_local $5 + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (if + (i32.eqz + (i32.shr_u + (tee_local $2 + (i32.sub + (get_local $4) + (get_local $7) + ) + ) + (i32.const 31) + ) + ) + (block + (set_local $4 + (get_local $2) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (if + (get_local $4) + (loop $continue|4 + (if + (i32.eqz + (i32.shr_u + (get_local $4) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.shl + (get_local $4) + (i32.const 1) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|4) + ) + ) + ) + (set_local $3 + (i32.const -30) + ) + ) + ) ) - (call $std/math/test_fmod + (set_local $0 + (f32.reinterpret/i32 + (tee_local $4 + (select + (i32.or + (i32.sub + (get_local $4) + (i32.const 8388608) + ) + (i32.shl + (get_local $3) + (i32.const 23) + ) + ) + (i32.shr_u + (get_local $4) + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + (i32.gt_s + (get_local $3) + (i32.const 0) + ) + ) + ) + ) + ) + (if + (get_local $9) + (set_local $1 + (f32.neg + (get_local $1) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $2 + (i32.eq + (get_local $3) + (get_local $6) + ) + ) + (get_local $2) + (if (result i32) + (tee_local $2 + (i32.eq + (i32.add + (get_local $3) + (i32.const 1) + ) + (get_local $6) + ) + ) + (if (result i32) + (tee_local $2 + (f32.gt + (f32.mul + (f32.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (get_local $2) + (if (result i32) + (tee_local $2 + (f32.eq + (f32.mul + (f32.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (i32.and + (i32.rem_s + (get_local $5) + (i32.const 2) + ) + (i32.const 1) + ) + (get_local $2) + ) + ) + (get_local $2) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f32.sub + (get_local $0) + (get_local $1) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.const 1) + ) + ) + ) + ) + (select + (f32.neg + (get_local $0) + ) + (get_local $0) + (get_local $10) + ) + ) + (func $std/math/test_remf (; 155 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.rem" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (func "$(lib)/math/NativeMath.sinh" (; 156 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (local $3 i64) + (local $4 i32) + (set_local $2 (f64.const 0.5) - (f64.const 1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) ) - (call $std/math/test_fmod - (f64.const -0.5) - (f64.const 1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.5) - (f64.const 1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.5) - (f64.const 1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 2) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -2) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0.5) - (f64.const -1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.5) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.5) - (f64.const -1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.5) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 2) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -2) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const -inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const inf) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const -inf) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 2) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const 2) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const inf) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const -inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const -inf) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -inf) - (f64.const -inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 1.75) - (f64.const 0.5) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.75) - (f64.const 0.5) - (f64.const -0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.75) - (f64.const -0.5) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.75) - (f64.const -0.5) - (f64.const -0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -8.066848754882812) - (f32.const 4.535662651062012) - (f32.const -3.531186103820801) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 4.345239639282227) - (f32.const -8.887990951538086) - (f32.const 4.345239639282227) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -8.381433486938477) - (f32.const -2.7636072635650635) - (f32.const -0.09061169624328613) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -6.531673431396484) - (f32.const 4.567535400390625) - (f32.const -1.9641380310058594) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 9.267057418823242) - (f32.const 4.811392307281494) - (f32.const 4.455665111541748) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -6.450045585632324) - (f32.const 0.6620717644691467) - (f32.const -0.49139970541000366) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 7.858890056610107) - (f32.const 0.052154526114463806) - (f32.const 0.0357111394405365) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.7920545339584351) - (f32.const 7.676402568817139) - (f32.const -0.7920545339584351) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0.6157026886940002) - (f32.const 2.0119025707244873) - (f32.const 0.6157026886940002) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5587586760520935) - (f32.const 0.03223983198404312) - (f32.const -0.010681532323360443) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf + (if + (i64.ne + (i64.shr_u + (tee_local $3 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 63) + ) + (i64.const 0) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (tee_local $3 + (i64.and + (get_local $3) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.lt_u + (tee_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $3) + (i64.const 32) + ) + ) + ) + (i32.const 1082535490) + ) + (block + (set_local $1 + (call "$(lib)/math/NativeMath.expm1" + (get_local $1) + ) + ) + (if + (i32.lt_u + (get_local $4) + (i32.const 1072693248) + ) + (block + (if + (i32.lt_u + (get_local $4) + (i32.const 1045430272) + ) + (return + (get_local $0) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.sub + (f64.mul + (f64.const 2) + (get_local $1) + ) + (f64.div + (f64.mul + (get_local $1) + (get_local $1) + ) + (f64.add + (get_local $1) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.add + (get_local $1) + (f64.div + (get_local $1) + (f64.add + (get_local $1) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $1) + ) + ) + ) + (func $std/math/test_sinh (; 157 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.sinh" (; 158 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 f32) + (local $3 i32) + (set_local $2 (f32.const 0.5) - (f32.const 1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5) - (f32.const 1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.5) - (f32.const 1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.5) - (f32.const 1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 2) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -2) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0.5) - (f32.const -1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.5) - (f32.const -1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.5) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 2) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -2) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const -inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const inf) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const -inf) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 2) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const 2) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const inf) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const -inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const -inf) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -inf) - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 1.75) - (f32.const 0.5) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.75) - (f32.const 0.5) - (f32.const -0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.75) - (f32.const -0.5) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.75) - (f32.const -0.5) - (f32.const -0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.const -8.06684839057968) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 4.345239849338305) - (f64.const 1.4690809584224322) - (f64.const -0.3412533402442932) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -8.38143342755525) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const -6.531673581913484) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 9.267056966972586) - (f64.const 2.2264658498795615) - (f64.const 0.3638114035129547) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const 0.6619858980995045) - (f64.const -0.4125110252365137) - (f64.const -0.29108747839927673) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -0.4066039223853553) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 0.5617597462207241) - (f64.const -0.5766810183195862) - (f64.const -0.10983199626207352) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const 0.7741522965913037) - (f64.const -0.2559866591263865) - (f64.const -0.057990044355392456) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -0.6787637026394024) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 0) - (f64.const -inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_log - (f64.const -0) - (f64.const -inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_log - (f64.const -7.888609052210118e-31) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.const -inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const 0) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -0) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -7.888609052210118e-31) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const 0) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -0) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -7.888609052210118e-31) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const -8.06684839057968) - (f64.const 3.137706068161745e-04) - (f64.const -0.2599197328090668) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 4.345239849338305) - (f64.const 77.11053017112141) - (f64.const -0.02792675793170929) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -8.38143342755525) - (f64.const 2.290813384916323e-04) - (f64.const -0.24974334239959717) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -6.531673581913484) - (f64.const 1.4565661260931588e-03) - (f64.const -0.4816822409629822) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 9.267056966972586) - (f64.const 10583.558245524993) - (f64.const 0.17696762084960938) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.6619858980995045) - (f64.const 1.9386384525571998) - (f64.const -0.4964246451854706) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -0.4066039223853553) - (f64.const 0.6659078892838025) - (f64.const -0.10608318448066711) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.5617597462207241) - (f64.const 1.7537559518626311) - (f64.const -0.39162111282348633) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.7741522965913037) - (f64.const 2.1687528885129246) - (f64.const -0.2996125817298889) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -0.6787637026394024) - (f64.const 0.5072437089402843) - (f64.const 0.47261738777160645) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const 1) - (f64.const 2.718281828459045) - (f64.const -0.3255307376384735) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -1) - (f64.const 0.36787944117144233) - (f64.const 0.22389651834964752) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const -inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const 1.0397214889526365) - (f64.const 2.828429155876411) - (f64.const 0.18803080916404724) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -1.0397214889526365) - (f64.const 0.35355313670217847) - (f64.const 0.2527272403240204) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 1.0397210121154785) - (f64.const 2.8284278071766122) - (f64.const -0.4184139370918274) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 1.0397214889526367) - (f64.const 2.8284291558764116) - (f64.const -0.22618377208709717) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -8.066848754882812) - (f32.const 3.1377049162983894e-04) - (f32.const -0.030193336308002472) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 4.345239639282227) - (f32.const 77.11051177978516) - (f32.const -0.2875460684299469) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -8.381433486938477) - (f32.const 2.2908132814336568e-04) - (f32.const 0.2237040400505066) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -6.531673431396484) - (f32.const 1.4565663877874613e-03) - (f32.const 0.36469703912734985) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 9.267057418823242) - (f32.const 10583.5634765625) - (f32.const 0.45962104201316833) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.6619858741760254) - (f32.const 1.93863844871521) - (f32.const 0.3568260967731476) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -0.40660393238067627) - (f32.const 0.6659078598022461) - (f32.const -0.38294991850852966) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.5617597699165344) - (f32.const 1.753756046295166) - (f32.const 0.44355490803718567) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.7741522789001465) - (f32.const 2.168752908706665) - (f32.const 0.24562469124794006) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -0.6787636876106262) - (f32.const 0.5072436928749084) - (f32.const -0.3974292278289795) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const 1) - (f32.const 2.7182817459106445) - (f32.const -0.3462330996990204) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -1) - (f32.const 0.3678794503211975) - (f32.const 0.3070148527622223) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const -inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const 88.72283172607422) - (f32.const 340279851902147610656242e15) - (f32.const -0.09067153930664062) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 88.72283935546875) - (f32.const inf) - (f32.const 0) - (i32.const 17) - ) - (call $std/math/test_expf - (f32.const -103.97207641601562) - (f32.const 1.401298464324817e-45) - (f32.const 0.49999967217445374) - (i32.const 9) - ) - (call $std/math/test_expf - (f32.const -103.97208404541016) - (f32.const 0) - (f32.const -0.49999651312828064) - (i32.const 9) - ) - (call $std/math/test_expf - (f32.const 0.3465735614299774) - (f32.const 1.4142135381698608) - (f32.const 0.13922421634197235) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.3465735912322998) - (f32.const 1.4142135381698608) - (f32.const -0.21432916820049286) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.3465736210346222) - (f32.const 1.4142136573791504) - (f32.const 0.43211743235588074) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -8.06684839057968) - (f64.const 4.535662560676869) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 4.345239849338305) - (f64.const -8.88799136300345) - (f64.const 2.1347118825587285e-06) - (f64.const 0.3250160217285156) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -8.38143342755525) - (f64.const -2.763607337379588) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -6.531673581913484) - (f64.const 4.567535276842744) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 9.267056966972586) - (f64.const 4.811392084359796) - (f64.const 44909.29941512966) - (f64.const -0.26659080386161804) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -6.450045556060236) - (f64.const 0.6620717923376739) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 7.858890253041697) - (f64.const 0.05215452675006225) - (f64.const 1.1135177413458652) - (f64.const -0.37168607115745544) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -0.792054511984896) - (f64.const 7.67640268511754) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 0.615702673197924) - (f64.const 2.0119025790324803) - (f64.const 0.37690773521380183) - (f64.const 0.32473301887512207) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -0.5587586823609152) - (f64.const 0.03223983060263804) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 3) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -1) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -2) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -3) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -4) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 3) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -1) - (f64.const -inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -2) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -3) - (f64.const -inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -4) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 2) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -1) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -2) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -3) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 3) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 0.5) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -0.5) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -3) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 1.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 2) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 3) - (f64.const -0.125) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const -inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.const -inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.const -inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 3) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 2) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 1) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const -inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const 3) - (f64.const -inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const 2) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const 1) - (f64.const -inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const -0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -inf) - (f64.const -2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -2) - (f64.const 1) - (f64.const -2) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -2) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -8.066848754882812) - (f32.const 4.535662651062012) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 4.345239639282227) - (f32.const -8.887990951538086) - (f32.const 2.134714122803416e-06) - (f32.const 0.1436440795660019) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -8.381433486938477) - (f32.const -2.7636072635650635) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -6.531673431396484) - (f32.const 4.567535400390625) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 9.267057418823242) - (f32.const 4.811392307281494) - (f32.const 44909.33203125) - (f32.const -0.05356409028172493) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -6.450045585632324) - (f32.const 0.6620717644691467) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 7.858890056610107) - (f32.const 0.052154526114463806) - (f32.const 1.1135177612304688) - (f32.const 0.19122089445590973) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -0.7920545339584351) - (f32.const 7.676402568817139) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 0.6157026886940002) - (f32.const 2.0119025707244873) - (f32.const 0.3769077658653259) - (f32.const 0.337149053812027) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -0.5587586760520935) - (f32.const 0.03223983198404312) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 3) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -1) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -2) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -3) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -4) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 3) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -1) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -2) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -3) - (f32.const -inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -4) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 2) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -1) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -2) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -3) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 3) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 0.5) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -0.5) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -3) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 1.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 2) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 3) - (f32.const -0.125) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const -inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.const -inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.const -inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 3) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 2) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 1) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const -inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const 3) - (f32.const -inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const 2) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const 1) - (f32.const -inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const -0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -inf) - (f32.const -2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -2) - (f32.const 1) - (f32.const -2) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -2) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -8.06684839057968) - (f64.const -2.0055552545020245) - (f64.const 0.46667951345443726) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 4.345239849338305) - (f64.const 1.6318162410515635) - (f64.const -0.08160271495580673) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -8.38143342755525) - (f64.const -2.031293910673361) - (f64.const -0.048101816326379776) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -6.531673581913484) - (f64.const -1.8692820012204925) - (f64.const 0.08624018728733063) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 9.267056966972586) - (f64.const 2.100457720859702) - (f64.const -0.2722989022731781) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.6619858980995045) - (f64.const 0.8715311470455973) - (f64.const 0.4414918124675751) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -0.4066039223853553) - (f64.const -0.740839030300223) - (f64.const 0.016453813761472702) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.5617597462207241) - (f64.const 0.8251195400559286) - (f64.const 0.30680638551712036) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.7741522965913037) - (f64.const 0.9182102478959914) - (f64.const 0.06543998420238495) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -0.6787637026394024) - (f64.const -0.8788326906580094) - (f64.const -0.2016713172197342) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -inf) - (f64.const -inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 0) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -0) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 9.313225746154785e-10) - (f64.const 0.0009765625) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -9.313225746154785e-10) - (f64.const -0.0009765625) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 1) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -1) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 8) - (f64.const 2) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -8.066848754882812) - (f32.const -2.0055553913116455) - (f32.const -0.44719240069389343) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 4.345239639282227) - (f32.const 1.6318162679672241) - (f32.const 0.44636252522468567) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -8.381433486938477) - (f32.const -2.0312938690185547) - (f32.const 0.19483426213264465) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -6.531673431396484) - (f32.const -1.8692820072174072) - (f32.const -0.17075514793395996) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 9.267057418823242) - (f32.const 2.1004576683044434) - (f32.const -0.36362043023109436) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 0.6619858741760254) - (f32.const 0.8715311288833618) - (f32.const -0.12857209146022797) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -0.40660393238067627) - (f32.const -0.7408390641212463) - (f32.const -0.4655757546424866) - (i32.const 1) ) - (call $std/math/test_cbrtf - (f32.const 0.5617597699165344) - (f32.const 0.8251195549964905) - (f32.const 0.05601907894015312) + (if + (i32.shr_u + (tee_local $3 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 31) + ) + (set_local $2 + (f32.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (f32.reinterpret/i32 + (tee_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $3) + (i32.const 1118925335) + ) + (block + (set_local $1 + (call "$(lib)/math/NativeMathf.expm1" + (get_local $1) + ) + ) + (if + (i32.lt_u + (get_local $3) + (i32.const 1065353216) + ) + (block + (if + (i32.lt_u + (get_local $3) + (i32.const 964689920) + ) + (return + (get_local $0) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.sub + (f32.mul + (f32.const 2) + (get_local $1) + ) + (f32.div + (f32.mul + (get_local $1) + (get_local $1) + ) + (f32.add + (get_local $1) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.add + (get_local $1) + (f32.div + (get_local $1) + (f32.add + (get_local $1) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + (f32.mul + (f32.mul + (f32.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMathf.__expo2" + (get_local $1) + ) + ) + ) + (func $std/math/test_sinhf (; 159 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.sqrt" (; 160 ;) (type $FF) (param $0 f64) (result f64) + (f64.sqrt + (get_local $0) + ) + ) + (func $std/math/test_sqrt (; 161 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) (i32.const 1) ) - (call $std/math/test_cbrtf - (f32.const 0.7741522789001465) - (f32.const 0.9182102680206299) - (f32.const 0.45498204231262207) + ) + (func "$(lib)/math/NativeMathf.sqrt" (; 162 ;) (type $ff) (param $0 f32) (result f32) + (f32.sqrt + (get_local $0) + ) + ) + (func $std/math/test_sqrtf (; 163 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.tanh" (; 164 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (tee_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 63) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (tee_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + ) + ) + (if + (i32.gt_u + (tee_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (i32.const 1071748074) + ) + (set_local $0 + (if (result f64) + (i32.gt_u + (get_local $2) + (i32.const 1077149696) + ) + (f64.sub + (f64.const 1) + (f64.div + (f64.const 0) + (get_local $0) + ) + ) + (f64.sub + (f64.const 1) + (f64.div + (f64.const 2) + (f64.add + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + (f64.const 2) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1070618798) + ) + (set_local $0 + (f64.div + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (f64.add + (get_local $0) + (f64.const 2) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (set_local $0 + (f64.div + (f64.neg + (tee_local $0 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const -2) + (get_local $0) + ) + ) + ) + ) + (f64.add + (get_local $0) + (f64.const 2) + ) + ) + ) + ) + ) + ) + (select + (f64.neg + (get_local $0) + ) + (get_local $0) + (get_local $3) + ) + ) + (func $std/math/test_tanh (; 165 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) (i32.const 1) ) - (call $std/math/test_cbrtf - (f32.const -0.6787636876106262) - (f32.const -0.8788326978683472) - (f32.const -0.22978967428207397) + ) + (func "$(lib)/math/NativeMathf.tanh" (; 166 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (set_local $2 + (i32.shr_u + (tee_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 31) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (tee_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1057791828) + ) + (set_local $0 + (if (result f32) + (i32.gt_u + (get_local $1) + (i32.const 1092616192) + ) + (f32.add + (f32.const 1) + (f32.div + (f32.const 0) + (get_local $0) + ) + ) + (f32.sub + (f32.const 1) + (f32.div + (f32.const 2) + (f32.add + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const 2) + (get_local $0) + ) + ) + (f32.const 2) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1048757624) + ) + (set_local $0 + (f32.div + (tee_local $0 + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const 2) + (get_local $0) + ) + ) + ) + (f32.add + (get_local $0) + (f32.const 2) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 8388608) + ) + (set_local $0 + (f32.div + (f32.neg + (tee_local $0 + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const -2) + (get_local $0) + ) + ) + ) + ) + (f32.add + (get_local $0) + (f32.const 2) + ) + ) + ) + ) + ) + ) + (select + (f32.neg + (get_local $0) + ) + (get_local $0) + (get_local $2) + ) + ) + (func $std/math/test_tanhf (; 167 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func "$(lib)/math/NativeMath.trunc" (; 168 ;) (type $FF) (param $0 f64) (result f64) + (f64.trunc + (get_local $0) + ) + ) + (func $std/math/test_trunc (; 169 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.const 0) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) (i32.const 1) ) - (call $std/math/test_cbrtf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -inf) - (f32.const -inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 0) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -0) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 9.313225746154785e-10) - (f32.const 0.0009765625) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -9.313225746154785e-10) - (f32.const -0.0009765625) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 1) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -1) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 8) - (f32.const 2) - (f32.const 0) - (i32.const 0) + ) + (func "$(lib)/math/NativeMathf.trunc" (; 170 ;) (type $ff) (param $0 f32) (result f32) + (f32.trunc + (get_local $0) + ) + ) + (func $std/math/test_truncf (; 171 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (call $std/math/check + (call "$(lib)/math/NativeMathf.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (func $start (; 172 ;) (type $v) + (local $0 i32) + (local $1 i32) + (local $2 f64) + (local $3 f32) + (if + (i32.eqz + (call $std/math/check + (f64.const 2.718281828459045) + (get_global "$(lib)/math/JSMath.E") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 0.6931471805599453) + (get_global "$(lib)/math/JSMath.LN2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 2.302585092994046) + (get_global "$(lib)/math/JSMath.LN10") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 1.4426950408889634) + (get_global "$(lib)/math/JSMath.LOG2E") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 3.141592653589793) + (get_global "$(lib)/math/JSMath.PI") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 0.7071067811865476) + (get_global "$(lib)/math/JSMath.SQRT1_2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 1.4142135623730951) + (get_global "$(lib)/math/JSMath.SQRT2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 2.7182817459106445) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.E") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 0.6931471824645996) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LN2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 2.3025851249694824) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LN10") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 1.4426950216293335) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LOG2E") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 3.1415927410125732) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.PI") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 0.7071067690849304) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.SQRT1_2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 1.4142135381698608) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.SQRT2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -8.06684839057968) + (i32.const -2) + (f64.const -2.01671209764492) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 4.345239849338305) + (i32.const -1) + (f64.const 2.1726199246691524) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -8.38143342755525) + (i32.const 0) + (f64.const -8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -6.531673581913484) + (i32.const 1) + (f64.const -13.063347163826968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 9.267056966972586) + (i32.const 2) + (f64.const 37.06822786789034) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.6619858980995045) + (i32.const 3) + (f64.const 5.295887184796036) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0.4066039223853553) + (i32.const 4) + (f64.const -6.505662758165685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.5617597462207241) + (i32.const 5) + (f64.const 17.97631187906317) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.7741522965913037) + (i32.const 6) + (f64.const 49.545746981843436) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0.6787637026394024) + (i32.const 7) + (f64.const -86.88175393784351) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0) + (i32.const 2147483647) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0) + (i32.const -2147483647) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0) + (i32.const 2147483647) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const nan:0x8000000000000) + (i32.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const 0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -inf) + (i32.const 0) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 1) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 2147483647) + (f64.const inf) + (f64.const 0) + (i32.const 17) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const nan:0x8000000000000) + (i32.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const 2147483647) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 167) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const -2147483647) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 168) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -inf) + (i32.const 2147483647) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 169) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 8988465674311579538646525e283) + (i32.const -2097) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 170) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 5e-324) + (i32.const 2097) + (f64.const 8988465674311579538646525e283) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 171) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1.000244140625) + (i32.const -1074) + (f64.const 5e-324) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 172) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.7499999999999999) + (i32.const -1073) + (f64.const 5e-324) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 173) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.5000000000000012) + (i32.const -1024) + (f64.const 2.781342323134007e-309) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 174) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -8.066848754882812) + (i32.const -2) + (f32.const -2.016712188720703) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 4.345239639282227) + (i32.const -1) + (f32.const 2.1726198196411133) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -8.381433486938477) + (i32.const 0) + (f32.const -8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -6.531673431396484) + (i32.const 1) + (f32.const -13.063346862792969) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 186) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 9.267057418823242) + (i32.const 2) + (f32.const 37.06822967529297) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 187) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.6619858741760254) + (i32.const 3) + (f32.const 5.295886993408203) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 188) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0.40660393238067627) + (i32.const 4) + (f32.const -6.50566291809082) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 189) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.5617597699165344) + (i32.const 5) + (f32.const 17.9763126373291) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 190) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.7741522789001465) + (i32.const 6) + (f32.const 49.545745849609375) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 191) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0.6787636876106262) + (i32.const 7) + (f32.const -86.88175201416016) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 192) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0) + (i32.const 2147483647) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0) + (i32.const -2147483647) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0) + (i32.const 2147483647) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const nan:0x400000) + (i32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const 0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -inf) + (i32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 1) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 2147483647) + (f32.const inf) + (f32.const 0) + (i32.const 17) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 204) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const nan:0x400000) + (i32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 205) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const 2147483647) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const -2147483647) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -inf) + (i32.const 2147483647) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1701411834604692317316873e14) + (i32.const -276) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1.401298464324817e-45) + (i32.const 276) + (f32.const 1701411834604692317316873e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1.000244140625) + (i32.const -149) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.7499999403953552) + (i32.const -148) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.5000006556510925) + (i32.const -128) + (f32.const 1.4693693398263237e-39) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -8.06684839057968) + (f64.const 8.06684839057968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 225) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 4.345239849338305) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 226) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -8.38143342755525) + (f64.const 8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 227) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -6.531673581913484) + (f64.const 6.531673581913484) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 228) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 9.267056966972586) + (f64.const 9.267056966972586) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 229) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.6619858980995045) + (f64.const 0.6619858980995045) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 230) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0.4066039223853553) + (f64.const 0.4066039223853553) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.5617597462207241) + (f64.const 0.5617597462207241) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.7741522965913037) + (f64.const 0.7741522965913037) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0.6787637026394024) + (f64.const 0.6787637026394024) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 241) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 242) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -8.066848754882812) + (f32.const 8.066848754882812) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 252) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 4.345239639282227) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 253) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -8.381433486938477) + (f32.const 8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 254) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -6.531673431396484) + (f32.const 6.531673431396484) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 255) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 9.267057418823242) + (f32.const 9.267057418823242) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 256) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.6619858741760254) + (f32.const 0.6619858741760254) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 257) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0.40660393238067627) + (f32.const 0.40660393238067627) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 258) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.5617597699165344) + (f32.const 0.5617597699165344) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 259) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.7741522789001465) + (f32.const 0.7741522789001465) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0.6787636876106262) + (f32.const 0.6787636876106262) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 270) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 282) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 283) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 284) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 285) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 286) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.6619858980995045) + (f64.const 0.8473310828433507) + (f64.const -0.41553276777267456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 287) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.4066039223853553) + (f64.const 1.989530071088669) + (f64.const 0.4973946213722229) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 288) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.5617597462207241) + (f64.const 0.9742849645674904) + (f64.const -0.4428897500038147) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 289) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.7741522965913037) + (f64.const 0.6854215158636222) + (f64.const -0.12589527666568756) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.6787637026394024) + (f64.const 2.316874138205964) + (f64.const -0.17284949123859406) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -1) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 298) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 299) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 300) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 301) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.5309227209592985) + (f64.const 2.1304853799705463) + (f64.const 0.1391008496284485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.4939556746399746) + (f64.const 1.0541629875851946) + (f64.const 0.22054767608642578) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.6619858741760254) + (f32.const 0.8473311066627502) + (f32.const -0.13588131964206696) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 317) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.40660393238067627) + (f32.const 1.989530086517334) + (f32.const 0.03764917701482773) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 318) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.5617597699165344) + (f32.const 0.9742849469184875) + (f32.const 0.18443739414215088) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 319) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.7741522789001465) + (f32.const 0.6854215264320374) + (f32.const -0.29158344864845276) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 320) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.6787636876106262) + (f32.const 2.3168740272521973) + (f32.const -0.3795364499092102) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 321) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 324) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -1) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.49965065717697144) + (f32.const 1.0476008653640747) + (f32.const -0.21161814033985138) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.5051405429840088) + (f32.const 2.1003410816192627) + (f32.const -0.20852705836296082) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.5189794898033142) + (f32.const 2.116452932357788) + (f32.const -0.14600826799869537) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 4.345239849338305) + (f64.const 2.1487163980597503) + (f64.const -0.291634738445282) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 9.267056966972586) + (f64.const 2.91668914109908) + (f64.const -0.24191908538341522) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.6619858980995045) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 352) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.5617597462207241) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 353) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.7741522965913037) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 354) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 355) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 358) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 359) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 360) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.9999923706054688) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 361) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 362) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1060831199926429) + (f64.const 0.4566373404384803) + (f64.const -0.29381608963012695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1089809557628658) + (f64.const 0.4627246859959428) + (f64.const -0.3990095555782318) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1169429159875521) + (f64.const 0.47902433134075284) + (f64.const -0.321674108505249) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 392) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 4.345239639282227) + (f32.const 2.148716449737549) + (f32.const 0.4251045286655426) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 393) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 394) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 395) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 9.267057418823242) + (f32.const 2.916689157485962) + (f32.const -0.1369788944721222) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 396) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.6619858741760254) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 397) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 398) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.5617597699165344) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 399) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.7741522789001465) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 400) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 401) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 404) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 405) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 406) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.9999923706054688) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 407) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 408) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 409) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 410) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -1125899906842624) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 411) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.6619858980995045) + (f64.const 0.7234652439515459) + (f64.const -0.13599912822246552) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0.4066039223853553) + (f64.const -0.41873374429377225) + (f64.const -0.09264230728149414) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.5617597462207241) + (f64.const 0.5965113622274062) + (f64.const -0.10864213854074478) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.7741522965913037) + (f64.const 0.8853748109312743) + (f64.const -0.4256366193294525) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0.6787637026394024) + (f64.const -0.7460778114110673) + (f64.const 0.13986606895923615) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 432) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 1) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 435) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -1) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 436) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 437) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 438) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 439) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 440) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 441) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 442) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 443) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.5073043929119148) + (f64.const 0.5320538997772349) + (f64.const -0.16157317161560059) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 453) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 454) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 455) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 456) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 457) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.6619858741760254) + (f32.const 0.7234652042388916) + (f32.const -0.1307632476091385) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 458) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0.40660393238067627) + (f32.const -0.41873374581336975) + (f32.const 0.3161141574382782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.5617597699165344) + (f32.const 0.5965113639831543) + (f32.const -0.4510819613933563) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.7741522789001465) + (f32.const 0.8853747844696045) + (f32.const 0.02493886835873127) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0.6787636876106262) + (f32.const -0.7460777759552002) + (f32.const 0.2515012323856354) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 1) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 465) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -1) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 466) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 467) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 468) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 469) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 470) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 471) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.5004770159721375) + (f32.const 0.5241496562957764) + (f32.const -0.29427099227905273) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -8.06684839057968) + (f64.const -2.784729878387861) + (f64.const -0.4762189984321594) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 4.345239849338305) + (f64.const 2.175213389013164) + (f64.const -0.02728751301765442) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -8.38143342755525) + (f64.const -2.822706083697696) + (f64.const 0.20985257625579834) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 488) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -6.531673581913484) + (f64.const -2.575619446591922) + (f64.const 0.3113134205341339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 489) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 9.267056966972586) + (f64.const 2.9225114951048674) + (f64.const 0.4991756081581116) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 490) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.6619858980995045) + (f64.const 0.6212462762707166) + (f64.const -0.4697347581386566) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 491) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0.4066039223853553) + (f64.const -0.39615990393192035) + (f64.const -0.40814438462257385) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 492) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.5617597462207241) + (f64.const 0.5357588870255474) + (f64.const 0.3520713150501251) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 493) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.7741522965913037) + (f64.const 0.7123571263197349) + (f64.const 0.13371451199054718) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 494) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0.6787637026394024) + (f64.const -0.635182348903198) + (f64.const 0.04749670997262001) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 495) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 498) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 499) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 500) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -8.066848754882812) + (f32.const -2.7847299575805664) + (f32.const -0.14418013393878937) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 531) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 4.345239639282227) + (f32.const 2.17521333694458) + (f32.const -0.020796965807676315) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 532) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -8.381433486938477) + (f32.const -2.8227059841156006) + (f32.const 0.44718533754348755) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -6.531673431396484) + (f32.const -2.5756194591522217) + (f32.const -0.14822272956371307) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 9.267057418823242) + (f32.const 2.922511577606201) + (f32.const 0.14270681142807007) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.6619858741760254) + (f32.const 0.6212462782859802) + (f32.const 0.3684912919998169) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0.40660393238067627) + (f32.const -0.39615991711616516) + (f32.const -0.13170306384563446) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.5617597699165344) + (f32.const 0.535758912563324) + (f32.const 0.08184859901666641) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.7741522789001465) + (f32.const 0.7123571038246155) + (f32.const -0.14270737767219543) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 539) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0.6787636876106262) + (f32.const -0.6351823210716248) + (f32.const 0.2583143711090088) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 540) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 543) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 544) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -8.06684839057968) + (f64.const -1.4474613762633468) + (f64.const 0.14857111871242523) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 559) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 4.345239849338305) + (f64.const 1.344597927114538) + (f64.const -0.08170335739850998) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -8.38143342755525) + (f64.const -1.4520463463295539) + (f64.const -0.07505480200052261) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -6.531673581913484) + (f64.const -1.4188758658752532) + (f64.const -0.057633496820926666) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 9.267056966972586) + (f64.const 1.463303145448706) + (f64.const 0.1606956422328949) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.6619858980995045) + (f64.const 0.5847550670238325) + (f64.const 0.4582556486129761) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0.4066039223853553) + (f64.const -0.3861864177552131) + (f64.const -0.2574281692504883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.5617597462207241) + (f64.const 0.5118269531628881) + (f64.const -0.11444277316331863) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.7741522965913037) + (f64.const 0.6587802431653822) + (f64.const -0.11286488175392151) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0.6787637026394024) + (f64.const -0.5963307826973472) + (f64.const -0.2182842344045639) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 571) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 1) + (f64.const 0.7853981633974483) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -1) + (f64.const -0.7853981633974483) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const inf) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -inf) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.6929821535674624) + (f64.const 0.6060004555152562) + (f64.const -0.17075790464878082) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -8.066848754882812) + (f32.const -1.4474613666534424) + (f32.const 0.12686480581760406) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 587) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 4.345239639282227) + (f32.const 1.3445979356765747) + (f32.const 0.16045434772968292) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -8.381433486938477) + (f32.const -1.4520463943481445) + (f32.const -0.39581751823425293) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -6.531673431396484) + (f32.const -1.418875813484192) + (f32.const 0.410570353269577) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 9.267057418823242) + (f32.const 1.4633032083511353) + (f32.const 0.48403501510620117) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.6619858741760254) + (f32.const 0.5847550630569458) + (f32.const 0.2125193476676941) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0.40660393238067627) + (f32.const -0.386186420917511) + (f32.const 0.18169628083705902) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.5617597699165344) + (f32.const 0.5118269920349121) + (f32.const 0.3499770760536194) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.7741522789001465) + (f32.const 0.6587802171707153) + (f32.const -0.2505330741405487) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0.6787636876106262) + (f32.const -0.5963307619094849) + (f32.const 0.17614826560020447) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 599) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 1) + (f32.const 0.7853981852531433) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -1) + (f32.const -0.7853981852531433) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const inf) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -inf) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 617) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 618) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 619) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.6619858980995045) + (f64.const 0.7963404371347943) + (f64.const 0.21338365972042084) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0.4066039223853553) + (f64.const -0.43153570730602897) + (f64.const -0.4325666129589081) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.5617597462207241) + (f64.const 0.6354006111644578) + (f64.const -0.06527865678071976) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.7741522965913037) + (f64.const 1.0306085575277995) + (f64.const 0.14632052183151245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0.6787637026394024) + (f64.const -0.8268179645205255) + (f64.const 0.1397128701210022) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 630) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 631) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -1) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1.0000152587890625) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -1.0000152587890625) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1.3552527156068805e-20) + (f64.const 1.3552527156068805e-20) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 9.332636185032189e-302) + (f64.const 9.332636185032189e-302) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 5.562684646268003e-309) + (f64.const 5.562684646268003e-309) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 640) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -5.562684646268003e-309) + (f64.const -5.562684646268003e-309) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 641) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 8988465674311579538646525e283) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 642) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.6619858741760254) + (f32.const 0.7963404059410095) + (f32.const 0.19112196564674377) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0.40660393238067627) + (f32.const -0.4315357208251953) + (f32.const -0.05180925130844116) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.5617597699165344) + (f32.const 0.635400652885437) + (f32.const 0.11911056190729141) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 658) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.7741522789001465) + (f32.const 1.0306085348129272) + (f32.const 0.1798270344734192) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 659) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0.6787636876106262) + (f32.const -0.8268179297447205) + (f32.const 0.11588983237743378) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 668) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -1) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 669) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1.0000152587890625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 670) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -1.0000152587890625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 671) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1.3552527156068805e-20) + (f32.const 1.3552527156068805e-20) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 672) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 7.888609052210118e-31) + (f32.const 7.888609052210118e-31) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 673) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 2.938735877055719e-39) + (f32.const 2.938735877055719e-39) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 674) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -2.938735877055719e-39) + (f32.const -2.938735877055719e-39) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 675) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1701411834604692317316873e14) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 676) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -1.0585895402489023) + (f64.const 0.09766263514757156) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 2.6868734126013067) + (f64.const 0.35833948850631714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 689) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -1.889300091849528) + (f64.const -0.46235957741737366) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 690) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -0.9605469021111489) + (f64.const -0.21524477005004883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 1.0919123946142109) + (f64.const 0.3894443213939667) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -1.468508500616424) + (f64.const -0.448591411113739) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 1.5641600512601268) + (f64.const 0.3784842789173126) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.10281658910678508) + (f64.const -0.13993260264396667) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.29697974004493516) + (f64.const 0.44753071665763855) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -1.5131612053303916) + (f64.const 0.39708876609802246) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 700) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const -0) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 701) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const -1) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 702) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const -inf) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 703) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 704) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 705) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const 0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 706) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const -0) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 707) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const -1) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 708) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const -inf) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 709) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 710) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 711) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const 0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 712) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const -0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 713) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 714) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const -0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 715) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 716) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 717) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const -inf) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 718) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const -inf) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 719) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 720) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -inf) + (f64.const 0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 721) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.const inf) + (f64.const 0.7853981633974483) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 722) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.const -inf) + (f64.const 2.356194490192345) + (f64.const -0.20682445168495178) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 723) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -inf) + (f64.const inf) + (f64.const -0.7853981633974483) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 724) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -inf) + (f64.const -inf) + (f64.const -2.356194490192345) + (f64.const 0.20682445168495178) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 725) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.1125369292536007e-308) + (f64.const 1) + (f64.const 1.1125369292536007e-308) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 726) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const 8988465674311579538646525e283) + (f64.const 1.1125369292536007e-308) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 727) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.5) + (f64.const 8988465674311579538646525e283) + (f64.const 1.668805393880401e-308) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 728) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.5) + (f64.const -8988465674311579538646525e283) + (f64.const 3.141592653589793) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 729) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -1.0585895776748657) + (f32.const -0.22352588176727295) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 738) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 2.686873435974121) + (f32.const 0.09464472532272339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 739) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -1.8893001079559326) + (f32.const -0.21941901743412018) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 740) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -0.9605468511581421) + (f32.const 0.46015575528144836) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 741) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 1.0919123888015747) + (f32.const -0.05708503723144531) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 742) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -1.4685084819793701) + (f32.const 0.19611206650733948) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 743) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 1.5641601085662842) + (f32.const 0.48143187165260315) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 744) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.10281659662723541) + (f32.const -0.4216274917125702) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 745) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.29697975516319275) + (f32.const 0.2322007566690445) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 746) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -1.5131611824035645) + (f32.const 0.16620726883411407) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 747) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 750) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const -0) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 751) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const -1) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 752) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const -inf) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 753) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 754) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 755) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const 0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 756) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const -0) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 757) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const -1) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 758) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const -inf) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 759) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 760) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 761) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const 0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 762) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const -0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const -0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 767) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const -inf) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 768) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const -inf) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -inf) + (f32.const 0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.const inf) + (f32.const 0.7853981852531433) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.const -inf) + (f32.const 2.356194496154785) + (f32.const 0.02500828728079796) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 773) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -inf) + (f32.const inf) + (f32.const -0.7853981852531433) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 774) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -inf) + (f32.const -inf) + (f32.const -2.356194496154785) + (f32.const -0.02500828728079796) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 5.877471754111438e-39) + (f32.const 1) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const 1701411834604692317316873e14) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -8.06684839057968) + (f64.const -2.0055552545020245) + (f64.const 0.46667951345443726) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 4.345239849338305) + (f64.const 1.6318162410515635) + (f64.const -0.08160271495580673) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -8.38143342755525) + (f64.const -2.031293910673361) + (f64.const -0.048101816326379776) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -6.531673581913484) + (f64.const -1.8692820012204925) + (f64.const 0.08624018728733063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 9.267056966972586) + (f64.const 2.100457720859702) + (f64.const -0.2722989022731781) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.6619858980995045) + (f64.const 0.8715311470455973) + (f64.const 0.4414918124675751) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0.4066039223853553) + (f64.const -0.740839030300223) + (f64.const 0.016453813761472702) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.5617597462207241) + (f64.const 0.8251195400559286) + (f64.const 0.30680638551712036) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.7741522965913037) + (f64.const 0.9182102478959914) + (f64.const 0.06543998420238495) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0.6787637026394024) + (f64.const -0.8788326906580094) + (f64.const -0.2016713172197342) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 798) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 805) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 9.313225746154785e-10) + (f64.const 0.0009765625) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 806) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -9.313225746154785e-10) + (f64.const -0.0009765625) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 807) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 808) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 809) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 8) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 810) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -8.066848754882812) + (f32.const -2.0055553913116455) + (f32.const -0.44719240069389343) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 4.345239639282227) + (f32.const 1.6318162679672241) + (f32.const 0.44636252522468567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -8.381433486938477) + (f32.const -2.0312938690185547) + (f32.const 0.19483426213264465) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -6.531673431396484) + (f32.const -1.8692820072174072) + (f32.const -0.17075514793395996) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 9.267057418823242) + (f32.const 2.1004576683044434) + (f32.const -0.36362043023109436) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.6619858741760254) + (f32.const 0.8715311288833618) + (f32.const -0.12857209146022797) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0.40660393238067627) + (f32.const -0.7408390641212463) + (f32.const -0.4655757546424866) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.5617597699165344) + (f32.const 0.8251195549964905) + (f32.const 0.05601907894015312) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 826) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.7741522789001465) + (f32.const 0.9182102680206299) + (f32.const 0.45498204231262207) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 827) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0.6787636876106262) + (f32.const -0.8788326978683472) + (f32.const -0.22978967428207397) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 828) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 831) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 832) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 833) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 834) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 835) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 9.313225746154785e-10) + (f32.const 0.0009765625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 836) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -9.313225746154785e-10) + (f32.const -0.0009765625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 837) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 8) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 4.345239849338305) + (f64.const 5) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -6.531673581913484) + (f64.const -6) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 9.267056966972586) + (f64.const 10) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.6619858980995045) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5617597462207241) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.7741522965913037) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.6787637026394024) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 902) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 903) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 904) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 905) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 906) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 907) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 908) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 4.345239639282227) + (f32.const 5) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -6.531673431396484) + (f32.const -6) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 920) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 9.267057418823242) + (f32.const 10) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 921) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.6619858741760254) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5617597699165344) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.7741522789001465) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.6787636876106262) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 926) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 944) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 945) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 946) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 947) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 948) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 949) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 950) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 951) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 952) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 953) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 954) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 955) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 956) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 957) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 958) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 959) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 960) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 961) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 962) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 963) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 964) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 965) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 966) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 967) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 968) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 969) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 970) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 971) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 972) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 973) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -8.06684839057968) + (f64.const 1593.5209938862329) + (f64.const -0.38098856806755066) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 4.345239849338305) + (f64.const 38.56174928426729) + (f64.const -0.2712278366088867) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -8.38143342755525) + (f64.const 2182.630979595893) + (f64.const 0.0817827582359314) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -6.531673581913484) + (f64.const 343.273849250879) + (f64.const -0.429940402507782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 9.267056966972586) + (f64.const 5291.779170005587) + (f64.const -0.1592995822429657) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.6619858980995045) + (f64.const 1.2272321957342842) + (f64.const 0.23280741274356842) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0.4066039223853553) + (f64.const 1.083808541871197) + (f64.const -0.3960916996002197) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.5617597462207241) + (f64.const 1.1619803583175077) + (f64.const 0.37748390436172485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.7741522965913037) + (f64.const 1.3149236876276706) + (f64.const 0.43587008118629456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0.6787637026394024) + (f64.const 1.2393413245934533) + (f64.const 0.10201606154441833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1126) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -8.066848754882812) + (f32.const 1593.5216064453125) + (f32.const 0.26242581009864807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 4.345239639282227) + (f32.const 38.56174087524414) + (f32.const -0.08168885856866837) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -8.381433486938477) + (f32.const 2182.631103515625) + (f32.const -0.02331414446234703) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -6.531673431396484) + (f32.const 343.2738037109375) + (f32.const 0.20081493258476257) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 9.267057418823242) + (f32.const 5291.78173828125) + (f32.const 0.36286723613739014) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.6619858741760254) + (f32.const 1.2272322177886963) + (f32.const 0.32777416706085205) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0.40660393238067627) + (f32.const 1.0838085412979126) + (f32.const -0.039848703891038895) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.5617597699165344) + (f32.const 1.161980390548706) + (f32.const 0.15274477005004883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.7741522789001465) + (f32.const 1.314923644065857) + (f32.const -0.2387111485004425) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0.6787636876106262) + (f32.const 1.2393412590026855) + (f32.const -0.45791932940483093) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -8.06684839057968) + (f64.const 3.137706068161745e-04) + (f64.const -0.2599197328090668) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 4.345239849338305) + (f64.const 77.11053017112141) + (f64.const -0.02792675793170929) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -8.38143342755525) + (f64.const 2.290813384916323e-04) + (f64.const -0.24974334239959717) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -6.531673581913484) + (f64.const 1.4565661260931588e-03) + (f64.const -0.4816822409629822) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 9.267056966972586) + (f64.const 10583.558245524993) + (f64.const 0.17696762084960938) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1167) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.6619858980995045) + (f64.const 1.9386384525571998) + (f64.const -0.4964246451854706) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1168) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0.4066039223853553) + (f64.const 0.6659078892838025) + (f64.const -0.10608318448066711) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1169) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.5617597462207241) + (f64.const 1.7537559518626311) + (f64.const -0.39162111282348633) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1170) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.7741522965913037) + (f64.const 2.1687528885129246) + (f64.const -0.2996125817298889) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1171) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0.6787637026394024) + (f64.const 0.5072437089402843) + (f64.const 0.47261738777160645) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1172) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1175) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1176) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1) + (f64.const 2.718281828459045) + (f64.const -0.3255307376384735) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1177) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -1) + (f64.const 0.36787944117144233) + (f64.const 0.22389651834964752) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1178) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1179) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1180) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1181) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397214889526365) + (f64.const 2.828429155876411) + (f64.const 0.18803080916404724) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1182) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -1.0397214889526365) + (f64.const 0.35355313670217847) + (f64.const 0.2527272403240204) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397210121154785) + (f64.const 2.8284278071766122) + (f64.const -0.4184139370918274) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397214889526367) + (f64.const 2.8284291558764116) + (f64.const -0.22618377208709717) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -8.066848754882812) + (f32.const 3.1377049162983894e-04) + (f32.const -0.030193336308002472) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1194) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 4.345239639282227) + (f32.const 77.11051177978516) + (f32.const -0.2875460684299469) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -8.381433486938477) + (f32.const 2.2908132814336568e-04) + (f32.const 0.2237040400505066) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -6.531673431396484) + (f32.const 1.4565663877874613e-03) + (f32.const 0.36469703912734985) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 9.267057418823242) + (f32.const 10583.5634765625) + (f32.const 0.45962104201316833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.6619858741760254) + (f32.const 1.93863844871521) + (f32.const 0.3568260967731476) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0.40660393238067627) + (f32.const 0.6659078598022461) + (f32.const -0.38294991850852966) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.5617597699165344) + (f32.const 1.753756046295166) + (f32.const 0.44355490803718567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.7741522789001465) + (f32.const 2.168752908706665) + (f32.const 0.24562469124794006) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0.6787636876106262) + (f32.const 0.5072436928749084) + (f32.const -0.3974292278289795) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 1) + (f32.const 2.7182817459106445) + (f32.const -0.3462330996990204) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -1) + (f32.const 0.3678794503211975) + (f32.const 0.3070148527622223) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 88.72283172607422) + (f32.const 340279851902147610656242e15) + (f32.const -0.09067153930664062) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 88.72283935546875) + (f32.const inf) + (f32.const 0) + (i32.const 17) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1214) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -103.97207641601562) + (f32.const 1.401298464324817e-45) + (f32.const 0.49999967217445374) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1215) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -103.97208404541016) + (f32.const 0) + (f32.const -0.49999651312828064) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1216) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465735614299774) + (f32.const 1.4142135381698608) + (f32.const 0.13922421634197235) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1217) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465735912322998) + (f32.const 1.4142135381698608) + (f32.const -0.21432916820049286) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1218) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465736210346222) + (f32.const 1.4142136573791504) + (f32.const 0.43211743235588074) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1219) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -8.06684839057968) + (f64.const -0.9996862293931839) + (f64.const -0.2760058343410492) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 4.345239849338305) + (f64.const 76.11053017112141) + (f64.const -0.02792675793170929) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -8.38143342755525) + (f64.const -0.9997709186615084) + (f64.const 0.10052496194839478) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -6.531673581913484) + (f64.const -0.9985434338739069) + (f64.const -0.27437829971313477) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 9.267056966972586) + (f64.const 10582.558245524993) + (f64.const 0.17696762084960938) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1235) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.6619858980995045) + (f64.const 0.9386384525571999) + (f64.const 0.007150684483349323) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1236) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0.4066039223853553) + (f64.const -0.3340921107161975) + (f64.const -0.21216636896133423) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.5617597462207241) + (f64.const 0.7537559518626312) + (f64.const 0.21675777435302734) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.7741522965913037) + (f64.const 1.1687528885129248) + (f64.const 0.4007748067378998) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0.6787637026394024) + (f64.const -0.4927562910597158) + (f64.const -0.05476519837975502) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1244) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 1) + (f64.const 1.7182818284590453) + (f64.const 0.348938524723053) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1245) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -1) + (f64.const -0.6321205588285577) + (f64.const 0.11194825917482376) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1246) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1247) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1248) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1249) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 2.225073858507201e-308) + (f64.const 2.225073858507201e-308) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1250) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -2.225073858507201e-308) + (f64.const -2.225073858507201e-308) + (f64.const 0) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1251) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -8.066848754882812) + (f32.const -0.9996862411499023) + (f32.const -0.19532723724842072) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 4.345239639282227) + (f32.const 76.11051177978516) + (f32.const -0.2875460684299469) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -8.381433486938477) + (f32.const -0.9997709393501282) + (f32.const -0.34686920046806335) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1262) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -6.531673431396484) + (f32.const -0.9985434412956238) + (f32.const -0.1281939446926117) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1263) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 9.267057418823242) + (f32.const 10582.5634765625) + (f32.const 0.45962104201316833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.6619858741760254) + (f32.const 0.9386383891105652) + (f32.const -0.28634780645370483) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0.40660393238067627) + (f32.const -0.3340921103954315) + (f32.const 0.23410017788410187) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.5617597699165344) + (f32.const 0.7537559866905212) + (f32.const -0.11289017647504807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.7741522789001465) + (f32.const 1.168752908706665) + (f32.const 0.4912493824958801) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0.6787636876106262) + (f32.const -0.49275627732276917) + (f32.const 0.20514154434204102) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1272) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1273) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 1) + (f32.const 1.718281865119934) + (f32.const 0.3075338304042816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1274) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -1) + (f32.const -0.6321205496788025) + (f32.const 0.15350742638111115) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1275) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1276) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1277) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1278) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -8.06684839057968) + (f64.const -9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -8.38143342755525) + (f64.const -9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1292) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -6.531673581913484) + (f64.const -7) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1293) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.6619858980995045) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.4066039223853553) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.5617597462207241) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.7741522965913037) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1298) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.6787637026394024) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1299) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1304) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1305) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1306) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1307) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1308) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1309) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1310) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1311) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -1.0000152587890625) + (f64.const -2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.9999923706054688) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.9999923706054688) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -7.888609052210118e-31) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -8.066848754882812) + (f32.const -9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -8.381433486938477) + (f32.const -9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -6.531673431396484) + (f32.const -7) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.6619858741760254) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.40660393238067627) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.5617597699165344) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.7741522789001465) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.6787636876106262) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1337) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1338) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1339) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1340) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1341) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1342) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1343) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1344) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.5) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1345) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -1.0000152587890625) + (f32.const -2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.9999923706054688) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.9999923706054688) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -7.888609052210118e-31) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 9.25452742288464) + (f64.const -0.31188681721687317) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 9.893305808328252) + (f64.const 0.4593673348426819) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const 8.825301797432132) + (f64.const -0.1701754331588745) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1365) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const 7.970265885519092) + (f64.const -0.3176782727241516) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1366) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 10.441639651824575) + (f64.const -0.2693633437156677) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1367) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 6.483936052542593) + (f64.const 0.35618898272514343) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1368) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 7.859063309581766) + (f64.const 0.08044655621051788) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1369) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const 7.717156764899584) + (f64.const 0.05178084969520569) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1370) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 2.104006123874314) + (f64.const -0.0918039008975029) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1371) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const 0.5596880129062913) + (f64.const 0.1383407711982727) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1372) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 3) + (f64.const 4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1375) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -3) + (f64.const 4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1376) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4) + (f64.const 3) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1377) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4) + (f64.const -3) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1378) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -3) + (f64.const -4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1379) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1797693134862315708145274e284) + (f64.const -0) + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1381) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 5e-324) + (f64.const 0) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 5e-324) + (f64.const -0) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1384) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1385) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1386) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1387) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1388) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1389) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1390) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1391) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1392) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1393) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 9.254528045654297) + (f32.const 0.2735958993434906) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1402) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 9.893305778503418) + (f32.const 0.4530770778656006) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1403) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const 8.825302124023438) + (f32.const 0.30755728483200073) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1404) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const 7.970265865325928) + (f32.const 0.06785223633050919) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1405) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 10.44163990020752) + (f32.const -0.26776307821273804) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1406) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 6.483936309814453) + (f32.const 0.48381292819976807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1407) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 7.859063148498535) + (f32.const 0.07413065433502197) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1408) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const 7.717156887054443) + (f32.const 0.4940592646598816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1409) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 2.104006052017212) + (f32.const -0.287089467048645) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1410) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const 0.5596880316734314) + (f32.const 0.4191940724849701) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1411) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3) + (f32.const 4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1414) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -3) + (f32.const 4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1415) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4) + (f32.const 3) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1416) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4) + (f32.const -3) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1417) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -3) + (f32.const -4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1418) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1419) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3402823466385288598117041e14) + (f32.const -0) + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1420) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1.401298464324817e-45) + (f32.const 0) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1421) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1.401298464324817e-45) + (f32.const -0) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1422) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1432) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 4.345239849338305) + (f64.const 1.4690809584224322) + (f64.const -0.3412533402442932) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1445) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1446) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1447) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 9.267056966972586) + (f64.const 2.2264658498795615) + (f64.const 0.3638114035129547) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1448) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.6619858980995045) + (f64.const -0.4125110252365137) + (f64.const -0.29108747839927673) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1449) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1450) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.5617597462207241) + (f64.const -0.5766810183195862) + (f64.const -0.10983199626207352) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1451) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.7741522965913037) + (f64.const -0.2559866591263865) + (f64.const -0.057990044355392456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1452) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1453) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1456) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1457) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1458) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1463) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1475) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1476) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1477) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1478) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1479) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1482) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1483) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1484) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1485) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1488) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1489) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 4.345239849338305) + (f64.const 0.6380137537120029) + (f64.const -0.2088824063539505) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1503) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1504) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 9.267056966972586) + (f64.const 0.9669418327487274) + (f64.const -0.06120431795716286) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1505) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.6619858980995045) + (f64.const -0.17915126198447093) + (f64.const 0.39090874791145325) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1506) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1507) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.5617597462207241) + (f64.const -0.25044938407454437) + (f64.const -0.3046841621398926) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1508) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.7741522965913037) + (f64.const -0.11117359349943837) + (f64.const -0.31503361463546753) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1509) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1510) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1513) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1514) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1515) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1516) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1517) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1518) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1519) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1520) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1529) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 4.345239639282227) + (f32.const 0.6380137205123901) + (f32.const -0.20476758480072021) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1530) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1531) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1532) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 9.267057418823242) + (f32.const 0.9669418334960938) + (f32.const -0.34273025393486023) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.6619858741760254) + (f32.const -0.1791512817144394) + (f32.const -0.27078554034233093) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.5617597699165344) + (f32.const -0.25044935941696167) + (f32.const 0.2126826047897339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.7741522789001465) + (f32.const -0.1111735999584198) + (f32.const 0.46515095233917236) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1541) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1542) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1543) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1544) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1548) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 4.345239849338305) + (f64.const 1.6762064170601734) + (f64.const 0.46188199520111084) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 9.267056966972586) + (f64.const 2.3289404168523826) + (f64.const -0.411114901304245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.6619858980995045) + (f64.const 0.5080132114992477) + (f64.const -0.29306045174598694) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0.4066039223853553) + (f64.const -0.5218931811663979) + (f64.const -0.25825726985931396) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.5617597462207241) + (f64.const 0.4458132279488102) + (f64.const -0.13274887204170227) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.7741522965913037) + (f64.const 0.5733227294648414) + (f64.const 0.02716583013534546) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0.6787637026394024) + (f64.const -1.1355782978128564) + (f64.const 0.2713092863559723) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1569) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -7.888609052210118e-31) + (f64.const -7.888609052210118e-31) + (f64.const 1.7763568394002505e-15) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 1) + (f64.const 0.6931471805599453) + (f64.const -0.2088811695575714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -1) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1579) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 4.345239639282227) + (f32.const 1.676206350326538) + (f32.const -0.23014859855175018) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 9.267057418823242) + (f32.const 2.3289403915405273) + (f32.const -0.29075589776039124) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.6619858741760254) + (f32.const 0.5080131888389587) + (f32.const -0.1386766880750656) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0.40660393238067627) + (f32.const -0.5218932032585144) + (f32.const -0.08804433047771454) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.5617597699165344) + (f32.const 0.44581323862075806) + (f32.const -0.15101368725299835) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.7741522789001465) + (f32.const 0.5733227133750916) + (f32.const -0.10264533013105392) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0.6787636876106262) + (f32.const -1.1355782747268677) + (f32.const -0.19879481196403503) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1597) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -7.888609052210118e-31) + (f32.const -7.888609052210118e-31) + (f32.const 3.308722450212111e-24) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 1) + (f32.const 0.6931471824645996) + (f32.const 0.031954795122146606) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -1) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1606) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1607) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -1.1754942106924411e-38) + (f32.const -1.1754942106924411e-38) + (f32.const 4.930380657631324e-32) + (i32.const 9) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1608) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 4.345239849338305) + (f64.const 2.1194358133804485) + (f64.const -0.10164877772331238) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 9.267056966972586) + (f64.const 3.2121112403298744) + (f64.const -0.15739446878433228) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.6619858980995045) + (f64.const -0.5951276104207402) + (f64.const 0.3321485221385956) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.5617597462207241) + (f64.const -0.8319748453044644) + (f64.const 0.057555437088012695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1627) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.7741522965913037) + (f64.const -0.36931068365537134) + (f64.const -0.19838279485702515) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1628) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1648) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 4.345239639282227) + (f32.const 2.1194357872009277) + (f32.const 0.18271538615226746) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1649) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1650) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 9.267057418823242) + (f32.const 3.212111234664917) + (f32.const -0.3188050389289856) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.6619858741760254) + (f32.const -0.5951276421546936) + (f32.const 0.34231460094451904) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.5617597699165344) + (f32.const -0.8319748044013977) + (f32.const -0.33473604917526245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.7741522789001465) + (f32.const -0.3693107068538666) + (f32.const 0.3278401792049408) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1661) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1662) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 4.535662560676869) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1679) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1680) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -2.763607337379588) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1681) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const 4.567535276842744) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1682) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 9.267056966972586) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1683) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 0.6620717923376739) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1684) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 7.858890253041697) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1685) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const 7.67640268511754) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1686) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 2.0119025790324803) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1687) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const 0.03223983060263804) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.5) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1698) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1699) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1700) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1701) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1702) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1703) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const -1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1704) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1705) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1706) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1707) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1708) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1709) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const -0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1710) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1711) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1712) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1713) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1714) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1715) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1716) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const -inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1717) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1718) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1719) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1720) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1721) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1722) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1723) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1724) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1725) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1726) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1727) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1728) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1729) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1730) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const 2) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1731) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1732) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1733) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1734) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1735) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1736) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1737) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1738) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1739) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1740) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const -inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1741) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1742) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1743) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -inf) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1744) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1.75) + (f64.const 0.5) + (f64.const 1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1745) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1.75) + (f64.const 0.5) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1746) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1.75) + (f64.const -0.5) + (f64.const 1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1747) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1.75) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1748) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 4.535662651062012) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1757) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1758) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -2.7636072635650635) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1759) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const 4.567535400390625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1760) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 9.267057418823242) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1761) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 0.6620717644691467) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1762) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 7.858890056610107) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const 7.676402568817139) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 2.0119025707244873) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const 0.03223983198404312) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.5) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1773) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1774) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1778) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1779) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1780) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1781) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const -1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1782) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1783) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1784) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1785) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1786) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1787) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const -0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1788) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const -inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1798) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1799) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1800) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1805) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1806) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1807) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1808) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const 2) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1809) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1810) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1811) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1812) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1813) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1814) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1815) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1816) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1817) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1818) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const -inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -inf) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1.75) + (f32.const 0.5) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1.75) + (f32.const -0.5) + (f32.const 1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1826) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -8.06684839057968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const -8.88799136300345) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -6.531673581913484) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1841) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 4.811392084359796) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1842) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -6.450045556060236) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1843) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 0.05215452675006225) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1844) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1845) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1846) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.5587586823609152) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1847) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1850) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1851) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const 1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const 1) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.5) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1862) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1863) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const -1) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const 0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const 0) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const -0) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const -0) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 2) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const 2) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const -0.5) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1902) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -inf) + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1903) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1.75) + (f64.const 0.5) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1904) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1.75) + (f64.const 0.5) + (f64.const -1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1905) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1.75) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1906) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1.75) + (f64.const -0.5) + (f64.const -1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1907) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -8.066848754882812) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1916) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const -8.887990951538086) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -6.531673431396484) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 4.811392307281494) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1920) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -6.450045585632324) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1921) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 0.052154526114463806) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.5587586760520935) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1928) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const 1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const 1) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.5) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const -1) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1944) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1945) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1946) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1947) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1948) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1949) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1950) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const 0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1951) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1952) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1953) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1954) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1955) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1956) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const 0) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1957) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1958) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1959) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1960) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const -0) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1961) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1962) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const -0) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1963) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1964) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 2) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1965) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1966) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1967) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const 2) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1968) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const -0.5) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1969) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1970) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1971) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1972) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1973) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1974) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1975) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1976) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1977) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1978) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1979) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1980) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -inf) + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1981) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1982) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1.75) + (f32.const 0.5) + (f32.const -1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1983) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1.75) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1984) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1985) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -3.531185829902812) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2001) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2002) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -0.09061141541648476) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2003) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -1.9641383050707404) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2004) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 4.45566488261279) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2005) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -0.4913994250211714) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2006) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 0.035711240532359426) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2007) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2008) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2009) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.0106815621160685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2010) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2013) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2014) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2015) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2016) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2017) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2018) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2019) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2020) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 2) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2021) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -2) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2022) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2023) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2024) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2025) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2026) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2027) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2028) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2029) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2030) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2031) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2032) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2033) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 2) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2034) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -2) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2035) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2036) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2037) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2038) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2039) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2040) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2041) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2042) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2043) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2044) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2045) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2046) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const -inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2047) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2048) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2049) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2050) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2051) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2052) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2053) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2054) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2055) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2056) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2057) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2058) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2059) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2060) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2061) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2062) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2063) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2064) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2065) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2066) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2067) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2068) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2069) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2070) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const -inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2071) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2072) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2073) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2074) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.75) + (f64.const 0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2075) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.75) + (f64.const 0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2076) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.75) + (f64.const -0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2077) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.75) + (f64.const -0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2078) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -3.531186103820801) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2087) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2088) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -0.09061169624328613) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2089) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -1.9641380310058594) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2090) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 4.455665111541748) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2091) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -0.49139970541000366) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2092) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 0.0357111394405365) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2093) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2094) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2095) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.010681532323360443) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2096) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2099) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2100) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2101) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2102) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2103) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2104) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2106) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2107) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -2) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 2) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -2) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2126) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const -inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2134) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2154) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2155) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const -inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -inf) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.75) + (f32.const 0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.75) + (f32.const -0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2176) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 2.1347118825587285e-06) + (f64.const 0.3250160217285156) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2177) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2178) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2179) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 44909.29941512966) + (f64.const -0.26659080386161804) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2180) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2181) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 1.1135177413458652) + (f64.const -0.37168607115745544) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2182) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.37690773521380183) + (f64.const 0.32473301887512207) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2188) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2189) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 3) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2190) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2191) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2192) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2193) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2194) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -1) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -2) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -3) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -4) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 3) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2204) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2205) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -1) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -2) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -3) + (f64.const -inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -4) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2214) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2215) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2216) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2217) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2218) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2219) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2220) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2221) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2222) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2223) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2224) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2225) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2226) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2227) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2228) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2229) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2230) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -3) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2235) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2236) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 3) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -0.5) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2241) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -3) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2242) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 1.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2244) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 2) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2245) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 3) + (f64.const -0.125) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2246) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2247) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2248) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2249) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2250) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.const -inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2251) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2252) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2253) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2254) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2255) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2256) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2257) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2258) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 3) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2259) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2262) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2263) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const 3) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2270) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const 1) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2271) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2272) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const -0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2273) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2274) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -inf) + (f64.const -2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2275) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2276) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2277) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -2) + (f64.const 1) + (f64.const -2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2278) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -2) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2279) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2288) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 2.134714122803416e-06) + (f32.const 0.1436440795660019) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2289) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 44909.33203125) + (f32.const -0.05356409028172493) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2292) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2293) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 1.1135177612304688) + (f32.const 0.19122089445590973) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.3769077658653259) + (f32.const 0.337149053812027) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2300) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2301) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 3) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2304) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2305) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2306) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2307) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2308) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -1) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2309) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -2) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2310) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -3) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2311) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -4) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 3) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2317) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2318) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2319) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2320) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2321) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2322) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -1) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2323) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -2) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2324) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -3) + (f32.const -inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -4) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2335) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2336) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2337) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2338) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2339) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2340) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2341) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2342) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2343) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2344) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2345) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -3) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 3) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2352) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -0.5) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2353) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -3) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2354) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2355) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 1.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2356) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 2) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2357) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 3) + (f32.const -0.125) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2358) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2359) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2360) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2361) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2362) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.const -inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2365) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2366) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2367) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2368) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2369) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2370) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 3) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2371) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2372) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2373) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2374) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2375) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2376) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2377) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2378) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2379) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const 3) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2381) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const 1) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2384) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const -0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2385) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2386) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -inf) + (f32.const -2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2387) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2388) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2389) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -2) + (f32.const 1) + (f32.const -2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2390) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -2) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2391) + (i32.const 0) + ) + (unreachable) + ) ) (call "$(lib)/math/NativeMath.seedRandom" (i64.reinterpret/f64 @@ -8366,26 +44623,26 @@ (f64.convert_s/i32 (get_local $0) ) - (f64.const 1e7) + (f64.const 1e6) ) (block (if (i32.eqz (i32.and (if (result i32) - (tee_local $2 + (tee_local $1 (f64.ge - (tee_local $1 + (tee_local $2 (call "$(lib)/math/NativeMath.random") ) (f64.const 0) ) ) (f64.lt - (get_local $1) + (get_local $2) (f64.const 1) ) - (get_local $2) + (get_local $1) ) (i32.const 1) ) @@ -8394,7 +44651,7 @@ (call $abort (i32.const 0) (i32.const 4) - (i32.const 601) + (i32.const 2400) (i32.const 2) ) (unreachable) @@ -8410,5 +44667,8805 @@ ) ) ) + (call "$(lib)/math/NativeMathf.seedRandom" + (i64.reinterpret/f64 + (call "$(lib)/math/JSMath.random") + ) + ) + (set_local $0 + (i32.const 0) + ) + (loop $continue|1 + (if + (f64.lt + (f64.convert_s/i32 + (get_local $0) + ) + (f64.const 1e6) + ) + (block + (if + (i32.eqz + (i32.and + (if (result i32) + (tee_local $1 + (f32.ge + (tee_local $3 + (call "$(lib)/math/NativeMathf.random") + ) + (f32.const 0) + ) + ) + (f32.lt + (get_local $3) + (f32.const 1) + ) + (get_local $1) + ) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2408) + (i32.const 2) + ) + (unreachable) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2422) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -6.531673581913484) + (f64.const -7) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.6619858980995045) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.5617597462207241) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.7741522965913037) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.6787637026394024) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2434) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2435) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2436) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2437) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2438) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2439) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2440) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2441) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2442) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.5) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2443) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2445) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2446) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2447) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.9999923706054688) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2448) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2449) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2450) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -6.531673431396484) + (f32.const -7) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2463) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.6619858741760254) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2464) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2465) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.5617597699165344) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2466) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.7741522789001465) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2467) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.6787636876106262) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2468) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2471) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2475) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2476) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2477) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2478) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2479) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.5) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2480) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2481) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2482) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2483) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2484) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.9999923706054688) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2485) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2498) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2499) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2500) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -2) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2503) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2504) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2505) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2506) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2514) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2515) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2516) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2517) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2518) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -2) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2519) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2520) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2521) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2522) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 1.0044767307740567) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -0.09061141541648476) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -1.9641383050707404) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const -0.35572720174700656) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 0.17067236731650248) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const -0.016443286217702822) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2539) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2540) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2541) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.0106815621160685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2542) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2548) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2549) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2550) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2551) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2552) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 2) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2553) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -2) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2554) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2555) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2556) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2557) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2558) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2559) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 2) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -2) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2569) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2570) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2571) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const -inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const -inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2579) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2580) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2581) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2582) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2583) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2584) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2585) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2586) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2587) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2597) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2598) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2599) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const -inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2606) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.75) + (f64.const 0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2607) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.75) + (f64.const 0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2608) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.75) + (f64.const -0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2609) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.75) + (f64.const -0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2610) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 8e-323) + (f64.const inf) + (f64.const 8e-323) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2611) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 1.004476547241211) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -0.09061169624328613) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -1.9641380310058594) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const -0.3557271957397461) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 0.17067205905914307) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const -0.016443386673927307) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2627) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2628) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.010681532323360443) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2640) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -2) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2641) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2642) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2643) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2644) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2645) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2646) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2647) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2648) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2649) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2650) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 2) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -2) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2658) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2659) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2661) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2662) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const -inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2668) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2669) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2670) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2671) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2672) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2673) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2674) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2675) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2676) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2677) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2678) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2679) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2680) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2681) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2682) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2683) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2684) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2685) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2686) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2687) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2689) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const -inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2690) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -inf) + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.75) + (f32.const 0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.75) + (f32.const 0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.75) + (f32.const -0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.75) + (f32.const -0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 5.877471754111438e-39) + (f32.const inf) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2698) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -8.06684839057968) + (f64.const -1593.5206801156262) + (f64.const -0.2138727605342865) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 4.345239849338305) + (f64.const 38.54878088685412) + (f64.const 0.21537430584430695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -8.38143342755525) + (f64.const -2182.6307505145546) + (f64.const 0.16213826835155487) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -6.531673581913484) + (f64.const -343.2723926847529) + (f64.const 0.20479513704776764) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 9.267056966972586) + (f64.const 5291.7790755194055) + (f64.const -0.48676517605781555) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2767) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.6619858980995045) + (f64.const 0.7114062568229157) + (f64.const -0.4584641456604004) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2768) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0.4066039223853553) + (f64.const -0.41790065258739445) + (f64.const 0.37220045924186707) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.5617597462207241) + (f64.const 0.5917755935451237) + (f64.const 0.46178996562957764) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.7741522965913037) + (f64.const 0.8538292008852542) + (f64.const -0.07019051909446716) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0.6787637026394024) + (f64.const -0.732097615653169) + (f64.const 0.26858529448509216) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2778) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2779) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -8.066848754882812) + (f32.const -1593.521240234375) + (f32.const 0.1671663224697113) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2788) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 4.345239639282227) + (f32.const 38.548770904541016) + (f32.const -0.49340328574180603) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -8.381433486938477) + (f32.const -2182.630859375) + (f32.const 0.0849970355629921) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -6.531673431396484) + (f32.const -343.2723388671875) + (f32.const 0.0704190656542778) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 9.267057418823242) + (f32.const 5291.78125) + (f32.const -0.44362515211105347) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.6619858741760254) + (f32.const 0.7114062309265137) + (f32.const 0.058103885501623154) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0.40660393238067627) + (f32.const -0.4179006516933441) + (f32.const 0.39349499344825745) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.5617597699165344) + (f32.const 0.5917755961418152) + (f32.const -0.4183797240257263) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.7741522789001465) + (f32.const 0.8538292050361633) + (f32.const 0.45992106199264526) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0.6787636876106262) + (f32.const -0.7320976257324219) + (f32.const -0.48159059882164) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2800) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2816) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4.345239849338305) + (f64.const 2.0845238903256313) + (f64.const -0.07180261611938477) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2817) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2818) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 9.267056966972586) + (f64.const 3.0441841217266385) + (f64.const -0.01546262577176094) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.6619858980995045) + (f64.const 0.8136251582267503) + (f64.const -0.08618157356977463) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.5617597462207241) + (f64.const 0.7495063350104014) + (f64.const -0.0981396734714508) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.7741522965913037) + (f64.const 0.879859248170583) + (f64.const -0.37124353647232056) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2828) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2829) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2830) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2831) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2832) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2833) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2834) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2835) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1e-323) + (f64.const 3.1434555694052576e-162) + (f64.const 0.43537619709968567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2836) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.5e-323) + (f64.const 3.849931087076416e-162) + (f64.const -0.45194002985954285) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2837) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5e-324) + (f64.const 2.2227587494850775e-162) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -5e-324) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.9999999999999999) + (f64.const 0.9999999999999999) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.9999999999999998) + (f64.const 1.414213562373095) + (f64.const -0.21107041835784912) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2841) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.0000000000000002) + (f64.const 1) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2842) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.0000000000000004) + (f64.const 1.4142135623730951) + (f64.const -0.27173060178756714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2843) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.0000000000000002) + (f64.const 1) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2844) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.9999999999999999) + (f64.const 0.9999999999999999) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2845) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -1797693134862315708145274e284) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2846) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862315708145274e284) + (f64.const 1340780792994259561100831e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2847) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 179769313486231490980915e285) + (f64.const 134078079299425926338769e131) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2848) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862314111473026e284) + (f64.const 1340780792994258965674548e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2849) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862313313136902e284) + (f64.const 1340780792994258667961407e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2850) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862312514800778e284) + (f64.const 1340780792994258370248265e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2851) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862311716464655e284) + (f64.const 1340780792994258072535124e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862310918128531e284) + (f64.const 1340780792994257774821982e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862310119792407e284) + (f64.const 1340780792994257477108841e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862309321456283e284) + (f64.const 1340780792994257179395699e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862308523120159e284) + (f64.const 1340780792994256881682558e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862307724784036e284) + (f64.const 1340780792994256583969417e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507203e-308) + (f64.const 1.4916681462400417e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507205e-308) + (f64.const 1.4916681462400423e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507207e-308) + (f64.const 1.491668146240043e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507209e-308) + (f64.const 1.4916681462400437e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507211e-308) + (f64.const 1.4916681462400443e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2862) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072127e-308) + (f64.const 1.491668146240045e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2863) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072147e-308) + (f64.const 1.4916681462400457e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072167e-308) + (f64.const 1.4916681462400463e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072187e-308) + (f64.const 1.491668146240047e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072207e-308) + (f64.const 1.4916681462400476e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072226e-308) + (f64.const 1.4916681462400483e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072246e-308) + (f64.const 1.491668146240049e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072266e-308) + (f64.const 1.4916681462400496e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072286e-308) + (f64.const 1.4916681462400503e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 92.35130391890645) + (f64.const 9.609958580499006) + (f64.const 0.4998137056827545) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 93.3599596388916) + (f64.const 9.662295774757238) + (f64.const -0.49979978799819946) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 95.42049628886124) + (f64.const 9.76834153215689) + (f64.const -0.49997270107269287) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 95.87916941885449) + (f64.const 9.791790919890728) + (f64.const 0.4998766779899597) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 96.84804174884022) + (f64.const 9.841140266698785) + (f64.const 0.499801903963089) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.43639050883155) + (f64.const 9.87098731175517) + (f64.const 0.4997696280479431) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.50957979883047) + (f64.const 9.874693909120955) + (f64.const 0.49999818205833435) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.80496893882612) + (f64.const 9.88963947466368) + (f64.const -0.4999580681324005) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 98.2751822888192) + (f64.const 9.913383997849534) + (f64.const 0.49979931116104126) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 99.47293564880155) + (f64.const 9.973611966023219) + (f64.const -0.4999540448188782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.57047130878539) + (f64.const 10.028483001370914) + (f64.const -0.49996453523635864) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.60954608878481) + (f64.const 10.030431002144665) + (f64.const 0.49975672364234924) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.67909109878379) + (f64.const 10.033897104255344) + (f64.const -0.4997771382331848) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 101.12268095877725) + (f64.const 10.055977374615422) + (f64.const 0.49988678097724915) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 101.3027691287746) + (f64.const 10.064927676281366) + (f64.const 0.4999105632305145) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.45932313565507e-307) + (f64.const 4.9591563149945874e-154) + (f64.const -0.4998999834060669) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5.610957305180409e-307) + (f64.const 7.490632353266584e-154) + (f64.const -0.4999343752861023) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5.8073887977408524e-307) + (f64.const 7.62062254526548e-154) + (f64.const -0.49989569187164307) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 7.026137080471427e-307) + (f64.const 8.382205605013174e-154) + (f64.const 0.49980640411376953) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 8.438697769194972e-307) + (f64.const 9.186238495268328e-154) + (f64.const -0.4999065697193146) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.1607792515836795e-306) + (f64.const 1.0773946591586944e-153) + (f64.const -0.49997684359550476) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.2827413827423193e-306) + (f64.const 1.1325817333606962e-153) + (f64.const -0.4999513030052185) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.7116604596087457e-306) + (f64.const 1.3083044216117078e-153) + (f64.const -0.49986395239830017) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.038173251686994e-306) + (f64.const 1.4276460526639628e-153) + (f64.const 0.4998403787612915) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.171572060856931e-306) + (f64.const 1.4736254818836879e-153) + (f64.const 0.4999290406703949) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.4681399631804094e-306) + (f64.const 1.5710314965589996e-153) + (f64.const 0.49989044666290283) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.5175533964200588e-306) + (f64.const 1.5866799918131124e-153) + (f64.const -0.4997701048851013) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.6461505468829625e-306) + (f64.const 1.6266992797941982e-153) + (f64.const 0.4998672902584076) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 3.8167076367720413e-306) + (f64.const 1.9536395872248397e-153) + (f64.const 0.49983471632003784) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4.5743220778562766e-306) + (f64.const 2.1387664851161936e-153) + (f64.const 0.49985939264297485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2910) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4.345239639282227) + (f32.const 2.084523916244507) + (f32.const 0.3200402557849884) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2911) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2912) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2913) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 9.267057418823242) + (f32.const 3.0441842079162598) + (f32.const 0.05022354796528816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2914) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.6619858741760254) + (f32.const 0.813625156879425) + (f32.const 0.2240506112575531) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2915) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2916) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.5617597699165344) + (f32.const 0.7495063543319702) + (f32.const 0.05895441770553589) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.7741522789001465) + (f32.const 0.879859209060669) + (f32.const -0.4874873757362366) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2926) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2927) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2928) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.802596928649634e-45) + (f32.const 5.293955920339377e-23) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4.203895392974451e-45) + (f32.const 6.483745598763743e-23) + (f32.const 0.37388554215431213) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.401298464324817e-45) + (f32.const 3.743392066509216e-23) + (f32.const -0.20303145051002502) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -1.401298464324817e-45) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 3402823466385288598117041e14) + (f32.const 18446742974197923840) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -3402823466385288598117041e14) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.9999998807907104) + (f32.const 0.9999999403953552) + (f32.const 2.980232594040899e-08) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.9999999403953552) + (f32.const 0.9999999403953552) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.999999761581421) + (f32.const 1.4142134189605713) + (f32.const -0.4959246516227722) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.9999998807907104) + (f32.const 1.4142135381698608) + (f32.const 0.15052194893360138) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.0000001192092896) + (f32.const 1) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.000000238418579) + (f32.const 1.0000001192092896) + (f32.const 5.960463766996327e-08) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.000000238418579) + (f32.const 1.4142136573791504) + (f32.const 0.08986179530620575) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.000000476837158) + (f32.const 1.41421377658844) + (f32.const 0.3827550709247589) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -8.06684839057968) + (f64.const -0.999999803096032) + (f64.const 0.012793331407010555) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3008) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 4.345239849338305) + (f64.const 0.9996636978961307) + (f64.const 0.1573508232831955) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3009) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -8.38143342755525) + (f64.const -0.9999998950434862) + (f64.const 0.27985066175460815) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3010) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -6.531673581913484) + (f64.const -0.9999957568392429) + (f64.const -0.44285574555397034) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3011) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 9.267056966972586) + (f64.const 0.9999999821447234) + (f64.const 0.4462755024433136) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3012) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.6619858980995045) + (f64.const 0.5796835018635275) + (f64.const 0.4892043173313141) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3013) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0.4066039223853553) + (f64.const -0.3855853099901652) + (f64.const 0.35993871092796326) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3014) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.5617597462207241) + (f64.const 0.5092819248700439) + (f64.const -0.39436522126197815) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3015) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.7741522965913037) + (f64.const 0.6493374550318555) + (f64.const -0.4899396002292633) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3016) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0.6787637026394024) + (f64.const -0.590715084799841) + (f64.const -0.0145387789234519) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3017) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3020) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3021) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3022) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3023) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3024) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -8.066848754882812) + (f32.const -0.9999998211860657) + (f32.const -0.3034979999065399) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3033) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 4.345239639282227) + (f32.const 0.9996637105941772) + (f32.const 0.2154078334569931) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3034) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -8.381433486938477) + (f32.const -0.9999998807907104) + (f32.const 0.23912210762500763) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3035) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -6.531673431396484) + (f32.const -0.999995768070221) + (f32.const -0.18844597041606903) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3036) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 9.267057418823242) + (f32.const 1) + (f32.const 0.1497807800769806) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3037) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.6619858741760254) + (f32.const 0.5796834826469421) + (f32.const -0.05590476095676422) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3038) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0.40660393238067627) + (f32.const -0.38558530807495117) + (f32.const 0.349787175655365) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3039) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.5617597699165344) + (f32.const 0.5092819333076477) + (f32.const -0.1528785079717636) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3040) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.7741522789001465) + (f32.const 0.6493374705314636) + (f32.const 0.4317026138305664) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3041) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0.6787636876106262) + (f32.const -0.5907150506973267) + (f32.const 0.4079873859882355) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3042) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3045) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3046) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3047) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3048) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3049) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3061) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3062) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3063) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -6.531673581913484) + (f64.const -6) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3064) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3065) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.6619858980995045) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3066) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3067) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.5617597462207241) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3068) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.7741522965913037) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3069) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.6787637026394024) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3070) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3073) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3074) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -inf) + (f64.const -inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3075) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3076) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3077) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3078) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3079) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3080) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3081) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3082) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3083) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.9999923706054688) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3084) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3085) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3086) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3087) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3096) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3097) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3098) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -6.531673431396484) + (f32.const -6) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3099) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3100) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.6619858741760254) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3101) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3102) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.5617597699165344) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3103) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.7741522789001465) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3104) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.6787636876106262) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -inf) + (f32.const -inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.9999923706054688) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3122) + (i32.const 0) + ) + (unreachable) + ) + ) ) ) diff --git a/tests/compiler/std/math.ts b/tests/compiler/std/math.ts index ed0095f7..f9b433fe 100644 --- a/tests/compiler/std/math.ts +++ b/tests/compiler/std/math.ts @@ -1,602 +1,3122 @@ -// based on http://nsz.repo.hu/git/?p=libc-test -// mostly generated from their tests using scripts/hexfloat.html +// Largely based on test cases from libc-test: http://nsz.repo.hu/git/?p=libc-test +/* + libc-test is licensed under the following standard MIT license: -assert(Math.E == NativeMath.E); // global alias should exist + Copyright © 2005-2013 libc-test AUTHORS + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Portions of this software is derived from software authored by + third parties: + + math tests use numbers under BSD and GPL licenses see src/math/ucb/* + and src/math/crlibm/* for details +*/ + +const js = true; // also test, and thus compare to, JS math? + +// these flags are unused, but kept in case these might just so happen to become useful const INEXACT = 1 << 0; const INVALID = 1 << 1; const DIVBYZERO = 1 << 2; const UNDERFLOW = 1 << 3; const OVERFLOW = 1 << 4; -function check(actual: T, expected: T, error: T, flags: i32): void { // TODO: is this correct? -0? - if (isNaN(expected)) { - if (!isNaN(actual)) unreachable(); - } else if (actual != expected) { - if (!(flags & INEXACT) || abs(actual - expected) > abs(error)) unreachable(); +function signbit(d: f64): i32 { + return (reinterpret(d) >> 63); +} + +function eulp(x: f64): i32 { + var u = reinterpret(x); + var e = (u >> 52 & 0x7ff); + if (!e) e++; + return e - 0x3ff - 52; +} + +function ulperr(got: f64, want: f64, dwant: f64): f64 { + const Ox1p1023 = reinterpret(0x7FE0000000000000); + if (isNaN(got) && isNaN(want)) return 0; + if (got == want) { + if (signbit(got) == signbit(want)) return dwant; + return Infinity; } + if (!isFinite(got)) { + got = copysign(Ox1p1023, got); + want *= 0.5; + } + return NativeMath.scalbn(got - want, -eulp(want)) + dwant; } -// ================================ built-in fmod ================================ +function signbitf(f: f32): i32 { + return (reinterpret(f) >> 31); +} -function test_fmod(left: f64, right: f64, expected: f64, error: f64, flags: i32): void { - check(left % right, expected, error, flags); +function eulpf(x: f32): i32 { + var u = reinterpret(x); + var e = (u >> 23 & 0xff); + if (!e) e++; + return e - 0x7f - 23; +} + +function ulperrf(got: f32, want: f32, dwant: f32): f32 { + const Ox1p127f = reinterpret(0x7F000000); + if (isNaN(got) && isNaN(want)) return 0; + if (got == want) { + if (signbitf(got) == signbitf(want)) return dwant; + return Infinity; + } + if (!isFinite(got)) { + got = copysign(Ox1p127f, got); + want *= 0.5; + } + return NativeMathf.scalbn(got - want, -eulpf(want)) + dwant; +} + +declare function logf(f: f64): void; + +function check(actual: T, expected: T, dy: T, flags: i32): bool { + if (actual == expected) return true; + if (isNaN(expected)) return isNaN(actual); + var d: T; + if (sizeof() == 8) d = ulperr(actual, expected, dy); + else if (sizeof() == 4) d = ulperrf(actual, expected, dy); + else return false; + if (abs(d) >= 1.5) { + logf(abs(d)); + return false; + } + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Global aliases +//////////////////////////////////////////////////////////////////////////////////////////////////// + +assert(Math.E == NativeMath.E); +assert(Mathf.E == NativeMathf.E); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Constants +//////////////////////////////////////////////////////////////////////////////////////////////////// + +assert(check(NativeMath.E, JSMath.E, 0.0, 0)); +assert(check(NativeMath.LN2, JSMath.LN2, 0.0, 0)); +assert(check(NativeMath.LN10, JSMath.LN10, 0.0, 0)); +assert(check(NativeMath.LOG2E, JSMath.LOG2E, 0.0, 0)); +assert(check(NativeMath.PI, JSMath.PI, 0.0, 0)); +assert(check(NativeMath.SQRT1_2, JSMath.SQRT1_2, 0.0, 0)); +assert(check(NativeMath.SQRT2, JSMath.SQRT2, 0.0, 0)); + +assert(check(NativeMathf.E, JSMath.E, 0.0, 0)); +assert(check(NativeMathf.LN2, JSMath.LN2, 0.0, 0)); +assert(check(NativeMathf.LN10, JSMath.LN10, 0.0, 0)); +assert(check(NativeMathf.LOG2E, JSMath.LOG2E, 0.0, 0)); +assert(check(NativeMathf.PI, JSMath.PI, 0.0, 0)); +assert(check(NativeMathf.SQRT1_2, JSMath.SQRT1_2, 0.0, 0)); +assert(check(NativeMathf.SQRT2, JSMath.SQRT2, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Internal scalbn +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_scalbn(value: f64, n: i32, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.scalbn(value, n), expected, error, flags); } // sanity -test_fmod(-8.06684839057968084, 4.53566256067686879, -3.53118582990281205, 0.0, 0); -test_fmod(4.34523984933830487, -8.88799136300345083, 4.34523984933830487, 0.0, 0); -test_fmod(-8.38143342755524934, -2.76360733737958819, -0.0906114154164847641, 0.0, 0); -test_fmod(-6.53167358191348413, 4.56753527684274374, -1.96413830507074039, 0.0, 0); -test_fmod(9.26705696697258574, 4.81139208435979615, 4.45566488261278959, 0.0, 0); -test_fmod(-6.45004555606023633, 0.662071792337673881, -0.491399425021171399, 0.0, 0); -test_fmod(7.85889025304169664, 0.0521545267500622481, 0.0357112405323594256, 0.0, 0); -test_fmod(-0.792054511984895959, 7.67640268511753998, -0.792054511984895959, 0.0, 0); -test_fmod(0.615702673197924044, 2.01190257903248026, 0.615702673197924044, 0.0, 0); -test_fmod(-0.558758682360915193, 0.0322398306026380407, -0.0106815621160685006, 0.0, 0); +assert(test_scalbn(-8.06684839057968084, -2, -2.01671209764492021, 0.0, 0)); +assert(test_scalbn(4.34523984933830487, -1, 2.17261992466915244, 0.0, 0)); +assert(test_scalbn(-8.38143342755524934, 0, -8.38143342755524934, 0.0, 0)); +assert(test_scalbn(-6.53167358191348413, 1, -13.0633471638269683, 0.0, 0)); +assert(test_scalbn(9.26705696697258574, 2, 37.068227867890343, 0.0, 0)); +assert(test_scalbn(0.661985898099504477, 3, 5.29588718479603582, 0.0, 0)); +assert(test_scalbn(-0.40660392238535531, 4, -6.50566275816568496, 0.0, 0)); +assert(test_scalbn(0.56175974622072411, 5, 17.9763118790631715, 0.0, 0)); +assert(test_scalbn(0.77415229659130369, 6, 49.5457469818434362, 0.0, 0)); +assert(test_scalbn(-0.678763702639402444, 7, -86.8817539378435129, 0.0, 0)); // special -test_fmod(0.0, 1.0, 0.0, 0.0, 0); -test_fmod(-0.0, 1.0, -0.0, 0.0, 0); -test_fmod(0.5, 1.0, 0.5, 0.0, 0); -test_fmod(-0.5, 1.0, -0.5, 0.0, 0); -test_fmod(1.0, 1.0, 0.0, 0.0, 0); -test_fmod(-1.0, 1.0, -0.0, 0.0, 0); -test_fmod(1.5, 1.0, 0.5, 0.0, 0); -test_fmod(-1.5, 1.0, -0.5, 0.0, 0); -test_fmod(2.0, 1.0, 0.0, 0.0, 0); -test_fmod(-2.0, 1.0, -0.0, 0.0, 0); -test_fmod(Infinity, 1.0, NaN, 0.0, INVALID); -test_fmod(-Infinity, 1.0, NaN, 0.0, INVALID); -test_fmod(NaN, 1.0, NaN, 0.0, 0); -test_fmod(0.0, -1.0, 0.0, 0.0, 0); -test_fmod(-0.0, -1.0, -0.0, 0.0, 0); -test_fmod(0.5, -1.0, 0.5, 0.0, 0); -test_fmod(-0.5, -1.0, -0.5, 0.0, 0); -test_fmod(1.0, -1.0, 0.0, 0.0, 0); -test_fmod(-1.0, -1.0, -0.0, 0.0, 0); -test_fmod(1.5, -1.0, 0.5, 0.0, 0); -test_fmod(-1.5, -1.0, -0.5, 0.0, 0); -test_fmod(2.0, -1.0, 0.0, 0.0, 0); -test_fmod(-2.0, -1.0, -0.0, 0.0, 0); -test_fmod(Infinity, -1.0, NaN, 0.0, INVALID); -test_fmod(-Infinity, -1.0, NaN, 0.0, INVALID); -test_fmod(NaN, -1.0, NaN, 0.0, 0); -test_fmod(0.0, 0.0, NaN, 0.0, INVALID); -test_fmod(0.0, -0.0, NaN, 0.0, INVALID); -test_fmod(0.0, Infinity, 0.0, 0.0, 0); -test_fmod(0.0, -Infinity, 0.0, 0.0, 0); -test_fmod(0.0, NaN, NaN, 0.0, 0); -test_fmod(-0.0, 0.0, NaN, 0.0, INVALID); -test_fmod(-0.0, -0.0, NaN, 0.0, INVALID); -test_fmod(-0.0, Infinity, -0.0, 0.0, 0); -test_fmod(-0.0, -Infinity, -0.0, 0.0, 0); -test_fmod(-0.0, NaN, NaN, 0.0, 0); -test_fmod(1.0, 0.0, NaN, 0.0, INVALID); -test_fmod(-1.0, 0.0, NaN, 0.0, INVALID); -test_fmod(Infinity, 0.0, NaN, 0.0, INVALID); -test_fmod(-Infinity, 0.0, NaN, 0.0, INVALID); -test_fmod(NaN, 0.0, NaN, 0.0, 0); -test_fmod(-1.0, -0.0, NaN, 0.0, INVALID); -test_fmod(Infinity, -0.0, NaN, 0.0, INVALID); -test_fmod(-Infinity, -0.0, NaN, 0.0, INVALID); -test_fmod(NaN, -0.0, NaN, 0.0, 0); -test_fmod(Infinity, 2.0, NaN, 0.0, INVALID); -test_fmod(Infinity, -0.5, NaN, 0.0, INVALID); -test_fmod(Infinity, NaN, NaN, 0.0, 0); -test_fmod(-Infinity, 2.0, NaN, 0.0, INVALID); -test_fmod(-Infinity, -0.5, NaN, 0.0, INVALID); -test_fmod(-Infinity, NaN, NaN, 0.0, 0); -test_fmod(NaN, NaN, NaN, 0.0, 0); -test_fmod(1.0, NaN, NaN, 0.0, 0); -test_fmod(-1.0, NaN, NaN, 0.0, 0); -test_fmod(1.0, Infinity, 1.0, 0.0, 0); -test_fmod(-1.0, Infinity, -1.0, 0.0, 0); -test_fmod(Infinity, Infinity, NaN, 0.0, INVALID); -test_fmod(-Infinity, Infinity, NaN, 0.0, INVALID); -test_fmod(1.0, -Infinity, 1.0, 0.0, 0); -test_fmod(-1.0, -Infinity, -1.0, 0.0, 0); -test_fmod(Infinity, -Infinity, NaN, 0.0, INVALID); -test_fmod(-Infinity, -Infinity, NaN, 0.0, INVALID); -test_fmod(1.75, 0.5, 0.25, 0.0, 0); -test_fmod(-1.75, 0.5, -0.25, 0.0, 0); -test_fmod(1.75, -0.5, 0.25, 0.0, 0); -test_fmod(-1.75, -0.5, -0.25, 0.0, 0); +assert(test_scalbn(0.0, 2147483647, 0.0, 0.0, 0)); +assert(test_scalbn(0.0, -2147483647, 0.0, 0.0, 0)); +assert(test_scalbn(-0.0, 2147483647, -0.0, 0.0, 0)); +assert(test_scalbn(NaN, 0, NaN, 0.0, 0)); +assert(test_scalbn(Infinity, 0, Infinity, 0.0, 0)); +assert(test_scalbn(-Infinity, 0, -Infinity, 0.0, 0)); +assert(test_scalbn(1.0, 0, 1.0, 0.0, 0)); +assert(test_scalbn(1.0, 1, 2.0, 0.0, 0)); +assert(test_scalbn(1.0, -1, 0.5, 0.0, 0)); +assert(test_scalbn(1.0, 2147483647, Infinity, 0.0, INEXACT | OVERFLOW)); +assert(test_scalbn(NaN, 1, NaN, 0.0, 0)); +assert(test_scalbn(Infinity, 2147483647, Infinity, 0.0, 0)); +assert(test_scalbn(Infinity, -2147483647, Infinity, 0.0, 0)); +assert(test_scalbn(-Infinity, 2147483647, -Infinity, 0.0, 0)); +assert(test_scalbn(8.98846567431157954e+307, -2097, 4.94065645841246544e-324, 0.0, 0)); +assert(test_scalbn(4.94065645841246544e-324, 2097, 8.98846567431157954e+307, 0.0, 0)); +assert(test_scalbn(1.000244140625, -1074, 4.94065645841246544e-324, 0.0, INEXACT | UNDERFLOW)); +assert(test_scalbn(0.749999999999999889, -1073, 4.94065645841246544e-324, 0.0, INEXACT | UNDERFLOW)); +assert(test_scalbn(0.500000000000001221, -1024, 2.78134232313400667e-309, 0.0, INEXACT | UNDERFLOW)); -// ================================ built-in fmodf ================================ +// Internal scalbnf //////////////////////////////////////////////////////////////////////////////// -function test_fmodf(left: f32, right: f32, expected: f32, error: f32, flags: i32): void { - check(left % right, expected, error, flags); +function test_scalbnf(value: f32, n: i32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.scalbn(value, n), expected, error, flags); } // sanity -test_fmodf(-8.066848755, 4.535662651, -3.531186104, 0.0, 0); -test_fmodf(4.345239639, -8.887990952, 4.345239639, 0.0, 0); -test_fmodf(-8.381433487, -2.763607264, -0.09061169624, 0.0, 0); -test_fmodf(-6.531673431, 4.5675354, -1.964138031, 0.0, 0); -test_fmodf(9.267057419, 4.811392307, 4.455665112, 0.0, 0); -test_fmodf(-6.450045586, 0.6620717645, -0.4913997054, 0.0, 0); -test_fmodf(7.858890057, 0.05215452611, 0.03571113944, 0.0, 0); -test_fmodf(-0.7920545340, 7.676402569, -0.7920545340, 0.0, 0); -test_fmodf(0.6157026887, 2.011902571, 0.6157026887, 0.0, 0); -test_fmodf(-0.5587586761, 0.03223983198, -0.01068153232, 0.0, 0); +assert(test_scalbnf(-8.066848755, -2, -2.016712189, 0.0, 0)); +assert(test_scalbnf(4.345239639, -1, 2.17261982, 0.0, 0)); +assert(test_scalbnf(-8.381433487, 0, -8.381433487, 0.0, 0)); +assert(test_scalbnf(-6.531673431, 1, -13.06334686, 0.0, 0)); +assert(test_scalbnf(9.267057419, 2, 37.06822968, 0.0, 0)); +assert(test_scalbnf(0.6619858742, 3, 5.295886993, 0.0, 0)); +assert(test_scalbnf(-0.4066039324, 4, -6.505662918, 0.0, 0)); +assert(test_scalbnf(0.5617597699, 5, 17.97631264, 0.0, 0)); +assert(test_scalbnf(0.7741522789, 6, 49.54574585, 0.0, 0)); +assert(test_scalbnf(-0.6787636876, 7, -86.88175201, 0.0, 0)); // special -test_fmodf(0.0, 1.0, 0.0, 0.0, 0); -test_fmodf(-0.0, 1.0, -0.0, 0.0, 0); -test_fmodf(0.5, 1.0, 0.5, 0.0, 0); -test_fmodf(-0.5, 1.0, -0.5, 0.0, 0); -test_fmodf(1.0, 1.0, 0.0, 0.0, 0); -test_fmodf(-1.0, 1.0, -0.0, 0.0, 0); -test_fmodf(1.5, 1.0, 0.5, 0.0, 0); -test_fmodf(-1.5, 1.0, -0.5, 0.0, 0); -test_fmodf(2.0, 1.0, 0.0, 0.0, 0); -test_fmodf(-2.0, 1.0, -0.0, 0.0, 0); -test_fmodf(Infinity, 1.0, NaN, 0.0, INVALID); -test_fmodf(-Infinity, 1.0, NaN, 0.0, INVALID); -test_fmodf(NaN, 1.0, NaN, 0.0, 0); -test_fmodf(0.0, -1.0, 0.0, 0.0, 0); -test_fmodf(-0.0, -1.0, -0.0, 0.0, 0); -test_fmodf(0.5, -1.0, 0.5, 0.0, 0); -test_fmodf(-0.5, -1.0, -0.5, 0.0, 0); -test_fmodf(1.0, -1.0, 0.0, 0.0, 0); -test_fmodf(-1.0, -1.0, -0.0, 0.0, 0); -test_fmodf(1.5, -1.0, 0.5, 0.0, 0); -test_fmodf(-1.5, -1.0, -0.5, 0.0, 0); -test_fmodf(2.0, -1.0, 0.0, 0.0, 0); -test_fmodf(-2.0, -1.0, -0.0, 0.0, 0); -test_fmodf(Infinity, -1.0, NaN, 0.0, INVALID); -test_fmodf(-Infinity, -1.0, NaN, 0.0, INVALID); -test_fmodf(NaN, -1.0, NaN, 0.0, 0); -test_fmodf(0.0, 0.0, NaN, 0.0, INVALID); -test_fmodf(0.0, -0.0, NaN, 0.0, INVALID); -test_fmodf(0.0, Infinity, 0.0, 0.0, 0); -test_fmodf(0.0, -Infinity, 0.0, 0.0, 0); -test_fmodf(0.0, NaN, NaN, 0.0, 0); -test_fmodf(-0.0, 0.0, NaN, 0.0, INVALID); -test_fmodf(-0.0, -0.0, NaN, 0.0, INVALID); -test_fmodf(-0.0, Infinity, -0.0, 0.0, 0); -test_fmodf(-0.0, -Infinity, -0.0, 0.0, 0); -test_fmodf(-0.0, NaN, NaN, 0.0, 0); -test_fmodf(1.0, 0.0, NaN, 0.0, INVALID); -test_fmodf(-1.0, 0.0, NaN, 0.0, INVALID); -test_fmodf(Infinity, 0.0, NaN, 0.0, INVALID); -test_fmodf(-Infinity, 0.0, NaN, 0.0, INVALID); -test_fmodf(NaN, 0.0, NaN, 0.0, 0); -test_fmodf(-1.0, -0.0, NaN, 0.0, INVALID); -test_fmodf(Infinity, -0.0, NaN, 0.0, INVALID); -test_fmodf(-Infinity, -0.0, NaN, 0.0, INVALID); -test_fmodf(NaN, -0.0, NaN, 0.0, 0); -test_fmodf(Infinity, 2.0, NaN, 0.0, INVALID); -test_fmodf(Infinity, -0.5, NaN, 0.0, INVALID); -test_fmodf(Infinity, NaN, NaN, 0.0, 0); -test_fmodf(-Infinity, 2.0, NaN, 0.0, INVALID); -test_fmodf(-Infinity, -0.5, NaN, 0.0, INVALID); -test_fmodf(-Infinity, NaN, NaN, 0.0, 0); -test_fmodf(NaN, NaN, NaN, 0.0, 0); -test_fmodf(1.0, NaN, NaN, 0.0, 0); -test_fmodf(-1.0, NaN, NaN, 0.0, 0); -test_fmodf(1.0, Infinity, 1.0, 0.0, 0); -test_fmodf(-1.0, Infinity, -1.0, 0.0, 0); -test_fmodf(Infinity, Infinity, NaN, 0.0, INVALID); -test_fmodf(-Infinity, Infinity, NaN, 0.0, INVALID); -test_fmodf(1.0, -Infinity, 1.0, 0.0, 0); -test_fmodf(-1.0, -Infinity, -1.0, 0.0, 0); -test_fmodf(Infinity, -Infinity, NaN, 0.0, INVALID); -test_fmodf(-Infinity, -Infinity, NaN, 0.0, INVALID); -test_fmodf(1.75, 0.5, 0.25, 0.0, 0); -test_fmodf(-1.75, 0.5, -0.25, 0.0, 0); -test_fmodf(1.75, -0.5, 0.25, 0.0, 0); -test_fmodf(-1.75, -0.5, -0.25, 0.0, 0); +assert(test_scalbnf(0.0, 2147483647, 0.0, 0.0, 0)); +assert(test_scalbnf(0.0, -2147483647, 0.0, 0.0, 0)); +assert(test_scalbnf(-0.0, 2147483647, -0.0, 0.0, 0)); +assert(test_scalbnf(NaN, 0, NaN, 0.0, 0)); +assert(test_scalbnf(Infinity, 0, Infinity, 0.0, 0)); +assert(test_scalbnf(-Infinity, 0, -Infinity, 0.0, 0)); +assert(test_scalbnf(1.0, 0, 1.0, 0.0, 0)); +assert(test_scalbnf(1.0, 1, 2.0, 0.0, 0)); +assert(test_scalbnf(1.0, -1, 0.5, 0.0, 0)); +assert(test_scalbnf(1.0, 2147483647, Infinity, 0.0, INEXACT | OVERFLOW)); +assert(test_scalbnf(NaN, 1, NaN, 0.0, 0)); +assert(test_scalbnf(Infinity, 2147483647, Infinity, 0.0, 0)); +assert(test_scalbnf(Infinity, -2147483647, Infinity, 0.0, 0)); +assert(test_scalbnf(-Infinity, 2147483647, -Infinity, 0.0, 0)); +assert(test_scalbnf(1.701411835e+38, -276, 1.401298464e-45, 0.0, 0)); +assert(test_scalbnf(1.401298464e-45, 276, 1.701411835e+38, 0.0, 0)); +assert(test_scalbnf(1.000244141, -149, 1.401298464e-45, 0.0, INEXACT | UNDERFLOW)); +assert(test_scalbnf(0.7499999404, -148, 1.401298464e-45, 0.0, INEXACT | UNDERFLOW)); +assert(test_scalbnf(0.5000006557, -128, 1.469369340e-39, 0.0, INEXACT | UNDERFLOW)); -// ================================ Math.log ================================ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.abs +//////////////////////////////////////////////////////////////////////////////////////////////////// -function test_log(value: f64, expected: f64, error: f64, flags: i32): void { - check(NativeMath.log(value), expected, error, flags); - check(JSMath.log(value), expected, error, flags); +function test_abs(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.abs(value), expected, error, flags) && + (!js || check( JSMath.abs(value), expected, error, flags)); } // sanity -test_log(-8.06684839057968084, NaN, 0.0, INVALID); -test_log(4.34523984933830487, 1.46908095842243225, -0.341253340244293213, INEXACT); -test_log(-8.38143342755524934, NaN, 0.0, INVALID); -test_log(-6.53167358191348413, NaN, 0.0, INVALID); -test_log(9.26705696697258574, 2.22646584987956153, 0.363811403512954712, INEXACT); -test_log(0.661985898099504477, -0.412511025236513673, -0.291087478399276733, INEXACT); -test_log(-0.406603922385355310, NaN, 0.0, INVALID); -test_log(0.561759746220724110, -0.576681018319586181, -0.109831996262073517, INEXACT); -test_log(0.774152296591303690, -0.255986659126386518, -0.0579900443553924561, INEXACT); -test_log(-0.678763702639402444, NaN, 0.0, INVALID); +assert(test_abs(-8.06684839057968084, 8.06684839057968084, 0.0, 0)); +assert(test_abs(4.34523984933830487, 4.34523984933830487, 0.0, 0)); +assert(test_abs(-8.38143342755524934, 8.38143342755524934, 0.0, 0)); +assert(test_abs(-6.53167358191348413, 6.53167358191348413, 0.0, 0)); +assert(test_abs(9.26705696697258574, 9.26705696697258574, 0.0, 0)); +assert(test_abs(0.661985898099504477, 0.661985898099504477, 0.0, 0)); +assert(test_abs(-0.40660392238535531, 0.40660392238535531, 0.0, 0)); +assert(test_abs(0.56175974622072411, 0.56175974622072411, 0.0, 0)); +assert(test_abs(0.77415229659130369, 0.77415229659130369, 0.0, 0)); +assert(test_abs(-0.678763702639402444, 0.678763702639402444, 0.0, 0)); // special -test_log(0.0, -Infinity, 0.0, DIVBYZERO); -test_log(-0.0, -Infinity, 0.0, DIVBYZERO); -test_log(-7.88860905221011805e-31, NaN, 0.0, INVALID); -test_log(1.0, 0.0, 0.0, 0); -test_log(-1.0, NaN, 0.0, INVALID); -test_log(Infinity, Infinity, 0.0, 0); -test_log(-Infinity, NaN, 0.0, INVALID); -test_log(NaN, NaN, 0.0, 0); +assert(test_abs(0.0, 0.0, 0.0, 0)); +assert(test_abs(-0.0, 0.0, 0.0, 0)); +assert(test_abs(1.0, 1.0, 0.0, 0)); +assert(test_abs(-1.0, 1.0, 0.0, 0)); +assert(test_abs(Infinity, Infinity, 0.0, 0)); +assert(test_abs(-Infinity, Infinity, 0.0, 0)); +assert(test_abs(NaN, NaN, 0.0, 0)); -// ================================ Mathf.log ================================ +// Mathf.abs /////////////////////////////////////////////////////////////////////////////////////// -function test_logf(value: f32, expected: f32, error: f32, flags: i32): void { - check(NativeMathf.log(value), expected, error, flags); +function test_absf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.abs(value), expected, error, flags); } // sanity -test_logf(0.0, -Infinity, 0.0, DIVBYZERO); -test_logf(-0.0, -Infinity, 0.0, DIVBYZERO); -test_logf(-7.888609052e-31, NaN, 0.0, INVALID); -test_logf(1.0, 0.0, 0.0, 0); -test_logf(-1.0, NaN, 0.0, INVALID); -test_logf(Infinity, Infinity, 0.0, 0); -test_logf(-Infinity, NaN, 0.0, INVALID); -test_logf(NaN, NaN, 0.0, 0); +assert(test_absf(-8.066848755, 8.066848755, 0.0, 0)); +assert(test_absf(4.345239639, 4.345239639, 0.0, 0)); +assert(test_absf(-8.381433487, 8.381433487, 0.0, 0)); +assert(test_absf(-6.531673431, 6.531673431, 0.0, 0)); +assert(test_absf(9.267057419, 9.267057419, 0.0, 0)); +assert(test_absf(0.6619858742, 0.6619858742, 0.0, 0)); +assert(test_absf(-0.4066039324, 0.4066039324, 0.0, 0)); +assert(test_absf(0.5617597699, 0.5617597699, 0.0, 0)); +assert(test_absf(0.7741522789, 0.7741522789, 0.0, 0)); +assert(test_absf(-0.6787636876, 0.6787636876, 0.0, 0)); // special -test_logf(0.0, -Infinity, 0.0, DIVBYZERO); -test_logf(-0.0, -Infinity, 0.0, DIVBYZERO); -test_logf(-7.888609052e-31, NaN, 0.0, INVALID); -test_logf(1.0, 0.0, 0.0, 0); -test_logf(-1.0, NaN, 0.0, INVALID); -test_logf(Infinity, Infinity, 0.0, 0); -test_logf(-Infinity, NaN, 0.0, INVALID); -test_logf(NaN, NaN, 0.0, 0); +assert(test_absf(0.0, 0.0, 0.0, 0)); +assert(test_absf(-0.0, 0.0, 0.0, 0)); +assert(test_absf(1.0, 1.0, 0.0, 0)); +assert(test_absf(-1.0, 1.0, 0.0, 0)); +assert(test_absf(Infinity, Infinity, 0.0, 0)); +assert(test_absf(-Infinity, Infinity, 0.0, 0)); +assert(test_absf(NaN, NaN, 0.0, 0)); -// ================================ Math.exp ================================ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.acos +//////////////////////////////////////////////////////////////////////////////////////////////////// -function test_exp(value: f64, expected: f64, error: f64, flags: i32): void { - check(NativeMath.exp(value), expected, error, flags); - check(JSMath.exp(value), expected, error, flags); +function test_acos(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.acos(value), expected, error, flags) && + (!js || check( JSMath.acos(value), expected, error, flags)); } // sanity -test_exp(-8.06684839057968084, 0.000313770606816174511, -0.259919732809066772, INEXACT); -test_exp(4.34523984933830487, 77.1105301711214111, -0.0279267579317092896, INEXACT); -test_exp(-8.38143342755524934, 0.000229081338491632304, -0.249743342399597168, INEXACT); -test_exp(-6.53167358191348413, 0.00145656612609315877, -0.481682240962982178, INEXACT); -test_exp(9.26705696697258574, 10583.5582455249933, 0.176967620849609375, INEXACT); -test_exp(0.661985898099504477, 1.93863845255719980, -0.496424645185470581, INEXACT); -test_exp(-0.406603922385355310, 0.665907889283802512, -0.106083184480667114, INEXACT); -test_exp(0.561759746220724110, 1.75375595186263111, -0.391621112823486328, INEXACT); -test_exp(0.774152296591303690, 2.16875288851292458, -0.299612581729888916, INEXACT); -test_exp(-0.678763702639402444, 0.507243708940284255, 0.472617387771606445, INEXACT); +assert(test_acos(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_acos(4.34523984933830487, NaN, 0.0, INVALID)); +assert(test_acos(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_acos(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_acos(9.26705696697258574, NaN, 0.0, INVALID)); +assert(test_acos(0.661985898099504477, 0.84733108284335068, -0.415532767772674561, INEXACT)); +assert(test_acos(-0.40660392238535531, 1.98953007108866897, 0.4973946213722229, INEXACT)); +assert(test_acos(0.56175974622072411, 0.974284964567490364, -0.442889750003814697, INEXACT)); +assert(test_acos(0.77415229659130369, 0.68542151586362221, -0.125895276665687561, INEXACT)); +assert(test_acos(-0.678763702639402444, 2.31687413820596388, -0.172849491238594055, INEXACT)); // special -test_exp(0.0, 1.0, 0.0, 0); -test_exp(-0.0, 1.0, 0.0, 0); -test_exp(1.0, 2.71828182845904509, -0.325530737638473511, INEXACT); -test_exp(-1.0, 0.367879441171442334, 0.223896518349647522, INEXACT); -test_exp(Infinity, Infinity, 0.0, 0); -test_exp(-Infinity, 0.0, 0.0, 0); -test_exp(NaN, NaN, 0.0, 0); -test_exp(1.03972148895263650, 2.82842915587641119, 0.188030809164047241, INEXACT); -test_exp(-1.03972148895263650, 0.353553136702178472, 0.252727240324020386, INEXACT); -test_exp(1.03972101211547852, 2.82842780717661224, -0.418413937091827393, INEXACT); -test_exp(1.03972148895263672, 2.82842915587641164, -0.226183772087097168, INEXACT); +assert(test_acos(0.0, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_acos(-1.0, 3.14159265358979312, -0.275765955448150635, INEXACT)); +assert(test_acos(1.0, 0.0, 0.0, 0)); +assert(test_acos(1.00000000000000022, NaN, 0.0, INVALID)); +assert(test_acos(-1.00000000000000022, NaN, 0.0, INVALID)); +assert(test_acos(Infinity, NaN, 0.0, INVALID)); +assert(test_acos(-Infinity, NaN, 0.0, INVALID)); +assert(test_acos(NaN, NaN, 0.0, 0)); +assert(test_acos(-0.530922720959298489, 2.13048537997054632, 0.139100849628448486, INEXACT)); +assert(test_acos(0.493955674639974585, 1.05416298758519456, 0.220547676086425781, INEXACT)); -// ================================ Mathf.exp ================================ +// Mathf.acos ////////////////////////////////////////////////////////////////////////////////////// -function test_expf(value: f32, expected: f32, error: f32, flags: i32): void { - check(NativeMathf.exp(value), expected, error, flags); +function test_acosf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.acos(value), expected, error, flags); } // sanity -test_expf(-8.066848755, 0.0003137704916, -0.03019333631, INEXACT); -test_expf(4.345239639, 77.11051178, -0.2875460684, INEXACT); -test_expf(-8.381433487, 0.0002290813281, 0.2237040401, INEXACT); -test_expf(-6.531673431, 0.001456566388, 0.3646970391, INEXACT); -test_expf(9.267057419, 10583.56348, 0.4596210420, INEXACT); -test_expf(0.6619858742, 1.938638449, 0.3568260968, INEXACT); -test_expf(-0.4066039324, 0.6659078598, -0.3829499185, INEXACT); -test_expf(0.5617597699, 1.753756046, 0.4435549080, INEXACT); -test_expf(0.7741522789, 2.168752909, 0.2456246912, INEXACT); -test_expf(-0.6787636876, 0.5072436929, -0.3974292278, INEXACT); +assert(test_acosf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_acosf(4.345239639, NaN, 0.0, INVALID)); +assert(test_acosf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_acosf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_acosf(9.267057419, NaN, 0.0, INVALID)); +assert(test_acosf(0.6619858742, 0.8473311067, -0.1358813196, INEXACT)); +assert(test_acosf(-0.4066039324, 1.989530087, 0.03764917701, INEXACT)); +assert(test_acosf(0.5617597699, 0.9742849469, 0.1844373941, INEXACT)); +assert(test_acosf(0.7741522789, 0.6854215264, -0.2915834486, INEXACT)); +assert(test_acosf(-0.6787636876, 2.316874027, -0.3795364499, INEXACT)); // special -test_expf(0.0, 1.0, 0.0, 0); -test_expf(-0.0, 1.0, 0.0, 0); -test_expf(1.0, 2.718281746, -0.3462330997, INEXACT); -test_expf(-1.0, 0.3678794503, 0.3070148528, INEXACT); -test_expf(Infinity, Infinity, 0.0, 0); -test_expf(-Infinity, 0.0, 0.0, 0); -test_expf(NaN, NaN, 0.0, 0); -test_expf(88.72283173, 3.402798519e+38, -0.09067153931, INEXACT); -test_expf(88.72283936, Infinity, 0.0, INEXACT|OVERFLOW); -test_expf(-103.9720764, 1.401298464e-45, 0.4999996722, INEXACT|UNDERFLOW); -test_expf(-103.9720840, 0.0, -0.4999965131, INEXACT|UNDERFLOW); -test_expf(0.3465735614, 1.414213538, 0.1392242163, INEXACT); -test_expf(0.3465735912, 1.414213538, -0.2143291682, INEXACT); -test_expf(0.3465736210, 1.414213657, 0.4321174324, INEXACT); +assert(test_acosf(0.0, 1.570796371, 0.3666777015, INEXACT)); +assert(test_acosf(-1.0, 3.141592741, 0.3666777015, INEXACT)); +assert(test_acosf(1.0, 0.0, 0.0, 0)); +assert(test_acosf(1.000000119, NaN, 0.0, INVALID)); +assert(test_acosf(-1.000000119, NaN, 0.0, INVALID)); +assert(test_acosf(Infinity, NaN, 0.0, INVALID)); +assert(test_acosf(-Infinity, NaN, 0.0, INVALID)); +assert(test_acosf(NaN, NaN, 0.0, 0)); +assert(test_acosf(0.4996506572, 1.047600865, -0.2116181403, INEXACT)); +assert(test_acosf(-0.505140543, 2.100341082, -0.2085270584, INEXACT)); +assert(test_acosf(-0.5189794898, 2.116452932, -0.146008268, INEXACT)); -// ================================ Math.pow ================================ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.acosh +//////////////////////////////////////////////////////////////////////////////////////////////////// -function test_pow(left: f64, right: f64, expected: f64, error: f64, flags: i32): void { - check(NativeMath.pow(left, right), expected, error, flags); +function test_acosh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.acosh(value), expected, error, flags) && + (!js || check( JSMath.acosh(value), expected, error, flags)); } // sanity -test_pow(-8.06684839057968084, 4.53566256067686879, NaN, 0.0, INVALID); -test_pow(4.34523984933830487, -8.88799136300345083, 0.00000213471188255872853, 0.325016021728515625, INEXACT); -test_pow(-8.38143342755524934, -2.76360733737958819, NaN, 0.0, INVALID); -test_pow(-6.53167358191348413, 4.56753527684274374, NaN, 0.0, INVALID); -test_pow(9.26705696697258574, 4.81139208435979615, 44909.2994151296589, -0.266590803861618042, INEXACT); -test_pow(-6.45004555606023633, 0.662071792337673881, NaN, 0.0, INVALID); -test_pow(7.85889025304169664, 0.0521545267500622481, 1.11351774134586523, -0.371686071157455444, INEXACT); -test_pow(-0.792054511984895959, 7.67640268511753998, NaN, 0.0, INVALID); -test_pow(0.615702673197924044, 2.01190257903248026, 0.376907735213801831, 0.324733018875122070, INEXACT); -test_pow(-0.558758682360915193, 0.0322398306026380407, NaN, 0.0, INVALID); +assert(test_acosh(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_acosh(4.34523984933830487, 2.14871639805975034, -0.291634738445281982, INEXACT)); +assert(test_acosh(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_acosh(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_acosh(9.26705696697258574, 2.91668914109907984, -0.241919085383415222, INEXACT)); +assert(test_acosh(0.661985898099504477, NaN, 0.0, INVALID)); +assert(test_acosh(-0.40660392238535531, NaN, 0.0, INVALID)); +assert(test_acosh(0.56175974622072411, NaN, 0.0, INVALID)); +assert(test_acosh(0.77415229659130369, NaN, 0.0, INVALID)); +assert(test_acosh(-0.678763702639402444, NaN, 0.0, INVALID)); + // special -test_pow(0.0, NaN, NaN, 0.0, 0); -test_pow(0.0, Infinity, 0.0, 0.0, 0); -test_pow(0.0, 3.0, 0.0, 0.0, 0); -test_pow(0.0, 2.0, 0.0, 0.0, 0); -test_pow(0.0, 1.0, 0.0, 0.0, 0); -test_pow(0.0, 0.5, 0.0, 0.0, 0); -test_pow(0.0, 0.0, 1.0, 0.0, 0); -test_pow(0.0, -0.0, 1.0, 0.0, 0); -test_pow(0.0, -0.5, Infinity, 0.0, DIVBYZERO); -test_pow(0.0, -1.0, Infinity, 0.0, DIVBYZERO); -test_pow(0.0, -2.0, Infinity, 0.0, DIVBYZERO); -test_pow(0.0, -3.0, Infinity, 0.0, DIVBYZERO); -test_pow(0.0, -4.0, Infinity, 0.0, DIVBYZERO); -test_pow(0.0, -Infinity, Infinity, 0.0, 0); -test_pow(-0.0, NaN, NaN, 0.0, 0); -test_pow(-0.0, Infinity, 0.0, 0.0, 0); -test_pow(-0.0, 3.0, -0.0, 0.0, 0); -test_pow(-0.0, 2.0, 0.0, 0.0, 0); -test_pow(-0.0, 1.0, -0.0, 0.0, 0); -test_pow(-0.0, 0.5, 0.0, 0.0, 0); -test_pow(-0.0, 0.0, 1.0, 0.0, 0); -test_pow(-0.0, -0.0, 1.0, 0.0, 0); -test_pow(-0.0, -0.5, Infinity, 0.0, DIVBYZERO); -test_pow(-0.0, -1.0, -Infinity, 0.0, DIVBYZERO); -test_pow(-0.0, -2.0, Infinity, 0.0, DIVBYZERO); -test_pow(-0.0, -3.0, -Infinity, 0.0, DIVBYZERO); -test_pow(-0.0, -4.0, Infinity, 0.0, DIVBYZERO); -test_pow(-0.0, -Infinity, Infinity, 0.0, 0); -test_pow(NaN, 0.0, 1.0, 0.0, 0); -test_pow(Infinity, 0.0, 1.0, 0.0, 0); -test_pow(-Infinity, 0.0, 1.0, 0.0, 0); -test_pow(1.0, 0.0, 1.0, 0.0, 0); -test_pow(-1.0, 0.0, 1.0, 0.0, 0); -test_pow(-0.5, 0.0, 1.0, 0.0, 0); -test_pow(NaN, -0.0, 1.0, 0.0, 0); -test_pow(Infinity, -0.0, 1.0, 0.0, 0); -test_pow(-Infinity, -0.0, 1.0, 0.0, 0); -test_pow(1.0, -0.0, 1.0, 0.0, 0); -test_pow(-1.0, -0.0, 1.0, 0.0, 0); -test_pow(-0.5, -0.0, 1.0, 0.0, 0); -test_pow(-1.0, NaN, NaN, 0.0, 0); -test_pow(-1.0, Infinity, 1.0, 0.0, 0); -test_pow(-1.0, -Infinity, 1.0, 0.0, 0); -test_pow(-1.0, 2.0, 1.0, 0.0, 0); -test_pow(-1.0, -1.0, -1.0, 0.0, 0); -test_pow(-1.0, -2.0, 1.0, 0.0, 0); -test_pow(-1.0, -3.0, -1.0, 0.0, 0); -test_pow(-1.0, 0.5, NaN, 0.0, INVALID); -test_pow(1.0, NaN, 1.0, 0.0, 0); -test_pow(1.0, Infinity, 1.0, 0.0, 0); -test_pow(1.0, -Infinity, 1.0, 0.0, 0); -test_pow(1.0, 3.0, 1.0, 0.0, 0); -test_pow(1.0, 0.5, 1.0, 0.0, 0); -test_pow(1.0, -0.5, 1.0, 0.0, 0); -test_pow(1.0, -3.0, 1.0, 0.0, 0); -test_pow(-0.5, 0.5, NaN, 0.0, INVALID); -test_pow(-0.5, 1.5, NaN, 0.0, INVALID); -test_pow(-0.5, 2.0, 0.25, 0.0, 0); -test_pow(-0.5, 3.0, -0.125, 0.0, 0); -test_pow(-0.5, Infinity, 0.0, 0.0, 0); -test_pow(-0.5, -Infinity, Infinity, 0.0, 0); -test_pow(-0.5, NaN, NaN, 0.0, 0); -test_pow(0.5, Infinity, 0.0, 0.0, 0); -test_pow(0.5, -Infinity, Infinity, 0.0, 0); -test_pow(0.5, NaN, NaN, 0.0, 0); -test_pow(1.5, Infinity, Infinity, 0.0, 0); -test_pow(1.5, -Infinity, 0.0, 0.0, 0); -test_pow(1.5, NaN, NaN, 0.0, 0); -test_pow(Infinity, NaN, NaN, 0.0, 0); -test_pow(Infinity, Infinity, Infinity, 0.0, 0); -test_pow(Infinity, -Infinity, 0.0, 0.0, 0); -test_pow(Infinity, 3.0, Infinity, 0.0, 0); -test_pow(Infinity, 2.0, Infinity, 0.0, 0); -test_pow(Infinity, 1.0, Infinity, 0.0, 0); -test_pow(Infinity, 0.5, Infinity, 0.0, 0); -test_pow(Infinity, -0.5, 0.0, 0.0, 0); -test_pow(Infinity, -1.0, 0.0, 0.0, 0); -test_pow(Infinity, -2.0, 0.0, 0.0, 0); -test_pow(-Infinity, NaN, NaN, 0.0, 0); -test_pow(-Infinity, Infinity, Infinity, 0.0, 0); -test_pow(-Infinity, -Infinity, 0.0, 0.0, 0); -test_pow(-Infinity, 3.0, -Infinity, 0.0, 0); -test_pow(-Infinity, 2.0, Infinity, 0.0, 0); -test_pow(-Infinity, 1.0, -Infinity, 0.0, 0); -test_pow(-Infinity, 0.5, Infinity, 0.0, 0); -test_pow(-Infinity, -0.5, 0.0, 0.0, 0); -test_pow(-Infinity, -1.0, -0.0, 0.0, 0); -test_pow(-Infinity, -2.0, 0.0, 0.0, 0); -test_pow(NaN, 1.0, NaN, 0.0, 0); -test_pow(NaN, -1.0, NaN, 0.0, 0); -test_pow(-2.0, 1.0, -2.0, 0.0, 0); -test_pow(-2.0, -1.0, -0.5, 0.0, 0); +assert(test_acosh(NaN, NaN, 0.0, 0)); +assert(test_acosh(Infinity, Infinity, 0.0, 0)); +assert(test_acosh(1.0, 0.0, 0.0, 0)); +assert(test_acosh(0.99999237060546875, NaN, 0.0, INVALID)); +assert(test_acosh(0.0, NaN, 0.0, INVALID)); +assert(test_acosh(-0.0, NaN, 0.0, INVALID)); +assert(test_acosh(-Infinity, NaN, 0.0, INVALID)); -// ================================ Mathf.pow ================================ +// TODO: hard cases close to 1 +// assert(test_acosh(1.00047471439683111, 0.030811583621269234, -0.147202208638191223, INEXACT)); +// assert(test_acosh(1.00183940730320464, 0.0606439391272710696, -0.27641335129737854, INEXACT)); +// assert(test_acosh(1.00188411580836734, 0.0613762895053152624, 0.144539892673492432, INEXACT)); +// assert(test_acosh(1.00710219219241903, 0.11911172253310362, -0.0701267644762992859, INEXACT)); +// assert(test_acosh(1.00721657615236126, 0.1200659234653388, 0.348167449235916138, INEXACT)); +// assert(test_acosh(1.00755889036240331, 0.122877066266470714, 0.238077804446220398, INEXACT)); +// assert(test_acosh(1.02542398474864016, 0.225019907470933367, -0.326139897108078003, INEXACT)); +// assert(test_acosh(1.0256625220747686, 0.226068601206439679, -0.038667779415845871, INEXACT)); +// assert(test_acosh(1.0258391651139116, 0.226842008792436378, -0.214941442012786865, INEXACT)); +// assert(test_acosh(1.02779264167821971, 0.235222655703679978, -0.18194638192653656, INEXACT)); +// assert(test_acosh(1.02795793845257588, 0.235917895367856345, -0.21022343635559082, INEXACT)); +// assert(test_acosh(1.03023030515918168, 0.245272131775117419, -0.281468182802200317, INEXACT)); +// assert(test_acosh(1.10422493637863384, 0.452687876797022049, 0.276559263467788696, INEXACT)); +assert(test_acosh(1.10608311999264286, 0.45663734043848031, -0.293816089630126953, INEXACT)); +// assert(test_acosh(1.10669650280664866, 0.457933064962976033, -0.261756330728530884, INEXACT)); +assert(test_acosh(1.10898095576286582, 0.462724685995942797, -0.399009555578231812, INEXACT)); +assert(test_acosh(1.11694291598755213, 0.47902433134075284, -0.321674108505249023, INEXACT)); -function test_powf(left: f32, right: f32, expected: f32, error: f32, flags: i32): void { - check(NativeMathf.pow(left, right), expected, error, flags); +// Mathf.acosh ///////////////////////////////////////////////////////////////////////////////////// + +function test_acoshf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.acosh(value), expected, error, flags); } // sanity -test_powf(-8.066848755, 4.535662651, NaN, 0.0, INVALID); -test_powf(4.345239639, -8.887990952, 0.000002134714123, 0.1436440796, INEXACT); -test_powf(-8.381433487, -2.763607264, NaN, 0.0, INVALID); -test_powf(-6.531673431, 4.567535400, NaN, 0.0, INVALID); -test_powf(9.267057419, 4.811392307, 44909.33203, -0.05356409028, INEXACT); -test_powf(-6.450045586, 0.6620717645, NaN, 0.0, INVALID); -test_powf(7.858890057, 0.05215452611, 1.113517761, 0.1912208945, INEXACT); -test_powf(-0.7920545340, 7.676402569, NaN, 0.0, INVALID); -test_powf(0.6157026887, 2.011902571, 0.3769077659, 0.3371490538, INEXACT); -test_powf(-0.5587586761, 0.03223983198, NaN, 0.0, INVALID); +assert(test_acoshf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_acoshf(4.345239639, 2.14871645, 0.4251045287, INEXACT)); +assert(test_acoshf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_acoshf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_acoshf(9.267057419, 2.916689157, -0.1369788945, INEXACT)); +assert(test_acoshf(0.6619858742, NaN, 0.0, INVALID)); +assert(test_acoshf(-0.4066039324, NaN, 0.0, INVALID)); +assert(test_acoshf(0.5617597699, NaN, 0.0, INVALID)); +assert(test_acoshf(0.7741522789, NaN, 0.0, INVALID)); +assert(test_acoshf(-0.6787636876, NaN, 0.0, INVALID)); + // special -test_powf(0.0, NaN, NaN, 0.0, 0); -test_powf(0.0, Infinity, 0.0, 0.0, 0); -test_powf(0.0, 3.0, 0.0, 0.0, 0); -test_powf(0.0, 2.0, 0.0, 0.0, 0); -test_powf(0.0, 1.0, 0.0, 0.0, 0); -test_powf(0.0, 0.5, 0.0, 0.0, 0); -test_powf(0.0, 0.0, 1.0, 0.0, 0); -test_powf(0.0, -0.0, 1.0, 0.0, 0); -test_powf(0.0, -0.5, Infinity, 0.0, DIVBYZERO); -test_powf(0.0, -1.0, Infinity, 0.0, DIVBYZERO); -test_powf(0.0, -2.0, Infinity, 0.0, DIVBYZERO); -test_powf(0.0, -3.0, Infinity, 0.0, DIVBYZERO); -test_powf(0.0, -4.0, Infinity, 0.0, DIVBYZERO); -test_powf(0.0, -Infinity, Infinity, 0.0, 0); -test_powf(-0.0, NaN, NaN, 0.0, 0); -test_powf(-0.0, Infinity, 0.0, 0.0, 0); -test_powf(-0.0, 3.0, -0.0, 0.0, 0); -test_powf(-0.0, 2.0, 0.0, 0.0, 0); -test_powf(-0.0, 1.0, -0.0, 0.0, 0); -test_powf(-0.0, 0.5, 0.0, 0.0, 0); -test_powf(-0.0, 0.0, 1.0, 0.0, 0); -test_powf(-0.0, -0.0, 1.0, 0.0, 0); -test_powf(-0.0, -0.5, Infinity, 0.0, DIVBYZERO); -test_powf(-0.0, -1.0, -Infinity, 0.0, DIVBYZERO); -test_powf(-0.0, -2.0, Infinity, 0.0, DIVBYZERO); -test_powf(-0.0, -3.0, -Infinity, 0.0, DIVBYZERO); -test_powf(-0.0, -4.0, Infinity, 0.0, DIVBYZERO); -test_powf(-0.0, -Infinity, Infinity, 0.0, 0); -test_powf(NaN, 0.0, 1.0, 0.0, 0); -test_powf(Infinity, 0.0, 1.0, 0.0, 0); -test_powf(-Infinity, 0.0, 1.0, 0.0, 0); -test_powf(1.0, 0.0, 1.0, 0.0, 0); -test_powf(-1.0, 0.0, 1.0, 0.0, 0); -test_powf(-0.5, 0.0, 1.0, 0.0, 0); -test_powf(NaN, -0.0, 1.0, 0.0, 0); -test_powf(Infinity, -0.0, 1.0, 0.0, 0); -test_powf(-Infinity, -0.0, 1.0, 0.0, 0); -test_powf(1.0, -0.0, 1.0, 0.0, 0); -test_powf(-1.0, -0.0, 1.0, 0.0, 0); -test_powf(-0.5, -0.0, 1.0, 0.0, 0); -test_powf(-1.0, NaN, NaN, 0.0, 0); -test_powf(-1.0, Infinity, 1.0, 0.0, 0); -test_powf(-1.0, -Infinity, 1.0, 0.0, 0); -test_powf(-1.0, 2.0, 1.0, 0.0, 0); -test_powf(-1.0, -1.0, -1.0, 0.0, 0); -test_powf(-1.0, -2.0, 1.0, 0.0, 0); -test_powf(-1.0, -3.0, -1.0, 0.0, 0); -test_powf(-1.0, 0.5, NaN, 0.0, INVALID); -test_powf(1.0, NaN, 1.0, 0.0, 0); -test_powf(1.0, Infinity, 1.0, 0.0, 0); -test_powf(1.0, -Infinity, 1.0, 0.0, 0); -test_powf(1.0, 3.0, 1.0, 0.0, 0); -test_powf(1.0, 0.5, 1.0, 0.0, 0); -test_powf(1.0, -0.5, 1.0, 0.0, 0); -test_powf(1.0, -3.0, 1.0, 0.0, 0); -test_powf(-0.5, 0.5, NaN, 0.0, INVALID); -test_powf(-0.5, 1.5, NaN, 0.0, INVALID); -test_powf(-0.5, 2.0, 0.25, 0.0, 0); -test_powf(-0.5, 3.0, -0.125, 0.0, 0); -test_powf(-0.5, Infinity, 0.0, 0.0, 0); -test_powf(-0.5, -Infinity, Infinity, 0.0, 0); -test_powf(-0.5, NaN, NaN, 0.0, 0); -test_powf(0.5, Infinity, 0.0, 0.0, 0); -test_powf(0.5, -Infinity, Infinity, 0.0, 0); -test_powf(0.5, NaN, NaN, 0.0, 0); -test_powf(1.5, Infinity, Infinity, 0.0, 0); -test_powf(1.5, -Infinity, 0.0, 0.0, 0); -test_powf(1.5, NaN, NaN, 0.0, 0); -test_powf(Infinity, NaN, NaN, 0.0, 0); -test_powf(Infinity, Infinity, Infinity, 0.0, 0); -test_powf(Infinity, -Infinity, 0.0, 0.0, 0); -test_powf(Infinity, 3.0, Infinity, 0.0, 0); -test_powf(Infinity, 2.0, Infinity, 0.0, 0); -test_powf(Infinity, 1.0, Infinity, 0.0, 0); -test_powf(Infinity, 0.5, Infinity, 0.0, 0); -test_powf(Infinity, -0.5, 0.0, 0.0, 0); -test_powf(Infinity, -1.0, 0.0, 0.0, 0); -test_powf(Infinity, -2.0, 0.0, 0.0, 0); -test_powf(-Infinity, NaN, NaN, 0.0, 0); -test_powf(-Infinity, Infinity, Infinity, 0.0, 0); -test_powf(-Infinity, -Infinity, 0.0, 0.0, 0); -test_powf(-Infinity, 3.0, -Infinity, 0.0, 0); -test_powf(-Infinity, 2.0, Infinity, 0.0, 0); -test_powf(-Infinity, 1.0, -Infinity, 0.0, 0); -test_powf(-Infinity, 0.5, Infinity, 0.0, 0); -test_powf(-Infinity, -0.5, 0.0, 0.0, 0); -test_powf(-Infinity, -1.0, -0.0, 0.0, 0); -test_powf(-Infinity, -2.0, 0.0, 0.0, 0); -test_powf(NaN, 1.0, NaN, 0.0, 0); -test_powf(NaN, -1.0, NaN, 0.0, 0); -test_powf(-2.0, 1.0, -2.0, 0.0, 0); -test_powf(-2.0, -1.0, -0.5, 0.0, 0); +assert(test_acoshf(NaN, NaN, 0.0, 0)); +assert(test_acoshf(Infinity, Infinity, 0.0, 0)); +assert(test_acoshf(1.0, 0.0, 0.0, 0)); +assert(test_acoshf(0.9999923706, NaN, 0.0, INVALID)); +assert(test_acoshf(0.0, NaN, 0.0, INVALID)); +assert(test_acoshf(-0.0, NaN, 0.0, INVALID)); +assert(test_acoshf(-Infinity, NaN, 0.0, INVALID)); +assert(test_acoshf(-1.125899907e+15, NaN, 0.0, INVALID)); -// ================================ Math.cbrt ================================ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.asin +//////////////////////////////////////////////////////////////////////////////////////////////////// -function test_cbrt(value: f64, expected: f64, error: f64, flags: i32): void { - check(NativeMath.cbrt(value), expected, error, flags); - check(JSMath.cbrt(value), expected, error, flags); +function test_asin(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.asin(value), expected, error, flags) && + (!js || check( JSMath.asin(value), expected, error, flags)); } // sanity -test_cbrt(-8.06684839057968084, -2.00555525450202454, 0.466679513454437256, INEXACT); -test_cbrt(4.34523984933830487, 1.63181624105156353, -0.0816027149558067322, INEXACT); -test_cbrt(-8.38143342755524934, -2.03129391067336096, -0.0481018163263797760, INEXACT); -test_cbrt(-6.53167358191348413, -1.86928200122049248, 0.0862401872873306274, INEXACT); -test_cbrt(9.26705696697258574, 2.10045772085970217, -0.272298902273178101, INEXACT); -test_cbrt(0.661985898099504477, 0.871531147045597310, 0.441491812467575073, INEXACT); -test_cbrt(-0.406603922385355310, -0.740839030300223023, 0.0164538137614727020, INEXACT); -test_cbrt(0.561759746220724110, 0.825119540055928580, 0.306806385517120361, INEXACT); -test_cbrt(0.774152296591303690, 0.918210247895991372, 0.0654399842023849487, INEXACT); -test_cbrt(-0.678763702639402444, -0.878832690658009397, -0.201671317219734192, INEXACT); +assert(test_asin(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_asin(4.34523984933830487, NaN, 0.0, INVALID)); +assert(test_asin(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_asin(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_asin(9.26705696697258574, NaN, 0.0, INVALID)); +assert(test_asin(0.661985898099504477, 0.723465243951545878, -0.135999128222465515, INEXACT)); +assert(test_asin(-0.40660392238535531, -0.418733744293772248, -0.0926423072814941406, INEXACT)); +assert(test_asin(0.56175974622072411, 0.596511362227406194, -0.108642138540744781, INEXACT)); +assert(test_asin(0.77415229659130369, 0.885374810931274348, -0.425636619329452515, INEXACT)); +assert(test_asin(-0.678763702639402444, -0.746077811411067326, 0.139866068959236145, INEXACT)); // special -test_cbrt(NaN, NaN, 0.0, 0); -test_cbrt(Infinity, Infinity, 0.0, 0); -test_cbrt(-Infinity, -Infinity, 0.0, 0); -test_cbrt(0.0, 0.0, 0.0, 0); -test_cbrt(-0.0, -0.0, 0.0, 0); -test_cbrt(9.31322574615478516e-10, 0.0009765625, 0.0, 0); -test_cbrt(-9.31322574615478516e-10, -0.0009765625, 0.0, 0); -test_cbrt(1.0, 1.0, 0.0, 0); -test_cbrt(-1.0, -1.0, 0.0, 0); -test_cbrt(8.0, 2.0, 0.0, 0); +assert(test_asin(1.0, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_asin(-1.0, -1.57079632679489656, 0.275765955448150635, INEXACT)); +assert(test_asin(0.0, 0.0, 0.0, 0)); +assert(test_asin(-0.0, -0.0, 0.0, 0)); +assert(test_asin(1.00000000000000022, NaN, 0.0, INVALID)); +assert(test_asin(-1.00000000000000022, NaN, 0.0, INVALID)); +assert(test_asin(Infinity, NaN, 0.0, INVALID)); +assert(test_asin(-Infinity, NaN, 0.0, INVALID)); +assert(test_asin(NaN, NaN, 0.0, 0)); +assert(test_asin(0.507304392911914759, 0.53205389977723494, -0.161573171615600586, INEXACT)); -// ================================ Mathf.cbrt ================================ +// Mathf.asin ////////////////////////////////////////////////////////////////////////////////////// -function test_cbrtf(value: f32, expected: f32, error: f32, flags: i32): void { - check(NativeMathf.cbrt(value), expected, error, flags); +function test_asinf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.asin(value), expected, error, flags); } // sanity -test_cbrtf(-8.066848755, -2.005555391, -0.4471924007, INEXACT); -test_cbrtf(4.345239639, 1.631816268, 0.4463625252, INEXACT); -test_cbrtf(-8.381433487, -2.031293869, 0.1948342621, INEXACT); -test_cbrtf(-6.531673431, -1.869282007, -0.1707551479, INEXACT); -test_cbrtf(9.267057419, 2.100457668, -0.3636204302, INEXACT); -test_cbrtf(0.6619858742, 0.8715311289, -0.1285720915, INEXACT); -test_cbrtf(-0.4066039324, -0.7408390641, -0.4655757546, INEXACT); -test_cbrtf(0.5617597699, 0.8251195550, 0.05601907894, INEXACT); -test_cbrtf(0.7741522789, 0.9182102680, 0.4549820423, INEXACT); -test_cbrtf(-0.6787636876, -0.8788326979, -0.2297896743, INEXACT); +assert(test_asinf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_asinf(4.345239639, NaN, 0.0, INVALID)); +assert(test_asinf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_asinf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_asinf(9.267057419, NaN, 0.0, INVALID)); +assert(test_asinf(0.6619858742, 0.7234652042, -0.1307632476, INEXACT)); +assert(test_asinf(-0.4066039324, -0.4187337458, 0.3161141574, INEXACT)); +assert(test_asinf(0.5617597699, 0.596511364, -0.4510819614, INEXACT)); +assert(test_asinf(0.7741522789, 0.8853747845, 0.02493886836, INEXACT)); +assert(test_asinf(-0.6787636876, -0.746077776, 0.2515012324, INEXACT)); // special -test_cbrtf(NaN, NaN, 0.0, 0); -test_cbrtf(Infinity, Infinity, 0.0, 0); -test_cbrtf(-Infinity, -Infinity, 0.0, 0); -test_cbrtf(0.0, 0.0, 0.0, 0); -test_cbrtf(-0.0, -0.0, 0.0, 0); -test_cbrtf(9.313225746e-10, 0.0009765625, 0.0, 0); -test_cbrtf(-9.313225746e-10, -0.0009765625, 0.0, 0); -test_cbrtf(1.0, 1.0, 0.0, 0); -test_cbrtf(-1.0, -1.0, 0.0, 0); -test_cbrtf(8.0, 2.0, 0.0, 0); +assert(test_asinf(1.0, 1.570796371, 0.3666777015, INEXACT)); +assert(test_asinf(-1.0, -1.570796371, -0.3666777015, INEXACT)); +assert(test_asinf(0.0, 0.0, 0.0, 0)); +assert(test_asinf(-0.0, -0.0, 0.0, 0)); +assert(test_asinf(1.000000119, NaN, 0.0, INVALID)); +assert(test_asinf(-1.000000119, NaN, 0.0, INVALID)); +assert(test_asinf(Infinity, NaN, 0.0, INVALID)); +assert(test_asinf(-Infinity, NaN, 0.0, INVALID)); +assert(test_asinf(NaN, NaN, 0.0, 0)); +assert(test_asinf(0.500477016, 0.5241496563, -0.2942709923, INEXACT)); -// ================================ Mathf.random ================================ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.asinh +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_asinh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.asinh(value), expected, error, flags) && + (!js || check( JSMath.asinh(value), expected, error, flags)); +} + +// sanity +assert(test_asinh(-8.06684839057968084, -2.78472987838786112, -0.476218998432159424, INEXACT)); +assert(test_asinh(4.34523984933830487, 2.17521338901316419, -0.0272875130176544189, INEXACT)); +assert(test_asinh(-8.38143342755524934, -2.82270608369769604, 0.20985257625579834, INEXACT)); +assert(test_asinh(-6.53167358191348413, -2.57561944659192221, 0.311313420534133911, INEXACT)); +assert(test_asinh(9.26705696697258574, 2.92251149510486741, 0.499175608158111572, INEXACT)); +assert(test_asinh(0.661985898099504477, 0.621246276270716602, -0.469734758138656616, INEXACT)); +assert(test_asinh(-0.40660392238535531, -0.396159903931920354, -0.408144384622573853, INEXACT)); +assert(test_asinh(0.56175974622072411, 0.535758887025547414, 0.352071315050125122, INEXACT)); +assert(test_asinh(0.77415229659130369, 0.712357126319734912, 0.13371451199054718, INEXACT)); +assert(test_asinh(-0.678763702639402444, -0.635182348903198024, 0.0474967099726200104, INEXACT)); + +// special +assert(test_asinh(NaN, NaN, 0.0, 0)); +assert(test_asinh(Infinity, Infinity, 0.0, 0)); +assert(test_asinh(-Infinity, -Infinity, 0.0, 0)); +assert(test_asinh(0.0, 0.0, 0.0, 0)); +assert(test_asinh(-0.0, -0.0, 0.0, 0)); + +// TODO: hard cases around 0.125? +// assert(test_asinh(0.247980229031791038, 0.245506531315820731, -0.487455964088439941, INEXACT)); +// assert(test_asinh(0.233961368245165308, 0.231877865394494953, 0.448774427175521851, INEXACT)); +// assert(test_asinh(0.24189636405949258, 0.239597351837045336, -0.43224412202835083, INEXACT)); +// assert(test_asinh(0.24297705017513252, 0.240647613714979003, 0.464605927467346191, INEXACT)); +// assert(test_asinh(0.243009640747287647, 0.240679282734723166, 0.474347352981567383, INEXACT)); +// assert(test_asinh(0.243762819057833202, 0.241411097647160899, -0.471239805221557617, INEXACT)); +// assert(test_asinh(0.244209582852871615, 0.241845129387203428, 0.357721567153930664, INEXACT)); +// assert(test_asinh(0.245142613572556872, 0.242751426027184358, 0.488074928522109985, INEXACT)); +// assert(test_asinh(0.248925886656024803, 0.246424287018607635, 0.423774600028991699, INEXACT)); +// assert(test_asinh(0.249687050136605942, 0.247162844410159732, 0.467378854751586914, INEXACT)); +// assert(test_asinh(0.252496955340698215, 0.249888150492394823, -0.330307126045227051, INEXACT)); +// assert(test_asinh(0.46527661837878348, 0.449940706126732537, 0.415301203727722168, INEXACT)); +// assert(test_asinh(0.467958660300663964, 0.452371172681032996, 0.495325148105621338, INEXACT)); +// assert(test_asinh(0.479083566135035333, 0.462425786301167263, 0.421210944652557373, INEXACT)); +// assert(test_asinh(0.481281048969517788, 0.464406726694242211, -0.483110427856445313, INEXACT)); +// assert(test_asinh(0.487328868799273951, 0.469849798263134111, -0.424072027206420898, INEXACT)); +// assert(test_asinh(0.489993198082535886, 0.472243604962259256, -0.437918633222579956, INEXACT)); +// assert(test_asinh(0.519085143365399015, 0.498216616337933904, -0.420524448156356812, INEXACT)); + +// Mathf.asinh ///////////////////////////////////////////////////////////////////////////////////// + +function test_asinhf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.asinh(value), expected, error, flags); +} + +// sanity +assert(test_asinhf(-8.066848755, -2.784729958, -0.1441801339, INEXACT)); +assert(test_asinhf(4.345239639, 2.175213337, -0.02079696581, INEXACT)); +assert(test_asinhf(-8.381433487, -2.822705984, 0.4471853375, INEXACT)); +assert(test_asinhf(-6.531673431, -2.575619459, -0.1482227296, INEXACT)); +assert(test_asinhf(9.267057419, 2.922511578, 0.1427068114, INEXACT)); +assert(test_asinhf(0.6619858742, 0.6212462783, 0.368491292, INEXACT)); +assert(test_asinhf(-0.4066039324, -0.3961599171, -0.1317030638, INEXACT)); +assert(test_asinhf(0.5617597699, 0.5357589126, 0.08184859902, INEXACT)); +assert(test_asinhf(0.7741522789, 0.7123571038, -0.1427073777, INEXACT)); +assert(test_asinhf(-0.6787636876, -0.6351823211, 0.2583143711, INEXACT)); + +// special +assert(test_asinhf(NaN, NaN, 0.0, 0)); +assert(test_asinhf(Infinity, Infinity, 0.0, 0)); +assert(test_asinhf(-Infinity, -Infinity, 0.0, 0)); +assert(test_asinhf(0.0, 0.0, 0.0, 0)); +assert(test_asinhf(-0.0, -0.0, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.atan +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_atan(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.atan(value), expected, error, flags) && + (!js || check( JSMath.atan(value), expected, error, flags)); +} + +// sanity +assert(test_atan(-8.06684839057968084, -1.44746137626334681, 0.148571118712425232, INEXACT)); +assert(test_atan(4.34523984933830487, 1.34459792711453807, -0.0817033573985099792, INEXACT)); +assert(test_atan(-8.38143342755524934, -1.45204634632955387, -0.0750548020005226135, INEXACT)); +assert(test_atan(-6.53167358191348413, -1.41887586587525316, -0.0576334968209266663, INEXACT)); +assert(test_atan(9.26705696697258574, 1.46330314544870599, 0.160695642232894897, INEXACT)); +assert(test_atan(0.661985898099504477, 0.584755067023832509, 0.458255648612976074, INEXACT)); +assert(test_atan(-0.40660392238535531, -0.386186417755213118, -0.257428169250488281, INEXACT)); +assert(test_atan(0.56175974622072411, 0.511826953162888065, -0.114442773163318634, INEXACT)); +assert(test_atan(0.77415229659130369, 0.658780243165382196, -0.112864881753921509, INEXACT)); +assert(test_atan(-0.678763702639402444, -0.596330782697347184, -0.218284234404563904, INEXACT)); + +// special +assert(test_atan(0.0, 0.0, 0.0, 0)); +assert(test_atan(-0.0, -0.0, 0.0, 0)); +assert(test_atan(1.0, 0.785398163397448279, -0.275765955448150635, INEXACT)); +assert(test_atan(-1.0, -0.785398163397448279, 0.275765955448150635, INEXACT)); +assert(test_atan(Infinity, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_atan(-Infinity, -1.57079632679489656, 0.275765955448150635, INEXACT)); +assert(test_atan(NaN, NaN, 0.0, 0)); +assert(test_atan(0.6929821535674624, 0.606000455515256164, -0.170757904648780823, INEXACT)); + +// Mathf.atan ////////////////////////////////////////////////////////////////////////////////////// + +function test_atanf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.atan(value), expected, error, flags); +} + +// sanity +assert(test_atanf(-8.066848755, -1.447461367, 0.1268648058, INEXACT)); +assert(test_atanf(4.345239639, 1.344597936, 0.1604543477, INEXACT)); +assert(test_atanf(-8.381433487, -1.452046394, -0.3958175182, INEXACT)); +assert(test_atanf(-6.531673431, -1.418875813, 0.4105703533, INEXACT)); +assert(test_atanf(9.267057419, 1.463303208, 0.4840350151, INEXACT)); +assert(test_atanf(0.6619858742, 0.5847550631, 0.2125193477, INEXACT)); +assert(test_atanf(-0.4066039324, -0.3861864209, 0.1816962808, INEXACT)); +assert(test_atanf(0.5617597699, 0.511826992, 0.3499770761, INEXACT)); +assert(test_atanf(0.7741522789, 0.6587802172, -0.2505330741, INEXACT)); +assert(test_atanf(-0.6787636876, -0.5963307619, 0.1761482656, INEXACT)); + +// special +assert(test_atanf(0.0, 0.0, 0.0, 0)); +assert(test_atanf(-0.0, -0.0, 0.0, 0)); +assert(test_atanf(1.0, 0.7853981853, 0.3666777015, INEXACT)); +assert(test_atanf(-1.0, -0.7853981853, -0.3666777015, INEXACT)); +assert(test_atanf(Infinity, 1.570796371, 0.3666777015, INEXACT)); +assert(test_atanf(-Infinity, -1.570796371, -0.3666777015, INEXACT)); +assert(test_atanf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.atanh +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_atanh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.atanh(value), expected, error, flags) && + (!js || check( JSMath.atanh(value), expected, error, flags)); +} + +// sanity +assert(test_atanh(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_atanh(4.34523984933830487, NaN, 0.0, INVALID)); +assert(test_atanh(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_atanh(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_atanh(9.26705696697258574, NaN, 0.0, INVALID)); +assert(test_atanh(0.661985898099504477, 0.796340437134794299, 0.213383659720420837, INEXACT)); +assert(test_atanh(-0.40660392238535531, -0.431535707306028971, -0.432566612958908081, INEXACT)); +assert(test_atanh(0.56175974622072411, 0.635400611164457785, -0.0652786567807197571, INEXACT)); +assert(test_atanh(0.77415229659130369, 1.03060855752779945, 0.146320521831512451, INEXACT)); +assert(test_atanh(-0.678763702639402444, -0.826817964520525472, 0.139712870121002197, INEXACT)); + +// special +assert(test_atanh(NaN, NaN, 0.0, 0)); +assert(test_atanh(Infinity, NaN, 0.0, INVALID)); +assert(test_atanh(-Infinity, NaN, 0.0, INVALID)); +assert(test_atanh(0.0, 0.0, 0.0, 0)); +assert(test_atanh(-0.0, -0.0, 0.0, 0)); +assert(test_atanh(1.0, Infinity, 0.0, DIVBYZERO)); +assert(test_atanh(-1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_atanh(1.0000152587890625, NaN, 0.0, INVALID)); +assert(test_atanh(-1.0000152587890625, NaN, 0.0, INVALID)); +assert(test_atanh(1.35525271560688054e-20, 1.35525271560688054e-20, 0.0, INEXACT)); +assert(test_atanh(9.33263618503218879e-302, 9.33263618503218879e-302, 0.0, INEXACT)); +assert(test_atanh(5.56268464626800346e-309, 5.56268464626800346e-309, 0.0, INEXACT | UNDERFLOW)); +assert(test_atanh(-5.56268464626800346e-309, -5.56268464626800346e-309, 0.0, INEXACT | UNDERFLOW)); +assert(test_atanh(8.98846567431157954e+307, NaN, 0.0, INVALID)); + +// Mathf.atanh ///////////////////////////////////////////////////////////////////////////////////// + +function test_atanhf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.atanh(value), expected, error, flags); +} + +// sanity +assert(test_atanhf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_atanhf(4.345239639, NaN, 0.0, INVALID)); +assert(test_atanhf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_atanhf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_atanhf(9.267057419, NaN, 0.0, INVALID)); +assert(test_atanhf(0.6619858742, 0.7963404059, 0.1911219656, INEXACT)); +assert(test_atanhf(-0.4066039324, -0.4315357208, -0.05180925131, INEXACT)); +assert(test_atanhf(0.5617597699, 0.6354006529, 0.1191105619, INEXACT)); +assert(test_atanhf(0.7741522789, 1.030608535, 0.1798270345, INEXACT)); +assert(test_atanhf(-0.6787636876, -0.8268179297, 0.1158898324, INEXACT)); + +// special +assert(test_atanhf(NaN, NaN, 0.0, 0)); +assert(test_atanhf(Infinity, NaN, 0.0, INVALID)); +assert(test_atanhf(-Infinity, NaN, 0.0, INVALID)); +assert(test_atanhf(0.0, 0.0, 0.0, 0)); +assert(test_atanhf(-0.0, -0.0, 0.0, 0)); +assert(test_atanhf(1.0, Infinity, 0.0, DIVBYZERO)); +assert(test_atanhf(-1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_atanhf(1.000015259, NaN, 0.0, INVALID)); +assert(test_atanhf(-1.000015259, NaN, 0.0, INVALID)); +assert(test_atanhf(1.355252716e-20, 1.355252716e-20, 0.0, INEXACT)); +assert(test_atanhf(7.888609052e-31, 7.888609052e-31, 0.0, INEXACT)); +assert(test_atanhf(2.938735877e-39, 2.938735877e-39, 0.0, INEXACT | UNDERFLOW)); +assert(test_atanhf(-2.938735877e-39, -2.938735877e-39, 0.0, INEXACT | UNDERFLOW)); +assert(test_atanhf(1.701411835e+38, NaN, 0.0, INVALID)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.atan2 +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_atan2(value1: f64, value2: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.atan2(value1, value2), expected, error, flags) && + (!js || check( JSMath.atan2(value1, value2), expected, error, flags)); +} + +// sanity +assert(test_atan2(-8.06684839057968084, 4.53566256067686879, -1.05858954024890228, 0.0976626351475715637, INEXACT)); +assert(test_atan2(4.34523984933830487, -8.88799136300345083, 2.68687341260130674, 0.358339488506317139, INEXACT)); +assert(test_atan2(-8.38143342755524934, -2.76360733737958819, -1.88930009184952796, -0.462359577417373657, INEXACT)); +assert(test_atan2(-6.53167358191348413, 4.56753527684274374, -0.960546902111148904, -0.215244770050048828, INEXACT)); +assert(test_atan2(9.26705696697258574, 4.81139208435979615, 1.09191239461421086, 0.389444321393966675, INEXACT)); +assert(test_atan2(-6.45004555606023633, 0.662071792337673881, -1.46850850061642402, -0.448591411113739014, INEXACT)); +assert(test_atan2(7.85889025304169664, 0.0521545267500622481, 1.5641600512601268, 0.378484278917312622, INEXACT)); +assert(test_atan2(-0.792054511984895959, 7.67640268511753998, -0.102816589106785081, -0.139932602643966675, INEXACT)); +assert(test_atan2(0.615702673197924044, 2.01190257903248026, 0.296979740044935159, 0.44753071665763855, INEXACT)); +assert(test_atan2(-0.558758682360915193, 0.0322398306026380407, -1.51316120533039156, 0.397088766098022461, INEXACT)); + +// special +assert(test_atan2(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_atan2(0.0, -0.0, 3.14159265358979312, -0.275765955448150635, INEXACT)); +assert(test_atan2(0.0, -1.0, 3.14159265358979312, -0.275765955448150635, INEXACT)); +assert(test_atan2(0.0, -Infinity, 3.14159265358979312, -0.275765955448150635, INEXACT)); +assert(test_atan2(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_atan2(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_atan2(-0.0, 0.0, -0.0, 0.0, 0)); +assert(test_atan2(-0.0, -0.0, -3.14159265358979312, 0.275765955448150635, INEXACT)); +assert(test_atan2(-0.0, -1.0, -3.14159265358979312, 0.275765955448150635, INEXACT)); +assert(test_atan2(-0.0, -Infinity, -3.14159265358979312, 0.275765955448150635, INEXACT)); +assert(test_atan2(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_atan2(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_atan2(-1.0, 0.0, -1.57079632679489656, 0.275765955448150635, INEXACT)); +assert(test_atan2(-1.0, -0.0, -1.57079632679489656, 0.275765955448150635, INEXACT)); +assert(test_atan2(1.0, 0.0, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_atan2(1.0, -0.0, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_atan2(-1.0, Infinity, -0.0, 0.0, 0)); +assert(test_atan2(1.0, Infinity, 0.0, 0.0, 0)); +assert(test_atan2(-1.0, -Infinity, -3.14159265358979312, 0.275765955448150635, INEXACT)); +assert(test_atan2(1.0, -Infinity, 3.14159265358979312, -0.275765955448150635, INEXACT)); +assert(test_atan2(Infinity, 0.0, 1.57079632679489656, -0.275765955448150635, INEXACT)); +assert(test_atan2(-Infinity, 0.0, -1.57079632679489656, 0.275765955448150635, INEXACT)); +assert(test_atan2(Infinity, Infinity, 0.785398163397448279, -0.275765955448150635, INEXACT)); +assert(test_atan2(Infinity, -Infinity, 2.35619449019234484, -0.206824451684951782, INEXACT)); +assert(test_atan2(-Infinity, Infinity, -0.785398163397448279, 0.275765955448150635, INEXACT)); +assert(test_atan2(-Infinity, -Infinity, -2.35619449019234484, 0.206824451684951782, INEXACT)); +assert(test_atan2(1.11253692925360069e-308, 1.0, 1.11253692925360069e-308, 0.0, INEXACT | UNDERFLOW)); +assert(test_atan2(1.0, 8.98846567431157954e+307, 1.11253692925360069e-308, 0.0, INEXACT | UNDERFLOW)); +assert(test_atan2(1.5, 8.98846567431157954e+307, 1.66880539388040104e-308, 0.0, INEXACT | UNDERFLOW)); +assert(test_atan2(1.5, -8.98846567431157954e+307, 3.14159265358979312, 0.0, INEXACT)); + +// Mathf.atan2 ///////////////////////////////////////////////////////////////////////////////////// + +function test_atan2f(value1: f32, value2: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.atan2(value1, value2), expected, error, flags); +} + +// sanity +assert(test_atan2f(-8.066848755, 4.535662651, -1.058589578, -0.2235258818, INEXACT)); +assert(test_atan2f(4.345239639, -8.887990952, 2.686873436, 0.09464472532, INEXACT)); +assert(test_atan2f(-8.381433487, -2.763607264, -1.889300108, -0.2194190174, INEXACT)); +assert(test_atan2f(-6.531673431, 4.5675354, -0.9605468512, 0.4601557553, INEXACT)); +assert(test_atan2f(9.267057419, 4.811392307, 1.091912389, -0.05708503723, INEXACT)); +assert(test_atan2f(-6.450045586, 0.6620717645, -1.468508482, 0.1961120665, INEXACT)); +assert(test_atan2f(7.858890057, 0.05215452611, 1.564160109, 0.4814318717, INEXACT)); +assert(test_atan2f(-0.792054534, 7.676402569, -0.1028165966, -0.4216274917, INEXACT)); +assert(test_atan2f(0.6157026887, 2.011902571, 0.2969797552, 0.2322007567, INEXACT)); +assert(test_atan2f(-0.5587586761, 0.03223983198, -1.513161182, 0.1662072688, INEXACT)); + +// special +assert(test_atan2f(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_atan2f(0.0, -0.0, 3.141592741, 0.3666777015, INEXACT)); +assert(test_atan2f(0.0, -1.0, 3.141592741, 0.3666777015, INEXACT)); +assert(test_atan2f(0.0, -Infinity, 3.141592741, 0.3666777015, INEXACT)); +assert(test_atan2f(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_atan2f(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_atan2f(-0.0, 0.0, -0.0, 0.0, 0)); +assert(test_atan2f(-0.0, -0.0, -3.141592741, -0.3666777015, INEXACT)); +assert(test_atan2f(-0.0, -1.0, -3.141592741, -0.3666777015, INEXACT)); +assert(test_atan2f(-0.0, -Infinity, -3.141592741, -0.3666777015, INEXACT)); +assert(test_atan2f(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_atan2f(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_atan2f(-1.0, 0.0, -1.570796371, -0.3666777015, INEXACT)); +assert(test_atan2f(-1.0, -0.0, -1.570796371, -0.3666777015, INEXACT)); +assert(test_atan2f(1.0, 0.0, 1.570796371, 0.3666777015, INEXACT)); +assert(test_atan2f(1.0, -0.0, 1.570796371, 0.3666777015, INEXACT)); +assert(test_atan2f(-1.0, Infinity, -0.0, 0.0, 0)); +assert(test_atan2f(1.0, Infinity, 0.0, 0.0, 0)); +assert(test_atan2f(-1.0, -Infinity, -3.141592741, -0.3666777015, INEXACT)); +assert(test_atan2f(1.0, -Infinity, 3.141592741, 0.3666777015, INEXACT)); +assert(test_atan2f(Infinity, 0.0, 1.570796371, 0.3666777015, INEXACT)); +assert(test_atan2f(-Infinity, 0.0, -1.570796371, -0.3666777015, INEXACT)); +assert(test_atan2f(Infinity, Infinity, 0.7853981853, 0.3666777015, INEXACT)); +assert(test_atan2f(Infinity, -Infinity, 2.356194496, 0.02500828728, INEXACT)); +assert(test_atan2f(-Infinity, Infinity, -0.7853981853, -0.3666777015, INEXACT)); +assert(test_atan2f(-Infinity, -Infinity, -2.356194496, -0.02500828728, INEXACT)); +assert(test_atan2f(5.877471754e-39, 1.0, 5.877471754e-39, 0.0, INEXACT | UNDERFLOW)); +assert(test_atan2f(1.0, 1.701411835e+38, 5.877471754e-39, 0.0, INEXACT | UNDERFLOW)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.cbrt +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_cbrt(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.cbrt(value), expected, error, flags) && + (!js || check( JSMath.cbrt(value), expected, error, flags)); +} + +// sanity +assert(test_cbrt(-8.06684839057968084, -2.00555525450202454, 0.466679513454437256, INEXACT)); +assert(test_cbrt(4.34523984933830487, 1.63181624105156353, -0.0816027149558067322, INEXACT)); +assert(test_cbrt(-8.38143342755524934, -2.03129391067336096, -0.048101816326379776, INEXACT)); +assert(test_cbrt(-6.53167358191348413, -1.86928200122049248, 0.0862401872873306274, INEXACT)); +assert(test_cbrt(9.26705696697258574, 2.10045772085970217, -0.272298902273178101, INEXACT)); +assert(test_cbrt(0.661985898099504477, 0.87153114704559731, 0.441491812467575073, INEXACT)); +assert(test_cbrt(-0.40660392238535531, -0.740839030300223023, 0.016453813761472702, INEXACT)); +assert(test_cbrt(0.56175974622072411, 0.82511954005592858, 0.306806385517120361, INEXACT)); +assert(test_cbrt(0.77415229659130369, 0.918210247895991372, 0.0654399842023849487, INEXACT)); +assert(test_cbrt(-0.678763702639402444, -0.878832690658009397, -0.201671317219734192, INEXACT)); + +// special +assert(test_cbrt(NaN, NaN, 0.0, 0)); +assert(test_cbrt(Infinity, Infinity, 0.0, 0)); +assert(test_cbrt(-Infinity, -Infinity, 0.0, 0)); +assert(test_cbrt(0.0, 0.0, 0.0, 0)); +assert(test_cbrt(-0.0, -0.0, 0.0, 0)); +assert(test_cbrt(9.31322574615478516e-10, 0.0009765625, 0.0, 0)); +assert(test_cbrt(-9.31322574615478516e-10, -0.0009765625, 0.0, 0)); +assert(test_cbrt(1.0, 1.0, 0.0, 0)); +assert(test_cbrt(-1.0, -1.0, 0.0, 0)); +assert(test_cbrt(8.0, 2.0, 0.0, 0)); + +// Mathf.cbrt ////////////////////////////////////////////////////////////////////////////////////// + +function test_cbrtf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.cbrt(value), expected, error, flags); +} + +// sanity +assert(test_cbrtf(-8.066848755, -2.005555391, -0.4471924007, INEXACT)); +assert(test_cbrtf(4.345239639, 1.631816268, 0.4463625252, INEXACT)); +assert(test_cbrtf(-8.381433487, -2.031293869, 0.1948342621, INEXACT)); +assert(test_cbrtf(-6.531673431, -1.869282007, -0.1707551479, INEXACT)); +assert(test_cbrtf(9.267057419, 2.100457668, -0.3636204302, INEXACT)); +assert(test_cbrtf(0.6619858742, 0.8715311289, -0.1285720915, INEXACT)); +assert(test_cbrtf(-0.4066039324, -0.7408390641, -0.4655757546, INEXACT)); +assert(test_cbrtf(0.5617597699, 0.825119555, 0.05601907894, INEXACT)); +assert(test_cbrtf(0.7741522789, 0.918210268, 0.4549820423, INEXACT)); +assert(test_cbrtf(-0.6787636876, -0.8788326979, -0.2297896743, INEXACT)); + +// special +assert(test_cbrtf(NaN, NaN, 0.0, 0)); +assert(test_cbrtf(Infinity, Infinity, 0.0, 0)); +assert(test_cbrtf(-Infinity, -Infinity, 0.0, 0)); +assert(test_cbrtf(0.0, 0.0, 0.0, 0)); +assert(test_cbrtf(-0.0, -0.0, 0.0, 0)); +assert(test_cbrtf(9.313225746e-10, 0.0009765625, 0.0, 0)); +assert(test_cbrtf(-9.313225746e-10, -0.0009765625, 0.0, 0)); +assert(test_cbrtf(1.0, 1.0, 0.0, 0)); +assert(test_cbrtf(-1.0, -1.0, 0.0, 0)); +assert(test_cbrtf(8.0, 2.0, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.ceil +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_ceil(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.ceil(value), expected, error, flags) && + (!js || check( JSMath.ceil(value), expected, error, flags)); +} + +// sanity +assert(test_ceil(-8.06684839057968084, -8.0, 0.0, INEXACT)); +assert(test_ceil(4.34523984933830487, 5.0, 0.0, INEXACT)); +assert(test_ceil(-8.38143342755524934, -8.0, 0.0, INEXACT)); +assert(test_ceil(-6.53167358191348413, -6.0, 0.0, INEXACT)); +assert(test_ceil(9.26705696697258574, 10.0, 0.0, INEXACT)); +assert(test_ceil(0.661985898099504477, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.40660392238535531, -0.0, 0.0, INEXACT)); +assert(test_ceil(0.56175974622072411, 1.0, 0.0, INEXACT)); +assert(test_ceil(0.77415229659130369, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.678763702639402444, -0.0, 0.0, INEXACT)); + +// special +assert(test_ceil(NaN, NaN, 0.0, 0)); +assert(test_ceil(Infinity, Infinity, 0.0, 0)); +assert(test_ceil(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceil(0.0, 0.0, 0.0, 0)); +assert(test_ceil(-0.0, -0.0, 0.0, 0)); +assert(test_ceil(1.0, 1.0, 0.0, 0)); +assert(test_ceil(-1.0, -1.0, 0.0, 0)); +assert(test_ceil(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceil(1.0000152587890625, 2.0, 0.0, INEXACT)); +assert(test_ceil(-1.0000152587890625, -1.0, 0.0, INEXACT)); +assert(test_ceil(0.99999237060546875, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.99999237060546875, -0.0, 0.0, INEXACT)); +assert(test_ceil(7.88860905221011805e-31, 1.0, 0.0, INEXACT)); +assert(test_ceil(-7.88860905221011805e-31, -0.0, 0.0, INEXACT)); +assert(test_ceil(NaN, NaN, 0.0, 0)); +assert(test_ceil(Infinity, Infinity, 0.0, 0)); +assert(test_ceil(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceil(0.0, 0.0, 0.0, 0)); +assert(test_ceil(-0.0, -0.0, 0.0, 0)); +assert(test_ceil(1.0, 1.0, 0.0, 0)); +assert(test_ceil(-1.0, -1.0, 0.0, 0)); +assert(test_ceil(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceil(1.0000152587890625, 2.0, 0.0, INEXACT)); +assert(test_ceil(-1.0000152587890625, -1.0, 0.0, INEXACT)); +assert(test_ceil(0.99999237060546875, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.99999237060546875, -0.0, 0.0, INEXACT)); +assert(test_ceil(7.88860905221011805e-31, 1.0, 0.0, INEXACT)); +assert(test_ceil(-7.88860905221011805e-31, -0.0, 0.0, INEXACT)); +assert(test_ceil(NaN, NaN, 0.0, 0)); +assert(test_ceil(Infinity, Infinity, 0.0, 0)); +assert(test_ceil(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceil(0.0, 0.0, 0.0, 0)); +assert(test_ceil(-0.0, -0.0, 0.0, 0)); +assert(test_ceil(1.0, 1.0, 0.0, 0)); +assert(test_ceil(-1.0, -1.0, 0.0, 0)); +assert(test_ceil(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceil(1.0000152587890625, 2.0, 0.0, INEXACT)); +assert(test_ceil(-1.0000152587890625, -1.0, 0.0, INEXACT)); +assert(test_ceil(0.99999237060546875, 1.0, 0.0, INEXACT)); +assert(test_ceil(-0.99999237060546875, -0.0, 0.0, INEXACT)); +assert(test_ceil(7.88860905221011805e-31, 1.0, 0.0, INEXACT)); +assert(test_ceil(-7.88860905221011805e-31, -0.0, 0.0, INEXACT)); + +// Mathf.ceil ////////////////////////////////////////////////////////////////////////////////////// + +function test_ceilf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.ceil(value), expected, error, flags); +} + +// sanity +assert(test_ceilf(-8.066848755, -8.0, 0.0, INEXACT)); +assert(test_ceilf(4.345239639, 5.0, 0.0, INEXACT)); +assert(test_ceilf(-8.381433487, -8.0, 0.0, INEXACT)); +assert(test_ceilf(-6.531673431, -6.0, 0.0, INEXACT)); +assert(test_ceilf(9.267057419, 10.0, 0.0, INEXACT)); +assert(test_ceilf(0.6619858742, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.4066039324, -0.0, 0.0, INEXACT)); +assert(test_ceilf(0.5617597699, 1.0, 0.0, INEXACT)); +assert(test_ceilf(0.7741522789, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.6787636876, -0.0, 0.0, INEXACT)); + +// special +assert(test_ceilf(NaN, NaN, 0.0, 0)); +assert(test_ceilf(Infinity, Infinity, 0.0, 0)); +assert(test_ceilf(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceilf(0.0, 0.0, 0.0, 0)); +assert(test_ceilf(-0.0, -0.0, 0.0, 0)); +assert(test_ceilf(1.0, 1.0, 0.0, 0)); +assert(test_ceilf(-1.0, -1.0, 0.0, 0)); +assert(test_ceilf(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceilf(1.000015259, 2.0, 0.0, INEXACT)); +assert(test_ceilf(-1.000015259, -1.0, 0.0, INEXACT)); +assert(test_ceilf(0.9999923706, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.9999923706, -0.0, 0.0, INEXACT)); +assert(test_ceilf(7.888609052e-31, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-7.888609052e-31, -0.0, 0.0, INEXACT)); +assert(test_ceilf(NaN, NaN, 0.0, 0)); +assert(test_ceilf(Infinity, Infinity, 0.0, 0)); +assert(test_ceilf(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceilf(0.0, 0.0, 0.0, 0)); +assert(test_ceilf(-0.0, -0.0, 0.0, 0)); +assert(test_ceilf(1.0, 1.0, 0.0, 0)); +assert(test_ceilf(-1.0, -1.0, 0.0, 0)); +assert(test_ceilf(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceilf(1.000015259, 2.0, 0.0, INEXACT)); +assert(test_ceilf(-1.000015259, -1.0, 0.0, INEXACT)); +assert(test_ceilf(0.9999923706, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.9999923706, -0.0, 0.0, INEXACT)); +assert(test_ceilf(7.888609052e-31, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-7.888609052e-31, -0.0, 0.0, INEXACT)); +assert(test_ceilf(NaN, NaN, 0.0, 0)); +assert(test_ceilf(Infinity, Infinity, 0.0, 0)); +assert(test_ceilf(-Infinity, -Infinity, 0.0, 0)); +assert(test_ceilf(0.0, 0.0, 0.0, 0)); +assert(test_ceilf(-0.0, -0.0, 0.0, 0)); +assert(test_ceilf(1.0, 1.0, 0.0, 0)); +assert(test_ceilf(-1.0, -1.0, 0.0, 0)); +assert(test_ceilf(0.5, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.5, -0.0, 0.0, INEXACT)); +assert(test_ceilf(1.000015259, 2.0, 0.0, INEXACT)); +assert(test_ceilf(-1.000015259, -1.0, 0.0, INEXACT)); +assert(test_ceilf(0.9999923706, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-0.9999923706, -0.0, 0.0, INEXACT)); +assert(test_ceilf(7.888609052e-31, 1.0, 0.0, INEXACT)); +assert(test_ceilf(-7.888609052e-31, -0.0, 0.0, INEXACT)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.cos +//////////////////////////////////////////////////////////////////////////////////////////////////// +/* TODO +function test_cos(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.cos(value), expected, error, flags) && + (!js || check( JSMath.cos(value), expected, error, flags)); +} + +// sanity +assert(test_cos(-8.06684839057968084, -0.211262815998871367, -0.109624691307544708, INEXACT)); +assert(test_cos(4.34523984933830487, -0.358956022975789546, -0.107598282396793365, INEXACT)); +assert(test_cos(-8.38143342755524934, -0.503333091765515994, -0.0214304737746715546, INEXACT)); +assert(test_cos(-6.53167358191348413, 0.969285321250328291, -0.478787630796432495, INEXACT)); +assert(test_cos(9.26705696697258574, -0.987587806478862684, 0.488066881895065308, INEXACT)); +assert(test_cos(0.661985898099504477, 0.788773086924857592, 0.127086669206619263, INEXACT)); +assert(test_cos(-0.40660392238535531, 0.918469239700729356, -0.261207133531570435, INEXACT)); +assert(test_cos(0.56175974622072411, 0.846319046741589642, -0.302586168050765991, INEXACT)); +assert(test_cos(0.77415229659130369, 0.715013928995238301, -0.0853774622082710266, INEXACT)); +assert(test_cos(-0.678763702639402444, 0.778349499475744722, 0.308907508850097656, INEXACT)); + +// special +assert(test_cos(0.0, 1.0, 0.0, 0)); +assert(test_cos(-0.0, 1.0, 0.0, 0)); +assert(test_cos(Infinity, NaN, 0.0, INVALID)); +assert(test_cos(-Infinity, NaN, 0.0, INVALID)); +assert(test_cos(NaN, NaN, 0.0, 0)); +assert(test_cos(1.0, 0.540302305868139765, 0.428828656673431396, INEXACT)); +assert(test_cos(2.0, -0.416146836547142407, -0.358593970537185669, INEXACT)); +assert(test_cos(3.0, -0.989992496600445415, 0.378845155239105225, INEXACT)); +assert(test_cos(4.0, -0.65364362086361194, -0.232805609703063965, INEXACT)); +assert(test_cos(5.0, 0.283662185463226246, -0.327735781669616699, INEXACT)); +assert(test_cos(0.100000000000000006, 0.995004165278025821, 0.495585262775421143, INEXACT)); +assert(test_cos(0.200000000000000011, 0.980066577841241626, -0.024076409637928009, INEXACT)); +assert(test_cos(0.299999999999999989, 0.955336489125605981, -0.377722293138504028, INEXACT)); +assert(test_cos(0.400000000000000022, 0.921060994002885103, 0.258184850215911865, INEXACT)); +assert(test_cos(0.5, 0.877582561890372759, 0.383915215730667114, INEXACT)); +assert(test_cos(2.36414097466390147e-308, 1.0, 0.0, INEXACT)); +assert(test_cos(1.18207048733195073e-308, 1.0, 0.0, INEXACT)); +assert(test_cos(4.94065645841246544e-324, 1.0, 0.0, INEXACT)); +assert(test_cos(-4.94065645841246544e-324, 1.0, 0.0, INEXACT)); +assert(test_cos(-3.14000000000000012, -0.999998731727539503, 0.385551601648330688, INEXACT)); +assert(test_cos(8.98846567431157954e+307, -0.826369834614148036, -0.369596511125564575, INEXACT)); +assert(test_cos(1.79769313486231571e+308, -0.999987689426559911, 0.234483435750007629, INEXACT)); +assert(test_cos(-8.98846567431157954e+307, -0.826369834614148036, -0.369596511125564575, INEXACT)); +assert(test_cos(3.14000000000000012, -0.999998731727539503, 0.385551601648330688, INEXACT)); +assert(test_cos(3.14150000000000018, -0.999999995707656186, -0.30608975887298584, INEXACT)); +assert(test_cos(3.14159200000000016, -0.999999999999786393, 0.154033288359642029, INEXACT)); +assert(test_cos(3.14159265000000021, -1.0, -0.0290180742740631104, INEXACT)); +assert(test_cos(3.14159265350000005, -1.0, -0.000018155848010792397, INEXACT)); +assert(test_cos(3.14159265358899997, -1.0, -1.41699141309459264e-9, INEXACT)); +assert(test_cos(3.14159265358979001, -1.0, -2.35086489798518386e-14, INEXACT)); +assert(test_cos(3.14159265358979312, -1.0, -3.37715874188331791e-17, INEXACT)); +assert(test_cos(1.57000000000000006, 0.000796326710733263345, 0.296815931797027588, INEXACT)); +assert(test_cos(1.57079600000000008, 3.26794896538138351e-7, -0.325708955526351929, INEXACT)); +assert(test_cos(1.57079632670000002, 9.48965963067801342e-11, -0.272456467151641846, INEXACT)); +assert(test_cos(1.5707963267948899, 6.72257048770830682e-15, -0.107476837933063507, INEXACT)); +assert(test_cos(1.57079632679489656, 6.12323399573676604e-17, 0.121482297778129578, INEXACT)); +assert(test_cos(0.670063519948610575, 0.783782219301615846, -0.0727850273251533508, INEXACT)); +assert(test_cos(0.534389018943755345, 0.860579971903951746, -0.484340280294418335, INEXACT)); +assert(test_cos(0.439997027548900854, 0.904752929300197573, 0.0297774728387594223, INEXACT)); +assert(test_cos(0.990284084468731285, 0.548452336448076783, 0.197652801871299744, INEXACT)); +assert(test_cos(0.453814475343389145, 0.898781390226378263, -0.017724866047501564, INEXACT)); +assert(test_cos(0.460988881358358915, 0.895613047471305657, 0.36449819803237915, INEXACT)); +assert(test_cos(0.928543409795642205, 0.599000979429298419, -0.289941638708114624, INEXACT)); +assert(test_cos(0.910909212448835159, 0.613027669277437792, -0.493531346321105957, INEXACT)); +assert(test_cos(0.832860065035955555, 0.672762471004635709, -0.366060882806777954, INEXACT)); +assert(test_cos(0.95362012522034334, 0.578734618348708429, -0.170898333191871643, INEXACT)); +assert(test_cos(0.872659006545769889, 0.642791914425904665, -0.274498611688613892, INEXACT)); +assert(test_cos(0.181004475359684475, 0.983663365688489333, 0.00301952729932963848, INEXACT)); +assert(test_cos(2.35619449034983885, -0.707106781297912601, -0.482787460088729858, INEXACT)); +assert(test_cos(2.35619449037227202, -0.707106781313775246, -0.486605018377304077, INEXACT)); +assert(test_cos(2.35619449022511152, -0.707106781209717039, -0.353395223617553711, INEXACT)); +assert(test_cos(2.35619449031499961, -0.707106781273277529, -0.419119864702224731, INEXACT)); +assert(test_cos(2.35619449036035267, -0.707106781305346987, -0.470620006322860718, INEXACT)); +assert(test_cos(2.35619449038261974, -0.70710678132109217, -0.306183516979217529, INEXACT)); +assert(test_cos(2.35619449037180306, -0.707106781313443622, -0.305648207664489746, INEXACT)); +assert(test_cos(2.35619449039993079, -0.707106781333332934, -0.388455718755722046, INEXACT)); +assert(test_cos(2.35619449026019101, -0.707106781234521975, -0.237968519330024719, INEXACT)); +assert(test_cos(2.35619449040431528, -0.707106781336433232, -0.327458947896957397, INEXACT)); +assert(test_cos(2.09439510247594463, -0.500000000071662898, -0.417113423347473145, INEXACT)); +assert(test_cos(2.09439510243324012, -0.500000000034679704, -0.356616497039794922, INEXACT)); +assert(test_cos(2.09439510251338845, -0.500000000104090181, -0.225348591804504395, INEXACT)); +assert(test_cos(2.09439510254667072, -0.500000000132913458, -0.129822596907615662, INEXACT)); +assert(test_cos(2.09439510241389604, -0.500000000017927215, -0.158867642283439636, INEXACT)); +assert(test_cos(2.09439510242234039, -0.500000000025240254, -0.266656756401062012, INEXACT)); +assert(test_cos(2.09439510249604766, -0.500000000089072638, -0.465207785367965698, INEXACT)); +assert(test_cos(2.09439510251733152, -0.500000000107505005, -0.467109948396682739, INEXACT)); +assert(test_cos(2.09439510240592419, -0.500000000011023404, -0.246960371732711792, INEXACT)); +assert(test_cos(2.09439510242855809, -0.500000000030624947, -0.379944115877151489, INEXACT)); +assert(test_cos(8.51321077086405609, -0.612507693998775915, 0.498996615409851074, INEXACT)); +assert(test_cos(6.80288612980101703, 0.867967796134545222, 0.497216552495956421, INEXACT)); +assert(test_cos(9.17192539308640775, -0.968202744042454433, -0.498275846242904663, INEXACT)); +assert(test_cos(8.85469011288857288, -0.841853566381852714, 0.497497975826263428, INEXACT)); +assert(test_cos(9.21351081385960846, -0.977765980283850644, -0.499560445547103882, INEXACT)); +assert(test_cos(7.78244908154215143, 0.0714715638129333891, 0.498581260442733765, INEXACT)); +assert(test_cos(7.5002613322736158, 0.346390176334581135, -0.499621003866195679, INEXACT)); +assert(test_cos(9.12173941873158789, -0.954434129754181071, 0.498281508684158325, INEXACT)); +assert(test_cos(6.78495402047631568, 0.876733223316664589, -0.498808383941650391, INEXACT)); +assert(test_cos(8.77084654266666419, -0.793698411740070497, 0.499968290328979492, INEXACT)); + +// Mathf.cos /////////////////////////////////////////////////////////////////////////////////////// + +function test_cosf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.cos(value), expected, error, flags); +} + +// sanity +assert(test_cosf(-8.0668487548828125, -0.211263164877891541, 0.483285695314407349, INEXACT)); +assert(test_cosf(4.34523963928222656, -0.358956217765808105, 0.0425052084028720856, INEXACT)); +assert(test_cosf(-8.38143348693847656, -0.503333151340484619, -0.138619571924209595, INEXACT)); +assert(test_cosf(-6.53167343139648438, 0.969285368919372559, 0.178695172071456909, INEXACT)); +assert(test_cosf(9.26705741882324219, -0.987587869167327881, 0.138960093259811401, INEXACT)); +assert(test_cosf(0.661985874176025391, 0.788773119449615479, 0.29895937442779541, INEXACT)); +assert(test_cosf(-0.40660393238067627, 0.918469250202178955, 0.242506653070449829, INEXACT)); +assert(test_cosf(0.561759769916534424, 0.846319019794464111, -0.240332409739494324, INEXACT)); +assert(test_cosf(0.774152278900146484, 0.71501392126083374, -0.337263524532318115, INEXACT)); +assert(test_cosf(-0.678763687610626221, 0.778349518775939941, 0.165501534938812256, INEXACT)); + +// special +assert(test_cosf(0.0, 1.0, 0.0, 0)); +assert(test_cosf(-0.0, 1.0, 0.0, 0)); +assert(test_cosf(Infinity, NaN, 0.0, INVALID)); +assert(test_cosf(-Infinity, NaN, 0.0, INVALID)); +assert(test_cosf(NaN, NaN, 0.0, 0)); */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.cosh +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_cosh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.cosh(value), expected, error, flags) && + (!js || check( JSMath.cosh(value), expected, error, flags)); +} +// sanity +assert(test_cosh(-8.06684839057968084, 1593.52099388623287, -0.380988568067550659, INEXACT)); +assert(test_cosh(4.34523984933830487, 38.5617492842672931, -0.271227836608886719, INEXACT)); +assert(test_cosh(-8.38143342755524934, 2182.63097959589322, 0.0817827582359313965, INEXACT)); +assert(test_cosh(-6.53167358191348413, 343.273849250878982, -0.429940402507781982, INEXACT)); +assert(test_cosh(9.26705696697258574, 5291.77917000558682, -0.159299582242965698, INEXACT)); +assert(test_cosh(0.661985898099504477, 1.22723219573428421, 0.23280741274356842, INEXACT)); +assert(test_cosh(-0.40660392238535531, 1.08380854187119691, -0.396091699600219727, INEXACT)); +assert(test_cosh(0.56175974622072411, 1.16198035831750768, 0.377483904361724854, INEXACT)); +assert(test_cosh(0.77415229659130369, 1.31492368762767065, 0.435870081186294556, INEXACT)); +assert(test_cosh(-0.678763702639402444, 1.23934132459345325, 0.102016061544418335, INEXACT)); + +// special +assert(test_cosh(0.0, 1.0, 0.0, 0)); +assert(test_cosh(-0.0, 1.0, 0.0, 0)); +assert(test_cosh(Infinity, Infinity, 0.0, 0)); +assert(test_cosh(-Infinity, Infinity, 0.0, 0)); +assert(test_cosh(NaN, NaN, 0.0, 0)); + +// Mathf.cosh ////////////////////////////////////////////////////////////////////////////////////// + +function test_coshf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.cosh(value), expected, error, flags); +} + +// sanity +assert(test_coshf(-8.066848755, 1593.521606, 0.2624258101, INEXACT)); +assert(test_coshf(4.345239639, 38.56174088, -0.08168885857, INEXACT)); +assert(test_coshf(-8.381433487, 2182.631104, -0.02331414446, INEXACT)); +assert(test_coshf(-6.531673431, 343.2738037, 0.2008149326, INEXACT)); +assert(test_coshf(9.267057419, 5291.781738, 0.3628672361, INEXACT)); +assert(test_coshf(0.6619858742, 1.227232218, 0.3277741671, INEXACT)); +assert(test_coshf(-0.4066039324, 1.083808541, -0.03984870389, INEXACT)); +assert(test_coshf(0.5617597699, 1.161980391, 0.1527447701, INEXACT)); +assert(test_coshf(0.7741522789, 1.314923644, -0.2387111485, INEXACT)); +assert(test_coshf(-0.6787636876, 1.239341259, -0.4579193294, INEXACT)); + +// special +assert(test_coshf(0.0, 1.0, 0.0, 0)); +assert(test_coshf(-0.0, 1.0, 0.0, 0)); +assert(test_coshf(Infinity, Infinity, 0.0, 0)); +assert(test_coshf(-Infinity, Infinity, 0.0, 0)); +assert(test_coshf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.exp +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_exp(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.exp(value), expected, error, flags) && + (!js || check( JSMath.exp(value), expected, error, flags)); +} + +// sanity +assert(test_exp(-8.06684839057968084, 0.000313770606816174511, -0.259919732809066772, INEXACT)); +assert(test_exp(4.34523984933830487, 77.1105301711214111, -0.0279267579317092896, INEXACT)); +assert(test_exp(-8.38143342755524934, 0.000229081338491632304, -0.249743342399597168, INEXACT)); +assert(test_exp(-6.53167358191348413, 0.00145656612609315877, -0.481682240962982178, INEXACT)); +assert(test_exp(9.26705696697258574, 10583.5582455249933, 0.176967620849609375, INEXACT)); +assert(test_exp(0.661985898099504477, 1.9386384525571998, -0.496424645185470581, INEXACT)); +assert(test_exp(-0.40660392238535531, 0.665907889283802512, -0.106083184480667114, INEXACT)); +assert(test_exp(0.56175974622072411, 1.75375595186263111, -0.391621112823486328, INEXACT)); +assert(test_exp(0.77415229659130369, 2.16875288851292458, -0.299612581729888916, INEXACT)); +assert(test_exp(-0.678763702639402444, 0.507243708940284255, 0.472617387771606445, INEXACT)); + +// special +assert(test_exp(0.0, 1.0, 0.0, 0)); +assert(test_exp(-0.0, 1.0, 0.0, 0)); +assert(test_exp(1.0, 2.71828182845904509, -0.325530737638473511, INEXACT)); +assert(test_exp(-1.0, 0.367879441171442334, 0.223896518349647522, INEXACT)); +assert(test_exp(Infinity, Infinity, 0.0, 0)); +assert(test_exp(-Infinity, 0.0, 0.0, 0)); +assert(test_exp(NaN, NaN, 0.0, 0)); +assert(test_exp(1.0397214889526365, 2.82842915587641119, 0.188030809164047241, INEXACT)); +assert(test_exp(-1.0397214889526365, 0.353553136702178472, 0.252727240324020386, INEXACT)); +assert(test_exp(1.03972101211547852, 2.82842780717661224, -0.418413937091827393, INEXACT)); +assert(test_exp(1.03972148895263672, 2.82842915587641164, -0.226183772087097168, INEXACT)); + +// Mathf.exp /////////////////////////////////////////////////////////////////////////////////////// + +function test_expf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.exp(value), expected, error, flags); +} + +// sanity +assert(test_expf(-8.066848755, 0.0003137704916, -0.03019333631, INEXACT)); +assert(test_expf(4.345239639, 77.11051178, -0.2875460684, INEXACT)); +assert(test_expf(-8.381433487, 0.0002290813281, 0.2237040401, INEXACT)); +assert(test_expf(-6.531673431, 0.001456566388, 0.3646970391, INEXACT)); +assert(test_expf(9.267057419, 10583.56348, 0.459621042, INEXACT)); +assert(test_expf(0.6619858742, 1.938638449, 0.3568260968, INEXACT)); +assert(test_expf(-0.4066039324, 0.6659078598, -0.3829499185, INEXACT)); +assert(test_expf(0.5617597699, 1.753756046, 0.443554908, INEXACT)); +assert(test_expf(0.7741522789, 2.168752909, 0.2456246912, INEXACT)); +assert(test_expf(-0.6787636876, 0.5072436929, -0.3974292278, INEXACT)); + +// special +assert(test_expf(0.0, 1.0, 0.0, 0)); +assert(test_expf(-0.0, 1.0, 0.0, 0)); +assert(test_expf(1.0, 2.718281746, -0.3462330997, INEXACT)); +assert(test_expf(-1.0, 0.3678794503, 0.3070148528, INEXACT)); +assert(test_expf(Infinity, Infinity, 0.0, 0)); +assert(test_expf(-Infinity, 0.0, 0.0, 0)); +assert(test_expf(NaN, NaN, 0.0, 0)); +assert(test_expf(88.72283173, 3.402798519e+38, -0.09067153931, INEXACT)); +assert(test_expf(88.72283936, Infinity, 0.0, INEXACT | OVERFLOW)); +assert(test_expf(-103.9720764, 1.401298464e-45, 0.4999996722, INEXACT | UNDERFLOW)); +assert(test_expf(-103.972084, 0.0, -0.4999965131, INEXACT | UNDERFLOW)); +assert(test_expf(0.3465735614, 1.414213538, 0.1392242163, INEXACT)); +assert(test_expf(0.3465735912, 1.414213538, -0.2143291682, INEXACT)); +assert(test_expf(0.346573621, 1.414213657, 0.4321174324, INEXACT)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.expm1 +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_expm1(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.expm1(value), expected, error, flags) && + (!js || check( JSMath.expm1(value), expected, error, flags)); +} + +// sanity +assert(test_expm1(-8.06684839057968084, -0.999686229393183856, -0.276005834341049194, INEXACT)); +assert(test_expm1(4.34523984933830487, 76.1105301711214111, -0.0279267579317092896, INEXACT)); +assert(test_expm1(-8.38143342755524934, -0.999770918661508357, 0.100524961948394775, INEXACT)); +assert(test_expm1(-6.53167358191348413, -0.998543433873906872, -0.274378299713134766, INEXACT)); +assert(test_expm1(9.26705696697258574, 10582.5582455249933, 0.176967620849609375, INEXACT)); +assert(test_expm1(0.661985898099504477, 0.938638452557199909, 0.00715068448334932327, INEXACT)); +assert(test_expm1(-0.40660392238535531, -0.334092110716197488, -0.212166368961334229, INEXACT)); +assert(test_expm1(0.56175974622072411, 0.753755951862631224, 0.216757774353027344, INEXACT)); +assert(test_expm1(0.77415229659130369, 1.1687528885129248, 0.40077480673789978, INEXACT)); +assert(test_expm1(-0.678763702639402444, -0.492756291059715801, -0.0547651983797550201, INEXACT)); + +// special +assert(test_expm1(0.0, 0.0, 0.0, 0)); +assert(test_expm1(-0.0, -0.0, 0.0, 0)); +assert(test_expm1(1.0, 1.71828182845904531, 0.348938524723052979, INEXACT)); +assert(test_expm1(-1.0, -0.632120558828557666, 0.111948259174823761, INEXACT)); +assert(test_expm1(Infinity, Infinity, 0.0, 0)); +assert(test_expm1(-Infinity, -1.0, 0.0, 0)); +assert(test_expm1(NaN, NaN, 0.0, 0)); +assert(test_expm1(2.22507385850720089e-308, 2.22507385850720089e-308, 0.0, INEXACT | UNDERFLOW)); +assert(test_expm1(-2.22507385850720089e-308,-2.22507385850720089e-308, 0.0, INEXACT | UNDERFLOW)); + +// Mathf.expm1 ///////////////////////////////////////////////////////////////////////////////////// + +function test_expm1f(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.expm1(value), expected, error, flags); +} + +// sanity +assert(test_expm1f(-8.066848755, -0.9996862411, -0.1953272372, INEXACT)); +assert(test_expm1f(4.345239639, 76.11051178, -0.2875460684, INEXACT)); +assert(test_expm1f(-8.381433487, -0.9997709394, -0.3468692005, INEXACT)); +assert(test_expm1f(-6.531673431, -0.9985434413, -0.1281939447, INEXACT)); +assert(test_expm1f(9.267057419, 10582.56348, 0.459621042, INEXACT)); +assert(test_expm1f(0.6619858742, 0.9386383891, -0.2863478065, INEXACT)); +assert(test_expm1f(-0.4066039324, -0.3340921104, 0.2341001779, INEXACT)); +assert(test_expm1f(0.5617597699, 0.7537559867, -0.1128901765, INEXACT)); +assert(test_expm1f(0.7741522789, 1.168752909, 0.4912493825, INEXACT)); +assert(test_expm1f(-0.6787636876, -0.4927562773, 0.2051415443, INEXACT)); + +// special +assert(test_expm1f(0.0, 0.0, 0.0, 0)); +assert(test_expm1f(-0.0, -0.0, 0.0, 0)); +assert(test_expm1f(1.0, 1.718281865, 0.3075338304, INEXACT)); +assert(test_expm1f(-1.0, -0.6321205497, 0.1535074264, INEXACT)); +assert(test_expm1f(Infinity, Infinity, 0.0, 0)); +assert(test_expm1f(-Infinity, -1.0, 0.0, 0)); +assert(test_expm1f(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.floor +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_floor(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.floor(value), expected, error, flags) && + (!js || check( JSMath.floor(value), expected, error, flags)); +} + +// sanity +assert(test_floor(-8.06684839057968084, -9.0, 0.0, INEXACT)); +assert(test_floor(4.34523984933830487, 4.0, 0.0, INEXACT)); +assert(test_floor(-8.38143342755524934, -9.0, 0.0, INEXACT)); +assert(test_floor(-6.53167358191348413, -7.0, 0.0, INEXACT)); +assert(test_floor(9.26705696697258574, 9.0, 0.0, INEXACT)); +assert(test_floor(0.661985898099504477, 0.0, 0.0, INEXACT)); +assert(test_floor(-0.40660392238535531, -1.0, 0.0, INEXACT)); +assert(test_floor(0.56175974622072411, 0.0, 0.0, INEXACT)); +assert(test_floor(0.77415229659130369, 0.0, 0.0, INEXACT)); +assert(test_floor(-0.678763702639402444, -1.0, 0.0, INEXACT)); + +// special +assert(test_floor(NaN, NaN, 0.0, 0)); +assert(test_floor(Infinity, Infinity, 0.0, 0)); +assert(test_floor(-Infinity, -Infinity, 0.0, 0)); +assert(test_floor(0.0, 0.0, 0.0, 0)); +assert(test_floor(-0.0, -0.0, 0.0, 0)); +assert(test_floor(1.0, 1.0, 0.0, 0)); +assert(test_floor(-1.0, -1.0, 0.0, 0)); +assert(test_floor(0.5, 0.0, 0.0, INEXACT)); +assert(test_floor(-0.5, -1.0, 0.0, INEXACT)); +assert(test_floor(1.0000152587890625, 1.0, 0.0, INEXACT)); +assert(test_floor(-1.0000152587890625, -2.0, 0.0, INEXACT)); +assert(test_floor(0.99999237060546875, 0.0, 0.0, INEXACT)); +assert(test_floor(-0.99999237060546875, -1.0, 0.0, INEXACT)); +assert(test_floor(7.88860905221011805e-31, 0.0, 0.0, INEXACT)); +assert(test_floor(-7.88860905221011805e-31, -1.0, 0.0, INEXACT)); + +// Mathf.floor ///////////////////////////////////////////////////////////////////////////////////// + +function test_floorf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.floor(value), expected, error, flags); +} + +// sanity +assert(test_floorf(-8.066848755, -9.0, 0.0, INEXACT)); +assert(test_floorf(4.345239639, 4.0, 0.0, INEXACT)); +assert(test_floorf(-8.381433487, -9.0, 0.0, INEXACT)); +assert(test_floorf(-6.531673431, -7.0, 0.0, INEXACT)); +assert(test_floorf(9.267057419, 9.0, 0.0, INEXACT)); +assert(test_floorf(0.6619858742, 0.0, 0.0, INEXACT)); +assert(test_floorf(-0.4066039324, -1.0, 0.0, INEXACT)); +assert(test_floorf(0.5617597699, 0.0, 0.0, INEXACT)); +assert(test_floorf(0.7741522789, 0.0, 0.0, INEXACT)); +assert(test_floorf(-0.6787636876, -1.0, 0.0, INEXACT)); + +// special +assert(test_floorf(NaN, NaN, 0.0, 0)); +assert(test_floorf(Infinity, Infinity, 0.0, 0)); +assert(test_floorf(-Infinity, -Infinity, 0.0, 0)); +assert(test_floorf(0.0, 0.0, 0.0, 0)); +assert(test_floorf(-0.0, -0.0, 0.0, 0)); +assert(test_floorf(1.0, 1.0, 0.0, 0)); +assert(test_floorf(-1.0, -1.0, 0.0, 0)); +assert(test_floorf(0.5, 0.0, 0.0, INEXACT)); +assert(test_floorf(-0.5, -1.0, 0.0, INEXACT)); +assert(test_floorf(1.000015259, 1.0, 0.0, INEXACT)); +assert(test_floorf(-1.000015259, -2.0, 0.0, INEXACT)); +assert(test_floorf(0.9999923706, 0.0, 0.0, INEXACT)); +assert(test_floorf(-0.9999923706, -1.0, 0.0, INEXACT)); +assert(test_floorf(7.888609052e-31, 0.0, 0.0, INEXACT)); +assert(test_floorf(-7.888609052e-31, -1.0, 0.0, INEXACT)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.hypot +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_hypot(value1: f64, value2: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.hypot(value1, value2), expected, error, flags) && + (!js || check( JSMath.hypot(value1, value2), expected, error, flags)); +} + +// sanity +assert(test_hypot(-8.06684839057968084, 4.53566256067686879, 9.25452742288464059, -0.311886817216873169, INEXACT)); +assert(test_hypot(4.34523984933830487, -8.88799136300345083, 9.89330580832825213, 0.459367334842681885, INEXACT)); +assert(test_hypot(-8.38143342755524934, -2.76360733737958819, 8.82530179743213239, -0.170175433158874512, INEXACT)); +assert(test_hypot(-6.53167358191348413, 4.56753527684274374, 7.97026588551909221, -0.317678272724151611, INEXACT)); +assert(test_hypot(9.26705696697258574, 4.81139208435979615, 10.4416396518245751, -0.269363343715667725, INEXACT)); +assert(test_hypot(-6.45004555606023633, 0.662071792337673881, 6.48393605254259331, 0.356188982725143433, INEXACT)); +assert(test_hypot(7.85889025304169664, 0.0521545267500622481, 7.85906330958176635, 0.0804465562105178833, INEXACT)); +assert(test_hypot(-0.792054511984895959, 7.67640268511753998, 7.7171567648995838, 0.0517808496952056885, INEXACT)); +assert(test_hypot(0.615702673197924044, 2.01190257903248026, 2.10400612387431396, -0.0918039008975028992, INEXACT)); +assert(test_hypot(-0.558758682360915193, 0.0322398306026380407, 0.559688012906291332, 0.138340771198272705, INEXACT)); + +// special +assert(test_hypot(3.0, 4.0, 5.0, 0.0, 0)); +assert(test_hypot(-3.0, 4.0, 5.0, 0.0, 0)); +assert(test_hypot(4.0, 3.0, 5.0, 0.0, 0)); +assert(test_hypot(4.0, -3.0, 5.0, 0.0, 0)); +assert(test_hypot(-3.0, -4.0, 5.0, 0.0, 0)); +assert(test_hypot(1.79769313486231571e+308, 0.0, 1.79769313486231571e+308, 0.0, 0)); +assert(test_hypot(1.79769313486231571e+308, -0.0, 1.79769313486231571e+308, 0.0, 0)); +assert(test_hypot(4.94065645841246544e-324, 0.0, 4.94065645841246544e-324, 0.0, 0)); +assert(test_hypot(4.94065645841246544e-324, -0.0, 4.94065645841246544e-324, 0.0, 0)); +assert(test_hypot(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_hypot(1.0, Infinity, Infinity, 0.0, 0)); +assert(test_hypot(Infinity, NaN, Infinity, 0.0, 0)); +assert(test_hypot(NaN, Infinity, Infinity, 0.0, 0)); +assert(test_hypot(-Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_hypot(1.0, -Infinity, Infinity, 0.0, 0)); +assert(test_hypot(-Infinity, NaN, Infinity, 0.0, 0)); +assert(test_hypot(NaN, -Infinity, Infinity, 0.0, 0)); +assert(test_hypot(NaN, 1.0, NaN, 0.0, 0)); +assert(test_hypot(1.0, NaN, NaN, 0.0, 0)); + +// Mathf.hypot ///////////////////////////////////////////////////////////////////////////////////// + +function test_hypotf(value1: f32, value2: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.hypot(value1, value2), expected, error, flags); +} + +// sanity +assert(test_hypotf(-8.066848755, 4.535662651, 9.254528046, 0.2735958993, INEXACT)); +assert(test_hypotf(4.345239639, -8.887990952, 9.893305779, 0.4530770779, INEXACT)); +assert(test_hypotf(-8.381433487, -2.763607264, 8.825302124, 0.3075572848, INEXACT)); +assert(test_hypotf(-6.531673431, 4.5675354, 7.970265865, 0.06785223633, INEXACT)); +assert(test_hypotf(9.267057419, 4.811392307, 10.4416399, -0.2677630782, INEXACT)); +assert(test_hypotf(-6.450045586, 0.6620717645, 6.48393631, 0.4838129282, INEXACT)); +assert(test_hypotf(7.858890057, 0.05215452611, 7.859063148, 0.07413065434, INEXACT)); +assert(test_hypotf(-0.792054534, 7.676402569, 7.717156887, 0.4940592647, INEXACT)); +assert(test_hypotf(0.6157026887, 2.011902571, 2.104006052, -0.287089467, INEXACT)); +assert(test_hypotf(-0.5587586761, 0.03223983198, 0.5596880317, 0.4191940725, INEXACT)); + +// special +assert(test_hypotf(3.0, 4.0, 5.0, 0.0, 0)); +assert(test_hypotf(-3.0, 4.0, 5.0, 0.0, 0)); +assert(test_hypotf(4.0, 3.0, 5.0, 0.0, 0)); +assert(test_hypotf(4.0, -3.0, 5.0, 0.0, 0)); +assert(test_hypotf(-3.0, -4.0, 5.0, 0.0, 0)); +assert(test_hypotf(3.402823466e+38, 0.0, 3.402823466e+38, 0.0, 0)); +assert(test_hypotf(3.402823466e+38, -0.0, 3.402823466e+38, 0.0, 0)); +assert(test_hypotf(1.401298464e-45, 0.0, 1.401298464e-45, 0.0, 0)); +assert(test_hypotf(1.401298464e-45, -0.0, 1.401298464e-45, 0.0, 0)); +assert(test_hypotf(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_hypotf(1.0, Infinity, Infinity, 0.0, 0)); +assert(test_hypotf(Infinity, NaN, Infinity, 0.0, 0)); +assert(test_hypotf(NaN, Infinity, Infinity, 0.0, 0)); +assert(test_hypotf(-Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_hypotf(1.0, -Infinity, Infinity, 0.0, 0)); +assert(test_hypotf(-Infinity, NaN, Infinity, 0.0, 0)); +assert(test_hypotf(NaN, -Infinity, Infinity, 0.0, 0)); +assert(test_hypotf(NaN, 1.0, NaN, 0.0, 0)); +assert(test_hypotf(1.0, NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.log +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_log(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.log(value), expected, error, flags) && + (!js || check( JSMath.log(value), expected, error, flags)); +} + +// sanity +assert(test_log(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_log(4.34523984933830487, 1.46908095842243225, -0.341253340244293213, INEXACT)); +assert(test_log(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_log(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_log(9.26705696697258574, 2.22646584987956153, 0.363811403512954712, INEXACT)); +assert(test_log(0.661985898099504477, -0.412511025236513673, -0.291087478399276733, INEXACT)); +assert(test_log(-0.40660392238535531, NaN, 0.0, INVALID)); +assert(test_log(0.56175974622072411, -0.576681018319586181, -0.109831996262073517, INEXACT)); +assert(test_log(0.77415229659130369, -0.255986659126386518, -0.0579900443553924561, INEXACT)); +assert(test_log(-0.678763702639402444, NaN, 0.0, INVALID)); + +// special +assert(test_log(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log(-7.88860905221011805e-31, NaN, 0.0, INVALID)); +assert(test_log(1.0, 0.0, 0.0, 0)); +assert(test_log(-1.0, NaN, 0.0, INVALID)); +assert(test_log(Infinity, Infinity, 0.0, 0)); +assert(test_log(-Infinity, NaN, 0.0, INVALID)); +assert(test_log(NaN, NaN, 0.0, 0)); + +// Mathf.log /////////////////////////////////////////////////////////////////////////////////////// + +function test_logf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.log(value), expected, error, flags); +} + +// sanity +assert(test_logf(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_logf(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_logf(-7.888609052e-31, NaN, 0.0, INVALID)); +assert(test_logf(1.0, 0.0, 0.0, 0)); +assert(test_logf(-1.0, NaN, 0.0, INVALID)); +assert(test_logf(Infinity, Infinity, 0.0, 0)); +assert(test_logf(-Infinity, NaN, 0.0, INVALID)); +assert(test_logf(NaN, NaN, 0.0, 0)); + +// special +assert(test_logf(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_logf(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_logf(-7.888609052e-31, NaN, 0.0, INVALID)); +assert(test_logf(1.0, 0.0, 0.0, 0)); +assert(test_logf(-1.0, NaN, 0.0, INVALID)); +assert(test_logf(Infinity, Infinity, 0.0, 0)); +assert(test_logf(-Infinity, NaN, 0.0, INVALID)); +assert(test_logf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.log10 +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_log10(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.log10(value), expected, error, flags) && + (!js || check( JSMath.log10(value), expected, error, flags)); +} + +// sanity +assert(test_log10(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_log10(4.34523984933830487, 0.638013753712002862, -0.2088824063539505, INEXACT)); +assert(test_log10(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_log10(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_log10(9.26705696697258574, 0.966941832748727359, -0.0612043179571628571, INEXACT)); +assert(test_log10(0.661985898099504477, -0.179151261984470928, 0.390908747911453247, INEXACT)); +assert(test_log10(-0.40660392238535531, NaN, 0.0, INVALID)); +assert(test_log10(0.56175974622072411, -0.250449384074544368, -0.304684162139892578, INEXACT)); +assert(test_log10(0.77415229659130369, -0.111173593499438367, -0.315033614635467529, INEXACT)); +assert(test_log10(-0.678763702639402444, NaN, 0.0, INVALID)); + +// special +assert(test_log10(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log10(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log10(-7.88860905221011805e-31, NaN, 0.0, INVALID)); +assert(test_log10(1.0, 0.0, 0.0, 0)); +assert(test_log10(-1.0, NaN, 0.0, INVALID)); +assert(test_log10(Infinity, Infinity, 0.0, 0)); +assert(test_log10(-Infinity, NaN, 0.0, INVALID)); +assert(test_log10(NaN, NaN, 0.0, 0)); + +// Mathf.log10 ///////////////////////////////////////////////////////////////////////////////////// + +function test_log10f(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.log10(value), expected, error, flags); +} + +// sanity +assert(test_log10f(-8.066848755, NaN, 0.0, INVALID)); +assert(test_log10f(4.345239639, 0.6380137205, -0.2047675848, INEXACT)); +assert(test_log10f(-8.381433487, NaN, 0.0, INVALID)); +assert(test_log10f(-6.531673431, NaN, 0.0, INVALID)); +assert(test_log10f(9.267057419, 0.9669418335, -0.3427302539, INEXACT)); +assert(test_log10f(0.6619858742, -0.1791512817, -0.2707855403, INEXACT)); +assert(test_log10f(-0.4066039324, NaN, 0.0, INVALID)); +assert(test_log10f(0.5617597699, -0.2504493594, 0.2126826048, INEXACT)); +assert(test_log10f(0.7741522789, -0.1111736, 0.4651509523, INEXACT)); +assert(test_log10f(-0.6787636876, NaN, 0.0, INVALID)); + +// special +assert(test_log10f(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log10f(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log10f(-7.888609052e-31, NaN, 0.0, INVALID)); +assert(test_log10f(1.0, 0.0, 0.0, 0)); +assert(test_log10f(-1.0, NaN, 0.0, INVALID)); +assert(test_log10f(Infinity, Infinity, 0.0, 0)); +assert(test_log10f(-Infinity, NaN, 0.0, INVALID)); +assert(test_log10f(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.log1p +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_log1p(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.log1p(value), expected, error, flags) && + (!js || check( JSMath.log1p(value), expected, error, flags)); +} + +// sanity +assert(test_log1p(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_log1p(4.34523984933830487, 1.67620641706017337, 0.46188199520111084, INEXACT)); +assert(test_log1p(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_log1p(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_log1p(9.26705696697258574, 2.32894041685238262, -0.411114901304244995, INEXACT)); +assert(test_log1p(0.661985898099504477, 0.508013211499247719, -0.293060451745986938, INEXACT)); +assert(test_log1p(-0.40660392238535531, -0.521893181166397935, -0.258257269859313965, INEXACT)); +assert(test_log1p(0.56175974622072411, 0.445813227948810176, -0.132748872041702271, INEXACT)); +assert(test_log1p(0.77415229659130369, 0.573322729464841419, 0.027165830135345459, INEXACT)); +assert(test_log1p(-0.678763702639402444, -1.13557829781285635, 0.27130928635597229, INEXACT)); + +// special +assert(test_log1p(0.0, 0.0, 0.0, 0)); +assert(test_log1p(-0.0, -0.0, 0.0, 0)); +assert(test_log1p(-7.88860905221011805e-31, -7.88860905221011805e-31, 1.77635683940025046e-15, INEXACT)); +assert(test_log1p(1.0, 0.693147180559945286, -0.208881169557571411, INEXACT)); +assert(test_log1p(-1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log1p(Infinity, Infinity, 0.0, 0)); +assert(test_log1p(-Infinity, NaN, 0.0, INVALID)); +assert(test_log1p(NaN, NaN, 0.0, 0)); + +// Mathf.log1p ///////////////////////////////////////////////////////////////////////////////////// + +function test_log1pf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.log1p(value), expected, error, flags); +} + +// sanity +assert(test_log1pf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_log1pf(4.345239639, 1.67620635, -0.2301485986, INEXACT)); +assert(test_log1pf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_log1pf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_log1pf(9.267057419, 2.328940392, -0.2907558978, INEXACT)); +assert(test_log1pf(0.6619858742, 0.5080131888, -0.1386766881, INEXACT)); +assert(test_log1pf(-0.4066039324, -0.5218932033, -0.08804433048, INEXACT)); +assert(test_log1pf(0.5617597699, 0.4458132386, -0.1510136873, INEXACT)); +assert(test_log1pf(0.7741522789, 0.5733227134, -0.1026453301, INEXACT)); +assert(test_log1pf(-0.6787636876, -1.135578275, -0.198794812, INEXACT)); + +// special +assert(test_log1pf(0.0, 0.0, 0.0, 0)); +assert(test_log1pf(-0.0, -0.0, 0.0, 0)); +assert(test_log1pf(-7.888609052e-31, -7.888609052e-31, 3.308722450e-24, INEXACT)); +assert(test_log1pf(1.0, 0.6931471825, 0.03195479512, INEXACT)); +assert(test_log1pf(-1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log1pf(Infinity, Infinity, 0.0, 0)); +assert(test_log1pf(-Infinity, NaN, 0.0, INVALID)); +assert(test_log1pf(NaN, NaN, 0.0, 0)); +assert(test_log1pf(-1.175494211e-38,-1.175494211e-38, 4.930380658e-32, INEXACT | UNDERFLOW)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.log2 +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_log2(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.log2(value), expected, error, flags) && + (!js || check( JSMath.log2(value), expected, error, flags)); +} + +// sanity +assert(test_log2(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_log2(4.34523984933830487, 2.11943581338044851, -0.101648777723312378, INEXACT)); +assert(test_log2(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_log2(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_log2(9.26705696697258574, 3.21211124032987438, -0.157394468784332275, INEXACT)); +assert(test_log2(0.661985898099504477, -0.59512761042074025, 0.332148522138595581, INEXACT)); +assert(test_log2(-0.40660392238535531, NaN, 0.0, INVALID)); +assert(test_log2(0.56175974622072411, -0.831974845304464417, 0.0575554370880126953, INEXACT)); +assert(test_log2(0.77415229659130369, -0.369310683655371341, -0.198382794857025146, INEXACT)); +assert(test_log2(-0.678763702639402444, NaN, 0.0, INVALID)); + +// special +assert(test_log2(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log2(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log2(-7.88860905221011805e-31, NaN, 0.0, INVALID)); +assert(test_log2(1.0, 0.0, 0.0, 0)); +assert(test_log2(-1.0, NaN, 0.0, INVALID)); +assert(test_log2(Infinity, Infinity, 0.0, 0)); +assert(test_log2(-Infinity, NaN, 0.0, INVALID)); +assert(test_log2(NaN, NaN, 0.0, 0)); + +// Mathf.log2 ////////////////////////////////////////////////////////////////////////////////////// + +function test_log2f(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.log2(value), expected, error, flags); +} + +// sanity +assert(test_log2f(-8.066848755, NaN, 0.0, INVALID)); +assert(test_log2f(4.345239639, 2.119435787, 0.1827153862, INEXACT)); +assert(test_log2f(-8.381433487, NaN, 0.0, INVALID)); +assert(test_log2f(-6.531673431, NaN, 0.0, INVALID)); +assert(test_log2f(9.267057419, 3.212111235, -0.3188050389, INEXACT)); +assert(test_log2f(0.6619858742, -0.5951276422, 0.3423146009, INEXACT)); +assert(test_log2f(-0.4066039324, NaN, 0.0, INVALID)); +assert(test_log2f(0.5617597699, -0.8319748044, -0.3347360492, INEXACT)); +assert(test_log2f(0.7741522789, -0.3693107069, 0.3278401792, INEXACT)); +assert(test_log2f(-0.6787636876, NaN, 0.0, INVALID)); + +// special +assert(test_log2f(0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log2f(-0.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_log2f(-7.888609052e-31, NaN, 0.0, INVALID)); +assert(test_log2f(1.0, 0.0, 0.0, 0)); +assert(test_log2f(-1.0, NaN, 0.0, INVALID)); +assert(test_log2f(Infinity, Infinity, 0.0, 0)); +assert(test_log2f(-Infinity, NaN, 0.0, INVALID)); +assert(test_log2f(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.max +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_max(left: f64, right: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.max(left, right), expected, error, flags) && + (!js || check( JSMath.max(left, right), expected, error, flags)); +} + +// sanity +assert(test_max(-8.06684839057968084, 4.53566256067686879, 4.53566256067686879, 0.0, 0)); +assert(test_max(4.34523984933830487, -8.88799136300345083, 4.34523984933830487, 0.0, 0)); +assert(test_max(-8.38143342755524934, -2.76360733737958819, -2.76360733737958819, 0.0, 0)); +assert(test_max(-6.53167358191348413, 4.56753527684274374, 4.56753527684274374, 0.0, 0)); +assert(test_max(9.26705696697258574, 4.81139208435979615, 9.26705696697258574, 0.0, 0)); +assert(test_max(-6.45004555606023633, 0.662071792337673881, 0.662071792337673881, 0.0, 0)); +assert(test_max(7.85889025304169664, 0.0521545267500622481, 7.85889025304169664, 0.0, 0)); +assert(test_max(-0.792054511984895959, 7.67640268511753998, 7.67640268511753998, 0.0, 0)); +assert(test_max(0.615702673197924044, 2.01190257903248026, 2.01190257903248026, 0.0, 0)); +assert(test_max(-0.558758682360915193, 0.0322398306026380407, 0.0322398306026380407, 0.0, 0)); + +// special +assert(test_max(0.0, 1.0, 1.0, 0.0, 0)); +assert(test_max(-0.0, 1.0, 1.0, 0.0, 0)); +assert(test_max(0.5, 1.0, 1.0, 0.0, 0)); +assert(test_max(-0.5, 1.0, 1.0, 0.0, 0)); +assert(test_max(1.0, 1.0, 1.0, 0.0, 0)); +assert(test_max(-1.0, 1.0, 1.0, 0.0, 0)); +assert(test_max(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_max(-Infinity, 1.0, 1.0, 0.0, 0)); +assert(test_max(NaN, 1.0, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_max(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_max(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_max(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_max(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_max(1.0, -1.0, 1.0, 0.0, 0)); +assert(test_max(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_max(Infinity, -1.0, Infinity, 0.0, 0)); +assert(test_max(-Infinity, -1.0, -1.0, 0.0, 0)); +assert(test_max(NaN, -1.0, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_max(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_max(0.0, -0.0, 0.0, 0.0, 0)); +assert(test_max(0.0, Infinity, Infinity, 0.0, 0)); +assert(test_max(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_max(0.0, NaN, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_max(-0.0, 0.0, 0.0, 0.0, 0)); +assert(test_max(-0.0, -0.0, -0.0, 0.0, 0)); +assert(test_max(-0.0, Infinity, Infinity, 0.0, 0)); +assert(test_max(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_max(-0.0, NaN, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_max(1.0, 0.0, 1.0, 0.0, 0)); +assert(test_max(-1.0, 0.0, 0.0, 0.0, 0)); +assert(test_max(Infinity, 0.0, Infinity, 0.0, 0)); +assert(test_max(-Infinity, 0.0, 0.0, 0.0, 0)); +assert(test_max(NaN, 0.0, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_max(-1.0, -0.0, -0.0, 0.0, 0)); +assert(test_max(Infinity, -0.0, Infinity, 0.0, 0)); +assert(test_max(-Infinity, -0.0, -0.0, 0.0, 0)); +assert(test_max(NaN, -0.0, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_max(Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_max(Infinity, -0.5, Infinity, 0.0, 0)); +assert(test_max(Infinity, NaN, NaN, 0.0, 0)); // C: Infinity, JS: NaN +assert(test_max(-Infinity, 2.0, 2.0, 0.0, 0)); +assert(test_max(-Infinity, -0.5, -0.5, 0.0, 0)); +assert(test_max(-Infinity, NaN, NaN, 0.0, 0)); // C: -Infinity, JS: NaN +assert(test_max(NaN, NaN, NaN, 0.0, 0)); +assert(test_max(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_max(-1.0, NaN, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_max(1.0, Infinity, Infinity, 0.0, 0)); +assert(test_max(-1.0, Infinity, Infinity, 0.0, 0)); +assert(test_max(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_max(-Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_max(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_max(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_max(Infinity, -Infinity, Infinity, 0.0, 0)); +assert(test_max(-Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_max(1.75, 0.5, 1.75, 0.0, 0)); +assert(test_max(-1.75, 0.5, 0.5, 0.0, 0)); +assert(test_max(1.75, -0.5, 1.75, 0.0, 0)); +assert(test_max(-1.75, -0.5, -0.5, 0.0, 0)); + +// Mathf.max /////////////////////////////////////////////////////////////////////////////////////// + +function test_maxf(left: f32, right: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.max(left, right), expected, error, flags); +} + +// sanity +assert(test_maxf(-8.066848755, 4.535662651, 4.535662651, 0.0, 0)); +assert(test_maxf(4.345239639, -8.887990952, 4.345239639, 0.0, 0)); +assert(test_maxf(-8.381433487, -2.763607264, -2.763607264, 0.0, 0)); +assert(test_maxf(-6.531673431, 4.5675354, 4.5675354, 0.0, 0)); +assert(test_maxf(9.267057419, 4.811392307, 9.267057419, 0.0, 0)); +assert(test_maxf(-6.450045586, 0.6620717645, 0.6620717645, 0.0, 0)); +assert(test_maxf(7.858890057, 0.05215452611, 7.858890057, 0.0, 0)); +assert(test_maxf(-0.792054534, 7.676402569, 7.676402569, 0.0, 0)); +assert(test_maxf(0.6157026887, 2.011902571, 2.011902571, 0.0, 0)); +assert(test_maxf(-0.5587586761, 0.03223983198, 0.03223983198, 0.0, 0)); + +// special +assert(test_maxf(0.0, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(-0.0, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(0.5, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(-0.5, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(1.0, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(-1.0, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, 1.0, 1.0, 0.0, 0)); +assert(test_maxf(NaN, 1.0, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_maxf(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_maxf(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_maxf(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_maxf(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_maxf(1.0, -1.0, 1.0, 0.0, 0)); +assert(test_maxf(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_maxf(Infinity, -1.0, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, -1.0, -1.0, 0.0, 0)); +assert(test_maxf(NaN, -1.0, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_maxf(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_maxf(0.0, -0.0, 0.0, 0.0, 0)); +assert(test_maxf(0.0, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_maxf(0.0, NaN, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_maxf(-0.0, 0.0, 0.0, 0.0, 0)); +assert(test_maxf(-0.0, -0.0, -0.0, 0.0, 0)); +assert(test_maxf(-0.0, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_maxf(-0.0, NaN, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_maxf(1.0, 0.0, 1.0, 0.0, 0)); +assert(test_maxf(-1.0, 0.0, 0.0, 0.0, 0)); +assert(test_maxf(Infinity, 0.0, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, 0.0, 0.0, 0.0, 0)); +assert(test_maxf(NaN, 0.0, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_maxf(-1.0, -0.0, -0.0, 0.0, 0)); +assert(test_maxf(Infinity, -0.0, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, -0.0, -0.0, 0.0, 0)); +assert(test_maxf(NaN, -0.0, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_maxf(Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_maxf(Infinity, -0.5, Infinity, 0.0, 0)); +assert(test_maxf(Infinity, NaN, NaN, 0.0, 0)); // C: Infinity, JS: NaN +assert(test_maxf(-Infinity, 2.0, 2.0, 0.0, 0)); +assert(test_maxf(-Infinity, -0.5, -0.5, 0.0, 0)); +assert(test_maxf(-Infinity, NaN, NaN, 0.0, 0)); // C: -Infinity, JS: NaN +assert(test_maxf(NaN, NaN, NaN, 0.0, 0)); +assert(test_maxf(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_maxf(-1.0, NaN, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_maxf(1.0, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(-1.0, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_maxf(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_maxf(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_maxf(Infinity, -Infinity, Infinity, 0.0, 0)); +assert(test_maxf(-Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_maxf(1.75, 0.5, 1.75, 0.0, 0)); +assert(test_maxf(-1.75, 0.5, 0.5, 0.0, 0)); +assert(test_maxf(1.75, -0.5, 1.75, 0.0, 0)); +assert(test_maxf(-1.75, -0.5, -0.5, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.min +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_min(left: f64, right: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.min(left, right), expected, error, flags) && + (!js || check( JSMath.min(left, right), expected, error, flags)); +} + +// sanity +assert(test_min(-8.06684839057968084, 4.53566256067686879, -8.06684839057968084, 0.0, 0)); +assert(test_min(4.34523984933830487, -8.88799136300345083, -8.88799136300345083, 0.0, 0)); +assert(test_min(-8.38143342755524934, -2.76360733737958819, -8.38143342755524934, 0.0, 0)); +assert(test_min(-6.53167358191348413, 4.56753527684274374, -6.53167358191348413, 0.0, 0)); +assert(test_min(9.26705696697258574, 4.81139208435979615, 4.81139208435979615, 0.0, 0)); +assert(test_min(-6.45004555606023633, 0.662071792337673881, -6.45004555606023633, 0.0, 0)); +assert(test_min(7.85889025304169664, 0.0521545267500622481, 0.0521545267500622481, 0.0, 0)); +assert(test_min(-0.792054511984895959, 7.67640268511753998, -0.792054511984895959, 0.0, 0)); +assert(test_min(0.615702673197924044, 2.01190257903248026, 0.615702673197924044, 0.0, 0)); +assert(test_min(-0.558758682360915193, 0.0322398306026380407, -0.558758682360915193, 0.0, 0)); + +// special +assert(test_min(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_min(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_min(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_min(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_min(1.0, 1.0, 1.0, 0.0, 0)); +assert(test_min(-1.0, 1.0, -1.0, 0.0, 0)); +assert(test_min(Infinity, 1.0, 1.0, 0.0, 0)); +assert(test_min(-Infinity, 1.0, -Infinity, 0.0, 0)); +assert(test_min(NaN, 1.0, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_min(0.0, -1.0, -1.0, 0.0, 0)); +assert(test_min(-0.0, -1.0, -1.0, 0.0, 0)); +assert(test_min(0.5, -1.0, -1.0, 0.0, 0)); +assert(test_min(-0.5, -1.0, -1.0, 0.0, 0)); +assert(test_min(1.0, -1.0, -1.0, 0.0, 0)); +assert(test_min(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_min(Infinity, -1.0, -1.0, 0.0, 0)); +assert(test_min(-Infinity, -1.0, -Infinity, 0.0, 0)); +assert(test_min(NaN, -1.0, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_min(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_min(0.0, -0.0, -0.0, 0.0, 0)); +assert(test_min(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_min(0.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(0.0, NaN, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_min(-0.0, 0.0, -0.0, 0.0, 0)); +assert(test_min(-0.0, -0.0, -0.0, 0.0, 0)); +assert(test_min(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_min(-0.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(-0.0, NaN, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_min(1.0, 0.0, 0.0, 0.0, 0)); +assert(test_min(-1.0, 0.0, -1.0, 0.0, 0)); +assert(test_min(Infinity, 0.0, 0.0, 0.0, 0)); +assert(test_min(-Infinity, 0.0, -Infinity, 0.0, 0)); +assert(test_min(NaN, 0.0, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_min(-1.0, -0.0, -1.0, 0.0, 0)); +assert(test_min(Infinity, -0.0, -0.0, 0.0, 0)); +assert(test_min(-Infinity, -0.0, -Infinity, 0.0, 0)); +assert(test_min(NaN, -0.0, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_min(Infinity, 2.0, 2.0, 0.0, 0)); +assert(test_min(Infinity, -0.5, -0.5, 0.0, 0)); +assert(test_min(Infinity, NaN, NaN, 0.0, 0)); // C: Infinity, JS: NaN +assert(test_min(-Infinity, 2.0, -Infinity, 0.0, 0)); +assert(test_min(-Infinity, -0.5, -Infinity, 0.0, 0)); +assert(test_min(-Infinity, NaN, NaN, 0.0, 0)); // C: -Infinity, JS: NaN +assert(test_min(NaN, NaN, NaN, 0.0, 0)); +assert(test_min(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_min(-1.0, NaN, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_min(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_min(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_min(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_min(-Infinity, Infinity, -Infinity, 0.0, 0)); +assert(test_min(1.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(-1.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(-Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_min(1.75, 0.5, 0.5, 0.0, 0)); +assert(test_min(-1.75, 0.5, -1.75, 0.0, 0)); +assert(test_min(1.75, -0.5, -0.5, 0.0, 0)); +assert(test_min(-1.75, -0.5, -1.75, 0.0, 0)); + +// Mathf.min /////////////////////////////////////////////////////////////////////////////////////// + +function test_minf(left: f32, right: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.min(left, right), expected, error, flags); +} + +// sanity +assert(test_minf(-8.066848755, 4.535662651, -8.066848755, 0.0, 0)); +assert(test_minf(4.345239639, -8.887990952, -8.887990952, 0.0, 0)); +assert(test_minf(-8.381433487, -2.763607264, -8.381433487, 0.0, 0)); +assert(test_minf(-6.531673431, 4.5675354, -6.531673431, 0.0, 0)); +assert(test_minf(9.267057419, 4.811392307, 4.811392307, 0.0, 0)); +assert(test_minf(-6.450045586, 0.6620717645, -6.450045586, 0.0, 0)); +assert(test_minf(7.858890057, 0.05215452611, 0.05215452611, 0.0, 0)); +assert(test_minf(-0.792054534, 7.676402569, -0.792054534, 0.0, 0)); +assert(test_minf(0.6157026887, 2.011902571, 0.6157026887, 0.0, 0)); +assert(test_minf(-0.5587586761, 0.03223983198, -0.5587586761, 0.0, 0)); + +// special +assert(test_minf(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_minf(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_minf(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_minf(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_minf(1.0, 1.0, 1.0, 0.0, 0)); +assert(test_minf(-1.0, 1.0, -1.0, 0.0, 0)); +assert(test_minf(Infinity, 1.0, 1.0, 0.0, 0)); +assert(test_minf(-Infinity, 1.0, -Infinity, 0.0, 0)); +assert(test_minf(NaN, 1.0, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_minf(0.0, -1.0, -1.0, 0.0, 0)); +assert(test_minf(-0.0, -1.0, -1.0, 0.0, 0)); +assert(test_minf(0.5, -1.0, -1.0, 0.0, 0)); +assert(test_minf(-0.5, -1.0, -1.0, 0.0, 0)); +assert(test_minf(1.0, -1.0, -1.0, 0.0, 0)); +assert(test_minf(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_minf(Infinity, -1.0, -1.0, 0.0, 0)); +assert(test_minf(-Infinity, -1.0, -Infinity, 0.0, 0)); +assert(test_minf(NaN, -1.0, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_minf(0.0, 0.0, 0.0, 0.0, 0)); +assert(test_minf(0.0, -0.0, -0.0, 0.0, 0)); +assert(test_minf(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_minf(0.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(0.0, NaN, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_minf(-0.0, 0.0, -0.0, 0.0, 0)); +assert(test_minf(-0.0, -0.0, -0.0, 0.0, 0)); +assert(test_minf(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_minf(-0.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(-0.0, NaN, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_minf(1.0, 0.0, 0.0, 0.0, 0)); +assert(test_minf(-1.0, 0.0, -1.0, 0.0, 0)); +assert(test_minf(Infinity, 0.0, 0.0, 0.0, 0)); +assert(test_minf(-Infinity, 0.0, -Infinity, 0.0, 0)); +assert(test_minf(NaN, 0.0, NaN, 0.0, 0)); // C: 0.0, JS: NaN +assert(test_minf(-1.0, -0.0, -1.0, 0.0, 0)); +assert(test_minf(Infinity, -0.0, -0.0, 0.0, 0)); +assert(test_minf(-Infinity, -0.0, -Infinity, 0.0, 0)); +assert(test_minf(NaN, -0.0, NaN, 0.0, 0)); // C: -0.0, JS: NaN +assert(test_minf(Infinity, 2.0, 2.0, 0.0, 0)); +assert(test_minf(Infinity, -0.5, -0.5, 0.0, 0)); +assert(test_minf(Infinity, NaN, NaN, 0.0, 0)); // C: Infinity, JS: NaN +assert(test_minf(-Infinity, 2.0, -Infinity, 0.0, 0)); +assert(test_minf(-Infinity, -0.5, -Infinity, 0.0, 0)); +assert(test_minf(-Infinity, NaN, NaN, 0.0, 0)); // C: -Infinity, JS: NaN +assert(test_minf(NaN, NaN, NaN, 0.0, 0)); +assert(test_minf(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_minf(-1.0, NaN, NaN, 0.0, 0)); // C: -1.0, JS: NaN +assert(test_minf(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_minf(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_minf(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_minf(-Infinity, Infinity, -Infinity, 0.0, 0)); +assert(test_minf(1.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(-1.0, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(-Infinity, -Infinity, -Infinity, 0.0, 0)); +assert(test_minf(1.75, 0.5, 0.5, 0.0, 0)); +assert(test_minf(-1.75, 0.5, -1.75, 0.0, 0)); +assert(test_minf(1.75, -0.5, -0.5, 0.0, 0)); +assert(test_minf(-1.75, -0.5, -1.75, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.mod +//////////////////////////////////////////////////////////////////////////////////////////////////// + +declare namespace JSOp { + export function mod(x: f64, y: f64): f64; +} + +function test_mod(left: f64, right: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.mod(left, right), expected, error, flags) && + (!js || check( JSOp.mod(left, right), expected, error, flags)); +} + +// sanity +assert(test_mod(-8.06684839057968084, 4.53566256067686879, -3.53118582990281205, 0.0, 0)); +assert(test_mod(4.34523984933830487, -8.88799136300345083, 4.34523984933830487, 0.0, 0)); +assert(test_mod(-8.38143342755524934, -2.76360733737958819, -0.0906114154164847641, 0.0, 0)); +assert(test_mod(-6.53167358191348413, 4.56753527684274374, -1.96413830507074039, 0.0, 0)); +assert(test_mod(9.26705696697258574, 4.81139208435979615, 4.45566488261278959, 0.0, 0)); +assert(test_mod(-6.45004555606023633, 0.662071792337673881, -0.491399425021171399, 0.0, 0)); +assert(test_mod(7.85889025304169664, 0.0521545267500622481, 0.0357112405323594256, 0.0, 0)); +assert(test_mod(-0.792054511984895959, 7.67640268511753998, -0.792054511984895959, 0.0, 0)); +assert(test_mod(0.615702673197924044, 2.01190257903248026, 0.615702673197924044, 0.0, 0)); +assert(test_mod(-0.558758682360915193, 0.0322398306026380407, -0.0106815621160685006, 0.0, 0)); + +// special +assert(test_mod(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_mod(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_mod(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_mod(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_mod(1.0, 1.0, 0.0, 0.0, 0)); +assert(test_mod(-1.0, 1.0, -0.0, 0.0, 0)); +assert(test_mod(1.5, 1.0, 0.5, 0.0, 0)); +assert(test_mod(-1.5, 1.0, -0.5, 0.0, 0)); +assert(test_mod(2.0, 1.0, 0.0, 0.0, 0)); +assert(test_mod(-2.0, 1.0, -0.0, 0.0, 0)); +assert(test_mod(Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_mod(NaN, 1.0, NaN, 0.0, 0)); +assert(test_mod(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_mod(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_mod(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_mod(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_mod(1.0, -1.0, 0.0, 0.0, 0)); +assert(test_mod(-1.0, -1.0, -0.0, 0.0, 0)); +assert(test_mod(1.5, -1.0, 0.5, 0.0, 0)); +assert(test_mod(-1.5, -1.0, -0.5, 0.0, 0)); +assert(test_mod(2.0, -1.0, 0.0, 0.0, 0)); +assert(test_mod(-2.0, -1.0, -0.0, 0.0, 0)); +assert(test_mod(Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_mod(NaN, -1.0, NaN, 0.0, 0)); +assert(test_mod(0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_mod(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_mod(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_mod(0.0, NaN, NaN, 0.0, 0)); +assert(test_mod(-0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(-0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_mod(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_mod(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_mod(-0.0, NaN, NaN, 0.0, 0)); +assert(test_mod(1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(-1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_mod(NaN, 0.0, NaN, 0.0, 0)); +assert(test_mod(-1.0, -0.0, NaN, 0.0, INVALID)); +assert(test_mod(Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_mod(NaN, -0.0, NaN, 0.0, 0)); +assert(test_mod(Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_mod(Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_mod(Infinity, NaN, NaN, 0.0, 0)); +assert(test_mod(-Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_mod(NaN, NaN, NaN, 0.0, 0)); +assert(test_mod(1.0, NaN, NaN, 0.0, 0)); +assert(test_mod(-1.0, NaN, NaN, 0.0, 0)); +assert(test_mod(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_mod(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_mod(Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_mod(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_mod(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_mod(Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_mod(-Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_mod(1.75, 0.5, 0.25, 0.0, 0)); +assert(test_mod(-1.75, 0.5, -0.25, 0.0, 0)); +assert(test_mod(1.75, -0.5, 0.25, 0.0, 0)); +assert(test_mod(-1.75, -0.5, -0.25, 0.0, 0)); + +// Mathf.mod /////////////////////////////////////////////////////////////////////////////////////// + +function test_modf(left: f32, right: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.mod(left, right), expected, error, flags); +} + +// sanity +assert(test_modf(-8.066848755, 4.535662651, -3.531186104, 0.0, 0)); +assert(test_modf(4.345239639, -8.887990952, 4.345239639, 0.0, 0)); +assert(test_modf(-8.381433487, -2.763607264, -0.09061169624, 0.0, 0)); +assert(test_modf(-6.531673431, 4.5675354, -1.964138031, 0.0, 0)); +assert(test_modf(9.267057419, 4.811392307, 4.455665112, 0.0, 0)); +assert(test_modf(-6.450045586, 0.6620717645, -0.4913997054, 0.0, 0)); +assert(test_modf(7.858890057, 0.05215452611, 0.03571113944, 0.0, 0)); +assert(test_modf(-0.792054534, 7.676402569, -0.792054534, 0.0, 0)); +assert(test_modf(0.6157026887, 2.011902571, 0.6157026887, 0.0, 0)); +assert(test_modf(-0.5587586761, 0.03223983198, -0.01068153232, 0.0, 0)); + +// special +assert(test_modf(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_modf(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_modf(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_modf(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_modf(1.0, 1.0, 0.0, 0.0, 0)); +assert(test_modf(-1.0, 1.0, -0.0, 0.0, 0)); +assert(test_modf(1.5, 1.0, 0.5, 0.0, 0)); +assert(test_modf(-1.5, 1.0, -0.5, 0.0, 0)); +assert(test_modf(2.0, 1.0, 0.0, 0.0, 0)); +assert(test_modf(-2.0, 1.0, -0.0, 0.0, 0)); +assert(test_modf(Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_modf(NaN, 1.0, NaN, 0.0, 0)); +assert(test_modf(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_modf(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_modf(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_modf(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_modf(1.0, -1.0, 0.0, 0.0, 0)); +assert(test_modf(-1.0, -1.0, -0.0, 0.0, 0)); +assert(test_modf(1.5, -1.0, 0.5, 0.0, 0)); +assert(test_modf(-1.5, -1.0, -0.5, 0.0, 0)); +assert(test_modf(2.0, -1.0, 0.0, 0.0, 0)); +assert(test_modf(-2.0, -1.0, -0.0, 0.0, 0)); +assert(test_modf(Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_modf(NaN, -1.0, NaN, 0.0, 0)); +assert(test_modf(0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_modf(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_modf(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_modf(0.0, NaN, NaN, 0.0, 0)); +assert(test_modf(-0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(-0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_modf(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_modf(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_modf(-0.0, NaN, NaN, 0.0, 0)); +assert(test_modf(1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(-1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_modf(NaN, 0.0, NaN, 0.0, 0)); +assert(test_modf(-1.0, -0.0, NaN, 0.0, INVALID)); +assert(test_modf(Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_modf(NaN, -0.0, NaN, 0.0, 0)); +assert(test_modf(Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_modf(Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_modf(Infinity, NaN, NaN, 0.0, 0)); +assert(test_modf(-Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_modf(NaN, NaN, NaN, 0.0, 0)); +assert(test_modf(1.0, NaN, NaN, 0.0, 0)); +assert(test_modf(-1.0, NaN, NaN, 0.0, 0)); +assert(test_modf(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_modf(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_modf(Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_modf(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_modf(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_modf(Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_modf(-Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_modf(1.75, 0.5, 0.25, 0.0, 0)); +assert(test_modf(-1.75, 0.5, -0.25, 0.0, 0)); +assert(test_modf(1.75, -0.5, 0.25, 0.0, 0)); +assert(test_modf(-1.75, -0.5, -0.25, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.pow +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_pow(left: f64, right: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.pow(left, right), expected, error, flags) && + (!js || check( JSMath.pow(left, right), expected, error, flags)); +} + +// sanity +assert(test_pow(-8.06684839057968084, 4.53566256067686879, NaN, 0.0, INVALID)); +assert(test_pow(4.34523984933830487, -8.88799136300345083, 0.00000213471188255872853, 0.325016021728515625, INEXACT)); +assert(test_pow(-8.38143342755524934, -2.76360733737958819, NaN, 0.0, INVALID)); +assert(test_pow(-6.53167358191348413, 4.56753527684274374, NaN, 0.0, INVALID)); +assert(test_pow(9.26705696697258574, 4.81139208435979615, 44909.2994151296589, -0.266590803861618042, INEXACT)); +assert(test_pow(-6.45004555606023633, 0.662071792337673881, NaN, 0.0, INVALID)); +assert(test_pow(7.85889025304169664, 0.0521545267500622481, 1.11351774134586523, -0.371686071157455444, INEXACT)); +assert(test_pow(-0.792054511984895959, 7.67640268511753998, NaN, 0.0, INVALID)); +assert(test_pow(0.615702673197924044, 2.01190257903248026, 0.376907735213801831, 0.32473301887512207, INEXACT)); +assert(test_pow(-0.558758682360915193, 0.0322398306026380407, NaN, 0.0, INVALID)); + +// special +assert(test_pow(0.0, NaN, NaN, 0.0, 0)); +assert(test_pow(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_pow(0.0, 3.0, 0.0, 0.0, 0)); +assert(test_pow(0.0, 2.0, 0.0, 0.0, 0)); +assert(test_pow(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_pow(0.0, 0.5, 0.0, 0.0, 0)); +assert(test_pow(0.0, 0.0, 1.0, 0.0, 0)); +assert(test_pow(0.0, -0.0, 1.0, 0.0, 0)); +assert(test_pow(0.0, -0.5, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(0.0, -1.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(0.0, -2.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(0.0, -3.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(0.0, -4.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(0.0, -Infinity, Infinity, 0.0, 0)); +assert(test_pow(-0.0, NaN, NaN, 0.0, 0)); +assert(test_pow(-0.0, Infinity, 0.0, 0.0, 0)); +assert(test_pow(-0.0, 3.0, -0.0, 0.0, 0)); +assert(test_pow(-0.0, 2.0, 0.0, 0.0, 0)); +assert(test_pow(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_pow(-0.0, 0.5, 0.0, 0.0, 0)); +assert(test_pow(-0.0, 0.0, 1.0, 0.0, 0)); +assert(test_pow(-0.0, -0.0, 1.0, 0.0, 0)); +assert(test_pow(-0.0, -0.5, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(-0.0, -1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_pow(-0.0, -2.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(-0.0, -3.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_pow(-0.0, -4.0, Infinity, 0.0, DIVBYZERO)); +assert(test_pow(-0.0, -Infinity, Infinity, 0.0, 0)); +assert(test_pow(NaN, 0.0, 1.0, 0.0, 0)); +assert(test_pow(Infinity, 0.0, 1.0, 0.0, 0)); +assert(test_pow(-Infinity, 0.0, 1.0, 0.0, 0)); +assert(test_pow(1.0, 0.0, 1.0, 0.0, 0)); +assert(test_pow(-1.0, 0.0, 1.0, 0.0, 0)); +assert(test_pow(-0.5, 0.0, 1.0, 0.0, 0)); +assert(test_pow(NaN, -0.0, 1.0, 0.0, 0)); +assert(test_pow(Infinity, -0.0, 1.0, 0.0, 0)); +assert(test_pow(-Infinity, -0.0, 1.0, 0.0, 0)); +assert(test_pow(1.0, -0.0, 1.0, 0.0, 0)); +assert(test_pow(-1.0, -0.0, 1.0, 0.0, 0)); +assert(test_pow(-0.5, -0.0, 1.0, 0.0, 0)); +assert(test_pow(-1.0, NaN, NaN, 0.0, 0)); +assert(test_pow(-1.0, Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_pow(-1.0, -Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_pow(-1.0, 2.0, 1.0, 0.0, 0)); +assert(test_pow(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_pow(-1.0, -2.0, 1.0, 0.0, 0)); +assert(test_pow(-1.0, -3.0, -1.0, 0.0, 0)); +assert(test_pow(-1.0, 0.5, NaN, 0.0, INVALID)); +assert(test_pow(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_pow(1.0, Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_pow(1.0, -Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_pow(1.0, 3.0, 1.0, 0.0, 0)); +assert(test_pow(1.0, 0.5, 1.0, 0.0, 0)); +assert(test_pow(1.0, -0.5, 1.0, 0.0, 0)); +assert(test_pow(1.0, -3.0, 1.0, 0.0, 0)); +assert(test_pow(-0.5, 0.5, NaN, 0.0, INVALID)); +assert(test_pow(-0.5, 1.5, NaN, 0.0, INVALID)); +assert(test_pow(-0.5, 2.0, 0.25, 0.0, 0)); +assert(test_pow(-0.5, 3.0, -0.125, 0.0, 0)); +assert(test_pow(-0.5, Infinity, 0.0, 0.0, 0)); +assert(test_pow(-0.5, -Infinity, Infinity, 0.0, 0)); +assert(test_pow(-0.5, NaN, NaN, 0.0, 0)); +assert(test_pow(0.5, Infinity, 0.0, 0.0, 0)); +assert(test_pow(0.5, -Infinity, Infinity, 0.0, 0)); +assert(test_pow(0.5, NaN, NaN, 0.0, 0)); +assert(test_pow(1.5, Infinity, Infinity, 0.0, 0)); +assert(test_pow(1.5, -Infinity, 0.0, 0.0, 0)); +assert(test_pow(1.5, NaN, NaN, 0.0, 0)); +assert(test_pow(Infinity, NaN, NaN, 0.0, 0)); +assert(test_pow(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_pow(Infinity, -Infinity, 0.0, 0.0, 0)); +assert(test_pow(Infinity, 3.0, Infinity, 0.0, 0)); +assert(test_pow(Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_pow(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_pow(Infinity, 0.5, Infinity, 0.0, 0)); +assert(test_pow(Infinity, -0.5, 0.0, 0.0, 0)); +assert(test_pow(Infinity, -1.0, 0.0, 0.0, 0)); +assert(test_pow(Infinity, -2.0, 0.0, 0.0, 0)); +assert(test_pow(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_pow(-Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_pow(-Infinity, -Infinity, 0.0, 0.0, 0)); +assert(test_pow(-Infinity, 3.0, -Infinity, 0.0, 0)); +assert(test_pow(-Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_pow(-Infinity, 1.0, -Infinity, 0.0, 0)); +assert(test_pow(-Infinity, 0.5, Infinity, 0.0, 0)); +assert(test_pow(-Infinity, -0.5, 0.0, 0.0, 0)); +assert(test_pow(-Infinity, -1.0, -0.0, 0.0, 0)); +assert(test_pow(-Infinity, -2.0, 0.0, 0.0, 0)); +assert(test_pow(NaN, 1.0, NaN, 0.0, 0)); +assert(test_pow(NaN, -1.0, NaN, 0.0, 0)); +assert(test_pow(-2.0, 1.0, -2.0, 0.0, 0)); +assert(test_pow(-2.0, -1.0, -0.5, 0.0, 0)); + +// Mathf.pow /////////////////////////////////////////////////////////////////////////////////////// + +function test_powf(left: f32, right: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.pow(left, right), expected, error, flags); +} + +// sanity +assert(test_powf(-8.066848755, 4.535662651, NaN, 0.0, INVALID)); +assert(test_powf(4.345239639, -8.887990952, 0.000002134714123, 0.1436440796, INEXACT)); +assert(test_powf(-8.381433487, -2.763607264, NaN, 0.0, INVALID)); +assert(test_powf(-6.531673431, 4.5675354, NaN, 0.0, INVALID)); +assert(test_powf(9.267057419, 4.811392307, 44909.33203, -0.05356409028, INEXACT)); +assert(test_powf(-6.450045586, 0.6620717645, NaN, 0.0, INVALID)); +assert(test_powf(7.858890057, 0.05215452611, 1.113517761, 0.1912208945, INEXACT)); +assert(test_powf(-0.792054534, 7.676402569, NaN, 0.0, INVALID)); +assert(test_powf(0.6157026887, 2.011902571, 0.3769077659, 0.3371490538, INEXACT)); +assert(test_powf(-0.5587586761, 0.03223983198, NaN, 0.0, INVALID)); + +// special +assert(test_powf(0.0, NaN, NaN, 0.0, 0)); +assert(test_powf(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_powf(0.0, 3.0, 0.0, 0.0, 0)); +assert(test_powf(0.0, 2.0, 0.0, 0.0, 0)); +assert(test_powf(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_powf(0.0, 0.5, 0.0, 0.0, 0)); +assert(test_powf(0.0, 0.0, 1.0, 0.0, 0)); +assert(test_powf(0.0, -0.0, 1.0, 0.0, 0)); +assert(test_powf(0.0, -0.5, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(0.0, -1.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(0.0, -2.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(0.0, -3.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(0.0, -4.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(0.0, -Infinity, Infinity, 0.0, 0)); +assert(test_powf(-0.0, NaN, NaN, 0.0, 0)); +assert(test_powf(-0.0, Infinity, 0.0, 0.0, 0)); +assert(test_powf(-0.0, 3.0, -0.0, 0.0, 0)); +assert(test_powf(-0.0, 2.0, 0.0, 0.0, 0)); +assert(test_powf(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_powf(-0.0, 0.5, 0.0, 0.0, 0)); +assert(test_powf(-0.0, 0.0, 1.0, 0.0, 0)); +assert(test_powf(-0.0, -0.0, 1.0, 0.0, 0)); +assert(test_powf(-0.0, -0.5, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(-0.0, -1.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_powf(-0.0, -2.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(-0.0, -3.0, -Infinity, 0.0, DIVBYZERO)); +assert(test_powf(-0.0, -4.0, Infinity, 0.0, DIVBYZERO)); +assert(test_powf(-0.0, -Infinity, Infinity, 0.0, 0)); +assert(test_powf(NaN, 0.0, 1.0, 0.0, 0)); +assert(test_powf(Infinity, 0.0, 1.0, 0.0, 0)); +assert(test_powf(-Infinity, 0.0, 1.0, 0.0, 0)); +assert(test_powf(1.0, 0.0, 1.0, 0.0, 0)); +assert(test_powf(-1.0, 0.0, 1.0, 0.0, 0)); +assert(test_powf(-0.5, 0.0, 1.0, 0.0, 0)); +assert(test_powf(NaN, -0.0, 1.0, 0.0, 0)); +assert(test_powf(Infinity, -0.0, 1.0, 0.0, 0)); +assert(test_powf(-Infinity, -0.0, 1.0, 0.0, 0)); +assert(test_powf(1.0, -0.0, 1.0, 0.0, 0)); +assert(test_powf(-1.0, -0.0, 1.0, 0.0, 0)); +assert(test_powf(-0.5, -0.0, 1.0, 0.0, 0)); +assert(test_powf(-1.0, NaN, NaN, 0.0, 0)); +assert(test_powf(-1.0, Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_powf(-1.0, -Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_powf(-1.0, 2.0, 1.0, 0.0, 0)); +assert(test_powf(-1.0, -1.0, -1.0, 0.0, 0)); +assert(test_powf(-1.0, -2.0, 1.0, 0.0, 0)); +assert(test_powf(-1.0, -3.0, -1.0, 0.0, 0)); +assert(test_powf(-1.0, 0.5, NaN, 0.0, INVALID)); +assert(test_powf(1.0, NaN, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_powf(1.0, Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_powf(1.0, -Infinity, NaN, 0.0, 0)); // C: 1.0, JS: NaN +assert(test_powf(1.0, 3.0, 1.0, 0.0, 0)); +assert(test_powf(1.0, 0.5, 1.0, 0.0, 0)); +assert(test_powf(1.0, -0.5, 1.0, 0.0, 0)); +assert(test_powf(1.0, -3.0, 1.0, 0.0, 0)); +assert(test_powf(-0.5, 0.5, NaN, 0.0, INVALID)); +assert(test_powf(-0.5, 1.5, NaN, 0.0, INVALID)); +assert(test_powf(-0.5, 2.0, 0.25, 0.0, 0)); +assert(test_powf(-0.5, 3.0, -0.125, 0.0, 0)); +assert(test_powf(-0.5, Infinity, 0.0, 0.0, 0)); +assert(test_powf(-0.5, -Infinity, Infinity, 0.0, 0)); +assert(test_powf(-0.5, NaN, NaN, 0.0, 0)); +assert(test_powf(0.5, Infinity, 0.0, 0.0, 0)); +assert(test_powf(0.5, -Infinity, Infinity, 0.0, 0)); +assert(test_powf(0.5, NaN, NaN, 0.0, 0)); +assert(test_powf(1.5, Infinity, Infinity, 0.0, 0)); +assert(test_powf(1.5, -Infinity, 0.0, 0.0, 0)); +assert(test_powf(1.5, NaN, NaN, 0.0, 0)); +assert(test_powf(Infinity, NaN, NaN, 0.0, 0)); +assert(test_powf(Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_powf(Infinity, -Infinity, 0.0, 0.0, 0)); +assert(test_powf(Infinity, 3.0, Infinity, 0.0, 0)); +assert(test_powf(Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_powf(Infinity, 1.0, Infinity, 0.0, 0)); +assert(test_powf(Infinity, 0.5, Infinity, 0.0, 0)); +assert(test_powf(Infinity, -0.5, 0.0, 0.0, 0)); +assert(test_powf(Infinity, -1.0, 0.0, 0.0, 0)); +assert(test_powf(Infinity, -2.0, 0.0, 0.0, 0)); +assert(test_powf(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_powf(-Infinity, Infinity, Infinity, 0.0, 0)); +assert(test_powf(-Infinity, -Infinity, 0.0, 0.0, 0)); +assert(test_powf(-Infinity, 3.0, -Infinity, 0.0, 0)); +assert(test_powf(-Infinity, 2.0, Infinity, 0.0, 0)); +assert(test_powf(-Infinity, 1.0, -Infinity, 0.0, 0)); +assert(test_powf(-Infinity, 0.5, Infinity, 0.0, 0)); +assert(test_powf(-Infinity, -0.5, 0.0, 0.0, 0)); +assert(test_powf(-Infinity, -1.0, -0.0, 0.0, 0)); +assert(test_powf(-Infinity, -2.0, 0.0, 0.0, 0)); +assert(test_powf(NaN, 1.0, NaN, 0.0, 0)); +assert(test_powf(NaN, -1.0, NaN, 0.0, 0)); +assert(test_powf(-2.0, 1.0, -2.0, 0.0, 0)); +assert(test_powf(-2.0, -1.0, -0.5, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.random +//////////////////////////////////////////////////////////////////////////////////////////////////// NativeMath.seedRandom(reinterpret(JSMath.random())); -for (let i = 0; i < 1e7; ++i) { +for (let i = 0; i < 1e6; ++i) { let r = NativeMath.random(); assert(r >= 0.0 && r < 1.0); } + +// Mathf.random //////////////////////////////////////////////////////////////////////////////////// + +NativeMathf.seedRandom(reinterpret(JSMath.random())); +for (let i = 0; i < 1e6; ++i) { + let r = NativeMathf.random(); + assert(r >= 0.0 && r < 1.0); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.round +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_round(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.round(value), expected, error, flags); + // (!js || check( JSMath.round(value), expected, error, flags)); + // FIXME: JS rounds fractional 0.5 towards +inf (why would one do that?) +} + +// sanity +assert(test_round(-8.06684839057968084, -8.0, 0.0, INEXACT)); +assert(test_round(4.34523984933830487, 4.0, 0.0, INEXACT)); +assert(test_round(-8.38143342755524934, -8.0, 0.0, INEXACT)); +assert(test_round(-6.53167358191348413, -7.0, 0.0, INEXACT)); +assert(test_round(9.26705696697258574, 9.0, 0.0, INEXACT)); +assert(test_round(0.661985898099504477, 1.0, 0.0, INEXACT)); +assert(test_round(-0.406603922385355310, -0.0, 0.0, INEXACT)); +assert(test_round(0.561759746220724110, 1.0, 0.0, INEXACT)); +assert(test_round(0.774152296591303690, 1.0, 0.0, INEXACT)); +assert(test_round(-0.678763702639402444, -1.0, 0.0, INEXACT)); + +// special +assert(test_round(NaN, NaN, 0.0, 0)); +assert(test_round(Infinity, Infinity, 0.0, 0)); +assert(test_round(-Infinity, -Infinity, 0.0, 0)); +assert(test_round(0.0, 0.0, 0.0, 0)); +assert(test_round(-0.0, -0.0, 0.0, 0)); +assert(test_round(1.0, 1.0, 0.0, 0)); +assert(test_round(-1.0, -1.0, 0.0, 0)); +assert(test_round(0.5, 1.0, 0.0, INEXACT)); +assert(test_round(-0.5, -0.0, 0.0, INEXACT)); // C: -1.0, JS: -0.0 +assert(test_round(1.5, 2.0, 0.0, INEXACT)); +assert(test_round(-1.5, -1.0, 0.0, INEXACT)); // C: -2.0, JS: -1.0 +assert(test_round(1.00001525878906250, 1.0, 0.0, INEXACT)); +assert(test_round(-1.00001525878906250, -1.0, 0.0, INEXACT)); +assert(test_round(0.999992370605468750, 1.0, 0.0, INEXACT)); +assert(test_round(-0.999992370605468750, -1.0, 0.0, INEXACT)); +assert(test_round(7.88860905221011805e-31, 0.0, 0.0, INEXACT)); +assert(test_round(-7.88860905221011805e-31, -0.0, 0.0, INEXACT)); + +// Mathf.round ///////////////////////////////////////////////////////////////////////////////////// + +function test_roundf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.round(value), expected, error, flags); +} + +// sanity +assert(test_roundf(-8.066848755, -8.0, 0.0, INEXACT)); +assert(test_roundf(4.345239639, 4.0, 0.0, INEXACT)); +assert(test_roundf(-8.381433487, -8.0, 0.0, INEXACT)); +assert(test_roundf(-6.531673431, -7.0, 0.0, INEXACT)); +assert(test_roundf(9.267057419, 9.0, 0.0, INEXACT)); +assert(test_roundf(0.6619858742, 1.0, 0.0, INEXACT)); +assert(test_roundf(-0.4066039324, -0.0, 0.0, INEXACT)); +assert(test_roundf(0.5617597699, 1.0, 0.0, INEXACT)); +assert(test_roundf(0.7741522789, 1.0, 0.0, INEXACT)); +assert(test_roundf(-0.6787636876, -1.0, 0.0, INEXACT)); + +// special +assert(test_roundf(NaN, NaN, 0.0, 0)); +assert(test_roundf(Infinity, Infinity, 0.0, 0)); +assert(test_roundf(-Infinity, -Infinity, 0.0, 0)); +assert(test_roundf(0.0, 0.0, 0.0, 0)); +assert(test_roundf(-0.0, -0.0, 0.0, 0)); +assert(test_roundf(1.0, 1.0, 0.0, 0)); +assert(test_roundf(-1.0, -1.0, 0.0, 0)); +assert(test_roundf(0.5, 1.0, 0.0, INEXACT)); +assert(test_roundf(-0.5, -0.0, 0.0, INEXACT)); // C: -1.0, JS: -0.0 +assert(test_round(1.5, 2.0, 0.0, INEXACT)); +assert(test_round(-1.5, -1.0, 0.0, INEXACT)); // C: -2.0, JS: -1.0 +assert(test_roundf(1.000015259, 1.0, 0.0, INEXACT)); +assert(test_roundf(-1.000015259, -1.0, 0.0, INEXACT)); +assert(test_roundf(0.9999923706, 1.0, 0.0, INEXACT)); +assert(test_roundf(-0.9999923706, -1.0, 0.0, INEXACT)); +assert(test_roundf(7.888609052e-31, 0.0, 0.0, INEXACT)); +assert(test_roundf(-7.888609052e-31, -0.0, 0.0, INEXACT)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.sign +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_sign(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.sign(value), expected, error, flags) && + (!js || check( JSMath.sign(value), expected, error, flags)); +} + +assert(test_sign(0.0, 0.0, 0.0, 0)); +assert(test_sign(-0.0, -0.0, 0.0, 0)); +assert(test_sign(1.0, 1.0, 0.0, 0)); +assert(test_sign(2.0, 1.0, 0.0, 0)); +assert(test_sign(-1.0, -1.0, 0.0, 0)); +assert(test_sign(-2.0, -1.0, 0.0, 0)); +assert(test_sign(Infinity, 1.0, 0.0, 0)); +assert(test_sign(-Infinity, -1.0, 0.0, 0)); +assert(test_sign(NaN, NaN, 0.0, 0)); + +// Mathf.sign ////////////////////////////////////////////////////////////////////////////////////// + +function test_signf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.sign(value), expected, error, flags); +} + +assert(test_signf(0.0, 0.0, 0.0, 0)); +assert(test_signf(-0.0, -0.0, 0.0, 0)); +assert(test_signf(1.0, 1.0, 0.0, 0)); +assert(test_signf(2.0, 1.0, 0.0, 0)); +assert(test_signf(-1.0, -1.0, 0.0, 0)); +assert(test_signf(-2.0, -1.0, 0.0, 0)); +assert(test_signf(Infinity, 1.0, 0.0, 0)); +assert(test_signf(-Infinity, -1.0, 0.0, 0)); +assert(test_signf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.rem +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_rem(left: f64, right: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.rem(left, right), expected, error, flags); +} + +// sanity +assert(test_rem(-8.06684839057968084, 4.53566256067686879, 1.00447673077405675, 0.0, 0)); +assert(test_rem(4.34523984933830487, -8.88799136300345083, 4.34523984933830487, 0.0, 0)); +assert(test_rem(-8.38143342755524934, -2.76360733737958819, -0.0906114154164847641, 0.0, 0)); +assert(test_rem(-6.53167358191348413, 4.56753527684274374, -1.96413830507074039, 0.0, 0)); +assert(test_rem(9.26705696697258574, 4.81139208435979615, -0.355727201747006561, 0.0, 0)); +assert(test_rem(-6.45004555606023633, 0.662071792337673881, 0.170672367316502482, 0.0, 0)); +assert(test_rem(7.85889025304169664, 0.0521545267500622481, -0.0164432862177028224, 0.0, 0)); +assert(test_rem(-0.792054511984895959, 7.67640268511753998, -0.792054511984895959, 0.0, 0)); +assert(test_rem(0.615702673197924044, 2.01190257903248026, 0.615702673197924044, 0.0, 0)); +assert(test_rem(-0.558758682360915193, 0.0322398306026380407, -0.0106815621160685006, 0.0, 0)); + +// special +assert(test_rem(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_rem(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_rem(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_rem(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_rem(1.0, 1.0, 0.0, 0.0, 0)); +assert(test_rem(-1.0, 1.0, -0.0, 0.0, 0)); +assert(test_rem(1.5, 1.0, -0.5, 0.0, 0)); +assert(test_rem(-1.5, 1.0, 0.5, 0.0, 0)); +assert(test_rem(2.0, 1.0, 0.0, 0.0, 0)); +assert(test_rem(-2.0, 1.0, -0.0, 0.0, 0)); +assert(test_rem(Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_rem(NaN, 1.0, NaN, 0.0, 0)); +assert(test_rem(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_rem(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_rem(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_rem(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_rem(1.0, -1.0, 0.0, 0.0, 0)); +assert(test_rem(-1.0, -1.0, -0.0, 0.0, 0)); +assert(test_rem(1.5, -1.0, -0.5, 0.0, 0)); +assert(test_rem(-1.5, -1.0, 0.5, 0.0, 0)); +assert(test_rem(2.0, -1.0, 0.0, 0.0, 0)); +assert(test_rem(-2.0, -1.0, -0.0, 0.0, 0)); +assert(test_rem(Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_rem(NaN, -1.0, NaN, 0.0, 0)); +assert(test_rem(0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_rem(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_rem(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_rem(0.0, NaN, NaN, 0.0, 0)); +assert(test_rem(-0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(-0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_rem(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_rem(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_rem(-0.0, NaN, NaN, 0.0, 0)); +assert(test_rem(1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(-1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_rem(NaN, 0.0, NaN, 0.0, 0)); +assert(test_rem(-1.0, -0.0, NaN, 0.0, INVALID)); +assert(test_rem(Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_rem(NaN, -0.0, NaN, 0.0, 0)); +assert(test_rem(Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_rem(Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_rem(Infinity, NaN, NaN, 0.0, 0)); +assert(test_rem(-Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_rem(NaN, NaN, NaN, 0.0, 0)); +assert(test_rem(1.0, NaN, NaN, 0.0, 0)); +assert(test_rem(-1.0, NaN, NaN, 0.0, 0)); +assert(test_rem(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_rem(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_rem(Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_rem(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_rem(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_rem(Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_rem(-Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_rem(1.75, 0.5, -0.25, 0.0, 0)); +assert(test_rem(-1.75, 0.5, 0.25, 0.0, 0)); +assert(test_rem(1.75, -0.5, -0.25, 0.0, 0)); +assert(test_rem(-1.75, -0.5, 0.25, 0.0, 0)); +assert(test_rem(7.90505033345994471e-323, Infinity, 7.90505033345994471e-323, 0.0, 0)); + +// Mathf.rem /////////////////////////////////////////////////////////////////////////////////////// + +function test_remf(left: f32, right: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.rem(left, right), expected, error, flags); +} + +// sanity +assert(test_remf(-8.066848755, 4.535662651, 1.004476547, 0.0, 0)); +assert(test_remf(4.345239639, -8.887990952, 4.345239639, 0.0, 0)); +assert(test_remf(-8.381433487, -2.763607264, -0.09061169624, 0.0, 0)); +assert(test_remf(-6.531673431, 4.5675354, -1.964138031, 0.0, 0)); +assert(test_remf(9.267057419, 4.811392307, -0.3557271957, 0.0, 0)); +assert(test_remf(-6.450045586, 0.6620717645, 0.1706720591, 0.0, 0)); +assert(test_remf(7.858890057, 0.05215452611, -0.01644338667, 0.0, 0)); +assert(test_remf(-0.792054534, 7.676402569, -0.792054534, 0.0, 0)); +assert(test_remf(0.6157026887, 2.011902571, 0.6157026887, 0.0, 0)); +assert(test_remf(-0.5587586761, 0.03223983198, -0.01068153232, 0.0, 0)); + +// special +assert(test_remf(0.0, 1.0, 0.0, 0.0, 0)); +assert(test_remf(-0.0, 1.0, -0.0, 0.0, 0)); +assert(test_remf(0.5, 1.0, 0.5, 0.0, 0)); +assert(test_remf(-0.5, 1.0, -0.5, 0.0, 0)); +assert(test_remf(1.0, 1.0, 0.0, 0.0, 0)); +assert(test_remf(-1.0, 1.0, -0.0, 0.0, 0)); +assert(test_remf(1.5, 1.0, -0.5, 0.0, 0)); +assert(test_remf(-1.5, 1.0, 0.5, 0.0, 0)); +assert(test_remf(2.0, 1.0, 0.0, 0.0, 0)); +assert(test_remf(-2.0, 1.0, -0.0, 0.0, 0)); +assert(test_remf(Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, 1.0, NaN, 0.0, INVALID)); +assert(test_remf(NaN, 1.0, NaN, 0.0, 0)); +assert(test_remf(0.0, -1.0, 0.0, 0.0, 0)); +assert(test_remf(-0.0, -1.0, -0.0, 0.0, 0)); +assert(test_remf(0.5, -1.0, 0.5, 0.0, 0)); +assert(test_remf(-0.5, -1.0, -0.5, 0.0, 0)); +assert(test_remf(1.0, -1.0, 0.0, 0.0, 0)); +assert(test_remf(-1.0, -1.0, -0.0, 0.0, 0)); +assert(test_remf(1.5, -1.0, -0.5, 0.0, 0)); +assert(test_remf(-1.5, -1.0, 0.5, 0.0, 0)); +assert(test_remf(2.0, -1.0, 0.0, 0.0, 0)); +assert(test_remf(-2.0, -1.0, -0.0, 0.0, 0)); +assert(test_remf(Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, -1.0, NaN, 0.0, INVALID)); +assert(test_remf(NaN, -1.0, NaN, 0.0, 0)); +assert(test_remf(0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_remf(0.0, Infinity, 0.0, 0.0, 0)); +assert(test_remf(0.0, -Infinity, 0.0, 0.0, 0)); +assert(test_remf(0.0, NaN, NaN, 0.0, 0)); +assert(test_remf(-0.0, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(-0.0, -0.0, NaN, 0.0, INVALID)); +assert(test_remf(-0.0, Infinity, -0.0, 0.0, 0)); +assert(test_remf(-0.0, -Infinity, -0.0, 0.0, 0)); +assert(test_remf(-0.0, NaN, NaN, 0.0, 0)); +assert(test_remf(1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(-1.0, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, 0.0, NaN, 0.0, INVALID)); +assert(test_remf(NaN, 0.0, NaN, 0.0, 0)); +assert(test_remf(-1.0, -0.0, NaN, 0.0, INVALID)); +assert(test_remf(Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, -0.0, NaN, 0.0, INVALID)); +assert(test_remf(NaN, -0.0, NaN, 0.0, 0)); +assert(test_remf(Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_remf(Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_remf(Infinity, NaN, NaN, 0.0, 0)); +assert(test_remf(-Infinity, 2.0, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, -0.5, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, NaN, NaN, 0.0, 0)); +assert(test_remf(NaN, NaN, NaN, 0.0, 0)); +assert(test_remf(1.0, NaN, NaN, 0.0, 0)); +assert(test_remf(-1.0, NaN, NaN, 0.0, 0)); +assert(test_remf(1.0, Infinity, 1.0, 0.0, 0)); +assert(test_remf(-1.0, Infinity, -1.0, 0.0, 0)); +assert(test_remf(Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, Infinity, NaN, 0.0, INVALID)); +assert(test_remf(1.0, -Infinity, 1.0, 0.0, 0)); +assert(test_remf(-1.0, -Infinity, -1.0, 0.0, 0)); +assert(test_remf(Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_remf(-Infinity, -Infinity, NaN, 0.0, INVALID)); +assert(test_remf(1.75, 0.5, -0.25, 0.0, 0)); +assert(test_remf(-1.75, 0.5, 0.25, 0.0, 0)); +assert(test_remf(1.75, -0.5, -0.25, 0.0, 0)); +assert(test_remf(-1.75, -0.5, 0.25, 0.0, 0)); +assert(test_remf(5.877471754e-39, Infinity, 5.877471754e-39, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.sin +//////////////////////////////////////////////////////////////////////////////////////////////////// +/* TODO +function test_sin(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.sin(value), expected, error, flags) && + (!js || check( JSMath.sin(value), expected, error, flags)); +} + +// sanity +assert(test_sin(-8.06684839057968084, -0.977429292878122746, -0.145649120211601257, INEXACT)); +assert(test_sin(4.34523984933830487, -0.933354473696571763, -0.0881374701857566833, INEXACT)); +assert(test_sin(-8.38143342755524934, -0.864092471170630372, -0.117438830435276031, INEXACT)); +assert(test_sin(-6.53167358191348413, -0.245938947726153739, -0.126978516578674316, INEXACT)); +assert(test_sin(9.26705696697258574, 0.15706789772028007, -0.0295501593500375748, INEXACT)); +assert(test_sin(0.661985898099504477, 0.614684486011344733, -0.0997673794627189636, INEXACT)); +assert(test_sin(-0.40660392238535531, -0.395492421828236962, -0.366877496242523193, INEXACT)); +assert(test_sin(0.56175974622072411, 0.532676328667237575, -0.355040758848190308, INEXACT)); +assert(test_sin(0.77415229659130369, 0.699110206864977934, -0.427672415971755981, INEXACT)); +assert(test_sin(-0.678763702639402444, -0.627831232630121527, -0.382811546325683594, INEXACT)); + +// special +assert(test_sin(0.0, 0.0, 0.0, 0)); +assert(test_sin(-0.0, -0.0, 0.0, 0)); +assert(test_sin(Infinity, NaN, 0.0, INVALID)); +assert(test_sin(-Infinity, NaN, 0.0, INVALID)); +assert(test_sin(NaN, NaN, 0.0, 0)); + +// Mathf.sin /////////////////////////////////////////////////////////////////////////////////////// + +function test_sinf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.sin(value), expected, error, flags); +} + +// sanity +assert(test_sinf(-8.066848755, -0.9774292111, 0.0801057294, INEXACT)); +assert(test_sinf(4.345239639, -0.9333543777, 0.3447562754, INEXACT)); +assert(test_sinf(-8.381433487, -0.8640924692, -0.4686599076, INEXACT)); +assert(test_sinf(-6.531673431, -0.2459388077, -0.3955177665, INEXACT)); +assert(test_sinf(9.267057419, 0.1570674479, -0.2400680929, INEXACT)); +assert(test_sinf(0.6619858742, 0.6146844625, -0.07707194239, INEXACT)); +assert(test_sinf(-0.4066039324, -0.3954924345, -0.1172061712, INEXACT)); +assert(test_sinf(0.5617597699, 0.5326763391, -0.1605911404, INEXACT)); +assert(test_sinf(0.7741522789, 0.6991102099, 0.2638436854, INEXACT)); +assert(test_sinf(-0.6787636876, -0.6278312206, 0.005127954297, INEXACT)); + +// special +assert(test_sinf(0.0, 0.0, 0.0, 0)); +assert(test_sinf(-0.0, -0.0, 0.0, 0)); +assert(test_sinf(Infinity, NaN, 0.0, INVALID)); +assert(test_sinf(-Infinity, NaN, 0.0, INVALID)); +assert(test_sinf(NaN, NaN, 0.0, 0)); */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.sinh +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_sinh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.sinh(value), expected, error, flags) && + (!js || check( JSMath.sinh(value), expected, error, flags)); +} + +// sanity +assert(test_sinh(-8.06684839057968084, -1593.52068011562619, -0.213872760534286499, INEXACT)); +assert(test_sinh(4.34523984933830487, 38.548780886854118, 0.215374305844306946, INEXACT)); +assert(test_sinh(-8.38143342755524934, -2182.63075051455462, 0.162138268351554871, INEXACT)); +assert(test_sinh(-6.53167358191348413, -343.272392684752901, 0.204795137047767639, INEXACT)); +assert(test_sinh(9.26705696697258574, 5291.77907551940552, -0.486765176057815552, INEXACT)); +assert(test_sinh(0.661985898099504477, 0.711406256822915695, -0.458464145660400391, INEXACT)); +assert(test_sinh(-0.40660392238535531, -0.41790065258739445, 0.372200459241867065, INEXACT)); +assert(test_sinh(0.56175974622072411, 0.591775593545123657, 0.461789965629577637, INEXACT)); +assert(test_sinh(0.77415229659130369, 0.853829200885254158, -0.0701905190944671631, INEXACT)); +assert(test_sinh(-0.678763702639402444, -0.732097615653168998, 0.268585294485092163, INEXACT)); + +// special +assert(test_sinh(0.0, 0.0, 0.0, 0)); +assert(test_sinh(-0.0, -0.0, 0.0, 0)); +assert(test_sinh(Infinity, Infinity, 0.0, 0)); +assert(test_sinh(-Infinity, -Infinity, 0.0, 0)); +assert(test_sinh(NaN, NaN, 0.0, 0)); + +// Mathf.sinh ////////////////////////////////////////////////////////////////////////////////////// + +function test_sinhf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.sinh(value), expected, error, flags); +} + +// sanity +assert(test_sinhf(-8.066848755, -1593.52124, 0.1671663225, INEXACT)); +assert(test_sinhf(4.345239639, 38.5487709, -0.4934032857, INEXACT)); +assert(test_sinhf(-8.381433487, -2182.630859, 0.08499703556, INEXACT)); +assert(test_sinhf(-6.531673431, -343.2723389, 0.07041906565, INEXACT)); +assert(test_sinhf(9.267057419, 5291.78125, -0.4436251521, INEXACT)); +assert(test_sinhf(0.6619858742, 0.7114062309, 0.0581038855, INEXACT)); +assert(test_sinhf(-0.4066039324, -0.4179006517, 0.3934949934, INEXACT)); +assert(test_sinhf(0.5617597699, 0.5917755961, -0.418379724, INEXACT)); +assert(test_sinhf(0.7741522789, 0.853829205, 0.459921062, INEXACT)); +assert(test_sinhf(-0.6787636876, -0.7320976257, -0.4815905988, INEXACT)); + +// special +assert(test_sinhf(0.0, 0.0, 0.0, 0)); +assert(test_sinhf(-0.0, -0.0, 0.0, 0)); +assert(test_sinhf(Infinity, Infinity, 0.0, 0)); +assert(test_sinhf(-Infinity, -Infinity, 0.0, 0)); +assert(test_sinhf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.sqrt +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_sqrt(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.sqrt(value), expected, error, flags) && + (!js || check( JSMath.sqrt(value), expected, error, flags)); +} + +// sanity +assert(test_sqrt(-8.06684839057968084, NaN, 0.0, INVALID)); +assert(test_sqrt(4.34523984933830487, 2.08452389032563135, -0.0718026161193847656, INEXACT)); +assert(test_sqrt(-8.38143342755524934, NaN, 0.0, INVALID)); +assert(test_sqrt(-6.53167358191348413, NaN, 0.0, INVALID)); +assert(test_sqrt(9.26705696697258574, 3.04418412172663855, -0.0154626257717609406, INEXACT)); +assert(test_sqrt(0.661985898099504477, 0.8136251582267503, -0.0861815735697746277, INEXACT)); +assert(test_sqrt(-0.40660392238535531, NaN, 0.0, INVALID)); +assert(test_sqrt(0.56175974622072411, 0.749506335010401425, -0.0981396734714508057, INEXACT)); +assert(test_sqrt(0.77415229659130369, 0.87985924817058303, -0.371243536472320557, INEXACT)); +assert(test_sqrt(-0.678763702639402444, NaN, 0.0, INVALID)); + +// special +assert(test_sqrt(NaN, NaN, 0.0, 0)); +assert(test_sqrt(Infinity, Infinity, 0.0, 0)); +assert(test_sqrt(-Infinity, NaN, 0.0, INVALID)); +assert(test_sqrt(0.0, 0.0, 0.0, 0)); +assert(test_sqrt(-0.0, -0.0, 0.0, 0)); +assert(test_sqrt(1.0, 1.0, 0.0, 0)); +assert(test_sqrt(-1.0, NaN, 0.0, INVALID)); +assert(test_sqrt(4.0, 2.0, 0.0, 0)); +assert(test_sqrt(9.88131291682493088e-324, 3.14345556940525759e-162, 0.435376197099685669, INEXACT)); +assert(test_sqrt(1.48219693752373963e-323, 3.84993108707641605e-162, -0.451940029859542847, INEXACT)); +assert(test_sqrt(4.94065645841246544e-324, 2.22275874948507748e-162, 0.0, 0)); +assert(test_sqrt(-4.94065645841246544e-324, NaN, 0.0, INVALID)); +assert(test_sqrt(0.999999999999999889, 0.999999999999999889, -0.5, INEXACT)); +assert(test_sqrt(1.99999999999999978, 1.41421356237309492, -0.211070418357849121, INEXACT)); +assert(test_sqrt(1.00000000000000022, 1.0, -0.5, INEXACT)); +assert(test_sqrt(2.00000000000000044, 1.41421356237309515, -0.271730601787567139, INEXACT)); +assert(test_sqrt(1.00000000000000022, 1.0, -0.5, INEXACT)); +assert(test_sqrt(0.999999999999999889, 0.999999999999999889, -0.5, INEXACT)); +assert(test_sqrt(-1.79769313486231571e+308, NaN, 0.0, INVALID)); +assert(test_sqrt(1.79769313486231571e+308, 1.34078079299425956e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231491e+308, 1.34078079299425926e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231411e+308, 1.34078079299425897e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231331e+308, 1.34078079299425867e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231251e+308, 1.34078079299425837e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231172e+308, 1.34078079299425807e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231092e+308, 1.34078079299425777e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486231012e+308, 1.34078079299425748e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486230932e+308, 1.34078079299425718e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486230852e+308, 1.34078079299425688e+154, -0.5, INEXACT)); +assert(test_sqrt(1.79769313486230772e+308, 1.34078079299425658e+154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850720287e-308, 1.49166814624004168e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850720484e-308, 1.49166814624004234e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850720682e-308, 1.49166814624004300e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850720879e-308, 1.49166814624004367e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850721077e-308, 1.49166814624004433e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850721275e-308, 1.49166814624004499e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850721472e-308, 1.49166814624004565e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850721670e-308, 1.49166814624004632e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850721868e-308, 1.49166814624004698e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850722065e-308, 1.49166814624004764e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850722263e-308, 1.49166814624004830e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850722460e-308, 1.49166814624004897e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850722658e-308, 1.49166814624004963e-154, -0.5, INEXACT)); +assert(test_sqrt(2.22507385850722856e-308, 1.49166814624005029e-154, -0.5, INEXACT)); +assert(test_sqrt(92.3513039189064529, 9.60995858049900598, 0.499813705682754517, INEXACT)); +assert(test_sqrt(93.3599596388915955, 9.66229577475723822, -0.499799787998199463, INEXACT)); +assert(test_sqrt(95.4204962888612442, 9.76834153215689049, -0.499972701072692871, INEXACT)); +assert(test_sqrt(95.8791694188544881, 9.79179091989072781, 0.499876677989959717, INEXACT)); +assert(test_sqrt(96.8480417488402168, 9.84114026669878506, 0.499801903963088989, INEXACT)); +assert(test_sqrt(97.4363905088315505, 9.87098731175517052, 0.499769628047943115, INEXACT)); +assert(test_sqrt(97.5095797988304724, 9.87469390912095513, 0.499998182058334351, INEXACT)); +assert(test_sqrt(97.8049689388261214, 9.88963947466367976, -0.499958068132400513, INEXACT)); +assert(test_sqrt(98.2751822888191953, 9.91338399784953417, 0.49979931116104126, INEXACT)); +assert(test_sqrt(99.4729356488015526, 9.97361196602321876, -0.499954044818878174, INEXACT)); +assert(test_sqrt(100.570471308785386, 10.0284830013709136, -0.499964535236358643, INEXACT)); +assert(test_sqrt(100.609546088784811, 10.030431002144665, 0.499756723642349243, INEXACT)); +assert(test_sqrt(100.679091098783786, 10.0338971042553435, -0.499777138233184814, INEXACT)); +assert(test_sqrt(101.122680958777252, 10.0559773746154217, 0.499886780977249146, INEXACT)); +assert(test_sqrt(101.302769128774599, 10.064927676281366, 0.499910563230514526, INEXACT)); +assert(test_sqrt(2.45932313565506984e-307, 4.95915631499458737e-154, -0.499899983406066895, INEXACT)); +assert(test_sqrt(5.61095730518040884e-307, 7.49063235326658376e-154, -0.499934375286102295, INEXACT)); +assert(test_sqrt(5.80738879774085241e-307, 7.62062254526547942e-154, -0.499895691871643066, INEXACT)); +assert(test_sqrt(7.02613708047142671e-307, 8.38220560501317447e-154, 0.499806404113769531, INEXACT)); +assert(test_sqrt(8.43869776919497201e-307, 9.18623849526832761e-154, -0.499906569719314575, INEXACT)); +assert(test_sqrt(1.16077925158367949e-306, 1.07739465915869443e-153, -0.499976843595504761, INEXACT)); +assert(test_sqrt(1.28274138274231934e-306, 1.13258173336069622e-153, -0.499951303005218506, INEXACT)); +assert(test_sqrt(1.71166045960874567e-306, 1.30830442161170782e-153, -0.499863952398300171, INEXACT)); +assert(test_sqrt(2.03817325168699409e-306, 1.42764605266396281e-153, 0.499840378761291504, INEXACT)); +assert(test_sqrt(2.17157206085693087e-306, 1.47362548188368786e-153, 0.499929040670394897, INEXACT)); +assert(test_sqrt(2.46813996318040945e-306, 1.57103149655899957e-153, 0.499890446662902832, INEXACT)); +assert(test_sqrt(2.51755339642005881e-306, 1.58667999181311239e-153, -0.499770104885101318, INEXACT)); +assert(test_sqrt(2.64615054688296253e-306, 1.62669927979419815e-153, 0.499867290258407593, INEXACT)); +assert(test_sqrt(3.81670763677204135e-306, 1.95363958722483965e-153, 0.499834716320037842, INEXACT)); +assert(test_sqrt(4.57432207785627658e-306, 2.13876648511619359e-153, 0.499859392642974854, INEXACT)); + +// Mathf.sqrt ////////////////////////////////////////////////////////////////////////////////////// + +function test_sqrtf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.sqrt(value), expected, error, flags); +} + +// sanity +assert(test_sqrtf(-8.066848755, NaN, 0.0, INVALID)); +assert(test_sqrtf(4.345239639, 2.084523916, 0.3200402558, INEXACT)); +assert(test_sqrtf(-8.381433487, NaN, 0.0, INVALID)); +assert(test_sqrtf(-6.531673431, NaN, 0.0, INVALID)); +assert(test_sqrtf(9.267057419, 3.044184208, 0.05022354797, INEXACT)); +assert(test_sqrtf(0.6619858742, 0.8136251569, 0.2240506113, INEXACT)); +assert(test_sqrtf(-0.4066039324, NaN, 0.0, INVALID)); +assert(test_sqrtf(0.5617597699, 0.7495063543, 0.05895441771, INEXACT)); +assert(test_sqrtf(0.7741522789, 0.8798592091, -0.4874873757, INEXACT)); +assert(test_sqrtf(-0.6787636876, NaN, 0.0, INVALID)); + +// special +assert(test_sqrtf(NaN, NaN, 0.0, 0)); +assert(test_sqrtf(Infinity, Infinity, 0.0, 0)); +assert(test_sqrtf(-Infinity, NaN, 0.0, INVALID)); +assert(test_sqrtf(0.0, 0.0, 0.0, 0)); +assert(test_sqrtf(-0.0, -0.0, 0.0, 0)); +assert(test_sqrtf(1.0, 1.0, 0.0, 0)); +assert(test_sqrtf(-1.0, NaN, 0.0, INVALID)); +assert(test_sqrtf(4.0, 2.0, 0.0, 0)); +assert(test_sqrtf(2.802596929e-45, 5.293955920e-23, 0.0, 0)); +assert(test_sqrtf(4.203895393e-45, 6.483745599e-23, 0.3738855422, INEXACT)); +assert(test_sqrtf(1.401298464e-45, 3.743392067e-23, -0.2030314505, INEXACT)); +assert(test_sqrtf(-1.401298464e-45, NaN, 0.0, INVALID)); +assert(test_sqrtf(3.402823466e+38, 1.844674297e+19, -0.5, INEXACT)); +assert(test_sqrtf(-3.402823466e+38, NaN, 0.0, INVALID)); +assert(test_sqrtf(0.9999998808, 0.9999999404, 2.980232594e-8, INEXACT)); +assert(test_sqrtf(0.9999999404, 0.9999999404, -0.5, INEXACT)); +assert(test_sqrtf(1.999999762, 1.414213419, -0.4959246516, INEXACT)); +assert(test_sqrtf(1.999999881, 1.414213538, 0.1505219489, INEXACT)); +assert(test_sqrtf(1.000000119, 1.0, -0.5, INEXACT)); +assert(test_sqrtf(1.000000238, 1.000000119, 5.960463767e-8, INEXACT)); +assert(test_sqrtf(2.000000238, 1.414213657, 0.08986179531, INEXACT)); +assert(test_sqrtf(2.000000477, 1.414213777, 0.3827550709, INEXACT)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.tan +//////////////////////////////////////////////////////////////////////////////////////////////////// +/* TODO +function test_tan(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.tan(value), expected, error, flags) && + (!js || check( JSMath.tan(value), expected, error, flags)); +} + +// sanity +assert(test_tan(-8.06684839057968084, 4.62660354240163318, -0.272760331630706787, INEXACT)); +assert(test_tan(4.34523984933830487, 2.60019170582220216, 0.265100330114364624, INEXACT)); +assert(test_tan(-8.38143342755524934, 1.71674083287410517, -0.246875196695327759, INEXACT)); +assert(test_tan(-6.53167358191348413, -0.2537322523453725, -0.467970371246337891, INEXACT)); +assert(test_tan(9.26705696697258574, -0.159041957271919582, -0.0670407786965370178, INEXACT)); +assert(test_tan(0.661985898099504477, 0.779291910691043421, -0.0380561351776123047, INEXACT)); +assert(test_tan(-0.40660392238535531, -0.430599528795436559, -0.0924271419644355774, INEXACT)); +assert(test_tan(0.56175974622072411, 0.629403687318739968, -0.321913480758666992, INEXACT)); +assert(test_tan(0.77415229659130369, 0.977757465294964545, -0.196665182709693909, INEXACT)); +assert(test_tan(-0.678763702639402444, -0.806618663020912341, -0.0676656961441040039, INEXACT)); + +// special +assert(test_tan(0.0, 0.0, 0.0, 0)); +assert(test_tan(-0.0, -0.0, 0.0, 0)); +assert(test_tan(Infinity, NaN, 0.0, INVALID)); +assert(test_tan(-Infinity, NaN, 0.0, INVALID)); +assert(test_tan(NaN, NaN, 0.0, 0)); + +// Mathf.tan /////////////////////////////////////////////////////////////////////////////////////// + +function test_tanf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.tan(value), expected, error, flags); +} + +// sanity +assert(test_tanf(-8.066848755, 4.626595497, 0.2455666959, INEXACT)); +assert(test_tanf(4.345239639, 2.600190163, 0.3652407229, INEXACT)); +assert(test_tanf(-8.381433487, 1.716740608, 0.08169349283, INEXACT)); +assert(test_tanf(-6.531673431, -0.2537320852, 0.2318651378, INEXACT)); +assert(test_tanf(9.267057419, -0.1590414941, -0.009332014248, INEXACT)); +assert(test_tanf(0.6619858742, 0.7792918682, -0.06759700924, INEXACT)); +assert(test_tanf(-0.4066039324, -0.4305995405, 0.005771996453, INEXACT)); +assert(test_tanf(0.5617597699, 0.6294037104, -0.1683816314, INEXACT)); +assert(test_tanf(0.7741522789, 0.9777574539, 0.389693886, INEXACT)); +assert(test_tanf(-0.6787636876, -0.8066186309, 0.1229405999, INEXACT)); + +// special +assert(test_tanf(0.0, 0.0, 0.0, 0)); +assert(test_tanf(-0.0, -0.0, 0.0, 0)); +assert(test_tanf(Infinity, NaN, 0.0, INVALID)); +assert(test_tanf(-Infinity, NaN, 0.0, INVALID)); +assert(test_tanf(NaN, NaN, 0.0, 0)); */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.tanh +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_tanh(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.tanh(value), expected, error, flags) && + (!js || check( JSMath.tanh(value), expected, error, flags)); +} + +// sanity +assert(test_tanh(-8.06684839057968084, -0.999999803096031981, 0.0127933314070105553, INEXACT)); +assert(test_tanh(4.34523984933830487, 0.999663697896130743, 0.157350823283195496, INEXACT)); +assert(test_tanh(-8.38143342755524934, -0.999999895043486187, 0.279850661754608154, INEXACT)); +assert(test_tanh(-6.53167358191348413, -0.999995756839242911, -0.442855745553970337, INEXACT)); +assert(test_tanh(9.26705696697258574, 0.999999982144723409, 0.446275502443313599, INEXACT)); +assert(test_tanh(0.661985898099504477, 0.579683501863527462, 0.489204317331314087, INEXACT)); +assert(test_tanh(-0.40660392238535531, -0.385585309990165215, 0.359938710927963257, INEXACT)); +assert(test_tanh(0.56175974622072411, 0.509281924870043867, -0.394365221261978149, INEXACT)); +assert(test_tanh(0.77415229659130369, 0.649337455031855471, -0.489939600229263306, INEXACT)); +assert(test_tanh(-0.678763702639402444, -0.590715084799841028, -0.0145387789234519005, INEXACT)); + +// special +assert(test_tanh(0.0, 0.0, 0.0, 0)); +assert(test_tanh(-0.0, -0.0, 0.0, 0)); +assert(test_tanh(Infinity, 1.0, 0.0, 0)); +assert(test_tanh(-Infinity, -1.0, 0.0, 0)); +assert(test_tanh(NaN, NaN, 0.0, 0)); + +// Mathf.tanh ////////////////////////////////////////////////////////////////////////////////////// + +function test_tanhf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.tanh(value), expected, error, flags); +} + +// sanity +assert(test_tanhf(-8.066848755, -0.9999998212, -0.3034979999, INEXACT)); +assert(test_tanhf(4.345239639, 0.9996637106, 0.2154078335, INEXACT)); +assert(test_tanhf(-8.381433487, -0.9999998808, 0.2391221076, INEXACT)); +assert(test_tanhf(-6.531673431, -0.9999957681, -0.1884459704, INEXACT)); +assert(test_tanhf(9.267057419, 1.0, 0.1497807801, INEXACT)); +assert(test_tanhf(0.6619858742, 0.5796834826, -0.05590476096, INEXACT)); +assert(test_tanhf(-0.4066039324, -0.3855853081, 0.3497871757, INEXACT)); +assert(test_tanhf(0.5617597699, 0.5092819333, -0.152878508, INEXACT)); +assert(test_tanhf(0.7741522789, 0.6493374705, 0.4317026138, INEXACT)); +assert(test_tanhf(-0.6787636876, -0.5907150507, 0.407987386, INEXACT)); + +// special +assert(test_tanhf(0.0, 0.0, 0.0, 0)); +assert(test_tanhf(-0.0, -0.0, 0.0, 0)); +assert(test_tanhf(Infinity, 1.0, 0.0, 0)); +assert(test_tanhf(-Infinity, -1.0, 0.0, 0)); +assert(test_tanhf(NaN, NaN, 0.0, 0)); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Math.trunc +//////////////////////////////////////////////////////////////////////////////////////////////////// + +function test_trunc(value: f64, expected: f64, error: f64, flags: i32): bool { + return check(NativeMath.trunc(value), expected, error, flags) && + (!js || check( JSMath.trunc(value), expected, error, flags)); +} + +// sanity +assert(test_trunc(-8.06684839057968084, -8.0, 0.0, INEXACT)); +assert(test_trunc(4.34523984933830487, 4.0, 0.0, INEXACT)); +assert(test_trunc(-8.38143342755524934, -8.0, 0.0, INEXACT)); +assert(test_trunc(-6.53167358191348413, -6.0, 0.0, INEXACT)); +assert(test_trunc(9.26705696697258574, 9.0, 0.0, INEXACT)); +assert(test_trunc(0.661985898099504477, 0.0, 0.0, INEXACT)); +assert(test_trunc(-0.40660392238535531, -0.0, 0.0, INEXACT)); +assert(test_trunc(0.56175974622072411, 0.0, 0.0, INEXACT)); +assert(test_trunc(0.77415229659130369, 0.0, 0.0, INEXACT)); +assert(test_trunc(-0.678763702639402444, -0.0, 0.0, INEXACT)); + +// special +assert(test_trunc(NaN, NaN, 0.0, 0)); +assert(test_trunc(Infinity, Infinity, 0.0, 0)); +assert(test_trunc(-Infinity, -Infinity, 0.0, 0)); +assert(test_trunc(0.0, 0.0, 0.0, 0)); +assert(test_trunc(-0.0, -0.0, 0.0, 0)); +assert(test_trunc(1.0, 1.0, 0.0, 0)); +assert(test_trunc(-1.0, -1.0, 0.0, 0)); +assert(test_trunc(0.5, 0.0, 0.0, INEXACT)); +assert(test_trunc(-0.5, -0.0, 0.0, INEXACT)); +assert(test_trunc(1.0000152587890625, 1.0, 0.0, INEXACT)); +assert(test_trunc(-1.0000152587890625, -1.0, 0.0, INEXACT)); +assert(test_trunc(0.99999237060546875, 0.0, 0.0, INEXACT)); +assert(test_trunc(-0.99999237060546875, -0.0, 0.0, INEXACT)); +assert(test_trunc(7.88860905221011805e-31, 0.0, 0.0, INEXACT)); +assert(test_trunc(-7.88860905221011805e-31, -0.0, 0.0, INEXACT)); + +// Mathf.trunc ///////////////////////////////////////////////////////////////////////////////////// + +function test_truncf(value: f32, expected: f32, error: f32, flags: i32): bool { + return check(NativeMathf.trunc(value), expected, error, flags); +} + +// sanity +assert(test_truncf(-8.066848755, -8.0, 0.0, INEXACT)); +assert(test_truncf(4.345239639, 4.0, 0.0, INEXACT)); +assert(test_truncf(-8.381433487, -8.0, 0.0, INEXACT)); +assert(test_truncf(-6.531673431, -6.0, 0.0, INEXACT)); +assert(test_truncf(9.267057419, 9.0, 0.0, INEXACT)); +assert(test_truncf(0.6619858742, 0.0, 0.0, INEXACT)); +assert(test_truncf(-0.4066039324, -0.0, 0.0, INEXACT)); +assert(test_truncf(0.5617597699, 0.0, 0.0, INEXACT)); +assert(test_truncf(0.7741522789, 0.0, 0.0, INEXACT)); +assert(test_truncf(-0.6787636876, -0.0, 0.0, INEXACT)); + +// special +assert(test_truncf(NaN, NaN, 0.0, 0)); +assert(test_truncf(Infinity, Infinity, 0.0, 0)); +assert(test_truncf(-Infinity, -Infinity, 0.0, 0)); +assert(test_truncf(0.0, 0.0, 0.0, 0)); +assert(test_truncf(-0.0, -0.0, 0.0, 0)); +assert(test_truncf(1.0, 1.0, 0.0, 0)); +assert(test_truncf(-1.0, -1.0, 0.0, 0)); +assert(test_truncf(0.5, 0.0, 0.0, INEXACT)); +assert(test_truncf(-0.5, -0.0, 0.0, INEXACT)); +assert(test_truncf(1.000015259, 1.0, 0.0, INEXACT)); +assert(test_truncf(-1.000015259, -1.0, 0.0, INEXACT)); +assert(test_truncf(0.9999923706, 0.0, 0.0, INEXACT)); +assert(test_truncf(-0.9999923706, -0.0, 0.0, INEXACT)); +assert(test_truncf(7.888609052e-31, 0.0, 0.0, INEXACT)); +assert(test_truncf(-7.888609052e-31, -0.0, 0.0, INEXACT)); diff --git a/tests/compiler/std/math.untouched.wat b/tests/compiler/std/math.untouched.wat index fecace83..f13a59da 100644 --- a/tests/compiler/std/math.untouched.wat +++ b/tests/compiler/std/math.untouched.wat @@ -1,42 +1,10401 @@ (module - (type $iiiiv (func (param i32 i32 i32 i32))) (type $i (func (result i32))) - (type $FFFFiv (func (param f64 f64 f64 f64 i32))) - (type $FFF (func (param f64 f64) (result f64))) - (type $FFFiv (func (param f64 f64 f64 i32))) - (type $ffffiv (func (param f32 f32 f32 f32 i32))) - (type $fff (func (param f32 f32) (result f32))) - (type $fffiv (func (param f32 f32 f32 i32))) - (type $FF (func (param f64) (result f64))) (type $F (func (result f64))) - (type $ff (func (param f32) (result f32))) + (type $iiiiv (func (param i32 i32 i32 i32))) (type $f (func (result f32))) + (type $FFFii (func (param f64 f64 f64 i32) (result i32))) + (type $FFFF (func (param f64 f64 f64) (result f64))) + (type $Fi (func (param f64) (result i32))) (type $FiF (func (param f64 i32) (result f64))) + (type $Fv (func (param f64))) + (type $fffii (func (param f32 f32 f32 i32) (result i32))) + (type $ffff (func (param f32 f32 f32) (result f32))) + (type $fi (func (param f32) (result i32))) (type $fif (func (param f32 i32) (result f32))) + (type $FiFFii (func (param f64 i32 f64 f64 i32) (result i32))) + (type $fiffii (func (param f32 i32 f32 f32 i32) (result i32))) + (type $FF (func (param f64) (result f64))) + (type $ff (func (param f32) (result f32))) + (type $FFFFii (func (param f64 f64 f64 f64 i32) (result i32))) + (type $FFF (func (param f64 f64) (result f64))) + (type $ffffii (func (param f32 f32 f32 f32 i32) (result i32))) + (type $fff (func (param f32 f32) (result f32))) (type $Iv (func (param i64))) (type $II (func (param i64) (result i64))) - (type $I (func (result i64))) (type $v (func)) (import "env" "abort" (func $abort (param i32 i32 i32 i32))) - (import "JSMath" "log" (func $(lib)/math/JSMath.log (param f64) (result f64))) - (import "JSMath" "exp" (func $(lib)/math/JSMath.exp (param f64) (result f64))) + (import "JSMath" "E" (global $(lib)/math/JSMath.E f64)) + (import "env" "logf" (func $std/math/logf (param f64))) + (import "JSMath" "LN2" (global $(lib)/math/JSMath.LN2 f64)) + (import "JSMath" "LN10" (global $(lib)/math/JSMath.LN10 f64)) + (import "JSMath" "LOG2E" (global $(lib)/math/JSMath.LOG2E f64)) + (import "JSMath" "PI" (global $(lib)/math/JSMath.PI f64)) + (import "JSMath" "SQRT1_2" (global $(lib)/math/JSMath.SQRT1_2 f64)) + (import "JSMath" "SQRT2" (global $(lib)/math/JSMath.SQRT2 f64)) + (import "JSMath" "abs" (func $(lib)/math/JSMath.abs (param f64) (result f64))) + (import "JSMath" "acos" (func $(lib)/math/JSMath.acos (param f64) (result f64))) + (import "JSMath" "acosh" (func $(lib)/math/JSMath.acosh (param f64) (result f64))) + (import "JSMath" "asin" (func $(lib)/math/JSMath.asin (param f64) (result f64))) + (import "JSMath" "asinh" (func $(lib)/math/JSMath.asinh (param f64) (result f64))) + (import "JSMath" "atan" (func $(lib)/math/JSMath.atan (param f64) (result f64))) + (import "JSMath" "atanh" (func $(lib)/math/JSMath.atanh (param f64) (result f64))) + (import "JSMath" "atan2" (func $(lib)/math/JSMath.atan2 (param f64 f64) (result f64))) (import "JSMath" "cbrt" (func $(lib)/math/JSMath.cbrt (param f64) (result f64))) + (import "JSMath" "ceil" (func $(lib)/math/JSMath.ceil (param f64) (result f64))) + (import "JSMath" "cosh" (func $(lib)/math/JSMath.cosh (param f64) (result f64))) + (import "JSMath" "exp" (func $(lib)/math/JSMath.exp (param f64) (result f64))) + (import "JSMath" "expm1" (func $(lib)/math/JSMath.expm1 (param f64) (result f64))) + (import "JSMath" "floor" (func $(lib)/math/JSMath.floor (param f64) (result f64))) + (import "JSMath" "hypot" (func $(lib)/math/JSMath.hypot (param f64 f64) (result f64))) + (import "JSMath" "log" (func $(lib)/math/JSMath.log (param f64) (result f64))) + (import "JSMath" "log10" (func $(lib)/math/JSMath.log10 (param f64) (result f64))) + (import "JSMath" "log1p" (func $(lib)/math/JSMath.log1p (param f64) (result f64))) + (import "JSMath" "log2" (func $(lib)/math/JSMath.log2 (param f64) (result f64))) + (import "JSMath" "max" (func $(lib)/math/JSMath.max (param f64 f64) (result f64))) + (import "JSMath" "min" (func $(lib)/math/JSMath.min (param f64 f64) (result f64))) + (import "JSOp" "mod" (func $std/math/JSOp.mod (param f64 f64) (result f64))) + (import "JSMath" "pow" (func $(lib)/math/JSMath.pow (param f64 f64) (result f64))) (import "JSMath" "random" (func $(lib)/math/JSMath.random (result f64))) + (import "JSMath" "sign" (func $(lib)/math/JSMath.sign (param f64) (result f64))) + (import "JSMath" "sinh" (func $(lib)/math/JSMath.sinh (param f64) (result f64))) + (import "JSMath" "sqrt" (func $(lib)/math/JSMath.sqrt (param f64) (result f64))) + (import "JSMath" "tanh" (func $(lib)/math/JSMath.tanh (param f64) (result f64))) + (import "JSMath" "trunc" (func $(lib)/math/JSMath.trunc (param f64) (result f64))) + (global $std/math/js i32 (i32.const 1)) (global $std/math/INEXACT i32 (i32.const 1)) (global $std/math/INVALID i32 (i32.const 2)) (global $std/math/DIVBYZERO i32 (i32.const 4)) (global $std/math/UNDERFLOW i32 (i32.const 8)) (global $std/math/OVERFLOW i32 (i32.const 16)) - (global "$(lib)/math/NativeMath.random_seeded" (mut i32) (i32.const 0)) - (global "$(lib)/math/NativeMath.random_state0" (mut i64) (i64.const 0)) - (global "$(lib)/math/NativeMath.random_state1" (mut i64) (i64.const 0)) + (global "$(lib)/math/random_seeded" (mut i32) (i32.const 0)) + (global "$(lib)/math/random_state0" (mut i64) (i64.const 0)) + (global "$(lib)/math/random_state1" (mut i64) (i64.const 0)) (global $HEAP_BASE i32 (i32.const 64)) (memory $0 1) (data (i32.const 4) "\0b\00\00\00s\00t\00d\00/\00m\00a\00t\00h\00.\00t\00s\00") (data (i32.const 32) "\0d\00\00\00(\00l\00i\00b\00)\00/\00m\00a\00t\00h\00.\00t\00s\00") (export "memory" (memory $0)) (start $start) - (func $fmod (; 5 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func $std/math/signbit (; 31 ;) (type $Fi) (param $0 f64) (result i32) + (return + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 63) + ) + ) + ) + ) + (func $std/math/eulp (; 32 ;) (type $Fi) (param $0 f64) (result i32) + (local $1 i64) + (local $2 i32) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.eqz + (get_local $2) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + ) + (return + (i32.sub + (i32.sub + (get_local $2) + (i32.const 1023) + ) + (i32.const 52) + ) + ) + ) + (func "$(lib)/math/NativeMath.scalbn" (; 33 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) + (local $2 f64) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 1023) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 1023) + ) + (set_local $1 + (i32.const 1023) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (block + (set_local $2 + (f64.mul + (get_local $2) + (f64.const 2.2250738585072014e-308) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 1022) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -1022) + ) + (set_local $1 + (i32.const -1022) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.reinterpret/i64 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $1) + ) + ) + (i64.const 52) + ) + ) + ) + ) + ) + (func $std/math/ulperr (; 34 ;) (type $FFFF) (param $0 f64) (param $1 f64) (param $2 f64) (result f64) + (local $3 f64) + (local $4 i32) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $4 + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + ) + (f64.ne + (tee_local $3 + (get_local $1) + ) + (get_local $3) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + (if + (f64.eq + (get_local $0) + (get_local $1) + ) + (block + (if + (i32.eq + (call $std/math/signbit + (get_local $0) + ) + (call $std/math/signbit + (get_local $1) + ) + ) + (return + (get_local $2) + ) + ) + (return + (f64.const inf) + ) + ) + ) + (if + (i32.eqz + (select + (f64.ne + (f64.abs + (tee_local $3 + (get_local $0) + ) + ) + (f64.const inf) + ) + (i32.const 0) + (f64.eq + (get_local $3) + (get_local $3) + ) + ) + ) + (block + (set_local $0 + (f64.copysign + (f64.const 8988465674311579538646525e283) + (get_local $0) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 0.5) + ) + ) + ) + ) + (return + (f64.add + (call "$(lib)/math/NativeMath.scalbn" + (f64.sub + (get_local $0) + (get_local $1) + ) + (i32.sub + (i32.const 0) + (call $std/math/eulp + (get_local $1) + ) + ) + ) + (get_local $2) + ) + ) + ) + (func $std/math/check (; 35 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 f64) + (local $5 f64) + (if + (f64.eq + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (if + (f64.ne + (tee_local $4 + (get_local $1) + ) + (get_local $4) + ) + (return + (f64.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + ) + ) + (nop) + (set_local $5 + (call $std/math/ulperr + (get_local $0) + (get_local $1) + (get_local $2) + ) + ) + (if + (f64.ge + (f64.abs + (get_local $5) + ) + (f64.const 1.5) + ) + (block + (call $std/math/logf + (f64.abs + (get_local $5) + ) + ) + (return + (i32.const 0) + ) + ) + ) + (return + (i32.const 1) + ) + ) + (func $std/math/signbitf (; 36 ;) (type $fi) (param $0 f32) (result i32) + (return + (i32.shr_u + (i32.reinterpret/f32 + (get_local $0) + ) + (i32.const 31) + ) + ) + ) + (func $std/math/eulpf (; 37 ;) (type $fi) (param $0 f32) (result i32) + (local $1 i32) + (local $2 i32) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (if + (i32.eqz + (get_local $2) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.const 1) + ) + ) + ) + (return + (i32.sub + (i32.sub + (get_local $2) + (i32.const 127) + ) + (i32.const 23) + ) + ) + ) + (func "$(lib)/math/NativeMathf.scalbn" (; 38 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) + (local $2 f32) + (nop) + (set_local $2 + (get_local $0) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $1 + (i32.sub + (get_local $1) + (i32.const 127) + ) + ) + (if + (i32.gt_s + (get_local $1) + (i32.const 127) + ) + (set_local $1 + (i32.const 127) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (block + (set_local $2 + (f32.mul + (get_local $2) + (f32.const 1.1754943508222875e-38) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.const 126) + ) + ) + (if + (i32.lt_s + (get_local $1) + (i32.const -126) + ) + (set_local $1 + (i32.const -126) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.reinterpret/i32 + (i32.shl + (i32.add + (i32.const 127) + (get_local $1) + ) + (i32.const 23) + ) + ) + ) + ) + ) + (func $std/math/ulperrf (; 39 ;) (type $ffff) (param $0 f32) (param $1 f32) (param $2 f32) (result f32) + (local $3 f32) + (local $4 i32) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $4 + (f32.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + ) + (f32.ne + (tee_local $3 + (get_local $1) + ) + (get_local $3) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f32.const 0) + ) + ) + (if + (f32.eq + (get_local $0) + (get_local $1) + ) + (block + (if + (i32.eq + (call $std/math/signbitf + (get_local $0) + ) + (call $std/math/signbitf + (get_local $1) + ) + ) + (return + (get_local $2) + ) + ) + (return + (f32.const inf) + ) + ) + ) + (if + (i32.eqz + (select + (f32.ne + (f32.abs + (tee_local $3 + (get_local $0) + ) + ) + (f32.const inf) + ) + (i32.const 0) + (f32.eq + (get_local $3) + (get_local $3) + ) + ) + ) + (block + (set_local $0 + (f32.copysign + (f32.const 1701411834604692317316873e14) + (get_local $0) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 0.5) + ) + ) + ) + ) + (return + (f32.add + (call "$(lib)/math/NativeMathf.scalbn" + (f32.sub + (get_local $0) + (get_local $1) + ) + (i32.sub + (i32.const 0) + (call $std/math/eulpf + (get_local $1) + ) + ) + ) + (get_local $2) + ) + ) + ) + (func $std/math/check (; 40 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (local $4 f32) + (local $5 f32) + (if + (f32.eq + (get_local $0) + (get_local $1) + ) + (return + (i32.const 1) + ) + ) + (if + (f32.ne + (tee_local $4 + (get_local $1) + ) + (get_local $4) + ) + (return + (f32.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + ) + ) + (nop) + (set_local $5 + (call $std/math/ulperrf + (get_local $0) + (get_local $1) + (get_local $2) + ) + ) + (if + (f32.ge + (f32.abs + (get_local $5) + ) + (f32.const 1.5) + ) + (block + (call $std/math/logf + (f64.promote/f32 + (f32.abs + (get_local $5) + ) + ) + ) + (return + (i32.const 0) + ) + ) + ) + (return + (i32.const 1) + ) + ) + (func $std/math/test_scalbn (; 41 ;) (type $FiFFii) (param $0 f64) (param $1 i32) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMath.scalbn" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func $std/math/test_scalbnf (; 42 ;) (type $fiffii) (param $0 f32) (param $1 i32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMath.abs" (; 43 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.abs + (get_local $0) + ) + ) + ) + (func $std/math/test_abs (; 44 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.abs" (; 45 ;) (type $ff) (param $0 f32) (result f32) + (return + (f32.abs + (get_local $0) + ) + ) + ) + (func $std/math/test_absf (; 46 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.abs" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.__R" (; 47 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (local $2 f64) + (nop) + (set_local $1 + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.16666666666666666) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.3255658186224009) + (f64.mul + (get_local $0) + (f64.add + (f64.const 0.20121253213486293) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.04005553450067941) + (f64.mul + (get_local $0) + (f64.add + (f64.const 7.915349942898145e-04) + (f64.mul + (get_local $0) + (f64.const 3.479331075960212e-05) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f64.add + (f64.const 1) + (f64.mul + (get_local $0) + (f64.add + (f64.const -2.403394911734414) + (f64.mul + (get_local $0) + (f64.add + (f64.const 2.0209457602335057) + (f64.mul + (get_local $0) + (f64.add + (f64.const -0.6882839716054533) + (f64.mul + (get_local $0) + (f64.const 0.07703815055590194) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.div + (get_local $1) + (get_local $2) + ) + ) + ) + (func "$(lib)/math/NativeMath.acos" (; 48 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072693248) + ) + (block + (set_local $3 + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (get_local $3) + ) + (i32.const 0) + ) + (block + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.add + (f64.mul + (f64.const 2) + (f64.const 1.5707963267948966) + ) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 1012924416) + ) + (return + (f64.add + (f64.const 1.5707963267948966) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (get_local $0) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (nop) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (block + (set_local $6 + (f64.mul + (f64.add + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + (set_local $4 + (f64.sqrt + (get_local $6) + ) + ) + (set_local $5 + (f64.sub + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $6) + ) + (get_local $4) + ) + (f64.const 6.123233995736766e-17) + ) + ) + (return + (f64.mul + (f64.const 2) + (f64.sub + (f64.const 1.5707963267948966) + (f64.add + (get_local $4) + (get_local $5) + ) + ) + ) + ) + ) + ) + (set_local $6 + (f64.mul + (f64.sub + (f64.const 1) + (get_local $0) + ) + (f64.const 0.5) + ) + ) + (set_local $4 + (f64.sqrt + (get_local $6) + ) + ) + (set_local $7 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $4) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $8 + (f64.div + (f64.sub + (get_local $6) + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (f64.add + (get_local $4) + (get_local $7) + ) + ) + ) + (set_local $5 + (f64.add + (f64.mul + (call "$(lib)/math/NativeMath.__R" + (get_local $6) + ) + (get_local $4) + ) + (get_local $8) + ) + ) + (return + (f64.mul + (f64.const 2) + (f64.add + (get_local $7) + (get_local $5) + ) + ) + ) + ) + (func $std/math/test_acos (; 49 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.__R" (; 50 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (local $2 f32) + (nop) + (set_local $1 + (f32.mul + (get_local $0) + (f32.add + (f32.const 0.16666586697101593) + (f32.mul + (get_local $0) + (f32.add + (f32.const -0.04274342209100723) + (f32.mul + (get_local $0) + (f32.const -0.008656363002955914) + ) + ) + ) + ) + ) + ) + (set_local $2 + (f32.add + (f32.const 1) + (f32.mul + (get_local $0) + (f32.const -0.7066296339035034) + ) + ) + ) + (return + (f32.div + (get_local $1) + (get_local $2) + ) + ) + ) + (func "$(lib)/math/NativeMathf.acos" (; 51 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1065353216) + ) + (block + (if + (i32.eq + (get_local $2) + (i32.const 1065353216) + ) + (block + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.add + (f32.mul + (f32.const 2) + (f32.const 1.570796251296997) + ) + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (f32.const 0) + ) + ) + ) + (return + (f32.div + (f32.const 0) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1056964608) + ) + (block + (if + (i32.le_u + (get_local $2) + (i32.const 847249408) + ) + (return + (f32.add + (f32.const 1.570796251296997) + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (f32.sub + (f32.const 1.570796251296997) + (f32.sub + (get_local $0) + (f32.sub + (f32.const 7.549789415861596e-08) + (f32.mul + (get_local $0) + (call "$(lib)/math/NativeMathf.__R" + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (nop) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (block + (set_local $3 + (f32.mul + (f32.add + (f32.const 1) + (get_local $0) + ) + (f32.const 0.5) + ) + ) + (set_local $5 + (f32.sqrt + (get_local $3) + ) + ) + (set_local $4 + (f32.sub + (f32.mul + (call "$(lib)/math/NativeMathf.__R" + (get_local $3) + ) + (get_local $5) + ) + (f32.const 7.549789415861596e-08) + ) + ) + (return + (f32.mul + (f32.const 2) + (f32.sub + (f32.const 1.570796251296997) + (f32.add + (get_local $5) + (get_local $4) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f32.mul + (f32.sub + (f32.const 1) + (get_local $0) + ) + (f32.const 0.5) + ) + ) + (set_local $5 + (f32.sqrt + (get_local $3) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (get_local $5) + ) + ) + (set_local $6 + (f32.reinterpret/i32 + (i32.and + (get_local $1) + (i32.const -4096) + ) + ) + ) + (set_local $7 + (f32.div + (f32.sub + (get_local $3) + (f32.mul + (get_local $6) + (get_local $6) + ) + ) + (f32.add + (get_local $5) + (get_local $6) + ) + ) + ) + (set_local $4 + (f32.add + (f32.mul + (call "$(lib)/math/NativeMathf.__R" + (get_local $3) + ) + (get_local $5) + ) + (get_local $7) + ) + ) + (return + (f32.mul + (f32.const 2) + (f32.add + (get_local $6) + (get_local $4) + ) + ) + ) + ) + (func $std/math/test_acosf (; 52 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.acos" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.log1p" (; 53 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 1) + ) + (block + (set_local $4 + (f64.const 0) + ) + (set_local $5 + (f64.const 0) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $6 + (i32.lt_u + (get_local $2) + (i32.const 1071284858) + ) + ) + (get_local $6) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $2) + (i32.const -1074790400) + ) + (block + (if + (f64.eq + (get_local $0) + (f64.const -1) + ) + (return + (f64.div + (get_local $0) + (f64.const 0) + ) + ) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (i32.const 1017118720) + (i32.const 1) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $2) + (i32.const -1076707644) + ) + (block + (set_local $3 + (i32.const 0) + ) + (set_local $4 + (f64.const 0) + ) + (set_local $5 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $3) + (block + (set_local $1 + (i64.reinterpret/f64 + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.add + (get_local $6) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.sub + (i32.shr_u + (get_local $6) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 54) + ) + (block + (set_local $7 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (if (result f64) + (i32.ge_s + (get_local $3) + (i32.const 2) + ) + (f64.sub + (f64.const 1) + (f64.sub + (get_local $7) + (get_local $0) + ) + ) + (f64.sub + (get_local $0) + (f64.sub + (get_local $7) + (f64.const 1) + ) + ) + ) + ) + (set_local $4 + (f64.div + (get_local $4) + (get_local $7) + ) + ) + ) + (set_local $4 + (f64.const 0) + ) + ) + (set_local $6 + (i32.add + (i32.and + (get_local $6) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $5 + (f64.sub + (f64.reinterpret/i64 + (get_local $1) + ) + (f64.const 1) + ) + ) + ) + ) + (set_local $8 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $9 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (get_local $9) + ) + ) + (set_local $11 + (f64.mul + (get_local $10) + (get_local $10) + ) + ) + (set_local $12 + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $11) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $13 + (f64.mul + (get_local $10) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $11) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $11) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $14 + (f64.add + (get_local $13) + (get_local $12) + ) + ) + (set_local $15 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (return + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $9) + (f64.add + (get_local $8) + (get_local $14) + ) + ) + (f64.add + (f64.mul + (get_local $15) + (f64.const 1.9082149292705877e-10) + ) + (get_local $4) + ) + ) + (get_local $8) + ) + (get_local $5) + ) + (f64.mul + (get_local $15) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.log" (; 54 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 i32) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_s + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (get_local $3) + ) + (return + (f64.add + (f64.add + (f64.sub + (f64.add + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $13) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (get_local $6) + ) + (get_local $5) + ) + (f64.mul + (f64.convert_s/i32 + (get_local $13) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + ) + (func "$(lib)/math/NativeMath.acosh" (; 55 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (nop) + (set_local $1 + (i64.and + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.add + (i64.const 1023) + (i64.const 1) + ) + ) + (return + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sqrt + (f64.add + (f64.mul + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i64.lt_u + (get_local $1) + (i64.add + (i64.const 1023) + (i64.const 26) + ) + ) + (return + (call "$(lib)/math/NativeMath.log" + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (get_local $0) + (f64.sqrt + (f64.sub + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + ) + (func $std/math/test_acosh (; 56 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.log1p" (; 57 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 f32) + (local $3 f32) + (local $4 i32) + (local $5 i32) + (local $6 f32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (block + (set_local $2 + (f32.const 0) + ) + (set_local $3 + (f32.const 0) + ) + ) + (set_local $4 + (i32.const 1) + ) + (if + (i32.and + (if (result i32) + (tee_local $5 + (i32.lt_u + (get_local $1) + (i32.const 1054086096) + ) + ) + (get_local $5) + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.ge_u + (get_local $1) + (i32.const -1082130432) + ) + (block + (if + (f32.eq + (get_local $0) + (f32.const -1) + ) + (return + (f32.div + (get_local $0) + (f32.const 0) + ) + ) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + ) + (if + (i32.lt_u + (i32.shl + (get_local $1) + (i32.const 1) + ) + (i32.shl + (i32.const 864026624) + (i32.const 1) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.le_u + (get_local $1) + (i32.const -1097468391) + ) + (block + (set_local $4 + (i32.const 0) + ) + (set_local $2 + (f32.const 0) + ) + (set_local $3 + (get_local $0) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + ) + ) + (if + (get_local $4) + (block + (set_local $6 + (f32.add + (f32.const 1) + (get_local $0) + ) + ) + (set_local $5 + (i32.reinterpret/f32 + (get_local $6) + ) + ) + (set_local $5 + (i32.add + (get_local $5) + (i32.sub + (i32.const 1065353216) + (i32.const 1060439283) + ) + ) + ) + (set_local $4 + (i32.sub + (i32.shr_u + (get_local $5) + (i32.const 23) + ) + (i32.const 127) + ) + ) + (if + (i32.lt_s + (get_local $4) + (i32.const 25) + ) + (block + (set_local $2 + (if (result f32) + (i32.ge_s + (get_local $4) + (i32.const 2) + ) + (f32.sub + (f32.const 1) + (f32.sub + (get_local $6) + (get_local $0) + ) + ) + (f32.sub + (get_local $0) + (f32.sub + (get_local $6) + (f32.const 1) + ) + ) + ) + ) + (set_local $2 + (f32.div + (get_local $2) + (get_local $6) + ) + ) + ) + (set_local $2 + (f32.const 0) + ) + ) + (set_local $5 + (i32.add + (i32.and + (get_local $5) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (set_local $3 + (f32.sub + (f32.reinterpret/i32 + (get_local $5) + ) + (f32.const 1) + ) + ) + ) + ) + (set_local $7 + (f32.div + (get_local $3) + (f32.add + (f32.const 2) + (get_local $3) + ) + ) + ) + (set_local $8 + (f32.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f32.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f32.mul + (get_local $9) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $9) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + (set_local $11 + (f32.mul + (get_local $8) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $9) + (f32.const 0.2849878668785095) + ) + ) + ) + ) + (set_local $12 + (f32.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $3) + ) + (get_local $3) + ) + ) + (set_local $14 + (f32.convert_s/i32 + (get_local $4) + ) + ) + (return + (f32.add + (f32.add + (f32.sub + (f32.add + (f32.mul + (get_local $7) + (f32.add + (get_local $13) + (get_local $12) + ) + ) + (f32.add + (f32.mul + (get_local $14) + (f32.const 9.05800061445916e-06) + ) + (get_local $2) + ) + ) + (get_local $13) + ) + (get_local $3) + ) + (f32.mul + (get_local $14) + (f32.const 0.6931381225585938) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.log" (; 58 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $1) + (i32.const 8388608) + ) + ) + (get_local $3) + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $1) + (i32.const 1) + ) + (i32.const 0) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.const 1060439283) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_s + (get_local $1) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $1 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (set_local $4 + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + (set_local $5 + (f32.div + (get_local $4) + (f32.add + (f32.const 2) + (get_local $4) + ) + ) + ) + (set_local $6 + (f32.mul + (get_local $5) + (get_local $5) + ) + ) + (set_local $7 + (f32.mul + (get_local $6) + (get_local $6) + ) + ) + (set_local $8 + (f32.mul + (get_local $7) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $7) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + (set_local $9 + (f32.mul + (get_local $6) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $7) + (f32.const 0.2849878668785095) + ) + ) + ) + ) + (set_local $10 + (f32.add + (get_local $9) + (get_local $8) + ) + ) + (set_local $11 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $4) + ) + (get_local $4) + ) + ) + (set_local $12 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (return + (f32.add + (f32.add + (f32.sub + (f32.add + (f32.mul + (get_local $5) + (f32.add + (get_local $11) + (get_local $10) + ) + ) + (f32.mul + (get_local $12) + (f32.const 9.05800061445916e-06) + ) + ) + (get_local $11) + ) + (get_local $4) + ) + (f32.mul + (get_local $12) + (f32.const 0.6931381225585938) + ) + ) + ) + ) + (func "$(lib)/math/NativeMathf.acosh" (; 59 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.add + (i32.const 1065353216) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (return + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.sqrt + (f32.add + (f32.mul + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + (f32.mul + (f32.const 2) + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.add + (i32.const 1065353216) + (i32.shl + (i32.const 12) + (i32.const 23) + ) + ) + ) + (return + (call "$(lib)/math/NativeMathf.log" + (f32.sub + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.div + (f32.const 1) + (f32.add + (get_local $0) + (f32.sqrt + (f32.sub + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.add + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (f32.const 0.6931471824645996) + ) + ) + ) + (func $std/math/test_acoshf (; 60 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.acosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.asin" (; 61 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072693248) + ) + (block + (set_local $3 + (i32.wrap/i64 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $2) + (i32.const 1072693248) + ) + (get_local $3) + ) + (i32.const 0) + ) + (return + (f64.add + (f64.mul + (get_local $0) + (f64.const 1.5707963267948966) + ) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + ) + (return + (f64.div + (f64.const 0) + (f64.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1071644672) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $2) + (i32.const 1045430272) + ) + ) + (i32.ge_u + (get_local $2) + (i32.const 1048576) + ) + (get_local $3) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f64.add + (get_local $0) + (f64.mul + (get_local $0) + (call "$(lib)/math/NativeMath.__R" + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.sub + (f64.const 1) + (f64.abs + (get_local $0) + ) + ) + (f64.const 0.5) + ) + ) + (set_local $5 + (f64.sqrt + (get_local $4) + ) + ) + (set_local $6 + (call "$(lib)/math/NativeMath.__R" + (get_local $4) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1072640819) + ) + (set_local $0 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.mul + (f64.const 2) + (f64.add + (get_local $5) + (f64.mul + (get_local $5) + (get_local $6) + ) + ) + ) + (f64.const 6.123233995736766e-17) + ) + ) + ) + (block + (set_local $7 + (f64.reinterpret/i64 + (i64.and + (i64.reinterpret/f64 + (get_local $5) + ) + (i64.const -4294967296) + ) + ) + ) + (set_local $8 + (f64.div + (f64.sub + (get_local $4) + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (f64.add + (get_local $5) + (get_local $7) + ) + ) + ) + (set_local $0 + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.const 1.5707963267948966) + ) + (f64.sub + (f64.sub + (f64.mul + (f64.mul + (f64.const 2) + (get_local $5) + ) + (get_local $6) + ) + (f64.sub + (f64.const 6.123233995736766e-17) + (f64.mul + (f64.const 2) + (get_local $8) + ) + ) + ) + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.const 1.5707963267948966) + ) + (f64.mul + (f64.const 2) + (get_local $7) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f64.neg + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + (func $std/math/test_asin (; 62 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.asin" (; 63 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f64) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1065353216) + ) + (block + (if + (i32.eq + (get_local $2) + (i32.const 1065353216) + ) + (return + (f32.add + (f32.mul + (get_local $0) + (f32.const 1.5707963705062866) + ) + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (f32.div + (f32.const 0) + (f32.sub + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1056964608) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $2) + (i32.const 964689920) + ) + ) + (i32.ge_u + (get_local $2) + (i32.const 8388608) + ) + (get_local $3) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (return + (f32.add + (get_local $0) + (f32.mul + (get_local $0) + (call "$(lib)/math/NativeMathf.__R" + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f32.mul + (f32.sub + (f32.const 1) + (f32.abs + (get_local $0) + ) + ) + (f32.const 0.5) + ) + ) + (set_local $5 + (f64.sqrt + (f64.promote/f32 + (get_local $4) + ) + ) + ) + (set_local $0 + (f32.demote/f64 + (f64.sub + (f64.promote/f32 + (f32.const 1.5707963705062866) + ) + (f64.mul + (f64.promote/f32 + (f32.const 2) + ) + (f64.add + (get_local $5) + (f64.mul + (get_local $5) + (f64.promote/f32 + (call "$(lib)/math/NativeMathf.__R" + (get_local $4) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.neg + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + (func $std/math/test_asinf (; 64 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.asin" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.asinh" (; 65 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.add + (i64.const 1023) + (i64.const 26) + ) + ) + (set_local $0 + (f64.add + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (f64.const 0.6931471805599453) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.add + (i64.const 1023) + (i64.const 1) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log" + (f64.add + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.div + (f64.const 1) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 26) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (get_local $0) + (f64.div + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.add + (f64.sqrt + (f64.add + (f64.mul + (get_local $0) + (get_local $0) + ) + (f64.const 1) + ) + ) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f64) + (i64.ne + (get_local $3) + (i64.const 0) + ) + (f64.neg + (get_local $0) + ) + (get_local $0) + ) + ) + ) + (func $std/math/test_asinh (; 66 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.asinh" (; 67 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $3 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (get_local $2) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.add + (i32.const 1065353216) + (i32.shl + (i32.const 12) + (i32.const 23) + ) + ) + ) + (set_local $0 + (f32.add + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (f32.const 0.6931471824645996) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.add + (i32.const 1065353216) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMathf.log" + (f32.add + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.div + (f32.const 1) + (f32.add + (f32.sqrt + (f32.add + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + (get_local $0) + ) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.sub + (i32.const 1065353216) + (i32.shl + (i32.const 12) + (i32.const 23) + ) + ) + ) + (set_local $0 + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (get_local $0) + (f32.div + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.add + (f32.sqrt + (f32.add + (f32.mul + (get_local $0) + (get_local $0) + ) + (f32.const 1) + ) + ) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f32) + (get_local $3) + (f32.neg + (get_local $0) + ) + (get_local $0) + ) + ) + ) + (func $std/math/test_asinhf (; 68 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.asinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.atan" (; 69 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 i32) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 i32) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (nop) + (if + (i32.ge_u + (get_local $1) + (i32.const 1141899264) + ) + (block + (if + (f64.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (f64.add + (f64.const 1.5707963267948966) + (f64.promote/f32 + (f32.const 7.52316384526264e-37) + ) + ) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $1) + (i32.const 1071382528) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 1044381696) + ) + (return + (get_local $0) + ) + ) + (set_local $5 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f64.abs + (get_local $0) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1072889856) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1072037888) + ) + (block + (set_local $5 + (i32.const 0) + ) + (set_local $0 + (f64.div + (f64.sub + (f64.mul + (f64.const 2) + (get_local $0) + ) + (f64.const 1) + ) + (f64.add + (f64.const 2) + (get_local $0) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 1) + ) + (set_local $0 + (f64.div + (f64.sub + (get_local $0) + (f64.const 1) + ) + (f64.add + (get_local $0) + (f64.const 1) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1073971200) + ) + (block + (set_local $5 + (i32.const 2) + ) + (set_local $0 + (f64.div + (f64.sub + (get_local $0) + (f64.const 1.5) + ) + (f64.add + (f64.const 1) + (f64.mul + (f64.const 1.5) + (get_local $0) + ) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 3) + ) + (set_local $0 + (f64.div + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $6 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (set_local $7 + (f64.mul + (get_local $3) + (f64.add + (f64.const 0.3333333333333293) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.14285714272503466) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.09090887133436507) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.06661073137387531) + (f64.mul + (get_local $6) + (f64.add + (f64.const 0.049768779946159324) + (f64.mul + (get_local $6) + (f64.const 0.016285820115365782) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.19999999999876483) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.11111110405462356) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.0769187620504483) + (f64.mul + (get_local $6) + (f64.add + (f64.const -0.058335701337905735) + (f64.mul + (get_local $6) + (f64.const -0.036531572744216916) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $9 + (get_local $5) + ) + (br_if $case0|0 + (i32.eq + (get_local $9) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $9) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $9) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $9) + (i32.const 3) + ) + ) + (br $case4|0) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.4636476090008061) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 2.2698777452961687e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.7853981633974483) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 3.061616997868383e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 0.982793723247329) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 1.3903311031230998e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.const 1.5707963267948966) + (f64.sub + (f64.sub + (f64.mul + (get_local $0) + (f64.add + (get_local $7) + (get_local $8) + ) + ) + (f64.const 6.123233995736766e-17) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (unreachable) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + (func $std/math/test_atan (; 70 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.atan" (; 71 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (local $4 f32) + (local $5 i32) + (local $6 f32) + (local $7 f32) + (local $8 f32) + (local $9 i32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (nop) + (if + (i32.ge_u + (get_local $1) + (i32.const 1283457024) + ) + (block + (if + (f32.ne + (tee_local $4 + (get_local $0) + ) + (get_local $4) + ) + (return + (get_local $0) + ) + ) + (set_local $3 + (f32.add + (f32.const 1.570796251296997) + (f32.const 7.52316384526264e-37) + ) + ) + (return + (if (result f32) + (get_local $2) + (f32.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $1) + (i32.const 1054867456) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.const 964689920) + ) + (return + (get_local $0) + ) + ) + (set_local $5 + (i32.const -1) + ) + ) + (block + (set_local $0 + (f32.abs + (get_local $0) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1066926080) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1060110336) + ) + (block + (set_local $5 + (i32.const 0) + ) + (set_local $0 + (f32.div + (f32.sub + (f32.mul + (f32.const 2) + (get_local $0) + ) + (f32.const 1) + ) + (f32.add + (f32.const 2) + (get_local $0) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 1) + ) + (set_local $0 + (f32.div + (f32.sub + (get_local $0) + (f32.const 1) + ) + (f32.add + (get_local $0) + (f32.const 1) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1075576832) + ) + (block + (set_local $5 + (i32.const 2) + ) + (set_local $0 + (f32.div + (f32.sub + (get_local $0) + (f32.const 1.5) + ) + (f32.add + (f32.const 1) + (f32.mul + (f32.const 1.5) + (get_local $0) + ) + ) + ) + ) + ) + (block + (set_local $5 + (i32.const 3) + ) + (set_local $0 + (f32.div + (f32.const -1) + (get_local $0) + ) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $6 + (f32.mul + (get_local $3) + (get_local $3) + ) + ) + (set_local $7 + (f32.mul + (get_local $3) + (f32.add + (f32.const 0.333333283662796) + (f32.mul + (get_local $6) + (f32.add + (f32.const 0.14253635704517365) + (f32.mul + (get_local $6) + (f32.const 0.06168760731816292) + ) + ) + ) + ) + ) + ) + (set_local $8 + (f32.mul + (get_local $6) + (f32.add + (f32.const -0.19999158382415771) + (f32.mul + (get_local $6) + (f32.const -0.106480173766613) + ) + ) + ) + ) + (if + (i32.lt_s + (get_local $5) + (i32.const 0) + ) + (return + (f32.sub + (get_local $0) + (f32.mul + (get_local $0) + (f32.add + (get_local $7) + (get_local $8) + ) + ) + ) + ) + ) + (block $break|0 + (block $case4|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $9 + (get_local $5) + ) + (br_if $case0|0 + (i32.eq + (get_local $9) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $9) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $9) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $9) + (i32.const 3) + ) + ) + (br $case4|0) + ) + (block + (set_local $3 + (f32.sub + (f32.const 0.46364760398864746) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $7) + (get_local $8) + ) + ) + (f32.const 5.01215824399992e-09) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f32.sub + (f32.const 0.7853981256484985) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $7) + (get_local $8) + ) + ) + (f32.const 3.774894707930798e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f32.sub + (f32.const 0.9827936887741089) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $7) + (get_local $8) + ) + ) + (f32.const 3.447321716976148e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (block + (set_local $3 + (f32.sub + (f32.const 1.570796251296997) + (f32.sub + (f32.sub + (f32.mul + (get_local $0) + (f32.add + (get_local $7) + (get_local $8) + ) + ) + (f32.const 7.549789415861596e-08) + ) + (get_local $0) + ) + ) + ) + (br $break|0) + ) + ) + (unreachable) + ) + (return + (if (result f32) + (get_local $2) + (f32.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + (func $std/math/test_atanf (; 72 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.atan" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.atanh" (; 73 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i64) + (local $3 i64) + (local $4 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + (set_local $3 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $4 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (if + (i64.lt_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 1) + ) + ) + (if + (i64.ge_u + (get_local $2) + (i64.sub + (i64.const 1023) + (i64.const 32) + ) + ) + (set_local $4 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.add + (f64.mul + (f64.const 2) + (get_local $4) + ) + (f64.div + (f64.mul + (f64.mul + (f64.const 2) + (get_local $4) + ) + (get_local $4) + ) + (f64.sub + (f64.const 1) + (get_local $4) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.const 0.5) + (call "$(lib)/math/NativeMath.log1p" + (f64.mul + (f64.const 2) + (f64.div + (get_local $4) + (f64.sub + (f64.const 1) + (get_local $4) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f64) + (i64.ne + (get_local $3) + (i64.const 0) + ) + (f64.neg + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (func $std/math/test_atanh (; 74 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.atanh" (; 75 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.shl + (i32.const 32) + (i32.const 23) + ) + ) + ) + (set_local $3 + (f32.mul + (f32.const 0.5) + (call "$(lib)/math/NativeMathf.log1p" + (f32.add + (f32.mul + (f32.const 2) + (get_local $3) + ) + (f32.div + (f32.mul + (f32.mul + (f32.const 2) + (get_local $3) + ) + (get_local $3) + ) + (f32.sub + (f32.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f32.mul + (f32.const 0.5) + (call "$(lib)/math/NativeMathf.log1p" + (f32.mul + (f32.const 2) + (f32.div + (get_local $3) + (f32.sub + (f32.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + ) + (return + (if (result f32) + (get_local $2) + (f32.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + (func $std/math/test_atanhf (; 76 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.atanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.atan2" (; 77 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 f64) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 f64) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $3 + (f64.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + ) + (get_local $3) + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + (i32.const 1) + ) + (return + (f64.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $4 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 32) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (get_local $4) + ) + ) + (set_local $4 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $4) + (i64.const 32) + ) + ) + ) + (set_local $8 + (i32.wrap/i64 + (get_local $4) + ) + ) + (if + (i32.eq + (i32.or + (i32.sub + (get_local $5) + (i32.const 1072693248) + ) + (get_local $6) + ) + (i32.const 0) + ) + (return + (call "$(lib)/math/NativeMath.atan" + (get_local $0) + ) + ) + ) + (set_local $9 + (i32.or + (i32.and + (i32.shr_u + (get_local $7) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.and + (i32.shr_u + (get_local $5) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $5 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (set_local $7 + (i32.and + (get_local $7) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (i32.or + (get_local $7) + (get_local $8) + ) + (i32.const 0) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $3 + (get_local $9) + ) + (br_if $case0|0 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.neg + (f64.const 3.141592653589793) + ) + ) + ) + ) + (if + (i32.eq + (i32.or + (get_local $5) + (get_local $6) + ) + (i32.const 0) + ) + (return + (if (result f64) + (i32.and + (get_local $9) + (i32.const 1) + ) + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 2) + ) + (f64.div + (f64.const 3.141592653589793) + (f64.const 2) + ) + ) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 2146435072) + ) + (if + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (set_local $3 + (get_local $9) + ) + (br_if $case0|1 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|1 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|1 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|1 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|1) + ) + (return + (f64.div + (f64.const 3.141592653589793) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.mul + (f64.const 3) + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (return + (f64.div + (f64.mul + (f64.const -3) + (f64.const 3.141592653589793) + ) + (f64.const 4) + ) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (set_local $3 + (get_local $9) + ) + (br_if $case0|2 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|2 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|2 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|2 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|2) + ) + (return + (f64.const 0) + ) + ) + (return + (f64.const -0) + ) + ) + (return + (f64.const 3.141592653589793) + ) + ) + (return + (f64.neg + (f64.const 3.141592653589793) + ) + ) + ) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (i32.add + (get_local $5) + (i32.shl + (i32.const 64) + (i32.const 20) + ) + ) + (get_local $7) + ) + ) + (get_local $3) + (i32.eq + (get_local $7) + (i32.const 2146435072) + ) + ) + (i32.const 1) + ) + (return + (if (result f64) + (i32.and + (get_local $9) + (i32.const 1) + ) + (f64.div + (f64.neg + (f64.const 3.141592653589793) + ) + (f64.const 2) + ) + (f64.div + (f64.const 3.141592653589793) + (f64.const 2) + ) + ) + ) + ) + (if + (if (result i32) + (tee_local $3 + (i32.and + (get_local $9) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $7) + (i32.shl + (i32.const 64) + (i32.const 20) + ) + ) + (get_local $5) + ) + (get_local $3) + ) + (set_local $10 + (f64.const 0) + ) + (set_local $10 + (call "$(lib)/math/NativeMath.atan" + (f64.abs + (f64.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (set_local $3 + (get_local $9) + ) + (br_if $case0|3 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|3 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|3 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|3 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|3) + ) + (return + (get_local $10) + ) + ) + (return + (f64.neg + (get_local $10) + ) + ) + ) + (return + (f64.sub + (f64.const 3.141592653589793) + (f64.sub + (get_local $10) + (f64.const 1.2246467991473532e-16) + ) + ) + ) + ) + (return + (f64.sub + (f64.sub + (get_local $10) + (f64.const 1.2246467991473532e-16) + ) + (f64.const 3.141592653589793) + ) + ) + ) + (unreachable) + (return + (f64.const 0) + ) + ) + (func $std/math/test_atan2 (; 78 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.atan2" (; 79 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 f32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $3 + (f32.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + ) + (get_local $3) + (f32.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $1) + (get_local $0) + ) + ) + ) + (set_local $4 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $5 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 1065353216) + ) + (return + (call "$(lib)/math/NativeMathf.atan" + (get_local $0) + ) + ) + ) + (set_local $6 + (i32.or + (i32.and + (i32.shr_u + (get_local $5) + (i32.const 31) + ) + (i32.const 1) + ) + (i32.and + (i32.shr_u + (get_local $4) + (i32.const 30) + ) + (i32.const 2) + ) + ) + ) + (set_local $4 + (i32.and + (get_local $4) + (i32.const 2147483647) + ) + ) + (set_local $5 + (i32.and + (get_local $5) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (get_local $5) + (i32.const 0) + ) + (block $break|0 + (block $case3|0 + (block $case2|0 + (block $case1|0 + (block $case0|0 + (set_local $3 + (get_local $6) + ) + (br_if $case0|0 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|0 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|0 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|0 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|0) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f32.const 3.1415927410125732) + ) + ) + (return + (f32.neg + (f32.const 3.1415927410125732) + ) + ) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 0) + ) + (return + (if (result f32) + (i32.and + (get_local $6) + (i32.const 1) + ) + (f32.div + (f32.neg + (f32.const 3.1415927410125732) + ) + (f32.const 2) + ) + (f32.div + (f32.const 3.1415927410125732) + (f32.const 2) + ) + ) + ) + ) + (if + (i32.eq + (get_local $4) + (i32.const 2139095040) + ) + (if + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + (block $break|1 + (block $case3|1 + (block $case2|1 + (block $case1|1 + (block $case0|1 + (set_local $3 + (get_local $6) + ) + (br_if $case0|1 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|1 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|1 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|1 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|1) + ) + (return + (f32.div + (f32.const 3.1415927410125732) + (f32.const 4) + ) + ) + ) + (return + (f32.div + (f32.neg + (f32.const 3.1415927410125732) + ) + (f32.const 4) + ) + ) + ) + (return + (f32.div + (f32.mul + (f32.const 3) + (f32.const 3.1415927410125732) + ) + (f32.const 4) + ) + ) + ) + (return + (f32.div + (f32.mul + (f32.const -3) + (f32.const 3.1415927410125732) + ) + (f32.const 4) + ) + ) + ) + (block $break|2 + (block $case3|2 + (block $case2|2 + (block $case1|2 + (block $case0|2 + (set_local $3 + (get_local $6) + ) + (br_if $case0|2 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|2 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|2 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|2 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|2) + ) + (return + (f32.const 0) + ) + ) + (return + (f32.const 0) + ) + ) + (return + (f32.const 3.1415927410125732) + ) + ) + (return + (f32.neg + (f32.const 3.1415927410125732) + ) + ) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (i32.add + (get_local $4) + (i32.shl + (i32.const 26) + (i32.const 23) + ) + ) + (get_local $5) + ) + ) + (get_local $3) + (i32.eq + (get_local $5) + (i32.const 2139095040) + ) + ) + (i32.const 1) + ) + (return + (if (result f32) + (i32.and + (get_local $6) + (i32.const 1) + ) + (f32.div + (f32.neg + (f32.const 3.1415927410125732) + ) + (f32.const 2) + ) + (f32.div + (f32.const 3.1415927410125732) + (f32.const 2) + ) + ) + ) + ) + (nop) + (if + (if (result i32) + (tee_local $3 + (i32.and + (get_local $6) + (i32.const 2) + ) + ) + (i32.lt_u + (i32.add + (get_local $5) + (i32.shl + (i32.const 26) + (i32.const 23) + ) + ) + (get_local $4) + ) + (get_local $3) + ) + (set_local $7 + (f32.const 0) + ) + (set_local $7 + (call "$(lib)/math/NativeMathf.atan" + (f32.abs + (f32.div + (get_local $0) + (get_local $1) + ) + ) + ) + ) + ) + (block $break|3 + (block $case3|3 + (block $case2|3 + (block $case1|3 + (block $case0|3 + (set_local $3 + (get_local $6) + ) + (br_if $case0|3 + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (br_if $case1|3 + (i32.eq + (get_local $3) + (i32.const 1) + ) + ) + (br_if $case2|3 + (i32.eq + (get_local $3) + (i32.const 2) + ) + ) + (br_if $case3|3 + (i32.eq + (get_local $3) + (i32.const 3) + ) + ) + (br $break|3) + ) + (return + (get_local $7) + ) + ) + (return + (f32.neg + (get_local $7) + ) + ) + ) + (return + (f32.sub + (f32.const 3.1415927410125732) + (f32.sub + (get_local $7) + (f32.const -8.742277657347586e-08) + ) + ) + ) + ) + (return + (f32.sub + (f32.sub + (get_local $7) + (f32.const -8.742277657347586e-08) + ) + (f32.const 3.1415927410125732) + ) + ) + ) + (unreachable) + (return + (f32.const 0) + ) + ) + (func $std/math/test_atan2f (; 80 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.atan2" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMath.cbrt" (; 81 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 f64) + (local $6 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (f64.add + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + (block + (set_local $1 + (i64.reinterpret/f64 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + ) + (set_local $2 + (i32.and + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + (i32.const 2147483647) + ) + ) + (if + (i32.eq + (get_local $2) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 696219795) + ) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 715094163) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.shl + (i64.const 1) + (i64.const 63) + ) + ) + ) + (set_local $1 + (i64.or + (get_local $1) + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (get_local $3) + (get_local $3) + ) + (f64.div + (get_local $3) + (get_local $0) + ) + ) + ) + (set_local $3 + (f64.mul + (get_local $3) + (f64.add + (f64.add + (f64.const 1.87595182427177) + (f64.mul + (get_local $4) + (f64.add + (f64.const -1.8849797954337717) + (f64.mul + (get_local $4) + (f64.const 1.6214297201053545) + ) + ) + ) + ) + (f64.mul + (f64.mul + (f64.mul + (get_local $4) + (get_local $4) + ) + (get_local $4) + ) + (f64.add + (f64.const -0.758397934778766) + (f64.mul + (get_local $4) + (f64.const 0.14599619288661245) + ) + ) + ) + ) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (i64.and + (i64.add + (i64.reinterpret/f64 + (get_local $3) + ) + (i64.const 2147483648) + ) + (i64.const -1073741824) + ) + ) + ) + (set_local $5 + (f64.mul + (get_local $3) + (get_local $3) + ) + ) + (set_local $4 + (f64.div + (get_local $0) + (get_local $5) + ) + ) + (set_local $6 + (f64.add + (get_local $3) + (get_local $3) + ) + ) + (set_local $4 + (f64.div + (f64.sub + (get_local $4) + (get_local $3) + ) + (f64.add + (get_local $6) + (get_local $4) + ) + ) + ) + (set_local $3 + (f64.add + (get_local $3) + (f64.mul + (get_local $3) + (get_local $4) + ) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/math/test_cbrt (; 82 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.cbrt" (; 83 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2139095040) + ) + (return + (f32.add + (get_local $0) + (get_local $0) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 8388608) + ) + (block + (if + (i32.eq + (get_local $2) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (f32.mul + (get_local $0) + (f32.const 16777216) + ) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 642849266) + ) + ) + ) + (set_local $2 + (i32.add + (i32.div_u + (get_local $2) + (i32.const 3) + ) + (i32.const 709958130) + ) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const -2147483648) + ) + ) + (set_local $1 + (i32.or + (get_local $1) + (get_local $2) + ) + ) + (set_local $3 + (f64.promote/f32 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (get_local $3) + (get_local $3) + ) + (get_local $3) + ) + ) + (set_local $3 + (f64.div + (f64.mul + (get_local $3) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (get_local $4) + ) + ) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (set_local $4 + (f64.mul + (f64.mul + (get_local $3) + (get_local $3) + ) + (get_local $3) + ) + ) + (set_local $3 + (f64.div + (f64.mul + (get_local $3) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (get_local $4) + ) + ) + (f64.add + (f64.add + (f64.promote/f32 + (get_local $0) + ) + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (return + (f32.demote/f64 + (get_local $3) + ) + ) + ) + (func $std/math/test_cbrtf (; 84 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.cbrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.ceil" (; 85 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.ceil + (get_local $0) + ) + ) + ) + (func $std/math/test_ceil (; 86 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.ceil" (; 87 ;) (type $ff) (param $0 f32) (result f32) + (return + (f32.ceil + (get_local $0) + ) + ) + ) + (func $std/math/test_ceilf (; 88 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.ceil" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.expm1" (; 89 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 i32) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + (i64.const 2147483647) + ) + ) + ) + (block + (set_local $3 + (i32.const 0) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1078159482) + ) + (block + (if + (f64.ne + (tee_local $5 + (get_local $0) + ) + (get_local $5) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $4) + (return + (f64.const -1) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (block + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + (return + (get_local $0) + ) + ) + ) + ) + ) + (set_local $6 + (f64.const 0) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1071001154) + ) + (block + (nop) + (if + (i32.lt_u + (get_local $2) + (i32.const 1072734898) + ) + (if + (i32.eqz + (get_local $4) + ) + (block + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (set_local $8 + (f64.const 1.9082149292705877e-10) + ) + (set_local $3 + (i32.const 1) + ) + ) + (block + (set_local $5 + (f64.add + (get_local $0) + (f64.const 0.6931471803691238) + ) + ) + (set_local $8 + (f64.neg + (f64.const 1.9082149292705877e-10) + ) + ) + (set_local $3 + (i32.const -1) + ) + ) + ) + (block + (set_local $3 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (if (result f64) + (get_local $4) + (f64.const -0.5) + (f64.const 0.5) + ) + ) + ) + ) + (set_local $7 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.mul + (get_local $7) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (f64.const 1.9082149292705877e-10) + ) + ) + ) + ) + (set_local $0 + (f64.sub + (get_local $5) + (get_local $8) + ) + ) + (set_local $6 + (f64.sub + (f64.sub + (get_local $5) + (get_local $0) + ) + (get_local $8) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1016070144) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $9 + (f64.mul + (f64.const 0.5) + (get_local $0) + ) + ) + (set_local $10 + (f64.mul + (get_local $0) + (get_local $9) + ) + ) + (set_local $11 + (f64.add + (f64.const 1) + (f64.mul + (get_local $10) + (f64.add + (f64.const -0.03333333333333313) + (f64.mul + (get_local $10) + (f64.add + (f64.const 1.5873015872548146e-03) + (f64.mul + (get_local $10) + (f64.add + (f64.const -7.93650757867488e-05) + (f64.mul + (get_local $10) + (f64.add + (f64.const 4.008217827329362e-06) + (f64.mul + (get_local $10) + (f64.const -2.0109921818362437e-07) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $7 + (f64.sub + (f64.const 3) + (f64.mul + (get_local $11) + (get_local $9) + ) + ) + ) + (set_local $12 + (f64.mul + (get_local $10) + (f64.div + (f64.sub + (get_local $11) + (get_local $7) + ) + (f64.sub + (f64.const 6) + (f64.mul + (get_local $0) + (get_local $7) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 0) + ) + (return + (f64.sub + (get_local $0) + (f64.sub + (f64.mul + (get_local $0) + (get_local $12) + ) + (get_local $10) + ) + ) + ) + ) + (set_local $12 + (f64.sub + (f64.mul + (get_local $0) + (f64.sub + (get_local $12) + (get_local $6) + ) + ) + (get_local $6) + ) + ) + (set_local $12 + (f64.sub + (get_local $12) + (get_local $10) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const -1) + ) + (return + (f64.sub + (f64.mul + (f64.const 0.5) + (f64.sub + (get_local $0) + (get_local $12) + ) + ) + (f64.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1) + ) + (block + (if + (f64.lt + (get_local $0) + (f64.const -0.25) + ) + (return + (f64.mul + (f64.const -2) + (f64.sub + (get_local $12) + (f64.add + (get_local $0) + (f64.const 0.5) + ) + ) + ) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.mul + (f64.const 2) + (f64.sub + (get_local $0) + (get_local $12) + ) + ) + ) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.add + (i64.const 1023) + (i64.extend_u/i32 + (get_local $3) + ) + ) + (i64.const 52) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $15 + (i32.lt_s + (get_local $3) + (i32.const 0) + ) + ) + (get_local $15) + (i32.gt_s + (get_local $3) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $14 + (f64.add + (f64.sub + (get_local $0) + (get_local $12) + ) + (f64.const 1) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.const 1024) + ) + (set_local $14 + (f64.mul + (f64.mul + (get_local $14) + (f64.const 2) + ) + (f64.const 8988465674311579538646525e283) + ) + ) + (set_local $14 + (f64.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (return + (f64.sub + (get_local $14) + (f64.const 1) + ) + ) + ) + ) + (set_local $1 + (i64.shl + (i64.sub + (i64.const 1023) + (i64.extend_u/i32 + (get_local $3) + ) + ) + (i64.const 52) + ) + ) + (if + (i32.lt_s + (get_local $3) + (i32.const 20) + ) + (set_local $14 + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (get_local $12) + ) + (f64.sub + (f64.const 1) + (f64.reinterpret/i64 + (get_local $1) + ) + ) + ) + (get_local $13) + ) + ) + (set_local $14 + (f64.mul + (f64.add + (f64.sub + (get_local $0) + (f64.add + (get_local $12) + (f64.reinterpret/i64 + (get_local $1) + ) + ) + ) + (f64.const 1) + ) + (get_local $13) + ) + ) + ) + (return + (get_local $14) + ) + ) + (func "$(lib)/math/NativeMath.exp" (; 90 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i32) + (local $2 i32) + (local $3 f64) + (local $4 f64) + (local $5 f64) + (local $6 i32) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (nop) + (set_local $1 + (i32.wrap/i64 + (i64.shr_u + (i64.reinterpret/f64 + (get_local $0) + ) + (i64.const 32) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 1082532651) + ) + (block + (if + (f64.ne + (tee_local $3 + (get_local $0) + ) + (get_local $3) + ) + (return + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $0) + (f64.const 709.782712893384) + ) + (block + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 8988465674311579538646525e283) + ) + ) + (return + (get_local $0) + ) + ) + ) + (if + (f64.lt + (get_local $0) + (f64.const -745.1332191019411) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $5 + (f64.const 0) + ) + (set_local $6 + (i32.const 0) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1071001154) + ) + (block + (if + (i32.ge_u + (get_local $1) + (i32.const 1072734898) + ) + (set_local $6 + (i32.trunc_s/f64 + (f64.add + (f64.mul + (f64.const 1.4426950408889634) + (get_local $0) + ) + (f64.copysign + (f64.const 0.5) + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.sub + (i32.const 1) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + (set_local $4 + (f64.sub + (get_local $0) + (f64.mul + (f64.convert_s/i32 + (get_local $6) + ) + (f64.const 0.6931471803691238) + ) + ) + ) + (set_local $5 + (f64.mul + (f64.convert_s/i32 + (get_local $6) + ) + (f64.const 1.9082149292705877e-10) + ) + ) + (set_local $0 + (f64.sub + (get_local $4) + (get_local $5) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1043333120) + ) + (set_local $4 + (get_local $0) + ) + (return + (f64.add + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $7 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $8 + (f64.sub + (get_local $0) + (f64.mul + (get_local $7) + (f64.add + (f64.const 0.16666666666666602) + (f64.mul + (get_local $7) + (f64.add + (f64.const -2.7777777777015593e-03) + (f64.mul + (get_local $7) + (f64.add + (f64.const 6.613756321437934e-05) + (f64.mul + (get_local $7) + (f64.add + (f64.const -1.6533902205465252e-06) + (f64.mul + (get_local $7) + (f64.const 4.1381367970572385e-08) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $9 + (f64.add + (f64.const 1) + (f64.add + (f64.sub + (f64.div + (f64.mul + (get_local $0) + (get_local $8) + ) + (f64.sub + (f64.const 2) + (get_local $8) + ) + ) + (get_local $5) + ) + (get_local $4) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (return + (get_local $9) + ) + ) + (return + (call "$(lib)/math/NativeMath.scalbn" + (get_local $9) + (get_local $6) + ) + ) + ) + (func "$(lib)/math/NativeMath.__expo2" (; 91 ;) (type $FF) (param $0 f64) (result f64) + (local $1 f64) + (nop) + (set_local $1 + (f64.reinterpret/i64 + (i64.shl + (i64.extend_u/i32 + (i32.shl + (i32.add + (i32.const 1023) + (i32.div_u + (i32.const 2043) + (i32.const 2) + ) + ) + (i32.const 20) + ) + ) + (i64.const 32) + ) + ) + ) + (return + (f64.mul + (f64.mul + (call "$(lib)/math/NativeMath.exp" + (f64.sub + (get_local $0) + (f64.const 1416.0996898839683) + ) + ) + (get_local $1) + ) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMath.cosh" (; 92 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $2) + (i32.const 1072049730) + ) + (block + (if + (i32.lt_u + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.shl + (i32.const 26) + (i32.const 20) + ) + ) + ) + (return + (f64.const 1) + ) + ) + (set_local $3 + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + ) + (return + (f64.add + (f64.const 1) + (f64.div + (f64.mul + (get_local $3) + (get_local $3) + ) + (f64.mul + (f64.const 2) + (f64.add + (f64.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 1082535490) + ) + (block + (set_local $3 + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + ) + (return + (f64.mul + (f64.const 0.5) + (f64.add + (get_local $3) + (f64.div + (f64.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (set_local $3 + (call "$(lib)/math/NativeMath.__expo2" + (get_local $0) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/math/test_cosh (; 93 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.expm1" (; 94 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 i32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (local $15 i32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $3 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 1100331076) + ) + (block + (if + (i32.gt_u + (get_local $2) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + ) + (if + (get_local $3) + (return + (f32.const -1) + ) + ) + (if + (f32.gt + (get_local $0) + (f32.const 88.7216796875) + ) + (block + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 1701411834604692317316873e14) + ) + ) + (return + (get_local $0) + ) + ) + ) + ) + ) + (set_local $4 + (f32.const 0) + ) + (if + (i32.gt_u + (get_local $2) + (i32.const 1051816472) + ) + (block + (nop) + (if + (i32.lt_u + (get_local $2) + (i32.const 1065686418) + ) + (if + (i32.eqz + (get_local $3) + ) + (block + (set_local $7 + (f32.sub + (get_local $0) + (f32.const 0.6931381225585938) + ) + ) + (set_local $8 + (f32.const 9.05800061445916e-06) + ) + (set_local $6 + (i32.const 1) + ) + ) + (block + (set_local $7 + (f32.add + (get_local $0) + (f32.const 0.6931381225585938) + ) + ) + (set_local $8 + (f32.neg + (f32.const 9.05800061445916e-06) + ) + ) + (set_local $6 + (i32.const -1) + ) + ) + ) + (block + (set_local $6 + (i32.trunc_s/f32 + (f32.add + (f32.mul + (f32.const 1.4426950216293335) + (get_local $0) + ) + (if (result f32) + (get_local $3) + (f32.const -0.5) + (f32.const 0.5) + ) + ) + ) + ) + (set_local $5 + (f32.convert_s/i32 + (get_local $6) + ) + ) + (set_local $7 + (f32.sub + (get_local $0) + (f32.mul + (get_local $5) + (f32.const 0.6931381225585938) + ) + ) + ) + (set_local $8 + (f32.mul + (get_local $5) + (f32.const 9.05800061445916e-06) + ) + ) + ) + ) + (set_local $0 + (f32.sub + (get_local $7) + (get_local $8) + ) + ) + (set_local $4 + (f32.sub + (f32.sub + (get_local $7) + (get_local $0) + ) + (get_local $8) + ) + ) + ) + (if + (i32.lt_u + (get_local $2) + (i32.const 855638016) + ) + (return + (get_local $0) + ) + (set_local $6 + (i32.const 0) + ) + ) + ) + (set_local $9 + (f32.mul + (f32.const 0.5) + (get_local $0) + ) + ) + (set_local $10 + (f32.mul + (get_local $0) + (get_local $9) + ) + ) + (set_local $11 + (f32.add + (f32.const 1) + (f32.mul + (get_local $10) + (f32.add + (f32.const -0.03333321213722229) + (f32.mul + (get_local $10) + (f32.const 1.5807170420885086e-03) + ) + ) + ) + ) + ) + (set_local $5 + (f32.sub + (f32.const 3) + (f32.mul + (get_local $11) + (get_local $9) + ) + ) + ) + (set_local $12 + (f32.mul + (get_local $10) + (f32.div + (f32.sub + (get_local $11) + (get_local $5) + ) + (f32.sub + (f32.const 6) + (f32.mul + (get_local $0) + (get_local $5) + ) + ) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (return + (f32.sub + (get_local $0) + (f32.sub + (f32.mul + (get_local $0) + (get_local $12) + ) + (get_local $10) + ) + ) + ) + ) + (set_local $12 + (f32.sub + (f32.mul + (get_local $0) + (f32.sub + (get_local $12) + (get_local $4) + ) + ) + (get_local $4) + ) + ) + (set_local $12 + (f32.sub + (get_local $12) + (get_local $10) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const -1) + ) + (return + (f32.sub + (f32.mul + (f32.const 0.5) + (f32.sub + (get_local $0) + (get_local $12) + ) + ) + (f32.const 0.5) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 1) + ) + (block + (if + (f32.lt + (get_local $0) + (f32.const -0.25) + ) + (return + (f32.mul + (f32.const -2) + (f32.sub + (get_local $12) + (f32.add + (get_local $0) + (f32.const 0.5) + ) + ) + ) + ) + ) + (return + (f32.add + (f32.const 1) + (f32.mul + (f32.const 2) + (f32.sub + (get_local $0) + (get_local $12) + ) + ) + ) + ) + ) + ) + (set_local $1 + (i32.shl + (i32.add + (i32.const 127) + (get_local $6) + ) + (i32.const 23) + ) + ) + (set_local $13 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (nop) + (if + (i32.and + (if (result i32) + (tee_local $15 + (i32.lt_s + (get_local $6) + (i32.const 0) + ) + ) + (get_local $15) + (i32.gt_s + (get_local $6) + (i32.const 56) + ) + ) + (i32.const 1) + ) + (block + (set_local $14 + (f32.add + (f32.sub + (get_local $0) + (get_local $12) + ) + (f32.const 1) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 128) + ) + (set_local $14 + (f32.mul + (f32.mul + (get_local $14) + (f32.const 2) + ) + (f32.const 1701411834604692317316873e14) + ) + ) + (set_local $14 + (f32.mul + (get_local $14) + (get_local $13) + ) + ) + ) + (return + (f32.sub + (get_local $14) + (f32.const 1) + ) + ) + ) + ) + (set_local $1 + (i32.shl + (i32.sub + (i32.const 127) + (get_local $6) + ) + (i32.const 23) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.const 23) + ) + (set_local $14 + (f32.mul + (f32.add + (f32.sub + (get_local $0) + (get_local $12) + ) + (f32.sub + (f32.const 1) + (f32.reinterpret/i32 + (get_local $1) + ) + ) + ) + (get_local $13) + ) + ) + (set_local $14 + (f32.mul + (f32.add + (f32.sub + (get_local $0) + (f32.add + (get_local $12) + (f32.reinterpret/i32 + (get_local $1) + ) + ) + ) + (f32.const 1) + ) + (get_local $13) + ) + ) + ) + (return + (get_local $14) + ) + ) + (func "$(lib)/math/NativeMathf.exp" (; 95 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 i32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 1118743632) + ) + (block + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.ge_u + (get_local $1) + (i32.const 1118925336) + ) + ) + (i32.eqz + (get_local $2) + ) + (get_local $3) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 1701411834604692317316873e14) + ) + ) + (return + (get_local $0) + ) + ) + ) + (if + (if (result i32) + (get_local $2) + (i32.ge_u + (get_local $1) + (i32.const 1120924085) + ) + (get_local $2) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (nop) + (nop) + (if + (i32.gt_u + (get_local $1) + (i32.const 1051816472) + ) + (block + (if + (i32.gt_u + (get_local $1) + (i32.const 1065686418) + ) + (set_local $6 + (i32.trunc_s/f32 + (f32.add + (f32.mul + (f32.const 1.4426950216293335) + (get_local $0) + ) + (f32.copysign + (f32.const 0.5) + (get_local $0) + ) + ) + ) + ) + (set_local $6 + (i32.sub + (i32.sub + (i32.const 1) + (get_local $2) + ) + (get_local $2) + ) + ) + ) + (set_local $4 + (f32.sub + (get_local $0) + (f32.mul + (f32.convert_s/i32 + (get_local $6) + ) + (f32.const 0.693145751953125) + ) + ) + ) + (set_local $5 + (f32.mul + (f32.convert_s/i32 + (get_local $6) + ) + (f32.const 1.428606765330187e-06) + ) + ) + (set_local $0 + (f32.sub + (get_local $4) + (get_local $5) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 956301312) + ) + (block + (set_local $6 + (i32.const 0) + ) + (set_local $4 + (get_local $0) + ) + (set_local $5 + (f32.const 0) + ) + ) + (return + (f32.add + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (set_local $7 + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $8 + (f32.sub + (get_local $0) + (f32.mul + (get_local $7) + (f32.add + (f32.const 0.16666625440120697) + (f32.mul + (get_local $7) + (f32.const -2.7667332906275988e-03) + ) + ) + ) + ) + ) + (set_local $9 + (f32.add + (f32.const 1) + (f32.add + (f32.sub + (f32.div + (f32.mul + (get_local $0) + (get_local $8) + ) + (f32.sub + (f32.const 2) + (get_local $8) + ) + ) + (get_local $5) + ) + (get_local $4) + ) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 0) + ) + (return + (get_local $9) + ) + ) + (return + (call "$(lib)/math/NativeMathf.scalbn" + (get_local $9) + (get_local $6) + ) + ) + ) + (func "$(lib)/math/NativeMathf.__expo2" (; 96 ;) (type $ff) (param $0 f32) (result f32) + (local $1 f32) + (nop) + (set_local $1 + (f32.reinterpret/i32 + (i32.shl + (i32.add + (i32.const 127) + (i32.div_u + (i32.const 235) + (i32.const 2) + ) + ) + (i32.const 23) + ) + ) + ) + (return + (f32.mul + (f32.mul + (call "$(lib)/math/NativeMathf.exp" + (f32.sub + (get_local $0) + (f32.const 162.88958740234375) + ) + ) + (get_local $1) + ) + (get_local $1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.cosh" (; 97 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 f32) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1060205079) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.shl + (i32.const 12) + (i32.const 23) + ) + ) + ) + (return + (f32.const 1) + ) + ) + (set_local $2 + (call "$(lib)/math/NativeMathf.expm1" + (get_local $0) + ) + ) + (return + (f32.add + (f32.const 1) + (f32.div + (f32.mul + (get_local $2) + (get_local $2) + ) + (f32.mul + (f32.const 2) + (f32.add + (f32.const 1) + (get_local $2) + ) + ) + ) + ) + ) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1118925335) + ) + (block + (set_local $2 + (call "$(lib)/math/NativeMathf.exp" + (get_local $0) + ) + ) + (return + (f32.mul + (f32.const 0.5) + (f32.add + (get_local $2) + (f32.div + (f32.const 1) + (get_local $2) + ) + ) + ) + ) + ) + ) + (return + (call "$(lib)/math/NativeMathf.__expo2" + (get_local $0) + ) + ) + ) + (func $std/math/test_coshf (; 98 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.cosh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func $std/math/test_exp (; 99 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func $std/math/test_expf (; 100 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.exp" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func $std/math/test_expm1 (; 101 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func $std/math/test_expm1f (; 102 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.expm1" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.floor" (; 103 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.floor + (get_local $0) + ) + ) + ) + (func $std/math/test_floor (; 104 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.floor" (; 105 ;) (type $ff) (param $0 f32) (result f32) + (return + (f32.floor + (get_local $0) + ) + ) + ) + (func $std/math/test_floorf (; 106 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.floor" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.hypot" (; 107 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i64) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (nop) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $2 + (i64.and + (get_local $2) + (i64.const 9223372036854775807) + ) + ) + (set_local $3 + (i64.and + (get_local $3) + (i64.const 9223372036854775807) + ) + ) + (if + (i64.lt_u + (get_local $2) + (get_local $3) + ) + (block + (set_local $4 + (get_local $2) + ) + (set_local $2 + (get_local $3) + ) + (set_local $3 + (get_local $4) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + ) + ) + (set_local $1 + (f64.reinterpret/i64 + (get_local $3) + ) + ) + (if + (i32.eq + (get_local $6) + (i32.const 2047) + ) + (return + (get_local $1) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $2) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.eq + (get_local $5) + (i32.const 2047) + ) + ) + (get_local $7) + (i64.eq + (get_local $3) + (i64.const 0) + ) + ) + (i32.const 1) + ) + (return + (get_local $0) + ) + ) + (if + (i32.gt_s + (i32.sub + (get_local $5) + (get_local $6) + ) + (i32.const 64) + ) + (return + (f64.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $8 + (f64.const 1) + ) + (if + (i32.gt_s + (get_local $5) + (i32.add + (i32.const 1023) + (i32.const 510) + ) + ) + (block + (set_local $8 + (f64.const 5260135901548373507240989e186) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 1.90109156629516e-211) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 1.90109156629516e-211) + ) + ) + ) + (if + (i32.lt_s + (get_local $6) + (i32.sub + (i32.const 1023) + (i32.const 450) + ) + ) + (block + (set_local $8 + (f64.const 1.90109156629516e-211) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 5260135901548373507240989e186) + ) + ) + (set_local $1 + (f64.mul + (get_local $1) + (f64.const 5260135901548373507240989e186) + ) + ) + ) + ) + ) + (set_local $9 + (f64.mul + (get_local $0) + (f64.const 134217729) + ) + ) + (set_local $10 + (f64.add + (f64.sub + (get_local $0) + (get_local $9) + ) + (get_local $9) + ) + ) + (set_local $11 + (f64.sub + (get_local $0) + (get_local $10) + ) + ) + (set_local $12 + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + (set_local $13 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $10) + (get_local $10) + ) + (get_local $12) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $10) + ) + (get_local $11) + ) + ) + (f64.mul + (get_local $11) + (get_local $11) + ) + ) + ) + (set_local $9 + (f64.mul + (get_local $1) + (f64.const 134217729) + ) + ) + (set_local $10 + (f64.add + (f64.sub + (get_local $1) + (get_local $9) + ) + (get_local $9) + ) + ) + (set_local $11 + (f64.sub + (get_local $1) + (get_local $10) + ) + ) + (set_local $14 + (f64.mul + (get_local $1) + (get_local $1) + ) + ) + (set_local $15 + (f64.add + (f64.add + (f64.sub + (f64.mul + (get_local $10) + (get_local $10) + ) + (get_local $14) + ) + (f64.mul + (f64.mul + (f64.const 2) + (get_local $10) + ) + (get_local $11) + ) + ) + (f64.mul + (get_local $11) + (get_local $11) + ) + ) + ) + (return + (f64.mul + (get_local $8) + (f64.sqrt + (f64.add + (f64.add + (f64.add + (get_local $15) + (get_local $13) + ) + (get_local $14) + ) + (get_local $12) + ) + ) + ) + ) + ) + (func $std/math/test_hypot (; 108 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.hypot" (; 109 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f32) + (nop) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $2 + (i32.and + (get_local $2) + (i32.const 2147483647) + ) + ) + (set_local $3 + (i32.and + (get_local $3) + (i32.const 2147483647) + ) + ) + (if + (i32.lt_u + (get_local $2) + (get_local $3) + ) + (block + (set_local $4 + (get_local $2) + ) + (set_local $2 + (get_local $3) + ) + (set_local $3 + (get_local $4) + ) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $2) + ) + ) + (set_local $1 + (f32.reinterpret/i32 + (get_local $3) + ) + ) + (if + (i32.eq + (get_local $3) + (i32.shl + (i32.const 255) + (i32.const 23) + ) + ) + (return + (get_local $1) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.and + (if (result i32) + (tee_local $4 + (i32.ge_u + (get_local $2) + (i32.shl + (i32.const 255) + (i32.const 23) + ) + ) + ) + (get_local $4) + (i32.eq + (get_local $3) + (i32.const 0) + ) + ) + (i32.const 1) + ) + ) + (get_local $4) + (i32.ge_u + (i32.sub + (get_local $2) + (get_local $3) + ) + (i32.shl + (i32.const 25) + (i32.const 23) + ) + ) + ) + (i32.const 1) + ) + (return + (f32.add + (get_local $0) + (get_local $1) + ) + ) + ) + (set_local $5 + (f32.const 1) + ) + (if + (i32.ge_u + (get_local $2) + (i32.shl + (i32.add + (i32.const 127) + (i32.const 60) + ) + (i32.const 23) + ) + ) + (block + (set_local $5 + (f32.const 1237940039285380274899124e3) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 8.077935669463161e-28) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 8.077935669463161e-28) + ) + ) + ) + (if + (i32.lt_u + (get_local $3) + (i32.shl + (i32.sub + (i32.const 127) + (i32.const 60) + ) + (i32.const 23) + ) + ) + (block + (set_local $5 + (f32.const 8.077935669463161e-28) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 1237940039285380274899124e3) + ) + ) + (set_local $1 + (f32.mul + (get_local $1) + (f32.const 1237940039285380274899124e3) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $5) + (f32.sqrt + (f32.demote/f64 + (f64.add + (f64.mul + (f64.promote/f32 + (get_local $0) + ) + (f64.promote/f32 + (get_local $0) + ) + ) + (f64.mul + (f64.promote/f32 + (get_local $1) + ) + (f64.promote/f32 + (get_local $1) + ) + ) + ) + ) + ) + ) + ) + ) + (func $std/math/test_hypotf (; 110 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.hypot" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func $std/math/test_log (; 111 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func $std/math/test_logf (; 112 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.log" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.log10" (; 113 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (local $18 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (f64.sub + (get_local $5) + (get_local $6) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const -4294967296) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $14 + (f64.add + (f64.sub + (f64.sub + (get_local $5) + (get_local $13) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + ) + ) + (set_local $15 + (f64.mul + (get_local $13) + (f64.const 0.4342944818781689) + ) + ) + (set_local $16 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $17 + (f64.mul + (get_local $16) + (f64.const 0.30102999566361177) + ) + ) + (set_local $18 + (f64.add + (f64.add + (f64.mul + (get_local $16) + (f64.const 3.694239077158931e-13) + ) + (f64.mul + (f64.add + (get_local $14) + (get_local $13) + ) + (f64.const 2.5082946711645275e-11) + ) + ) + (f64.mul + (get_local $14) + (f64.const 0.4342944818781689) + ) + ) + ) + (set_local $9 + (f64.add + (get_local $17) + (get_local $15) + ) + ) + (set_local $18 + (f64.add + (get_local $18) + (f64.add + (f64.sub + (get_local $17) + (get_local $9) + ) + (get_local $15) + ) + ) + ) + (set_local $15 + (get_local $9) + ) + (return + (f64.add + (get_local $18) + (get_local $15) + ) + ) + ) + (func $std/math/test_log10 (; 114 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.log10" (; 115 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 f32) + (local $14 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $1) + (i32.const 8388608) + ) + ) + (get_local $3) + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $1) + (i32.const 1) + ) + (i32.const 0) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.const 1060439283) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_u + (get_local $1) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $1 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (set_local $4 + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + (set_local $5 + (f32.div + (get_local $4) + (f32.add + (f32.const 2) + (get_local $4) + ) + ) + ) + (set_local $6 + (f32.mul + (get_local $5) + (get_local $5) + ) + ) + (set_local $7 + (f32.mul + (get_local $6) + (get_local $6) + ) + ) + (set_local $8 + (f32.mul + (get_local $7) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $7) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + (set_local $9 + (f32.mul + (get_local $6) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $7) + (f32.const 0.2849878668785095) + ) + ) + ) + ) + (set_local $10 + (f32.add + (get_local $9) + (get_local $8) + ) + ) + (set_local $11 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $4) + ) + (get_local $4) + ) + ) + (set_local $12 + (f32.sub + (get_local $4) + (get_local $11) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (get_local $12) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const -4096) + ) + ) + (set_local $12 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (set_local $13 + (f32.add + (f32.sub + (f32.sub + (get_local $4) + (get_local $12) + ) + (get_local $11) + ) + (f32.mul + (get_local $5) + (f32.add + (get_local $11) + (get_local $10) + ) + ) + ) + ) + (set_local $14 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (return + (f32.add + (f32.add + (f32.add + (f32.add + (f32.mul + (get_local $14) + (f32.const 7.903415166765626e-07) + ) + (f32.mul + (f32.add + (get_local $13) + (get_local $12) + ) + (f32.const -3.168997136526741e-05) + ) + ) + (f32.mul + (get_local $13) + (f32.const 0.434326171875) + ) + ) + (f32.mul + (get_local $12) + (f32.const 0.434326171875) + ) + ) + (f32.mul + (get_local $14) + (f32.const 0.3010292053222656) + ) + ) + ) + ) + (func $std/math/test_log10f (; 116 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.log10" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func $std/math/test_log1p (; 117 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func $std/math/test_log1pf (; 118 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.log1p" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.log2" (; 119 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 f64) + (local $6 f64) + (local $7 f64) + (local $8 f64) + (local $9 f64) + (local $10 f64) + (local $11 f64) + (local $12 f64) + (local $13 f64) + (local $14 f64) + (local $15 f64) + (local $16 f64) + (local $17 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (set_local $3 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.lt_u + (get_local $2) + (i32.const 1048576) + ) + ) + (get_local $4) + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $1) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (f64.div + (f64.const -1) + (f64.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + (return + (f64.div + (f64.sub + (get_local $0) + (get_local $0) + ) + (f64.const 0) + ) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 54) + ) + ) + (set_local $0 + (f64.mul + (get_local $0) + (f64.const 18014398509481984) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $2) + (i32.const 2146435072) + ) + (return + (get_local $0) + ) + (if + (i32.and + (if (result i32) + (tee_local $4 + (i32.eq + (get_local $2) + (i32.const 1072693248) + ) + ) + (i64.eq + (i64.shl + (get_local $1) + (i64.const 32) + ) + (i64.const 0) + ) + (get_local $4) + ) + (i32.const 1) + ) + (return + (f64.const 0) + ) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.const 1072693248) + (i32.const 1072079006) + ) + ) + ) + (set_local $3 + (i32.add + (get_local $3) + (i32.sub + (i32.shr_u + (get_local $2) + (i32.const 20) + ) + (i32.const 1023) + ) + ) + ) + (set_local $2 + (i32.add + (i32.and + (get_local $2) + (i32.const 1048575) + ) + (i32.const 1072079006) + ) + ) + (set_local $1 + (i64.or + (i64.shl + (i64.extend_u/i32 + (get_local $2) + ) + (i64.const 32) + ) + (i64.and + (get_local $1) + (i64.const 4294967295) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $5 + (f64.sub + (get_local $0) + (f64.const 1) + ) + ) + (set_local $6 + (f64.mul + (f64.mul + (f64.const 0.5) + (get_local $5) + ) + (get_local $5) + ) + ) + (set_local $7 + (f64.div + (get_local $5) + (f64.add + (f64.const 2) + (get_local $5) + ) + ) + ) + (set_local $8 + (f64.mul + (get_local $7) + (get_local $7) + ) + ) + (set_local $9 + (f64.mul + (get_local $8) + (get_local $8) + ) + ) + (set_local $10 + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.3999999999940942) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.22222198432149784) + (f64.mul + (get_local $9) + (f64.const 0.15313837699209373) + ) + ) + ) + ) + ) + ) + (set_local $11 + (f64.mul + (get_local $8) + (f64.add + (f64.const 0.6666666666666735) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.2857142874366239) + (f64.mul + (get_local $9) + (f64.add + (f64.const 0.1818357216161805) + (f64.mul + (get_local $9) + (f64.const 0.14798198605116586) + ) + ) + ) + ) + ) + ) + ) + ) + (set_local $12 + (f64.add + (get_local $11) + (get_local $10) + ) + ) + (set_local $13 + (f64.sub + (get_local $5) + (get_local $6) + ) + ) + (set_local $1 + (i64.reinterpret/f64 + (get_local $13) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const -4294967296) + ) + ) + (set_local $13 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $14 + (f64.add + (f64.sub + (f64.sub + (get_local $5) + (get_local $13) + ) + (get_local $6) + ) + (f64.mul + (get_local $7) + (f64.add + (get_local $6) + (get_local $12) + ) + ) + ) + ) + (set_local $15 + (f64.mul + (get_local $13) + (f64.const 1.4426950407214463) + ) + ) + (set_local $16 + (f64.add + (f64.mul + (f64.add + (get_local $14) + (get_local $13) + ) + (f64.const 1.6751713164886512e-10) + ) + (f64.mul + (get_local $14) + (f64.const 1.4426950407214463) + ) + ) + ) + (set_local $17 + (f64.convert_s/i32 + (get_local $3) + ) + ) + (set_local $9 + (f64.add + (get_local $17) + (get_local $15) + ) + ) + (set_local $16 + (f64.add + (get_local $16) + (f64.add + (f64.sub + (get_local $17) + (get_local $9) + ) + (get_local $15) + ) + ) + ) + (set_local $15 + (get_local $9) + ) + (return + (f64.add + (get_local $16) + (get_local $15) + ) + ) + ) + (func $std/math/test_log2 (; 120 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.log2" (; 121 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 f32) + (local $5 f32) + (local $6 f32) + (local $7 f32) + (local $8 f32) + (local $9 f32) + (local $10 f32) + (local $11 f32) + (local $12 f32) + (local $13 i32) + (local $14 f32) + (local $15 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.const 0) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.lt_u + (get_local $1) + (i32.const 8388608) + ) + ) + (get_local $3) + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (i32.const 1) + ) + ) + (i32.const 1) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $1) + (i32.const 1) + ) + (i32.const 0) + ) + (return + (f32.div + (f32.const -1) + (f32.mul + (get_local $0) + (get_local $0) + ) + ) + ) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (return + (f32.div + (f32.sub + (get_local $0) + (get_local $0) + ) + (f32.const 0) + ) + ) + ) + (set_local $2 + (i32.sub + (get_local $2) + (i32.const 25) + ) + ) + (set_local $0 + (f32.mul + (get_local $0) + (f32.const 33554432) + ) + ) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 2139095040) + ) + (return + (get_local $0) + ) + (if + (i32.eq + (get_local $1) + (i32.const 1065353216) + ) + (return + (f32.const 0) + ) + ) + ) + ) + (set_local $1 + (i32.add + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.const 1060439283) + ) + ) + ) + (set_local $2 + (i32.add + (get_local $2) + (i32.sub + (i32.shr_u + (get_local $1) + (i32.const 23) + ) + (i32.const 127) + ) + ) + ) + (set_local $1 + (i32.add + (i32.and + (get_local $1) + (i32.const 8388607) + ) + (i32.const 1060439283) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (set_local $4 + (f32.sub + (get_local $0) + (f32.const 1) + ) + ) + (set_local $5 + (f32.div + (get_local $4) + (f32.add + (f32.const 2) + (get_local $4) + ) + ) + ) + (set_local $6 + (f32.mul + (get_local $5) + (get_local $5) + ) + ) + (set_local $7 + (f32.mul + (get_local $6) + (get_local $6) + ) + ) + (set_local $8 + (f32.mul + (get_local $7) + (f32.add + (f32.const 0.40000972151756287) + (f32.mul + (get_local $7) + (f32.const 0.24279078841209412) + ) + ) + ) + ) + (set_local $9 + (f32.mul + (get_local $6) + (f32.add + (f32.const 0.6666666269302368) + (f32.mul + (get_local $7) + (f32.const 0.2849878668785095) + ) + ) + ) + ) + (set_local $10 + (f32.add + (get_local $9) + (get_local $8) + ) + ) + (set_local $11 + (f32.mul + (f32.mul + (f32.const 0.5) + (get_local $4) + ) + (get_local $4) + ) + ) + (set_local $12 + (f32.sub + (get_local $4) + (get_local $11) + ) + ) + (set_local $13 + (i32.reinterpret/f32 + (get_local $12) + ) + ) + (set_local $13 + (i32.and + (get_local $13) + (i32.const -4096) + ) + ) + (set_local $12 + (f32.reinterpret/i32 + (get_local $13) + ) + ) + (set_local $14 + (f32.add + (f32.sub + (f32.sub + (get_local $4) + (get_local $12) + ) + (get_local $11) + ) + (f32.mul + (get_local $5) + (f32.add + (get_local $11) + (get_local $10) + ) + ) + ) + ) + (set_local $15 + (f32.convert_s/i32 + (get_local $2) + ) + ) + (return + (f32.add + (f32.add + (f32.add + (f32.mul + (f32.add + (get_local $14) + (get_local $12) + ) + (f32.const -1.7605285393074155e-04) + ) + (f32.mul + (get_local $14) + (f32.const 1.44287109375) + ) + ) + (f32.mul + (get_local $12) + (f32.const 1.44287109375) + ) + ) + (get_local $15) + ) + ) + ) + (func $std/math/test_log2f (; 122 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.log2" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.max" (; 123 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (f64.max + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/math/test_max (; 124 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.max" (; 125 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (return + (f32.max + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/math/test_maxf (; 126 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.max" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMath.min" (; 127 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (return + (f64.min + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/math/test_min (; 128 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.min" (; 129 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (return + (f32.min + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/math/test_minf (; 130 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.min" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMath.mod" (; 131 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 i64) (local $3 i64) (local $4 i32) @@ -491,75 +10850,46 @@ ) ) ) - (func $std/math/check (; 6 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (local $4 f64) + (func $std/math/test_mod (; 132 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) (local $5 i32) - (if - (f64.ne - (tee_local $4 - (get_local $1) - ) - (get_local $4) - ) - (if - (i32.eqz - (f64.ne - (tee_local $4 - (get_local $0) - ) - (get_local $4) - ) - ) - (unreachable) - ) - (if - (f64.ne - (get_local $0) - (get_local $1) - ) - (if - (i32.and - (if (result i32) - (tee_local $5 - (i32.eqz - (i32.and - (get_local $3) - (i32.const 1) - ) - ) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.mod" + (get_local $0) + (get_local $1) ) - (get_local $5) - (f64.gt - (f64.abs - (f64.sub - (get_local $0) - (get_local $1) - ) - ) - (f64.abs - (get_local $2) - ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) ) ) - (i32.const 1) + (get_local $5) + (call $std/math/check + (call $std/math/JSOp.mod + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) ) - (unreachable) + (get_local $5) ) + (i32.const 1) ) ) ) - (func $std/math/test_fmod (; 7 ;) (type $FFFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) - (call $std/math/check - (call $fmod - (get_local $0) - (get_local $1) - ) - (get_local $2) - (get_local $3) - (get_local $4) - ) - ) - (func $fmodf (; 8 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func "$(lib)/math/NativeMathf.mod" (; 133 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (local $2 i32) (local $3 i32) (local $4 i32) @@ -995,1408 +11325,20 @@ ) ) ) - (func $std/math/check (; 9 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (local $4 f32) - (local $5 i32) - (if - (f32.ne - (tee_local $4 - (get_local $1) - ) - (get_local $4) - ) - (if - (i32.eqz - (f32.ne - (tee_local $4 - (get_local $0) - ) - (get_local $4) - ) - ) - (unreachable) - ) - (if - (f32.ne + (func $std/math/test_modf (; 134 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.mod" (get_local $0) (get_local $1) ) - (if - (i32.and - (if (result i32) - (tee_local $5 - (i32.eqz - (i32.and - (get_local $3) - (i32.const 1) - ) - ) - ) - (get_local $5) - (f32.gt - (f32.abs - (f32.sub - (get_local $0) - (get_local $1) - ) - ) - (f32.abs - (get_local $2) - ) - ) - ) - (i32.const 1) - ) - (unreachable) - ) - ) - ) - ) - (func $std/math/test_fmodf (; 10 ;) (type $ffffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) - (call $std/math/check - (call $fmodf - (get_local $0) - (get_local $1) - ) - (get_local $2) - (get_local $3) - (get_local $4) - ) - ) - (func "$(lib)/math/NativeMath.log" (; 11 ;) (type $FF) (param $0 f64) (result f64) - (local $1 i64) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 f64) - (local $6 f64) - (local $7 f64) - (local $8 f64) - (local $9 f64) - (local $10 f64) - (local $11 f64) - (local $12 f64) - (local $13 i32) - (nop) - (set_local $1 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (set_local $2 - (i32.wrap/i64 - (i64.shr_u - (get_local $1) - (i64.const 32) - ) - ) - ) - (set_local $3 - (i32.const 0) - ) - (if - (i32.and - (if (result i32) - (tee_local $4 - (i32.lt_u - (get_local $2) - (i32.const 1048576) - ) - ) - (get_local $4) - (i32.and - (i32.shr_u - (get_local $2) - (i32.const 31) - ) - (i32.const 1) - ) - ) - (i32.const 1) - ) - (block - (if - (i64.eq - (i64.shl - (get_local $1) - (i64.const 1) - ) - (i64.const 0) - ) - (return - (f64.div - (f64.const -1) - (f64.mul - (get_local $0) - (get_local $0) - ) - ) - ) - ) - (if - (i32.shr_u - (get_local $2) - (i32.const 31) - ) - (return - (f64.div - (f64.sub - (get_local $0) - (get_local $0) - ) - (f64.const 0) - ) - ) - ) - (set_local $3 - (i32.sub - (get_local $3) - (i32.const 54) - ) - ) - (set_local $0 - (f64.mul - (get_local $0) - (f64.const 18014398509481984) - ) - ) - (set_local $1 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (set_local $2 - (i32.wrap/i64 - (i64.shr_u - (get_local $1) - (i64.const 32) - ) - ) - ) - ) - (if - (i32.ge_u - (get_local $2) - (i32.const 2146435072) - ) - (return - (get_local $0) - ) - (if - (i32.and - (if (result i32) - (tee_local $4 - (i32.eq - (get_local $2) - (i32.const 1072693248) - ) - ) - (i64.eq - (i64.shl - (get_local $1) - (i64.const 32) - ) - (i64.const 0) - ) - (get_local $4) - ) - (i32.const 1) - ) - (return - (f64.const 0) - ) - ) - ) - ) - (set_local $2 - (i32.add (get_local $2) - (i32.sub - (i32.const 1072693248) - (i32.const 1072079006) - ) - ) - ) - (set_local $3 - (i32.add (get_local $3) - (i32.sub - (i32.shr_s - (get_local $2) - (i32.const 20) - ) - (i32.const 1023) - ) - ) - ) - (set_local $2 - (i32.add - (i32.and - (get_local $2) - (i32.const 1048575) - ) - (i32.const 1072079006) - ) - ) - (set_local $1 - (i64.or - (i64.shl - (i64.extend_u/i32 - (get_local $2) - ) - (i64.const 32) - ) - (i64.and - (get_local $1) - (i64.const 4294967295) - ) - ) - ) - (set_local $0 - (f64.reinterpret/i64 - (get_local $1) - ) - ) - (set_local $5 - (f64.sub - (get_local $0) - (f64.const 1) - ) - ) - (set_local $6 - (f64.mul - (f64.mul - (f64.const 0.5) - (get_local $5) - ) - (get_local $5) - ) - ) - (set_local $7 - (f64.div - (get_local $5) - (f64.add - (f64.const 2) - (get_local $5) - ) - ) - ) - (set_local $8 - (f64.mul - (get_local $7) - (get_local $7) - ) - ) - (set_local $9 - (f64.mul - (get_local $8) - (get_local $8) - ) - ) - (set_local $10 - (f64.mul - (get_local $9) - (f64.add - (f64.const 0.3999999999940942) - (f64.mul - (get_local $9) - (f64.add - (f64.const 0.22222198432149784) - (f64.mul - (get_local $9) - (f64.const 0.15313837699209373) - ) - ) - ) - ) - ) - ) - (set_local $11 - (f64.mul - (get_local $8) - (f64.add - (f64.const 0.6666666666666735) - (f64.mul - (get_local $9) - (f64.add - (f64.const 0.2857142874366239) - (f64.mul - (get_local $9) - (f64.add - (f64.const 0.1818357216161805) - (f64.mul - (get_local $9) - (f64.const 0.14798198605116586) - ) - ) - ) - ) - ) - ) - ) - ) - (set_local $12 - (f64.add - (get_local $11) - (get_local $10) - ) - ) - (set_local $13 - (get_local $3) - ) - (return - (f64.add - (f64.add - (f64.sub - (f64.add - (f64.mul - (get_local $7) - (f64.add - (get_local $6) - (get_local $12) - ) - ) - (f64.mul - (f64.convert_s/i32 - (get_local $13) - ) - (f64.const 1.9082149292705877e-10) - ) - ) - (get_local $6) - ) - (get_local $5) - ) - (f64.mul - (f64.convert_s/i32 - (get_local $13) - ) - (f64.const 0.6931471803691238) - ) - ) - ) - ) - (func $std/math/test_log (; 12 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.log" (; 13 ;) (type $ff) (param $0 f32) (result f32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 f32) - (local $5 f32) - (local $6 f32) - (local $7 f32) - (local $8 f32) - (local $9 f32) - (local $10 f32) - (local $11 f32) - (local $12 f32) - (nop) - (set_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (set_local $2 - (i32.const 0) - ) - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.lt_u - (get_local $1) - (i32.const 8388608) - ) - ) - (get_local $3) - (i32.and - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - (i32.const 1) - ) - ) - (i32.const 1) - ) - (block - (if - (i32.eq - (i32.shl - (get_local $1) - (i32.const 1) - ) - (i32.const 0) - ) - (return - (f32.div - (f32.const -1) - (f32.mul - (get_local $0) - (get_local $0) - ) - ) - ) - ) - (if - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - (return - (f32.div - (f32.sub - (get_local $0) - (get_local $0) - ) - (f32.const 0) - ) - ) - ) - (set_local $2 - (i32.sub - (get_local $2) - (i32.const 25) - ) - ) - (set_local $0 - (f32.mul - (get_local $0) - (f32.const 33554432) - ) - ) - (set_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - ) - (if - (i32.ge_u - (get_local $1) - (i32.const 2139095040) - ) - (return - (get_local $0) - ) - (if - (i32.eq - (get_local $1) - (i32.const 1065353216) - ) - (return - (f32.const 0) - ) - ) - ) - ) - (set_local $1 - (i32.add - (get_local $1) - (i32.sub - (i32.const 1065353216) - (i32.const 1060439283) - ) - ) - ) - (set_local $2 - (i32.add - (get_local $2) - (i32.sub - (i32.shr_s - (get_local $1) - (i32.const 23) - ) - (i32.const 127) - ) - ) - ) - (set_local $1 - (i32.add - (i32.and - (get_local $1) - (i32.const 8388607) - ) - (i32.const 1060439283) - ) - ) - (set_local $0 - (f32.reinterpret/i32 - (get_local $1) - ) - ) - (set_local $4 - (f32.sub - (get_local $0) - (f32.const 1) - ) - ) - (set_local $5 - (f32.div - (get_local $4) - (f32.add - (f32.const 2) - (get_local $4) - ) - ) - ) - (set_local $6 - (f32.mul - (get_local $5) - (get_local $5) - ) - ) - (set_local $7 - (f32.mul - (get_local $6) - (get_local $6) - ) - ) - (set_local $8 - (f32.mul - (get_local $7) - (f32.add - (f32.const 0.40000972151756287) - (f32.mul - (get_local $7) - (f32.const 0.24279078841209412) - ) - ) - ) - ) - (set_local $9 - (f32.mul - (get_local $6) - (f32.add - (f32.const 0.6666666269302368) - (f32.mul - (get_local $7) - (f32.const 0.2849878668785095) - ) - ) - ) - ) - (set_local $10 - (f32.add - (get_local $9) - (get_local $8) - ) - ) - (set_local $11 - (f32.mul - (f32.mul - (f32.const 0.5) - (get_local $4) - ) (get_local $4) ) ) - (set_local $12 - (f32.convert_s/i32 - (get_local $2) - ) - ) - (return - (f32.add - (f32.add - (f32.sub - (f32.add - (f32.mul - (get_local $5) - (f32.add - (get_local $11) - (get_local $10) - ) - ) - (f32.mul - (get_local $12) - (f32.const 9.05800061445916e-06) - ) - ) - (get_local $11) - ) - (get_local $4) - ) - (f32.mul - (get_local $12) - (f32.const 0.6931381225585938) - ) - ) - ) ) - (func $std/math/test_logf (; 14 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.log" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.scalbn" (; 15 ;) (type $FiF) (param $0 f64) (param $1 i32) (result f64) - (local $2 f64) - (nop) - (set_local $2 - (get_local $0) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 1023) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 8988465674311579538646525e283) - ) - ) - (set_local $1 - (i32.sub - (get_local $1) - (i32.const 1023) - ) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 1023) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 8988465674311579538646525e283) - ) - ) - (set_local $1 - (i32.sub - (get_local $1) - (i32.const 1023) - ) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 1023) - ) - (set_local $1 - (i32.const 1023) - ) - ) - ) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -1022) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 2.2250738585072014e-308) - ) - ) - (set_local $1 - (i32.add - (get_local $1) - (i32.const 1022) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -1022) - ) - (block - (set_local $2 - (f64.mul - (get_local $2) - (f64.const 2.2250738585072014e-308) - ) - ) - (set_local $1 - (i32.add - (get_local $1) - (i32.const 1022) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -1022) - ) - (set_local $1 - (i32.const -1022) - ) - ) - ) - ) - ) - ) - ) - (return - (f64.mul - (get_local $2) - (f64.reinterpret/i64 - (i64.shl - (i64.add - (i64.const 1023) - (i64.extend_u/i32 - (get_local $1) - ) - ) - (i64.const 52) - ) - ) - ) - ) - ) - (func "$(lib)/math/NativeMath.exp" (; 16 ;) (type $FF) (param $0 f64) (result f64) - (local $1 i32) - (local $2 f64) - (local $3 f64) - (local $4 f64) - (local $5 i32) - (local $6 i32) - (local $7 f64) - (local $8 f64) - (local $9 f64) - (nop) - (set_local $1 - (i32.wrap/i64 - (i64.shr_u - (i64.reinterpret/f64 - (get_local $0) - ) - (i64.const 32) - ) - ) - ) - (set_local $1 - (i32.and - (get_local $1) - (i32.const 2147483647) - ) - ) - (if - (i32.ge_u - (get_local $1) - (i32.const 1082532651) - ) - (block - (if - (f64.ne - (tee_local $2 - (get_local $0) - ) - (get_local $2) - ) - (return - (get_local $0) - ) - ) - (if - (f64.gt - (get_local $0) - (f64.const 709.782712893384) - ) - (block - (set_local $0 - (f64.mul - (get_local $0) - (f64.const 8988465674311579538646525e283) - ) - ) - (return - (get_local $0) - ) - ) - ) - (if - (f64.lt - (get_local $0) - (f64.const -708.3964185322641) - ) - (if - (f64.lt - (get_local $0) - (f64.const -745.1332191019411) - ) - (return - (f64.const 0) - ) - ) - ) - ) - ) - (nop) - (nop) - (if - (i32.gt_u - (get_local $1) - (i32.const 1071001154) - ) - (block - (if - (i32.ge_u - (get_local $1) - (i32.const 1072734898) - ) - (set_local $5 - (i32.trunc_s/f64 - (f64.add - (f64.mul - (f64.const 1.4426950408889634) - (get_local $0) - ) - (f64.copysign - (f64.const 0.5) - (get_local $0) - ) - ) - ) - ) - (block - (set_local $6 - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - ) - (set_local $5 - (i32.sub - (i32.sub - (i32.const 1) - (get_local $6) - ) - (get_local $6) - ) - ) - ) - ) - (set_local $3 - (f64.sub - (get_local $0) - (f64.mul - (f64.convert_s/i32 - (get_local $5) - ) - (f64.const 0.6931471803691238) - ) - ) - ) - (set_local $4 - (f64.mul - (f64.convert_s/i32 - (get_local $5) - ) - (f64.const 1.9082149292705877e-10) - ) - ) - (set_local $0 - (f64.sub - (get_local $3) - (get_local $4) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 1043333120) - ) - (block - (set_local $5 - (i32.const 0) - ) - (set_local $3 - (get_local $0) - ) - (set_local $4 - (f64.const 0) - ) - ) - (return - (f64.add - (f64.const 1) - (get_local $0) - ) - ) - ) - ) - (set_local $7 - (f64.mul - (get_local $0) - (get_local $0) - ) - ) - (set_local $8 - (f64.sub - (get_local $0) - (f64.mul - (get_local $7) - (f64.add - (f64.const 0.16666666666666602) - (f64.mul - (get_local $7) - (f64.add - (f64.const -2.7777777777015593e-03) - (f64.mul - (get_local $7) - (f64.add - (f64.const 6.613756321437934e-05) - (f64.mul - (get_local $7) - (f64.add - (f64.const -1.6533902205465252e-06) - (f64.mul - (get_local $7) - (f64.const 4.1381367970572385e-08) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - (set_local $9 - (f64.add - (f64.const 1) - (f64.add - (f64.sub - (f64.div - (f64.mul - (get_local $0) - (get_local $8) - ) - (f64.sub - (f64.const 2) - (get_local $8) - ) - ) - (get_local $4) - ) - (get_local $3) - ) - ) - ) - (if - (i32.eq - (get_local $5) - (i32.const 0) - ) - (return - (get_local $9) - ) - ) - (return - (call "$(lib)/math/NativeMath.scalbn" - (get_local $9) - (get_local $5) - ) - ) - ) - (func $std/math/test_exp (; 17 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.scalbn" (; 18 ;) (type $fif) (param $0 f32) (param $1 i32) (result f32) - (local $2 f32) - (nop) - (set_local $2 - (get_local $0) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 127) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1701411834604692317316873e14) - ) - ) - (set_local $1 - (i32.sub - (get_local $1) - (i32.const 127) - ) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 127) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1701411834604692317316873e14) - ) - ) - (set_local $1 - (i32.sub - (get_local $1) - (i32.const 127) - ) - ) - (if - (i32.gt_s - (get_local $1) - (i32.const 127) - ) - (set_local $1 - (i32.const 127) - ) - ) - ) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -126) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1.1754943508222875e-38) - ) - ) - (set_local $1 - (i32.add - (get_local $1) - (i32.const 126) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -126) - ) - (block - (set_local $2 - (f32.mul - (get_local $2) - (f32.const 1.1754943508222875e-38) - ) - ) - (set_local $1 - (i32.add - (get_local $1) - (i32.const 126) - ) - ) - (if - (i32.lt_s - (get_local $1) - (i32.const -126) - ) - (set_local $1 - (i32.const -126) - ) - ) - ) - ) - ) - ) - ) - (return - (f32.mul - (get_local $2) - (f32.reinterpret/i32 - (i32.shl - (i32.add - (i32.const 127) - (get_local $1) - ) - (i32.const 23) - ) - ) - ) - ) - ) - (func "$(lib)/math/NativeMathf.exp" (; 19 ;) (type $ff) (param $0 f32) (result f32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 f32) - (local $5 f32) - (local $6 i32) - (local $7 f32) - (local $8 f32) - (local $9 f32) - (nop) - (set_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (set_local $2 - (i32.shr_u - (get_local $1) - (i32.const 31) - ) - ) - (set_local $1 - (i32.and - (get_local $1) - (i32.const 2147483647) - ) - ) - (if - (i32.ge_u - (get_local $1) - (i32.const 1118743632) - ) - (block - (if - (i32.and - (if (result i32) - (tee_local $3 - (i32.ge_u - (get_local $1) - (i32.const 1118925336) - ) - ) - (i32.eqz - (get_local $2) - ) - (get_local $3) - ) - (i32.const 1) - ) - (block - (set_local $0 - (f32.mul - (get_local $0) - (f32.const 1701411834604692317316873e14) - ) - ) - (return - (get_local $0) - ) - ) - ) - (if - (get_local $2) - (if - (i32.ge_u - (get_local $1) - (i32.const 1120924085) - ) - (return - (f32.const 0) - ) - ) - ) - ) - ) - (nop) - (nop) - (if - (i32.gt_u - (get_local $1) - (i32.const 1051816472) - ) - (block - (if - (i32.gt_u - (get_local $1) - (i32.const 1065686418) - ) - (set_local $6 - (i32.trunc_s/f32 - (f32.add - (f32.mul - (f32.const 1.4426950216293335) - (get_local $0) - ) - (f32.copysign - (f32.const 0.5) - (get_local $0) - ) - ) - ) - ) - (set_local $6 - (i32.sub - (i32.sub - (i32.const 1) - (get_local $2) - ) - (get_local $2) - ) - ) - ) - (set_local $4 - (f32.sub - (get_local $0) - (f32.mul - (f32.convert_s/i32 - (get_local $6) - ) - (f32.const 0.693145751953125) - ) - ) - ) - (set_local $5 - (f32.mul - (f32.convert_s/i32 - (get_local $6) - ) - (f32.const 1.428606765330187e-06) - ) - ) - (set_local $0 - (f32.sub - (get_local $4) - (get_local $5) - ) - ) - ) - (if - (i32.gt_u - (get_local $1) - (i32.const 956301312) - ) - (block - (set_local $6 - (i32.const 0) - ) - (set_local $4 - (get_local $0) - ) - (set_local $5 - (f32.const 0) - ) - ) - (return - (f32.add - (f32.const 1) - (get_local $0) - ) - ) - ) - ) - (set_local $7 - (f32.mul - (get_local $0) - (get_local $0) - ) - ) - (set_local $8 - (f32.sub - (get_local $0) - (f32.mul - (get_local $7) - (f32.add - (f32.const 0.16666625440120697) - (f32.mul - (get_local $7) - (f32.const -2.7667332906275988e-03) - ) - ) - ) - ) - ) - (set_local $9 - (f32.add - (f32.const 1) - (f32.add - (f32.sub - (f32.div - (f32.mul - (get_local $0) - (get_local $8) - ) - (f32.sub - (f32.const 2) - (get_local $8) - ) - ) - (get_local $5) - ) - (get_local $4) - ) - ) - ) - (if - (i32.eq - (get_local $6) - (i32.const 0) - ) - (return - (get_local $9) - ) - ) - (return - (call "$(lib)/math/NativeMathf.scalbn" - (get_local $9) - (get_local $6) - ) - ) - ) - (func $std/math/test_expf (; 20 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.exp" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.sqrt" (; 21 ;) (type $FF) (param $0 f64) (result f64) - (return - (f64.sqrt - (get_local $0) - ) - ) - ) - (func "$(lib)/math/NativeMath.pow" (; 22 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (func "$(lib)/math/NativeMath.pow" (; 135 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) (local $2 i64) (local $3 i32) (local $4 i32) @@ -2495,27 +11437,6 @@ (f64.const 1) ) ) - (if - (i32.and - (if (result i32) - (tee_local $9 - (i32.eq - (get_local $3) - (i32.const 1072693248) - ) - ) - (i32.eq - (get_local $4) - (i32.const 0) - ) - (get_local $9) - ) - (i32.const 1) - ) - (return - (f64.const 1) - ) - ) (if (i32.and (if (result i32) @@ -2716,7 +11637,7 @@ (i32.const 0) ) (return - (f64.const 1) + (f64.const nan:0x8000000000000) ) (if (i32.ge_s @@ -2794,7 +11715,7 @@ (i32.const 0) ) (return - (call "$(lib)/math/NativeMath.sqrt" + (f64.sqrt (get_local $0) ) ) @@ -3095,7 +12016,7 @@ (f64.sub (f64.mul (get_local $20) - (f64.const 1.9259629911266174) + (f64.const 1.9259629911266175e-08) ) (f64.mul (get_local $23) @@ -3996,18 +12917,46 @@ ) ) ) - (func $std/math/test_pow (; 23 ;) (type $FFFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.pow" - (get_local $0) - (get_local $1) + (func $std/math/test_pow (; 136 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (local $5 i32) + (return + (i32.and + (if (result i32) + (tee_local $5 + (call $std/math/check + (call "$(lib)/math/NativeMath.pow" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (if (result i32) + (tee_local $5 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $5) + (call $std/math/check + (call "$(lib)/math/JSMath.pow" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + (get_local $5) + ) + (i32.const 1) ) - (get_local $2) - (get_local $3) - (get_local $4) ) ) - (func "$(lib)/math/NativeMathf.pow" (; 24 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (func "$(lib)/math/NativeMathf.pow" (; 137 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) (local $2 i32) (local $3 i32) (local $4 i32) @@ -4075,15 +13024,6 @@ (f32.const 1) ) ) - (if - (i32.eq - (get_local $2) - (i32.const 1065353216) - ) - (return - (f32.const 1) - ) - ) (if (i32.and (if (result i32) @@ -4184,7 +13124,7 @@ (i32.const 1065353216) ) (return - (f32.const 1) + (f32.const nan:0x400000) ) (if (i32.gt_s @@ -5347,440 +14287,20 @@ ) ) ) - (func $std/math/test_powf (; 25 ;) (type $ffffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.pow" - (get_local $0) - (get_local $1) - ) - (get_local $2) - (get_local $3) - (get_local $4) - ) - ) - (func "$(lib)/math/NativeMath.cbrt" (; 26 ;) (type $FF) (param $0 f64) (result f64) - (local $1 i64) - (local $2 i32) - (local $3 f64) - (local $4 f64) - (local $5 f64) - (local $6 f64) - (nop) - (set_local $1 - (i64.reinterpret/f64 - (get_local $0) - ) - ) - (set_local $2 - (i32.and - (i32.wrap/i64 - (i64.shr_u - (get_local $1) - (i64.const 32) - ) - ) - (i32.const 2147483647) - ) - ) - (if - (i32.ge_u - (get_local $2) - (i32.const 2146435072) - ) - (return - (f64.add - (get_local $0) - (get_local $0) - ) - ) - ) - (if - (i32.lt_u - (get_local $2) - (i32.const 1048576) - ) - (block - (set_local $1 - (i64.reinterpret/f64 - (f64.mul - (get_local $0) - (f64.const 18014398509481984) - ) - ) - ) - (set_local $2 - (i32.and - (i32.wrap/i64 - (i64.shr_u - (get_local $1) - (i64.const 32) - ) - ) - (i32.const 2147483647) - ) - ) - (if - (i32.eq - (get_local $2) - (i32.const 0) - ) - (return - (get_local $0) - ) - ) - (set_local $2 - (i32.add - (i32.div_u - (get_local $2) - (i32.const 3) - ) - (i32.const 696219795) - ) - ) - ) - (set_local $2 - (i32.add - (i32.div_u - (get_local $2) - (i32.const 3) - ) - (i32.const 715094163) - ) - ) - ) - (set_local $1 - (i64.and - (get_local $1) - (i64.shl - (i64.const 1) - (i64.const 63) - ) - ) - ) - (set_local $1 - (i64.or - (get_local $1) - (i64.shl - (i64.extend_u/i32 - (get_local $2) - ) - (i64.const 32) - ) - ) - ) - (set_local $3 - (f64.reinterpret/i64 - (get_local $1) - ) - ) - (set_local $4 - (f64.mul - (f64.mul - (get_local $3) - (get_local $3) - ) - (f64.div - (get_local $3) - (get_local $0) - ) - ) - ) - (set_local $3 - (f64.mul - (get_local $3) - (f64.add - (f64.add - (f64.const 1.87595182427177) - (f64.mul - (get_local $4) - (f64.add - (f64.const -1.8849797954337717) - (f64.mul - (get_local $4) - (f64.const 1.6214297201053545) - ) - ) - ) - ) - (f64.mul - (f64.mul - (f64.mul - (get_local $4) - (get_local $4) - ) - (get_local $4) - ) - (f64.add - (f64.const -0.758397934778766) - (f64.mul - (get_local $4) - (f64.const 0.14599619288661245) - ) - ) - ) - ) - ) - ) - (set_local $3 - (f64.reinterpret/i64 - (i64.and - (i64.add - (i64.reinterpret/f64 - (get_local $3) - ) - (i64.const 2147483648) - ) - (i64.const -1073741824) - ) - ) - ) - (set_local $5 - (f64.mul - (get_local $3) - (get_local $3) - ) - ) - (set_local $4 - (f64.div - (get_local $0) - (get_local $5) - ) - ) - (set_local $6 - (f64.add - (get_local $3) - (get_local $3) - ) - ) - (set_local $4 - (f64.div - (f64.sub - (get_local $4) - (get_local $3) - ) - (f64.add - (get_local $6) - (get_local $4) - ) - ) - ) - (set_local $3 - (f64.add - (get_local $3) - (f64.mul - (get_local $3) - (get_local $4) - ) - ) - ) + (func $std/math/test_powf (; 138 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) (return - (get_local $3) - ) - ) - (func $std/math/test_cbrt (; 27 ;) (type $FFFiv) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMath.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - (call $std/math/check - (call "$(lib)/math/JSMath.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMathf.cbrt" (; 28 ;) (type $ff) (param $0 f32) (result f32) - (local $1 i32) - (local $2 i32) - (local $3 f64) - (local $4 f64) - (nop) - (set_local $1 - (i32.reinterpret/f32 - (get_local $0) - ) - ) - (set_local $2 - (i32.and - (get_local $1) - (i32.const 2147483647) - ) - ) - (if - (i32.ge_u - (get_local $2) - (i32.const 2139095040) - ) - (return - (f32.add + (call $std/math/check + (call "$(lib)/math/NativeMathf.pow" (get_local $0) - (get_local $0) - ) - ) - ) - (if - (i32.lt_u - (get_local $2) - (i32.const 8388608) - ) - (block - (if - (i32.eq - (get_local $2) - (i32.const 0) - ) - (return - (get_local $0) - ) - ) - (set_local $1 - (i32.reinterpret/f32 - (f32.mul - (get_local $0) - (f32.const 16777216) - ) - ) - ) - (set_local $2 - (i32.and - (get_local $1) - (i32.const 2147483647) - ) - ) - (set_local $2 - (i32.add - (i32.div_u - (get_local $2) - (i32.const 3) - ) - (i32.const 642849266) - ) - ) - ) - (set_local $2 - (i32.add - (i32.div_u - (get_local $2) - (i32.const 3) - ) - (i32.const 709958130) - ) - ) - ) - (set_local $1 - (i32.and - (get_local $1) - (i32.const -2147483648) - ) - ) - (set_local $1 - (i32.or - (get_local $1) - (get_local $2) - ) - ) - (set_local $3 - (f64.promote/f32 - (f32.reinterpret/i32 (get_local $1) ) - ) - ) - (set_local $4 - (f64.mul - (f64.mul - (get_local $3) - (get_local $3) - ) - (get_local $3) - ) - ) - (set_local $3 - (f64.div - (f64.mul - (get_local $3) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (f64.promote/f32 - (get_local $0) - ) - ) - (get_local $4) - ) - ) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (get_local $4) - ) - (get_local $4) - ) - ) - ) - (set_local $4 - (f64.mul - (f64.mul - (get_local $3) - (get_local $3) - ) - (get_local $3) - ) - ) - (set_local $3 - (f64.div - (f64.mul - (get_local $3) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (f64.promote/f32 - (get_local $0) - ) - ) - (get_local $4) - ) - ) - (f64.add - (f64.add - (f64.promote/f32 - (get_local $0) - ) - (get_local $4) - ) - (get_local $4) - ) - ) - ) - (return - (f32.demote/f64 + (get_local $2) (get_local $3) + (get_local $4) ) ) ) - (func $std/math/test_cbrtf (; 29 ;) (type $fffiv) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) - (call $std/math/check - (call "$(lib)/math/NativeMathf.cbrt" - (get_local $0) - ) - (get_local $1) - (get_local $2) - (get_local $3) - ) - ) - (func "$(lib)/math/NativeMath.murmurHash3" (; 30 ;) (type $II) (param $0 i64) (result i64) + (func "$(lib)/math/murmurHash3" (; 139 ;) (type $II) (param $0 i64) (result i64) (set_local $0 (i64.xor (get_local $0) @@ -5824,7 +14344,7 @@ (get_local $0) ) ) - (func "$(lib)/math/NativeMath.seedRandom" (; 31 ;) (type $Iv) (param $0 i64) + (func "$(lib)/math/NativeMath.seedRandom" (; 140 ;) (type $Iv) (param $0 i64) (if (i64.eqz (get_local $0) @@ -5833,36 +14353,43 @@ (call $abort (i32.const 0) (i32.const 32) - (i32.const 613) + (i32.const 980) (i32.const 4) ) (unreachable) ) ) - (set_global "$(lib)/math/NativeMath.random_seeded" + (set_global "$(lib)/math/random_seeded" (i32.const 1) ) - (set_global "$(lib)/math/NativeMath.random_state0" - (call "$(lib)/math/NativeMath.murmurHash3" + (set_global "$(lib)/math/random_state0" + (call "$(lib)/math/murmurHash3" (get_local $0) ) ) - (set_global "$(lib)/math/NativeMath.random_state1" - (call "$(lib)/math/NativeMath.murmurHash3" - (get_global "$(lib)/math/NativeMath.random_state0") + (set_global "$(lib)/math/random_state1" + (call "$(lib)/math/murmurHash3" + (get_global "$(lib)/math/random_state0") ) ) ) - (func "$(lib)/math/NativeMath.xorShift128Plus" (; 32 ;) (type $I) (result i64) + (func "$(lib)/math/NativeMath.random" (; 141 ;) (type $F) (result f64) (local $0 i64) (local $1 i64) + (local $2 i64) + (if + (i32.eqz + (get_global "$(lib)/math/random_seeded") + ) + (unreachable) + ) (set_local $0 - (get_global "$(lib)/math/NativeMath.random_state0") + (get_global "$(lib)/math/random_state0") ) (set_local $1 - (get_global "$(lib)/math/NativeMath.random_state1") + (get_global "$(lib)/math/random_state1") ) - (set_global "$(lib)/math/NativeMath.random_state0" + (set_global "$(lib)/math/random_state0" (get_local $1) ) (set_local $0 @@ -5898,29 +14425,16 @@ ) ) ) - (set_global "$(lib)/math/NativeMath.random_state1" + (set_global "$(lib)/math/random_state1" (get_local $0) ) - (return - (i64.add - (get_local $1) - (get_local $0) - ) - ) - ) - (func "$(lib)/math/NativeMath.random" (; 33 ;) (type $F) (result f64) - (local $0 i64) - (nop) - (if - (i32.eqz - (get_global "$(lib)/math/NativeMath.random_seeded") - ) - (unreachable) - ) - (set_local $0 + (set_local $2 (i64.or (i64.and - (call "$(lib)/math/NativeMath.xorShift128Plus") + (i64.add + (get_local $1) + (get_local $0) + ) (i64.const 4503599627370495) ) (i64.const 4607182418800017408) @@ -5929,16 +14443,2402 @@ (return (f64.sub (f64.reinterpret/i64 - (get_local $0) + (get_local $2) ) (f64.const 1) ) ) ) - (func $start (; 34 ;) (type $v) + (func "$(lib)/math/NativeMathf.seedRandom" (; 142 ;) (type $Iv) (param $0 i64) + (call "$(lib)/math/NativeMath.seedRandom" + (get_local $0) + ) + ) + (func "$(lib)/math/NativeMathf.random" (; 143 ;) (type $f) (result f32) + (return + (f32.demote/f64 + (call "$(lib)/math/NativeMath.random") + ) + ) + ) + (func "$(lib)/math/NativeMath.round" (; 144 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 f64) + (nop) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $1) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.ge_s + (get_local $2) + (i32.add + (i32.const 1023) + (i32.const 52) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.sub + (i32.const 1023) + (i32.const 1) + ) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (nop) + (if + (i64.ne + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $3 + (f64.add + (f64.sub + (f64.sub + (f64.const 4503599627370496) + (get_local $0) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (if + (f64.ge + (get_local $3) + (f64.const 0.5) + ) + (set_local $3 + (f64.add + (f64.sub + (get_local $0) + (get_local $3) + ) + (f64.const 1) + ) + ) + (if + (f64.lt + (get_local $3) + (f64.const -0.5) + ) + (set_local $3 + (f64.sub + (f64.sub + (get_local $0) + (get_local $3) + ) + (f64.const 1) + ) + ) + (set_local $3 + (f64.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + ) + (block + (set_local $3 + (f64.sub + (f64.sub + (f64.add + (get_local $0) + (f64.const 4503599627370496) + ) + (f64.const 4503599627370496) + ) + (get_local $0) + ) + ) + (if + (f64.gt + (get_local $3) + (f64.const 0.5) + ) + (set_local $3 + (f64.sub + (f64.add + (get_local $3) + (get_local $0) + ) + (f64.const 1) + ) + ) + (if + (f64.le + (get_local $3) + (f64.const -0.5) + ) + (set_local $3 + (f64.add + (f64.add + (get_local $3) + (get_local $0) + ) + (f64.const 1) + ) + ) + (set_local $3 + (f64.add + (get_local $3) + (get_local $0) + ) + ) + ) + ) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/math/test_round (; 145 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMath.round" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMathf.round" (; 146 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (nop) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.and + (i32.shr_u + (get_local $1) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (if + (i32.ge_s + (get_local $2) + (i32.add + (i32.const 127) + (i32.const 23) + ) + ) + (return + (get_local $0) + ) + ) + (if + (i32.lt_s + (get_local $2) + (i32.sub + (i32.const 127) + (i32.const 1) + ) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (block + (set_local $3 + (f32.add + (f32.sub + (f32.sub + (f32.const 8388608) + (get_local $0) + ) + (f32.const 8388608) + ) + (get_local $0) + ) + ) + (if + (f32.ge + (get_local $3) + (f32.const 0.5) + ) + (set_local $3 + (f32.add + (f32.sub + (get_local $0) + (get_local $3) + ) + (f32.const 1) + ) + ) + (if + (f32.lt + (get_local $3) + (f32.const -0.5) + ) + (set_local $3 + (f32.sub + (f32.sub + (get_local $0) + (get_local $3) + ) + (f32.const 1) + ) + ) + (set_local $3 + (f32.sub + (get_local $0) + (get_local $3) + ) + ) + ) + ) + ) + (block + (set_local $3 + (f32.sub + (f32.sub + (f32.add + (get_local $0) + (f32.const 8388608) + ) + (f32.const 8388608) + ) + (get_local $0) + ) + ) + (if + (f32.gt + (get_local $3) + (f32.const 0.5) + ) + (set_local $3 + (f32.sub + (f32.add + (get_local $3) + (get_local $0) + ) + (f32.const 1) + ) + ) + (if + (f32.le + (get_local $3) + (f32.const -0.5) + ) + (set_local $3 + (f32.add + (f32.add + (get_local $3) + (get_local $0) + ) + (f32.const 1) + ) + ) + (set_local $3 + (f32.add + (get_local $3) + (get_local $0) + ) + ) + ) + ) + ) + ) + (return + (get_local $3) + ) + ) + (func $std/math/test_roundf (; 147 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.round" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.sign" (; 148 ;) (type $FF) (param $0 f64) (result f64) + (return + (if (result f64) + (f64.gt + (get_local $0) + (f64.const 0) + ) + (f64.const 1) + (if (result f64) + (f64.lt + (get_local $0) + (f64.const 0) + ) + (f64.const -1) + (get_local $0) + ) + ) + ) + ) + (func $std/math/test_sign (; 149 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.sign" (; 150 ;) (type $ff) (param $0 f32) (result f32) + (return + (if (result f32) + (f32.gt + (get_local $0) + (f32.const 0) + ) + (f32.const 1) + (if (result f32) + (f32.lt + (get_local $0) + (f32.const 0) + ) + (f32.const -1) + (get_local $0) + ) + ) + ) + ) + (func $std/math/test_signf (; 151 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.sign" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.rem" (; 152 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 f64) + (local $9 i32) + (local $10 i64) + (local $11 i64) + (local $12 i32) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $3) + (i64.const 63) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.and + (if (result i32) + (tee_local $9 + (i64.eq + (i64.shl + (get_local $3) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $9) + (f64.ne + (tee_local $8 + (get_local $1) + ) + (get_local $8) + ) + ) + (i32.const 1) + ) + ) + (get_local $9) + (i32.eq + (get_local $4) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.eq + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.const 0) + ) + (return + (get_local $0) + ) + ) + (set_local $10 + (get_local $2) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $11 + (i64.shl + (get_local $10) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eq + (i64.shr_u + (get_local $11) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (block + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $11 + (i64.shl + (get_local $11) + (i64.const 1) + ) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $10 + (i64.shl + (get_local $10) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $10 + (i64.and + (get_local $10) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $10 + (i64.or + (get_local $10) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $11 + (i64.shl + (get_local $3) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eq + (i64.shr_u + (get_local $11) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (block + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $11 + (i64.shl + (get_local $11) + (i64.const 1) + ) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i64.shl + (get_local $3) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $3 + (i64.and + (get_local $3) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $3 + (i64.or + (get_local $3) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (set_local $12 + (i32.const 0) + ) + (block $break|2 + (loop $continue|2 + (block + (if + (i32.lt_s + (get_local $4) + (get_local $5) + ) + (block + (if + (i32.eq + (i32.add + (get_local $4) + (i32.const 1) + ) + (get_local $5) + ) + (br $break|2) + ) + (return + (get_local $0) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $11 + (i64.sub + (get_local $10) + (get_local $3) + ) + ) + (if + (i64.eq + (i64.shr_u + (get_local $11) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $10 + (get_local $11) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (set_local $10 + (i64.shl + (get_local $10) + (i64.const 1) + ) + ) + (set_local $12 + (i32.shl + (get_local $12) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (set_local $11 + (i64.sub + (get_local $10) + (get_local $3) + ) + ) + (if + (i64.eq + (i64.shr_u + (get_local $11) + (i64.const 63) + ) + (i64.const 0) + ) + (block + (set_local $10 + (get_local $11) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (if + (i64.eq + (get_local $10) + (i64.const 0) + ) + (set_local $4 + (i32.const -60) + ) + (block $break|4 + (nop) + (loop $continue|4 + (if + (i64.eq + (i64.shr_u + (get_local $10) + (i64.const 52) + ) + (i64.const 0) + ) + (block + (block + ) + (block + (set_local $10 + (i64.shl + (get_local $10) + (i64.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + ) + (br $continue|4) + ) + ) + ) + ) + ) + (br $break|2) + ) + (br_if $continue|2 + (i32.const 0) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $10 + (i64.sub + (get_local $10) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + (set_local $10 + (i64.or + (get_local $10) + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 52) + ) + ) + ) + ) + (set_local $10 + (i64.shr_u + (get_local $10) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $10) + ) + ) + (if + (get_local $7) + (set_local $1 + (f64.neg + (get_local $1) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $9 + (i32.eq + (get_local $4) + (get_local $5) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (i32.eq + (i32.add + (get_local $4) + (i32.const 1) + ) + (get_local $5) + ) + ) + (if (result i32) + (tee_local $9 + (f64.gt + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (get_local $9) + (if (result i32) + (tee_local $9 + (f64.eq + (f64.mul + (f64.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (i32.and + (i32.rem_u + (get_local $12) + (i32.const 2) + ) + (i32.const 1) + ) + (get_local $9) + ) + ) + (get_local $9) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f64.sub + (get_local $0) + (get_local $1) + ) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (set_local $12 + (i32.and + (get_local $12) + (i32.const 2147483647) + ) + ) + (return + (if (result f64) + (get_local $6) + (f64.neg + (get_local $0) + ) + (get_local $0) + ) + ) + ) + (func $std/math/test_rem (; 153 ;) (type $FFFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 f64) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMath.rem" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMathf.rem" (; 154 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 f32) + (local $11 i32) + (local $12 i32) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $5 + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.shr_u + (get_local $2) + (i32.const 31) + ) + ) + (set_local $7 + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (nop) + (set_local $9 + (get_local $2) + ) + (if + (i32.and + (if (result i32) + (tee_local $11 + (i32.and + (if (result i32) + (tee_local $11 + (i32.eq + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 0) + ) + ) + (get_local $11) + (f32.ne + (tee_local $10 + (get_local $1) + ) + (get_local $10) + ) + ) + (i32.const 1) + ) + ) + (get_local $11) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.const 0) + ) + (return + (get_local $0) + ) + ) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $8 + (i32.shl + (get_local $9) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eq + (i32.shr_u + (get_local $8) + (i32.const 31) + ) + (i32.const 0) + ) + (block + (block + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $8 + (i32.shl + (get_local $8) + (i32.const 1) + ) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $9 + (i32.and + (get_local $9) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $9 + (i32.or + (get_local $9) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $8 + (i32.shl + (get_local $3) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eq + (i32.shr_u + (get_local $8) + (i32.const 31) + ) + (i32.const 0) + ) + (block + (block + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $8 + (i32.shl + (get_local $8) + (i32.const 1) + ) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $3 + (i32.and + (get_local $3) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $3 + (i32.or + (get_local $3) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (set_local $12 + (i32.const 0) + ) + (block $break|2 + (loop $continue|2 + (block + (if + (i32.lt_s + (get_local $4) + (get_local $5) + ) + (block + (if + (i32.eq + (i32.add + (get_local $4) + (i32.const 1) + ) + (get_local $5) + ) + (br $break|2) + ) + (return + (get_local $0) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $8 + (i32.sub + (get_local $9) + (get_local $3) + ) + ) + (if + (i32.eq + (i32.shr_u + (get_local $8) + (i32.const 31) + ) + (i32.const 0) + ) + (block + (set_local $9 + (get_local $8) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (set_local $12 + (i32.shl + (get_local $12) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (set_local $8 + (i32.sub + (get_local $9) + (get_local $3) + ) + ) + (if + (i32.eq + (i32.shr_u + (get_local $8) + (i32.const 31) + ) + (i32.const 0) + ) + (block + (set_local $9 + (get_local $8) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (if + (i32.eq + (get_local $9) + (i32.const 0) + ) + (set_local $4 + (i32.const -30) + ) + (block $break|4 + (nop) + (loop $continue|4 + (if + (i32.eq + (i32.shr_u + (get_local $9) + (i32.const 23) + ) + (i32.const 0) + ) + (block + (block + ) + (block + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + ) + (br $continue|4) + ) + ) + ) + ) + ) + (br $break|2) + ) + (br_if $continue|2 + (i32.const 0) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $9 + (i32.sub + (get_local $9) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (set_local $9 + (i32.or + (get_local $9) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + ) + (set_local $9 + (i32.shr_u + (get_local $9) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $9) + ) + ) + (if + (get_local $7) + (set_local $1 + (f32.neg + (get_local $1) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $11 + (i32.eq + (get_local $4) + (get_local $5) + ) + ) + (get_local $11) + (if (result i32) + (tee_local $11 + (i32.eq + (i32.add + (get_local $4) + (i32.const 1) + ) + (get_local $5) + ) + ) + (if (result i32) + (tee_local $11 + (f32.gt + (f32.mul + (f32.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (get_local $11) + (if (result i32) + (tee_local $11 + (f32.eq + (f32.mul + (f32.const 2) + (get_local $0) + ) + (get_local $1) + ) + ) + (i32.and + (i32.rem_s + (get_local $12) + (i32.const 2) + ) + (i32.const 1) + ) + (get_local $11) + ) + ) + (get_local $11) + ) + ) + (i32.const 1) + ) + (block + (set_local $0 + (f32.sub + (get_local $0) + (get_local $1) + ) + ) + (set_local $12 + (i32.add + (get_local $12) + (i32.const 1) + ) + ) + ) + ) + (set_local $12 + (i32.and + (get_local $12) + (i32.const 2147483647) + ) + ) + (return + (if (result f32) + (get_local $6) + (f32.neg + (get_local $0) + ) + (get_local $0) + ) + ) + ) + (func $std/math/test_remf (; 155 ;) (type $ffffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 f32) (param $4 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.rem" + (get_local $0) + (get_local $1) + ) + (get_local $2) + (get_local $3) + (get_local $4) + ) + ) + ) + (func "$(lib)/math/NativeMath.sinh" (; 156 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 f64) + (local $3 f64) + (local $4 i32) + (local $5 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (f64.const 0.5) + ) + (if + (i64.ne + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + (i64.const 0) + ) + (set_local $2 + (f64.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $3 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $4) + (i32.const 1082535490) + ) + (block + (set_local $5 + (call "$(lib)/math/NativeMath.expm1" + (get_local $3) + ) + ) + (if + (i32.lt_u + (get_local $4) + (i32.const 1072693248) + ) + (block + (if + (i32.lt_u + (get_local $4) + (i32.sub + (i32.const 1072693248) + (i32.shl + (i32.const 26) + (i32.const 20) + ) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.sub + (f64.mul + (f64.const 2) + (get_local $5) + ) + (f64.div + (f64.mul + (get_local $5) + (get_local $5) + ) + (f64.add + (get_local $5) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f64.mul + (get_local $2) + (f64.add + (get_local $5) + (f64.div + (get_local $5) + (f64.add + (get_local $5) + (f64.const 1) + ) + ) + ) + ) + ) + ) + ) + (set_local $5 + (f64.mul + (f64.mul + (f64.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMath.__expo2" + (get_local $3) + ) + ) + ) + (return + (get_local $5) + ) + ) + (func $std/math/test_sinh (; 157 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.sinh" (; 158 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 f32) + (local $3 f32) + (local $4 f32) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (f32.const 0.5) + ) + (if + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + (set_local $2 + (f32.neg + (get_local $2) + ) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $3 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (nop) + (if + (i32.lt_u + (get_local $1) + (i32.const 1118925335) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMathf.expm1" + (get_local $3) + ) + ) + (if + (i32.lt_u + (get_local $1) + (i32.const 1065353216) + ) + (block + (if + (i32.lt_u + (get_local $1) + (i32.sub + (i32.const 1065353216) + (i32.shl + (i32.const 12) + (i32.const 23) + ) + ) + ) + (return + (get_local $0) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.sub + (f32.mul + (f32.const 2) + (get_local $4) + ) + (f32.div + (f32.mul + (get_local $4) + (get_local $4) + ) + (f32.add + (get_local $4) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + (return + (f32.mul + (get_local $2) + (f32.add + (get_local $4) + (f32.div + (get_local $4) + (f32.add + (get_local $4) + (f32.const 1) + ) + ) + ) + ) + ) + ) + ) + (set_local $4 + (f32.mul + (f32.mul + (f32.const 2) + (get_local $2) + ) + (call "$(lib)/math/NativeMathf.__expo2" + (get_local $3) + ) + ) + ) + (return + (get_local $4) + ) + ) + (func $std/math/test_sinhf (; 159 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.sinh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.sqrt" (; 160 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.sqrt + (get_local $0) + ) + ) + ) + (func $std/math/test_sqrt (; 161 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.sqrt" (; 162 ;) (type $ff) (param $0 f32) (result f32) + (return + (f32.sqrt + (get_local $0) + ) + ) + ) + (func $std/math/test_sqrtf (; 163 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.sqrt" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.tanh" (; 164 ;) (type $FF) (param $0 f64) (result f64) + (local $1 i64) + (local $2 i32) + (local $3 i32) + (local $4 f64) + (set_local $1 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $2 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 63) + ) + ) + ) + (set_local $1 + (i64.and + (get_local $1) + (i64.const 9223372036854775807) + ) + ) + (set_local $0 + (f64.reinterpret/i64 + (get_local $1) + ) + ) + (set_local $3 + (i32.wrap/i64 + (i64.shr_u + (get_local $1) + (i64.const 32) + ) + ) + ) + (nop) + (if + (i32.gt_u + (get_local $3) + (i32.const 1071748074) + ) + (if + (i32.gt_u + (get_local $3) + (i32.const 1077149696) + ) + (set_local $4 + (f64.sub + (f64.const 1) + (f64.div + (f64.const 0) + (get_local $0) + ) + ) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.sub + (f64.const 1) + (f64.div + (f64.const 2) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $3) + (i32.const 1070618798) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const 2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.div + (get_local $4) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $3) + (i32.const 1048576) + ) + (block + (set_local $4 + (call "$(lib)/math/NativeMath.expm1" + (f64.mul + (f64.const -2) + (get_local $0) + ) + ) + ) + (set_local $4 + (f64.div + (f64.neg + (get_local $4) + ) + (f64.add + (get_local $4) + (f64.const 2) + ) + ) + ) + ) + (set_local $4 + (get_local $0) + ) + ) + ) + ) + (return + (if (result f64) + (get_local $2) + (f64.neg + (get_local $4) + ) + (get_local $4) + ) + ) + ) + (func $std/math/test_tanh (; 165 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.tanh" (; 166 ;) (type $ff) (param $0 f32) (result f32) + (local $1 i32) + (local $2 i32) + (local $3 f32) + (set_local $1 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $1) + (i32.const 31) + ) + ) + (set_local $1 + (i32.and + (get_local $1) + (i32.const 2147483647) + ) + ) + (set_local $0 + (f32.reinterpret/i32 + (get_local $1) + ) + ) + (nop) + (if + (i32.gt_u + (get_local $1) + (i32.const 1057791828) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1092616192) + ) + (set_local $3 + (f32.add + (f32.const 1) + (f32.div + (f32.const 0) + (get_local $0) + ) + ) + ) + (block + (set_local $3 + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const 2) + (get_local $0) + ) + ) + ) + (set_local $3 + (f32.sub + (f32.const 1) + (f32.div + (f32.const 2) + (f32.add + (get_local $3) + (f32.const 2) + ) + ) + ) + ) + ) + ) + (if + (i32.gt_u + (get_local $1) + (i32.const 1048757624) + ) + (block + (set_local $3 + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const 2) + (get_local $0) + ) + ) + ) + (set_local $3 + (f32.div + (get_local $3) + (f32.add + (get_local $3) + (f32.const 2) + ) + ) + ) + ) + (if + (i32.ge_u + (get_local $1) + (i32.const 8388608) + ) + (block + (set_local $3 + (call "$(lib)/math/NativeMathf.expm1" + (f32.mul + (f32.const -2) + (get_local $0) + ) + ) + ) + (set_local $3 + (f32.div + (f32.neg + (get_local $3) + ) + (f32.add + (get_local $3) + (f32.const 2) + ) + ) + ) + ) + (set_local $3 + (get_local $0) + ) + ) + ) + ) + (return + (if (result f32) + (get_local $2) + (f32.neg + (get_local $3) + ) + (get_local $3) + ) + ) + ) + (func $std/math/test_tanhf (; 167 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.tanh" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func "$(lib)/math/NativeMath.trunc" (; 168 ;) (type $FF) (param $0 f64) (result f64) + (return + (f64.trunc + (get_local $0) + ) + ) + ) + (func $std/math/test_trunc (; 169 ;) (type $FFFii) (param $0 f64) (param $1 f64) (param $2 f64) (param $3 i32) (result i32) + (local $4 i32) + (return + (i32.and + (if (result i32) + (tee_local $4 + (call $std/math/check + (call "$(lib)/math/NativeMath.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (if (result i32) + (tee_local $4 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $4) + (call $std/math/check + (call "$(lib)/math/JSMath.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.trunc" (; 170 ;) (type $ff) (param $0 f32) (result f32) + (return + (f32.trunc + (get_local $0) + ) + ) + ) + (func $std/math/test_truncf (; 171 ;) (type $fffii) (param $0 f32) (param $1 f32) (param $2 f32) (param $3 i32) (result i32) + (return + (call $std/math/check + (call "$(lib)/math/NativeMathf.trunc" + (get_local $0) + ) + (get_local $1) + (get_local $2) + (get_local $3) + ) + ) + ) + (func $start (; 172 ;) (type $v) (local $0 i32) (local $1 f64) (local $2 i32) + (local $3 f32) (if (i32.eqz (f64.eq @@ -5950,3416 +16850,31039 @@ (call $abort (i32.const 0) (i32.const 4) - (i32.const 4) + (i32.const 112) (i32.const 0) ) (unreachable) ) ) - (call $std/math/test_fmod - (f64.const -8.06684839057968) - (f64.const 4.535662560676869) - (f64.const -3.531185829902812) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 4.345239849338305) - (f64.const -8.88799136300345) - (f64.const 4.345239849338305) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -8.38143342755525) - (f64.const -2.763607337379588) - (f64.const -0.09061141541648476) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -6.531673581913484) - (f64.const 4.567535276842744) - (f64.const -1.9641383050707404) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 9.267056966972586) - (f64.const 4.811392084359796) - (f64.const 4.45566488261279) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -6.450045556060236) - (f64.const 0.6620717923376739) - (f64.const -0.4913994250211714) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 7.858890253041697) - (f64.const 0.05215452675006225) - (f64.const 0.035711240532359426) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.792054511984896) - (f64.const 7.67640268511754) - (f64.const -0.792054511984896) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0.615702673197924) - (f64.const 2.0119025790324803) - (f64.const 0.615702673197924) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.5587586823609152) - (f64.const 0.03223983060263804) - (f64.const -0.0106815621160685) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0.5) - (f64.const 1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.5) - (f64.const 1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.5) - (f64.const 1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.5) - (f64.const 1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 2) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -2) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0.5) - (f64.const -1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0.5) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.5) - (f64.const -1) - (f64.const 0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.5) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 2) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -2) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const inf) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.neg - (f64.const inf) - ) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const 2) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const 2) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.const inf) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 1) - (f64.neg - (f64.const inf) - ) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1) - (f64.neg - (f64.const inf) - ) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const inf) - (f64.neg - (f64.const inf) - ) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.neg - (f64.const inf) - ) - (f64.neg - (f64.const inf) - ) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_fmod - (f64.const 1.75) - (f64.const 0.5) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.75) - (f64.const 0.5) - (f64.const -0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const 1.75) - (f64.const -0.5) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmod - (f64.const -1.75) - (f64.const -0.5) - (f64.const -0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -8.066848754882812) - (f32.const 4.535662651062012) - (f32.const -3.531186103820801) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 4.345239639282227) - (f32.const -8.887990951538086) - (f32.const 4.345239639282227) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -8.381433486938477) - (f32.const -2.7636072635650635) - (f32.const -0.09061169624328613) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -6.531673431396484) - (f32.const 4.567535400390625) - (f32.const -1.9641380310058594) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 9.267057418823242) - (f32.const 4.811392307281494) - (f32.const 4.455665111541748) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -6.450045585632324) - (f32.const 0.6620717644691467) - (f32.const -0.49139970541000366) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 7.858890056610107) - (f32.const 0.052154526114463806) - (f32.const 0.0357111394405365) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.7920545339584351) - (f32.const 7.676402568817139) - (f32.const -0.7920545339584351) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0.6157026886940002) - (f32.const 2.0119025707244873) - (f32.const 0.6157026886940002) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5587586760520935) - (f32.const 0.03223983198404312) - (f32.const -0.010681532323360443) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0.5) - (f32.const 1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5) - (f32.const 1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.5) - (f32.const 1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.5) - (f32.const 1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 2) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -2) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0.5) - (f32.const -1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0.5) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.5) - (f32.const -1) - (f32.const 0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.5) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 2) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -2) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const inf) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.neg - (f32.const inf) - ) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const 0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const -0) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const 2) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const 2) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.const inf) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.const inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 1) - (f32.neg - (f32.const inf) - ) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1) - (f32.neg - (f32.const inf) - ) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const inf) - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.neg - (f32.const inf) - ) - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_fmodf - (f32.const 1.75) - (f32.const 0.5) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.75) - (f32.const 0.5) - (f32.const -0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const 1.75) - (f32.const -0.5) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_fmodf - (f32.const -1.75) - (f32.const -0.5) - (f32.const -0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.const -8.06684839057968) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 4.345239849338305) - (f64.const 1.4690809584224322) - (f64.const -0.3412533402442932) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -8.38143342755525) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const -6.531673581913484) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 9.267056966972586) - (f64.const 2.2264658498795615) - (f64.const 0.3638114035129547) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const 0.6619858980995045) - (f64.const -0.4125110252365137) - (f64.const -0.29108747839927673) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -0.4066039223853553) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 0.5617597462207241) - (f64.const -0.5766810183195862) - (f64.const -0.10983199626207352) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const 0.7741522965913037) - (f64.const -0.2559866591263865) - (f64.const -0.057990044355392456) - (i32.const 1) - ) - (call $std/math/test_log - (f64.const -0.6787637026394024) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 0) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_log - (f64.const -0) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_log - (f64.const -7.888609052210118e-31) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_log - (f64.neg - (f64.const inf) - ) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_log - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const 0) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -0) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -7.888609052210118e-31) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const 0) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -0) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_logf - (f32.const -7.888609052210118e-31) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_logf - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_logf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const -8.06684839057968) - (f64.const 3.137706068161745e-04) - (f64.const -0.2599197328090668) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 4.345239849338305) - (f64.const 77.11053017112141) - (f64.const -0.02792675793170929) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -8.38143342755525) - (f64.const 2.290813384916323e-04) - (f64.const -0.24974334239959717) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -6.531673581913484) - (f64.const 1.4565661260931588e-03) - (f64.const -0.4816822409629822) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 9.267056966972586) - (f64.const 10583.558245524993) - (f64.const 0.17696762084960938) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.6619858980995045) - (f64.const 1.9386384525571998) - (f64.const -0.4964246451854706) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -0.4066039223853553) - (f64.const 0.6659078892838025) - (f64.const -0.10608318448066711) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.5617597462207241) - (f64.const 1.7537559518626311) - (f64.const -0.39162111282348633) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0.7741522965913037) - (f64.const 2.1687528885129246) - (f64.const -0.2996125817298889) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -0.6787637026394024) - (f64.const 0.5072437089402843) - (f64.const 0.47261738777160645) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const 1) - (f64.const 2.718281828459045) - (f64.const -0.3255307376384735) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -1) - (f64.const 0.36787944117144233) - (f64.const 0.22389651834964752) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_exp - (f64.const 1.0397214889526365) - (f64.const 2.828429155876411) - (f64.const 0.18803080916404724) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const -1.0397214889526365) - (f64.const 0.35355313670217847) - (f64.const 0.2527272403240204) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 1.0397210121154785) - (f64.const 2.8284278071766122) - (f64.const -0.4184139370918274) - (i32.const 1) - ) - (call $std/math/test_exp - (f64.const 1.0397214889526367) - (f64.const 2.8284291558764116) - (f64.const -0.22618377208709717) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -8.066848754882812) - (f32.const 3.1377049162983894e-04) - (f32.const -0.030193336308002472) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 4.345239639282227) - (f32.const 77.11051177978516) - (f32.const -0.2875460684299469) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -8.381433486938477) - (f32.const 2.2908132814336568e-04) - (f32.const 0.2237040400505066) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -6.531673431396484) - (f32.const 1.4565663877874613e-03) - (f32.const 0.36469703912734985) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 9.267057418823242) - (f32.const 10583.5634765625) - (f32.const 0.45962104201316833) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.6619858741760254) - (f32.const 1.93863844871521) - (f32.const 0.3568260967731476) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -0.40660393238067627) - (f32.const 0.6659078598022461) - (f32.const -0.38294991850852966) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.5617597699165344) - (f32.const 1.753756046295166) - (f32.const 0.44355490803718567) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.7741522789001465) - (f32.const 2.168752908706665) - (f32.const 0.24562469124794006) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -0.6787636876106262) - (f32.const 0.5072436928749084) - (f32.const -0.3974292278289795) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const 1) - (f32.const 2.7182817459106445) - (f32.const -0.3462330996990204) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const -1) - (f32.const 0.3678794503211975) - (f32.const 0.3070148527622223) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_expf - (f32.const 88.72283172607422) - (f32.const 340279851902147610656242e15) - (f32.const -0.09067153930664062) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 88.72283935546875) - (f32.const inf) - (f32.const 0) - (i32.or - (i32.const 1) - (i32.const 16) - ) - ) - (call $std/math/test_expf - (f32.const -103.97207641601562) - (f32.const 1.401298464324817e-45) - (f32.const 0.49999967217445374) - (i32.or - (i32.const 1) - (i32.const 8) - ) - ) - (call $std/math/test_expf - (f32.const -103.97208404541016) - (f32.const 0) - (f32.const -0.49999651312828064) - (i32.or - (i32.const 1) - (i32.const 8) - ) - ) - (call $std/math/test_expf - (f32.const 0.3465735614299774) - (f32.const 1.4142135381698608) - (f32.const 0.13922421634197235) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.3465735912322998) - (f32.const 1.4142135381698608) - (f32.const -0.21432916820049286) - (i32.const 1) - ) - (call $std/math/test_expf - (f32.const 0.3465736210346222) - (f32.const 1.4142136573791504) - (f32.const 0.43211743235588074) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -8.06684839057968) - (f64.const 4.535662560676869) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 4.345239849338305) - (f64.const -8.88799136300345) - (f64.const 2.1347118825587285e-06) - (f64.const 0.3250160217285156) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -8.38143342755525) - (f64.const -2.763607337379588) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -6.531673581913484) - (f64.const 4.567535276842744) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 9.267056966972586) - (f64.const 4.811392084359796) - (f64.const 44909.29941512966) - (f64.const -0.26659080386161804) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -6.450045556060236) - (f64.const 0.6620717923376739) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 7.858890253041697) - (f64.const 0.05215452675006225) - (f64.const 1.1135177413458652) - (f64.const -0.37168607115745544) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -0.792054511984896) - (f64.const 7.67640268511754) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 0.615702673197924) - (f64.const 2.0119025790324803) - (f64.const 0.37690773521380183) - (f64.const 0.32473301887512207) - (i32.const 1) - ) - (call $std/math/test_pow - (f64.const -0.5587586823609152) - (f64.const 0.03223983060263804) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 3) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -1) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -2) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -3) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.const -4) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const 0) - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 3) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -1) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -2) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -3) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.const -4) - (f64.const inf) - (f64.const 0) - (i32.const 4) - ) - (call $std/math/test_pow - (f64.const -0) - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const -0) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.neg - (f64.const inf) - ) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 2) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -1) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -2) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const -3) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -1) - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const inf) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.neg - (f64.const inf) - ) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 3) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const 0.5) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -0.5) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1) - (f64.const -3) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 1.5) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 2) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 2) - (f64.const 0.25) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const 3) - (f64.const -0.125) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -0.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 0.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const 1.5) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 3) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 2) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 1) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -1) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const inf) - (f64.const -2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const 3) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const 2) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const 1) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const 0.5) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const -0.5) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const -1) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.neg - (f64.const inf) - ) - (f64.const -2) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const 1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const nan:0x8000000000000) - (f64.const -1) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -2) - (f64.const 1) - (f64.const -2) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_pow - (f64.const -2) - (f64.const -1) - (f64.const -0.5) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -8.066848754882812) - (f32.const 4.535662651062012) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 4.345239639282227) - (f32.const -8.887990951538086) - (f32.const 2.134714122803416e-06) - (f32.const 0.1436440795660019) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -8.381433486938477) - (f32.const -2.7636072635650635) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -6.531673431396484) - (f32.const 4.567535400390625) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 9.267057418823242) - (f32.const 4.811392307281494) - (f32.const 44909.33203125) - (f32.const -0.05356409028172493) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -6.450045585632324) - (f32.const 0.6620717644691467) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 7.858890056610107) - (f32.const 0.052154526114463806) - (f32.const 1.1135177612304688) - (f32.const 0.19122089445590973) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -0.7920545339584351) - (f32.const 7.676402568817139) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 0.6157026886940002) - (f32.const 2.0119025707244873) - (f32.const 0.3769077658653259) - (f32.const 0.337149053812027) - (i32.const 1) - ) - (call $std/math/test_powf - (f32.const -0.5587586760520935) - (f32.const 0.03223983198404312) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 3) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -1) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -2) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -3) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.const -4) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const 0) - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 3) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -1) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -2) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -3) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.const -4) - (f32.const inf) - (f32.const 0) - (i32.const 4) - ) - (call $std/math/test_powf - (f32.const -0) - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const -0) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.neg - (f32.const inf) - ) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 2) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -1) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -2) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const -3) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -1) - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const inf) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.neg - (f32.const inf) - ) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 3) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const 0.5) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -0.5) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1) - (f32.const -3) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 1.5) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 2) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 2) - (f32.const 0.25) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const 3) - (f32.const -0.125) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -0.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 0.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const 1.5) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 3) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 2) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 1) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -1) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const inf) - (f32.const -2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const 3) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const 2) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const 1) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const 0.5) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const -0.5) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const -1) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.neg - (f32.const inf) - ) - (f32.const -2) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const 1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const nan:0x400000) - (f32.const -1) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -2) - (f32.const 1) - (f32.const -2) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_powf - (f32.const -2) - (f32.const -1) - (f32.const -0.5) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -8.06684839057968) - (f64.const -2.0055552545020245) - (f64.const 0.46667951345443726) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 4.345239849338305) - (f64.const 1.6318162410515635) - (f64.const -0.08160271495580673) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -8.38143342755525) - (f64.const -2.031293910673361) - (f64.const -0.048101816326379776) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -6.531673581913484) - (f64.const -1.8692820012204925) - (f64.const 0.08624018728733063) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 9.267056966972586) - (f64.const 2.100457720859702) - (f64.const -0.2722989022731781) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.6619858980995045) - (f64.const 0.8715311470455973) - (f64.const 0.4414918124675751) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -0.4066039223853553) - (f64.const -0.740839030300223) - (f64.const 0.016453813761472702) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.5617597462207241) - (f64.const 0.8251195400559286) - (f64.const 0.30680638551712036) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const 0.7741522965913037) - (f64.const 0.9182102478959914) - (f64.const 0.06543998420238495) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const -0.6787637026394024) - (f64.const -0.8788326906580094) - (f64.const -0.2016713172197342) - (i32.const 1) - ) - (call $std/math/test_cbrt - (f64.const nan:0x8000000000000) - (f64.const nan:0x8000000000000) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const inf) - (f64.const inf) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.neg - (f64.const inf) - ) - (f64.neg - (f64.const inf) - ) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 0) - (f64.const 0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -0) - (f64.const -0) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 9.313225746154785e-10) - (f64.const 0.0009765625) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -9.313225746154785e-10) - (f64.const -0.0009765625) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 1) - (f64.const 1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const -1) - (f64.const -1) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrt - (f64.const 8) - (f64.const 2) - (f64.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -8.066848754882812) - (f32.const -2.0055553913116455) - (f32.const -0.44719240069389343) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 4.345239639282227) - (f32.const 1.6318162679672241) - (f32.const 0.44636252522468567) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -8.381433486938477) - (f32.const -2.0312938690185547) - (f32.const 0.19483426213264465) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -6.531673431396484) - (f32.const -1.8692820072174072) - (f32.const -0.17075514793395996) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 9.267057418823242) - (f32.const 2.1004576683044434) - (f32.const -0.36362043023109436) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 0.6619858741760254) - (f32.const 0.8715311288833618) - (f32.const -0.12857209146022797) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -0.40660393238067627) - (f32.const -0.7408390641212463) - (f32.const -0.4655757546424866) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 0.5617597699165344) - (f32.const 0.8251195549964905) - (f32.const 0.05601907894015312) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const 0.7741522789001465) - (f32.const 0.9182102680206299) - (f32.const 0.45498204231262207) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const -0.6787636876106262) - (f32.const -0.8788326978683472) - (f32.const -0.22978967428207397) - (i32.const 1) - ) - (call $std/math/test_cbrtf - (f32.const nan:0x400000) - (f32.const nan:0x400000) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const inf) - (f32.const inf) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.neg - (f32.const inf) - ) - (f32.neg - (f32.const inf) - ) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 0) - (f32.const 0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -0) - (f32.const -0) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 9.313225746154785e-10) - (f32.const 0.0009765625) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -9.313225746154785e-10) - (f32.const -0.0009765625) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 1) - (f32.const 1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const -1) - (f32.const -1) - (f32.const 0) - (i32.const 0) - ) - (call $std/math/test_cbrtf - (f32.const 8) - (f32.const 2) - (f32.const 0) - (i32.const 0) + (if + (i32.eqz + (f32.eq + (f32.const 2.7182817459106445) + (f32.const 2.7182817459106445) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 2.718281828459045) + (get_global "$(lib)/math/JSMath.E") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 0.6931471805599453) + (get_global "$(lib)/math/JSMath.LN2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 2.302585092994046) + (get_global "$(lib)/math/JSMath.LN10") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 1.4426950408889634) + (get_global "$(lib)/math/JSMath.LOG2E") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 3.141592653589793) + (get_global "$(lib)/math/JSMath.PI") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 0.7071067811865476) + (get_global "$(lib)/math/JSMath.SQRT1_2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f64.const 1.4142135623730951) + (get_global "$(lib)/math/JSMath.SQRT2") + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 2.7182817459106445) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.E") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 0.6931471824645996) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LN2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 2.3025851249694824) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LN10") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 1.4426950216293335) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.LOG2E") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 3.1415927410125732) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.PI") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 0.7071067690849304) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.SQRT1_2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/check + (f32.const 1.4142135381698608) + (f32.demote/f64 + (get_global "$(lib)/math/JSMath.SQRT2") + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -8.06684839057968) + (i32.const -2) + (f64.const -2.01671209764492) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 4.345239849338305) + (i32.const -1) + (f64.const 2.1726199246691524) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -8.38143342755525) + (i32.const 0) + (f64.const -8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -6.531673581913484) + (i32.const 1) + (f64.const -13.063347163826968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 9.267056966972586) + (i32.const 2) + (f64.const 37.06822786789034) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.6619858980995045) + (i32.const 3) + (f64.const 5.295887184796036) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0.4066039223853553) + (i32.const 4) + (f64.const -6.505662758165685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.5617597462207241) + (i32.const 5) + (f64.const 17.97631187906317) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.7741522965913037) + (i32.const 6) + (f64.const 49.545746981843436) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0.6787637026394024) + (i32.const 7) + (f64.const -86.88175393784351) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0) + (i32.const 2147483647) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0) + (i32.const -2147483647) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const -0) + (i32.const 2147483647) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const nan:0x8000000000000) + (i32.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const 0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.neg + (f64.const inf) + ) + (i32.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 1) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1) + (i32.const 2147483647) + (f64.const inf) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 16) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const nan:0x8000000000000) + (i32.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const 2147483647) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 167) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const inf) + (i32.const -2147483647) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 168) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.neg + (f64.const inf) + ) + (i32.const 2147483647) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 169) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 8988465674311579538646525e283) + (i32.const -2097) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 170) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 5e-324) + (i32.const 2097) + (f64.const 8988465674311579538646525e283) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 171) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 1.000244140625) + (i32.const -1074) + (f64.const 5e-324) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 172) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.7499999999999999) + (i32.const -1073) + (f64.const 5e-324) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 173) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbn + (f64.const 0.5000000000000012) + (i32.const -1024) + (f64.const 2.781342323134007e-309) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 174) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -8.066848754882812) + (i32.const -2) + (f32.const -2.016712188720703) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 4.345239639282227) + (i32.const -1) + (f32.const 2.1726198196411133) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -8.381433486938477) + (i32.const 0) + (f32.const -8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -6.531673431396484) + (i32.const 1) + (f32.const -13.063346862792969) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 186) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 9.267057418823242) + (i32.const 2) + (f32.const 37.06822967529297) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 187) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.6619858741760254) + (i32.const 3) + (f32.const 5.295886993408203) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 188) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0.40660393238067627) + (i32.const 4) + (f32.const -6.50566291809082) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 189) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.5617597699165344) + (i32.const 5) + (f32.const 17.9763126373291) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 190) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.7741522789001465) + (i32.const 6) + (f32.const 49.545745849609375) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 191) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0.6787636876106262) + (i32.const 7) + (f32.const -86.88175201416016) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 192) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0) + (i32.const 2147483647) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0) + (i32.const -2147483647) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const -0) + (i32.const 2147483647) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const nan:0x400000) + (i32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const 0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.neg + (f32.const inf) + ) + (i32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 1) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1) + (i32.const 2147483647) + (f32.const inf) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 16) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 204) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const nan:0x400000) + (i32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 205) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const 2147483647) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const inf) + (i32.const -2147483647) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.neg + (f32.const inf) + ) + (i32.const 2147483647) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1701411834604692317316873e14) + (i32.const -276) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1.401298464324817e-45) + (i32.const 276) + (f32.const 1701411834604692317316873e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 1.000244140625) + (i32.const -149) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.7499999403953552) + (i32.const -148) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_scalbnf + (f32.const 0.5000006556510925) + (i32.const -128) + (f32.const 1.4693693398263237e-39) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -8.06684839057968) + (f64.const 8.06684839057968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 225) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 4.345239849338305) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 226) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -8.38143342755525) + (f64.const 8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 227) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -6.531673581913484) + (f64.const 6.531673581913484) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 228) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 9.267056966972586) + (f64.const 9.267056966972586) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 229) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.6619858980995045) + (f64.const 0.6619858980995045) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 230) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0.4066039223853553) + (f64.const 0.4066039223853553) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.5617597462207241) + (f64.const 0.5617597462207241) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0.7741522965913037) + (f64.const 0.7741522965913037) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0.6787637026394024) + (f64.const 0.6787637026394024) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const -1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 241) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 242) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_abs + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -8.066848754882812) + (f32.const 8.066848754882812) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 252) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 4.345239639282227) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 253) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -8.381433486938477) + (f32.const 8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 254) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -6.531673431396484) + (f32.const 6.531673431396484) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 255) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 9.267057418823242) + (f32.const 9.267057418823242) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 256) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.6619858741760254) + (f32.const 0.6619858741760254) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 257) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0.40660393238067627) + (f32.const 0.40660393238067627) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 258) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.5617597699165344) + (f32.const 0.5617597699165344) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 259) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0.7741522789001465) + (f32.const 0.7741522789001465) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0.6787636876106262) + (f32.const 0.6787636876106262) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const -1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_absf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 270) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 282) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 283) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 284) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 285) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 286) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.6619858980995045) + (f64.const 0.8473310828433507) + (f64.const -0.41553276777267456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 287) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.4066039223853553) + (f64.const 1.989530071088669) + (f64.const 0.4973946213722229) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 288) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.5617597462207241) + (f64.const 0.9742849645674904) + (f64.const -0.4428897500038147) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 289) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.7741522965913037) + (f64.const 0.6854215158636222) + (f64.const -0.12589527666568756) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.6787637026394024) + (f64.const 2.316874138205964) + (f64.const -0.17284949123859406) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -1) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 298) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 299) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 300) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 301) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const -0.5309227209592985) + (f64.const 2.1304853799705463) + (f64.const 0.1391008496284485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acos + (f64.const 0.4939556746399746) + (f64.const 1.0541629875851946) + (f64.const 0.22054767608642578) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.6619858741760254) + (f32.const 0.8473311066627502) + (f32.const -0.13588131964206696) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 317) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.40660393238067627) + (f32.const 1.989530086517334) + (f32.const 0.03764917701482773) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 318) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.5617597699165344) + (f32.const 0.9742849469184875) + (f32.const 0.18443739414215088) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 319) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.7741522789001465) + (f32.const 0.6854215264320374) + (f32.const -0.29158344864845276) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 320) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.6787636876106262) + (f32.const 2.3168740272521973) + (f32.const -0.3795364499092102) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 321) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 324) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -1) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const 0.49965065717697144) + (f32.const 1.0476008653640747) + (f32.const -0.21161814033985138) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.5051405429840088) + (f32.const 2.1003410816192627) + (f32.const -0.20852705836296082) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosf + (f32.const -0.5189794898033142) + (f32.const 2.116452932357788) + (f32.const -0.14600826799869537) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 4.345239849338305) + (f64.const 2.1487163980597503) + (f64.const -0.291634738445282) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 9.267056966972586) + (f64.const 2.91668914109908) + (f64.const -0.24191908538341522) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.6619858980995045) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 352) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.5617597462207241) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 353) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.7741522965913037) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 354) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 355) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 358) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 359) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 360) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0.9999923706054688) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 361) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 362) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1060831199926429) + (f64.const 0.4566373404384803) + (f64.const -0.29381608963012695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1089809557628658) + (f64.const 0.4627246859959428) + (f64.const -0.3990095555782318) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acosh + (f64.const 1.1169429159875521) + (f64.const 0.47902433134075284) + (f64.const -0.321674108505249) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 392) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 4.345239639282227) + (f32.const 2.148716449737549) + (f32.const 0.4251045286655426) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 393) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 394) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 395) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 9.267057418823242) + (f32.const 2.916689157485962) + (f32.const -0.1369788944721222) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 396) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.6619858741760254) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 397) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 398) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.5617597699165344) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 399) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.7741522789001465) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 400) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 401) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 404) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 405) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 406) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0.9999923706054688) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 407) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 408) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 409) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 410) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_acoshf + (f32.const -1125899906842624) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 411) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.6619858980995045) + (f64.const 0.7234652439515459) + (f64.const -0.13599912822246552) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0.4066039223853553) + (f64.const -0.41873374429377225) + (f64.const -0.09264230728149414) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.5617597462207241) + (f64.const 0.5965113622274062) + (f64.const -0.10864213854074478) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.7741522965913037) + (f64.const 0.8853748109312743) + (f64.const -0.4256366193294525) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0.6787637026394024) + (f64.const -0.7460778114110673) + (f64.const 0.13986606895923615) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 432) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 1) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 435) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -1) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 436) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 437) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 438) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 439) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const -1.0000000000000002) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 440) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 441) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 442) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 443) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asin + (f64.const 0.5073043929119148) + (f64.const 0.5320538997772349) + (f64.const -0.16157317161560059) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 453) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 454) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 455) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 456) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 457) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.6619858741760254) + (f32.const 0.7234652042388916) + (f32.const -0.1307632476091385) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 458) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0.40660393238067627) + (f32.const -0.41873374581336975) + (f32.const 0.3161141574382782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.5617597699165344) + (f32.const 0.5965113639831543) + (f32.const -0.4510819613933563) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.7741522789001465) + (f32.const 0.8853747844696045) + (f32.const 0.02493886835873127) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0.6787636876106262) + (f32.const -0.7460777759552002) + (f32.const 0.2515012323856354) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 1) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 465) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -1) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 466) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 467) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 468) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 469) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const -1.0000001192092896) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 470) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 471) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinf + (f32.const 0.5004770159721375) + (f32.const 0.5241496562957764) + (f32.const -0.29427099227905273) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -8.06684839057968) + (f64.const -2.784729878387861) + (f64.const -0.4762189984321594) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 4.345239849338305) + (f64.const 2.175213389013164) + (f64.const -0.02728751301765442) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -8.38143342755525) + (f64.const -2.822706083697696) + (f64.const 0.20985257625579834) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 488) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -6.531673581913484) + (f64.const -2.575619446591922) + (f64.const 0.3113134205341339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 489) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 9.267056966972586) + (f64.const 2.9225114951048674) + (f64.const 0.4991756081581116) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 490) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.6619858980995045) + (f64.const 0.6212462762707166) + (f64.const -0.4697347581386566) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 491) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0.4066039223853553) + (f64.const -0.39615990393192035) + (f64.const -0.40814438462257385) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 492) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.5617597462207241) + (f64.const 0.5357588870255474) + (f64.const 0.3520713150501251) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 493) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0.7741522965913037) + (f64.const 0.7123571263197349) + (f64.const 0.13371451199054718) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 494) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0.6787637026394024) + (f64.const -0.635182348903198) + (f64.const 0.04749670997262001) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 495) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 498) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 499) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 500) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -8.066848754882812) + (f32.const -2.7847299575805664) + (f32.const -0.14418013393878937) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 531) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 4.345239639282227) + (f32.const 2.17521333694458) + (f32.const -0.020796965807676315) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 532) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -8.381433486938477) + (f32.const -2.8227059841156006) + (f32.const 0.44718533754348755) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -6.531673431396484) + (f32.const -2.5756194591522217) + (f32.const -0.14822272956371307) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 9.267057418823242) + (f32.const 2.922511577606201) + (f32.const 0.14270681142807007) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.6619858741760254) + (f32.const 0.6212462782859802) + (f32.const 0.3684912919998169) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0.40660393238067627) + (f32.const -0.39615991711616516) + (f32.const -0.13170306384563446) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.5617597699165344) + (f32.const 0.535758912563324) + (f32.const 0.08184859901666641) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0.7741522789001465) + (f32.const 0.7123571038246155) + (f32.const -0.14270737767219543) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 539) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0.6787636876106262) + (f32.const -0.6351823210716248) + (f32.const 0.2583143711090088) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 540) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 543) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 544) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_asinhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -8.06684839057968) + (f64.const -1.4474613762633468) + (f64.const 0.14857111871242523) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 559) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 4.345239849338305) + (f64.const 1.344597927114538) + (f64.const -0.08170335739850998) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -8.38143342755525) + (f64.const -1.4520463463295539) + (f64.const -0.07505480200052261) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -6.531673581913484) + (f64.const -1.4188758658752532) + (f64.const -0.057633496820926666) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 9.267056966972586) + (f64.const 1.463303145448706) + (f64.const 0.1606956422328949) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.6619858980995045) + (f64.const 0.5847550670238325) + (f64.const 0.4582556486129761) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0.4066039223853553) + (f64.const -0.3861864177552131) + (f64.const -0.2574281692504883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.5617597462207241) + (f64.const 0.5118269531628881) + (f64.const -0.11444277316331863) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.7741522965913037) + (f64.const 0.6587802431653822) + (f64.const -0.11286488175392151) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0.6787637026394024) + (f64.const -0.5963307826973472) + (f64.const -0.2182842344045639) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 571) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 1) + (f64.const 0.7853981633974483) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const -1) + (f64.const -0.7853981633974483) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const inf) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.neg + (f64.const inf) + ) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan + (f64.const 0.6929821535674624) + (f64.const 0.6060004555152562) + (f64.const -0.17075790464878082) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -8.066848754882812) + (f32.const -1.4474613666534424) + (f32.const 0.12686480581760406) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 587) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 4.345239639282227) + (f32.const 1.3445979356765747) + (f32.const 0.16045434772968292) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -8.381433486938477) + (f32.const -1.4520463943481445) + (f32.const -0.39581751823425293) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -6.531673431396484) + (f32.const -1.418875813484192) + (f32.const 0.410570353269577) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 9.267057418823242) + (f32.const 1.4633032083511353) + (f32.const 0.48403501510620117) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.6619858741760254) + (f32.const 0.5847550630569458) + (f32.const 0.2125193476676941) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0.40660393238067627) + (f32.const -0.386186420917511) + (f32.const 0.18169628083705902) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.5617597699165344) + (f32.const 0.5118269920349121) + (f32.const 0.3499770760536194) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0.7741522789001465) + (f32.const 0.6587802171707153) + (f32.const -0.2505330741405487) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0.6787636876106262) + (f32.const -0.5963307619094849) + (f32.const 0.17614826560020447) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 599) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const 1) + (f32.const 0.7853981852531433) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const -1) + (f32.const -0.7853981852531433) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const inf) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.neg + (f32.const inf) + ) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 617) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 4.345239849338305) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 618) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 619) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 9.267056966972586) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.6619858980995045) + (f64.const 0.7963404371347943) + (f64.const 0.21338365972042084) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0.4066039223853553) + (f64.const -0.43153570730602897) + (f64.const -0.4325666129589081) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.5617597462207241) + (f64.const 0.6354006111644578) + (f64.const -0.06527865678071976) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0.7741522965913037) + (f64.const 1.0306085575277995) + (f64.const 0.14632052183151245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0.6787637026394024) + (f64.const -0.8268179645205255) + (f64.const 0.1397128701210022) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 630) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 631) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1.0000152587890625) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -1.0000152587890625) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 1.3552527156068805e-20) + (f64.const 1.3552527156068805e-20) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 9.332636185032189e-302) + (f64.const 9.332636185032189e-302) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 5.562684646268003e-309) + (f64.const 5.562684646268003e-309) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 640) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const -5.562684646268003e-309) + (f64.const -5.562684646268003e-309) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 641) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanh + (f64.const 8988465674311579538646525e283) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 642) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 4.345239639282227) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 9.267057418823242) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.6619858741760254) + (f32.const 0.7963404059410095) + (f32.const 0.19112196564674377) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0.40660393238067627) + (f32.const -0.4315357208251953) + (f32.const -0.05180925130844116) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.5617597699165344) + (f32.const 0.635400652885437) + (f32.const 0.11911056190729141) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 658) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0.7741522789001465) + (f32.const 1.0306085348129272) + (f32.const 0.1798270344734192) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 659) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0.6787636876106262) + (f32.const -0.8268179297447205) + (f32.const 0.11588983237743378) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 668) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 669) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1.0000152587890625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 670) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -1.0000152587890625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 671) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1.3552527156068805e-20) + (f32.const 1.3552527156068805e-20) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 672) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 7.888609052210118e-31) + (f32.const 7.888609052210118e-31) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 673) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 2.938735877055719e-39) + (f32.const 2.938735877055719e-39) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 674) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const -2.938735877055719e-39) + (f32.const -2.938735877055719e-39) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 675) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atanhf + (f32.const 1701411834604692317316873e14) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 676) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -1.0585895402489023) + (f64.const 0.09766263514757156) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 2.6868734126013067) + (f64.const 0.35833948850631714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 689) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -1.889300091849528) + (f64.const -0.46235957741737366) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 690) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -0.9605469021111489) + (f64.const -0.21524477005004883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 1.0919123946142109) + (f64.const 0.3894443213939667) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -1.468508500616424) + (f64.const -0.448591411113739) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 1.5641600512601268) + (f64.const 0.3784842789173126) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.10281658910678508) + (f64.const -0.13993260264396667) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.29697974004493516) + (f64.const 0.44753071665763855) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -1.5131612053303916) + (f64.const 0.39708876609802246) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 700) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const -0) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 701) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const -1) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 702) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 703) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 704) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 705) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const 0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 706) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const -0) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 707) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const -1) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 708) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 709) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 710) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 711) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const 0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 712) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const -0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 713) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 714) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const -0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 715) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 716) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 717) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const -3.141592653589793) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 718) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 3.141592653589793) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 719) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.const 0) + (f64.const 1.5707963267948966) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 720) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const -1.5707963267948966) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 721) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.const inf) + (f64.const 0.7853981633974483) + (f64.const -0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 722) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const 2.356194490192345) + (f64.const -0.20682445168495178) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 723) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const -0.7853981633974483) + (f64.const 0.27576595544815063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 724) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const -2.356194490192345) + (f64.const 0.20682445168495178) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 725) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.1125369292536007e-308) + (f64.const 1) + (f64.const 1.1125369292536007e-308) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 726) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1) + (f64.const 8988465674311579538646525e283) + (f64.const 1.1125369292536007e-308) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 727) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.5) + (f64.const 8988465674311579538646525e283) + (f64.const 1.668805393880401e-308) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 728) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2 + (f64.const 1.5) + (f64.const -8988465674311579538646525e283) + (f64.const 3.141592653589793) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 729) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -1.0585895776748657) + (f32.const -0.22352588176727295) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 738) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 2.686873435974121) + (f32.const 0.09464472532272339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 739) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -1.8893001079559326) + (f32.const -0.21941901743412018) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 740) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -0.9605468511581421) + (f32.const 0.46015575528144836) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 741) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 1.0919123888015747) + (f32.const -0.05708503723144531) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 742) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -1.4685084819793701) + (f32.const 0.19611206650733948) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 743) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 1.5641601085662842) + (f32.const 0.48143187165260315) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 744) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.10281659662723541) + (f32.const -0.4216274917125702) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 745) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.29697975516319275) + (f32.const 0.2322007566690445) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 746) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -1.5131611824035645) + (f32.const 0.16620726883411407) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 747) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 750) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const -0) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 751) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const -1) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 752) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 753) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 754) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 755) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const 0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 756) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const -0) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 757) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const -1) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 758) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 759) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 760) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 761) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const 0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 762) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const -0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const -0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 767) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const -3.1415927410125732) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 768) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 3.1415927410125732) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.const 0) + (f32.const 1.5707963705062866) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const -1.5707963705062866) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.const inf) + (f32.const 0.7853981852531433) + (f32.const 0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const 2.356194496154785) + (f32.const 0.02500828728079796) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 773) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const -0.7853981852531433) + (f32.const -0.3666777014732361) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 774) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const -2.356194496154785) + (f32.const -0.02500828728079796) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 5.877471754111438e-39) + (f32.const 1) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_atan2f + (f32.const 1) + (f32.const 1701411834604692317316873e14) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -8.06684839057968) + (f64.const -2.0055552545020245) + (f64.const 0.46667951345443726) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 4.345239849338305) + (f64.const 1.6318162410515635) + (f64.const -0.08160271495580673) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -8.38143342755525) + (f64.const -2.031293910673361) + (f64.const -0.048101816326379776) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -6.531673581913484) + (f64.const -1.8692820012204925) + (f64.const 0.08624018728733063) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 9.267056966972586) + (f64.const 2.100457720859702) + (f64.const -0.2722989022731781) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.6619858980995045) + (f64.const 0.8715311470455973) + (f64.const 0.4414918124675751) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0.4066039223853553) + (f64.const -0.740839030300223) + (f64.const 0.016453813761472702) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.5617597462207241) + (f64.const 0.8251195400559286) + (f64.const 0.30680638551712036) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0.7741522965913037) + (f64.const 0.9182102478959914) + (f64.const 0.06543998420238495) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0.6787637026394024) + (f64.const -0.8788326906580094) + (f64.const -0.2016713172197342) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 798) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 805) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 9.313225746154785e-10) + (f64.const 0.0009765625) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 806) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -9.313225746154785e-10) + (f64.const -0.0009765625) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 807) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 808) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 809) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrt + (f64.const 8) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 810) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -8.066848754882812) + (f32.const -2.0055553913116455) + (f32.const -0.44719240069389343) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 4.345239639282227) + (f32.const 1.6318162679672241) + (f32.const 0.44636252522468567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -8.381433486938477) + (f32.const -2.0312938690185547) + (f32.const 0.19483426213264465) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -6.531673431396484) + (f32.const -1.8692820072174072) + (f32.const -0.17075514793395996) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 9.267057418823242) + (f32.const 2.1004576683044434) + (f32.const -0.36362043023109436) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.6619858741760254) + (f32.const 0.8715311288833618) + (f32.const -0.12857209146022797) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0.40660393238067627) + (f32.const -0.7408390641212463) + (f32.const -0.4655757546424866) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.5617597699165344) + (f32.const 0.8251195549964905) + (f32.const 0.05601907894015312) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 826) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0.7741522789001465) + (f32.const 0.9182102680206299) + (f32.const 0.45498204231262207) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 827) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0.6787636876106262) + (f32.const -0.8788326978683472) + (f32.const -0.22978967428207397) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 828) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 831) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 832) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 833) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 834) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 835) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 9.313225746154785e-10) + (f32.const 0.0009765625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 836) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -9.313225746154785e-10) + (f32.const -0.0009765625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 837) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cbrtf + (f32.const 8) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 4.345239849338305) + (f64.const 5) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -6.531673581913484) + (f64.const -6) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 9.267056966972586) + (f64.const 10) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.6619858980995045) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5617597462207241) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.7741522965913037) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.6787637026394024) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 902) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 1.0000152587890625) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 903) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 904) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 905) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 906) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const 7.888609052210118e-31) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 907) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceil + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 908) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 4.345239639282227) + (f32.const 5) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -6.531673431396484) + (f32.const -6) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 920) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 9.267057418823242) + (f32.const 10) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 921) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.6619858741760254) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5617597699165344) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.7741522789001465) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.6787636876106262) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 926) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 944) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 945) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 946) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 947) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 948) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 949) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 950) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 951) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 952) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 953) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 954) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 955) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 956) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 957) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 958) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 959) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 960) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 961) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 962) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 963) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 964) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 965) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 966) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 967) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 1.0000152587890625) + (f32.const 2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 968) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 969) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 970) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 971) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const 7.888609052210118e-31) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 972) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_ceilf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 973) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -8.06684839057968) + (f64.const 1593.5209938862329) + (f64.const -0.38098856806755066) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 4.345239849338305) + (f64.const 38.56174928426729) + (f64.const -0.2712278366088867) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -8.38143342755525) + (f64.const 2182.630979595893) + (f64.const 0.0817827582359314) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -6.531673581913484) + (f64.const 343.273849250879) + (f64.const -0.429940402507782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 9.267056966972586) + (f64.const 5291.779170005587) + (f64.const -0.1592995822429657) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.6619858980995045) + (f64.const 1.2272321957342842) + (f64.const 0.23280741274356842) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0.4066039223853553) + (f64.const 1.083808541871197) + (f64.const -0.3960916996002197) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.5617597462207241) + (f64.const 1.1619803583175077) + (f64.const 0.37748390436172485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0.7741522965913037) + (f64.const 1.3149236876276706) + (f64.const 0.43587008118629456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0.6787637026394024) + (f64.const 1.2393413245934533) + (f64.const 0.10201606154441833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_cosh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1126) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -8.066848754882812) + (f32.const 1593.5216064453125) + (f32.const 0.26242581009864807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 4.345239639282227) + (f32.const 38.56174087524414) + (f32.const -0.08168885856866837) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -8.381433486938477) + (f32.const 2182.631103515625) + (f32.const -0.02331414446234703) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -6.531673431396484) + (f32.const 343.2738037109375) + (f32.const 0.20081493258476257) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 9.267057418823242) + (f32.const 5291.78173828125) + (f32.const 0.36286723613739014) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.6619858741760254) + (f32.const 1.2272322177886963) + (f32.const 0.32777416706085205) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0.40660393238067627) + (f32.const 1.0838085412979126) + (f32.const -0.039848703891038895) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.5617597699165344) + (f32.const 1.161980390548706) + (f32.const 0.15274477005004883) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0.7741522789001465) + (f32.const 1.314923644065857) + (f32.const -0.2387111485004425) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0.6787636876106262) + (f32.const 1.2393412590026855) + (f32.const -0.45791932940483093) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_coshf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -8.06684839057968) + (f64.const 3.137706068161745e-04) + (f64.const -0.2599197328090668) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 4.345239849338305) + (f64.const 77.11053017112141) + (f64.const -0.02792675793170929) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -8.38143342755525) + (f64.const 2.290813384916323e-04) + (f64.const -0.24974334239959717) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -6.531673581913484) + (f64.const 1.4565661260931588e-03) + (f64.const -0.4816822409629822) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 9.267056966972586) + (f64.const 10583.558245524993) + (f64.const 0.17696762084960938) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1167) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.6619858980995045) + (f64.const 1.9386384525571998) + (f64.const -0.4964246451854706) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1168) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0.4066039223853553) + (f64.const 0.6659078892838025) + (f64.const -0.10608318448066711) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1169) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.5617597462207241) + (f64.const 1.7537559518626311) + (f64.const -0.39162111282348633) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1170) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0.7741522965913037) + (f64.const 2.1687528885129246) + (f64.const -0.2996125817298889) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1171) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0.6787637026394024) + (f64.const 0.5072437089402843) + (f64.const 0.47261738777160645) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1172) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1175) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1176) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1) + (f64.const 2.718281828459045) + (f64.const -0.3255307376384735) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1177) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -1) + (f64.const 0.36787944117144233) + (f64.const 0.22389651834964752) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1178) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1179) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1180) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1181) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397214889526365) + (f64.const 2.828429155876411) + (f64.const 0.18803080916404724) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1182) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const -1.0397214889526365) + (f64.const 0.35355313670217847) + (f64.const 0.2527272403240204) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397210121154785) + (f64.const 2.8284278071766122) + (f64.const -0.4184139370918274) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_exp + (f64.const 1.0397214889526367) + (f64.const 2.8284291558764116) + (f64.const -0.22618377208709717) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -8.066848754882812) + (f32.const 3.1377049162983894e-04) + (f32.const -0.030193336308002472) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1194) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 4.345239639282227) + (f32.const 77.11051177978516) + (f32.const -0.2875460684299469) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -8.381433486938477) + (f32.const 2.2908132814336568e-04) + (f32.const 0.2237040400505066) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -6.531673431396484) + (f32.const 1.4565663877874613e-03) + (f32.const 0.36469703912734985) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 9.267057418823242) + (f32.const 10583.5634765625) + (f32.const 0.45962104201316833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.6619858741760254) + (f32.const 1.93863844871521) + (f32.const 0.3568260967731476) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0.40660393238067627) + (f32.const 0.6659078598022461) + (f32.const -0.38294991850852966) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.5617597699165344) + (f32.const 1.753756046295166) + (f32.const 0.44355490803718567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.7741522789001465) + (f32.const 2.168752908706665) + (f32.const 0.24562469124794006) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0.6787636876106262) + (f32.const 0.5072436928749084) + (f32.const -0.3974292278289795) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 1) + (f32.const 2.7182817459106445) + (f32.const -0.3462330996990204) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -1) + (f32.const 0.3678794503211975) + (f32.const 0.3070148527622223) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 88.72283172607422) + (f32.const 340279851902147610656242e15) + (f32.const -0.09067153930664062) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 88.72283935546875) + (f32.const inf) + (f32.const 0) + (i32.or + (i32.const 1) + (i32.const 16) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1214) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -103.97207641601562) + (f32.const 1.401298464324817e-45) + (f32.const 0.49999967217445374) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1215) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const -103.97208404541016) + (f32.const 0) + (f32.const -0.49999651312828064) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1216) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465735614299774) + (f32.const 1.4142135381698608) + (f32.const 0.13922421634197235) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1217) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465735912322998) + (f32.const 1.4142135381698608) + (f32.const -0.21432916820049286) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1218) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expf + (f32.const 0.3465736210346222) + (f32.const 1.4142136573791504) + (f32.const 0.43211743235588074) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1219) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -8.06684839057968) + (f64.const -0.9996862293931839) + (f64.const -0.2760058343410492) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 4.345239849338305) + (f64.const 76.11053017112141) + (f64.const -0.02792675793170929) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -8.38143342755525) + (f64.const -0.9997709186615084) + (f64.const 0.10052496194839478) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -6.531673581913484) + (f64.const -0.9985434338739069) + (f64.const -0.27437829971313477) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 9.267056966972586) + (f64.const 10582.558245524993) + (f64.const 0.17696762084960938) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1235) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.6619858980995045) + (f64.const 0.9386384525571999) + (f64.const 0.007150684483349323) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1236) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0.4066039223853553) + (f64.const -0.3340921107161975) + (f64.const -0.21216636896133423) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.5617597462207241) + (f64.const 0.7537559518626312) + (f64.const 0.21675777435302734) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0.7741522965913037) + (f64.const 1.1687528885129248) + (f64.const 0.4007748067378998) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0.6787637026394024) + (f64.const -0.4927562910597158) + (f64.const -0.05476519837975502) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1244) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 1) + (f64.const 1.7182818284590453) + (f64.const 0.348938524723053) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1245) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -1) + (f64.const -0.6321205588285577) + (f64.const 0.11194825917482376) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1246) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1247) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1248) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1249) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const 2.225073858507201e-308) + (f64.const 2.225073858507201e-308) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1250) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1 + (f64.const -2.225073858507201e-308) + (f64.const -2.225073858507201e-308) + (f64.const 0) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1251) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -8.066848754882812) + (f32.const -0.9996862411499023) + (f32.const -0.19532723724842072) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 4.345239639282227) + (f32.const 76.11051177978516) + (f32.const -0.2875460684299469) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -8.381433486938477) + (f32.const -0.9997709393501282) + (f32.const -0.34686920046806335) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1262) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -6.531673431396484) + (f32.const -0.9985434412956238) + (f32.const -0.1281939446926117) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1263) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 9.267057418823242) + (f32.const 10582.5634765625) + (f32.const 0.45962104201316833) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.6619858741760254) + (f32.const 0.9386383891105652) + (f32.const -0.28634780645370483) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0.40660393238067627) + (f32.const -0.3340921103954315) + (f32.const 0.23410017788410187) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.5617597699165344) + (f32.const 0.7537559866905212) + (f32.const -0.11289017647504807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0.7741522789001465) + (f32.const 1.168752908706665) + (f32.const 0.4912493824958801) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0.6787636876106262) + (f32.const -0.49275627732276917) + (f32.const 0.20514154434204102) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1272) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1273) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const 1) + (f32.const 1.718281865119934) + (f32.const 0.3075338304042816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1274) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const -1) + (f32.const -0.6321205496788025) + (f32.const 0.15350742638111115) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1275) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1276) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1277) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_expm1f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1278) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -8.06684839057968) + (f64.const -9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -8.38143342755525) + (f64.const -9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1292) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -6.531673581913484) + (f64.const -7) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1293) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.6619858980995045) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.4066039223853553) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.5617597462207241) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.7741522965913037) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1298) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.6787637026394024) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1299) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1304) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1305) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1306) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1307) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1308) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1309) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1310) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1311) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -1.0000152587890625) + (f64.const -2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 0.9999923706054688) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -0.9999923706054688) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floor + (f64.const -7.888609052210118e-31) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -8.066848754882812) + (f32.const -9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -8.381433486938477) + (f32.const -9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -6.531673431396484) + (f32.const -7) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.6619858741760254) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.40660393238067627) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.5617597699165344) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.7741522789001465) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.6787636876106262) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1337) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1338) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1339) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1340) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1341) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1342) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1343) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1344) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.5) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1345) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -1.0000152587890625) + (f32.const -2) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 0.9999923706054688) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -0.9999923706054688) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_floorf + (f32.const -7.888609052210118e-31) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 9.25452742288464) + (f64.const -0.31188681721687317) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 9.893305808328252) + (f64.const 0.4593673348426819) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const 8.825301797432132) + (f64.const -0.1701754331588745) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1365) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const 7.970265885519092) + (f64.const -0.3176782727241516) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1366) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 10.441639651824575) + (f64.const -0.2693633437156677) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1367) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 6.483936052542593) + (f64.const 0.35618898272514343) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1368) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 7.859063309581766) + (f64.const 0.08044655621051788) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1369) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const 7.717156764899584) + (f64.const 0.05178084969520569) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1370) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 2.104006123874314) + (f64.const -0.0918039008975029) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1371) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const 0.5596880129062913) + (f64.const 0.1383407711982727) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1372) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 3) + (f64.const 4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1375) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -3) + (f64.const 4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1376) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4) + (f64.const 3) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1377) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 4) + (f64.const -3) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1378) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const -3) + (f64.const -4) + (f64.const 5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1379) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1797693134862315708145274e284) + (f64.const -0) + (f64.const 1797693134862315708145274e284) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1381) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 5e-324) + (f64.const 0) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 5e-324) + (f64.const -0) + (f64.const 5e-324) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1384) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1385) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1386) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1387) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1388) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1389) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1390) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1391) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1392) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypot + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1393) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 9.254528045654297) + (f32.const 0.2735958993434906) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1402) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 9.893305778503418) + (f32.const 0.4530770778656006) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1403) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const 8.825302124023438) + (f32.const 0.30755728483200073) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1404) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const 7.970265865325928) + (f32.const 0.06785223633050919) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1405) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 10.44163990020752) + (f32.const -0.26776307821273804) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1406) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 6.483936309814453) + (f32.const 0.48381292819976807) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1407) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 7.859063148498535) + (f32.const 0.07413065433502197) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1408) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const 7.717156887054443) + (f32.const 0.4940592646598816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1409) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 2.104006052017212) + (f32.const -0.287089467048645) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1410) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const 0.5596880316734314) + (f32.const 0.4191940724849701) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1411) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3) + (f32.const 4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1414) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -3) + (f32.const 4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1415) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4) + (f32.const 3) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1416) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 4) + (f32.const -3) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1417) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const -3) + (f32.const -4) + (f32.const 5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1418) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1419) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 3402823466385288598117041e14) + (f32.const -0) + (f32.const 3402823466385288598117041e14) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1420) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1.401298464324817e-45) + (f32.const 0) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1421) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1.401298464324817e-45) + (f32.const -0) + (f32.const 1.401298464324817e-45) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1422) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_hypotf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1432) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 4.345239849338305) + (f64.const 1.4690809584224322) + (f64.const -0.3412533402442932) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1445) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1446) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1447) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 9.267056966972586) + (f64.const 2.2264658498795615) + (f64.const 0.3638114035129547) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1448) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.6619858980995045) + (f64.const -0.4125110252365137) + (f64.const -0.29108747839927673) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1449) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1450) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.5617597462207241) + (f64.const -0.5766810183195862) + (f64.const -0.10983199626207352) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1451) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0.7741522965913037) + (f64.const -0.2559866591263865) + (f64.const -0.057990044355392456) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1452) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1453) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1456) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1457) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1458) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1463) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1475) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1476) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1477) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1478) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1479) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1482) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1483) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1484) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1485) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1488) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_logf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1489) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 4.345239849338305) + (f64.const 0.6380137537120029) + (f64.const -0.2088824063539505) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1503) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1504) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 9.267056966972586) + (f64.const 0.9669418327487274) + (f64.const -0.06120431795716286) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1505) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.6619858980995045) + (f64.const -0.17915126198447093) + (f64.const 0.39090874791145325) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1506) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1507) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.5617597462207241) + (f64.const -0.25044938407454437) + (f64.const -0.3046841621398926) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1508) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0.7741522965913037) + (f64.const -0.11117359349943837) + (f64.const -0.31503361463546753) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1509) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1510) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1513) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1514) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1515) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1516) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1517) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1518) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1519) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1520) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1529) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 4.345239639282227) + (f32.const 0.6380137205123901) + (f32.const -0.20476758480072021) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1530) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1531) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1532) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 9.267057418823242) + (f32.const 0.9669418334960938) + (f32.const -0.34273025393486023) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.6619858741760254) + (f32.const -0.1791512817144394) + (f32.const -0.27078554034233093) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.5617597699165344) + (f32.const -0.25044935941696167) + (f32.const 0.2126826047897339) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0.7741522789001465) + (f32.const -0.1111735999584198) + (f32.const 0.46515095233917236) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1541) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1542) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1543) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1544) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log10f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1548) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 4.345239849338305) + (f64.const 1.6762064170601734) + (f64.const 0.46188199520111084) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 9.267056966972586) + (f64.const 2.3289404168523826) + (f64.const -0.411114901304245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.6619858980995045) + (f64.const 0.5080132114992477) + (f64.const -0.29306045174598694) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0.4066039223853553) + (f64.const -0.5218931811663979) + (f64.const -0.25825726985931396) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.5617597462207241) + (f64.const 0.4458132279488102) + (f64.const -0.13274887204170227) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0.7741522965913037) + (f64.const 0.5733227294648414) + (f64.const 0.02716583013534546) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0.6787637026394024) + (f64.const -1.1355782978128564) + (f64.const 0.2713092863559723) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1569) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -7.888609052210118e-31) + (f64.const -7.888609052210118e-31) + (f64.const 1.7763568394002505e-15) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const 1) + (f64.const 0.6931471805599453) + (f64.const -0.2088811695575714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1p + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1579) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 4.345239639282227) + (f32.const 1.676206350326538) + (f32.const -0.23014859855175018) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 9.267057418823242) + (f32.const 2.3289403915405273) + (f32.const -0.29075589776039124) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.6619858741760254) + (f32.const 0.5080131888389587) + (f32.const -0.1386766880750656) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0.40660393238067627) + (f32.const -0.5218932032585144) + (f32.const -0.08804433047771454) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.5617597699165344) + (f32.const 0.44581323862075806) + (f32.const -0.15101368725299835) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0.7741522789001465) + (f32.const 0.5733227133750916) + (f32.const -0.10264533013105392) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0.6787636876106262) + (f32.const -1.1355782747268677) + (f32.const -0.19879481196403503) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1597) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -7.888609052210118e-31) + (f32.const -7.888609052210118e-31) + (f32.const 3.308722450212111e-24) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const 1) + (f32.const 0.6931471824645996) + (f32.const 0.031954795122146606) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1606) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1607) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log1pf + (f32.const -1.1754942106924411e-38) + (f32.const -1.1754942106924411e-38) + (f32.const 4.930380657631324e-32) + (i32.or + (i32.const 1) + (i32.const 8) + ) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1608) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 4.345239849338305) + (f64.const 2.1194358133804485) + (f64.const -0.10164877772331238) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 9.267056966972586) + (f64.const 3.2121112403298744) + (f64.const -0.15739446878433228) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.6619858980995045) + (f64.const -0.5951276104207402) + (f64.const 0.3321485221385956) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.5617597462207241) + (f64.const -0.8319748453044644) + (f64.const 0.057555437088012695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1627) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0.7741522965913037) + (f64.const -0.36931068365537134) + (f64.const -0.19838279485702515) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1628) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -7.888609052210118e-31) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2 + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1648) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 4.345239639282227) + (f32.const 2.1194357872009277) + (f32.const 0.18271538615226746) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1649) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1650) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 9.267057418823242) + (f32.const 3.212111234664917) + (f32.const -0.3188050389289856) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.6619858741760254) + (f32.const -0.5951276421546936) + (f32.const 0.34231460094451904) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.5617597699165344) + (f32.const -0.8319748044013977) + (f32.const -0.33473604917526245) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0.7741522789001465) + (f32.const -0.3693107068538666) + (f32.const 0.3278401792049408) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1661) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -7.888609052210118e-31) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1662) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_log2f + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 4.535662560676869) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1679) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1680) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -2.763607337379588) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1681) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const 4.567535276842744) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1682) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 9.267056966972586) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1683) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 0.6620717923376739) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1684) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 7.858890253041697) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1685) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const 7.67640268511754) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1686) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 2.0119025790324803) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1687) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const 0.03223983060263804) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.5) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1698) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1699) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1700) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1701) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1702) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1703) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const -1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1704) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1705) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1706) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1707) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1708) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1709) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const -0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1710) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1711) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1712) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1713) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1714) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1715) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1716) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1717) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1718) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1719) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1720) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1721) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1722) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1723) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1724) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -0) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1725) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1726) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1727) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1728) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1729) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1730) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const 2) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1731) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1732) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1733) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1734) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1735) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1736) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1737) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1738) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1739) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1740) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1741) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1742) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1743) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1744) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1.75) + (f64.const 0.5) + (f64.const 1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1745) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1.75) + (f64.const 0.5) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1746) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const 1.75) + (f64.const -0.5) + (f64.const 1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1747) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_max + (f64.const -1.75) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1748) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 4.535662651062012) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1757) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1758) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -2.7636072635650635) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1759) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const 4.567535400390625) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1760) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 9.267057418823242) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1761) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 0.6620717644691467) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1762) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 7.858890056610107) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const 7.676402568817139) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 2.0119025707244873) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const 0.03223983198404312) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.5) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1773) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1774) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1778) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1779) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1780) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1781) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const -1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1782) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1783) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1784) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1785) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1786) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1787) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const -0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1788) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1798) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1799) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1800) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -0) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1805) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1806) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1807) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1808) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const 2) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1809) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1810) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1811) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1812) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1813) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1814) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1815) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1816) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1817) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1818) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1.75) + (f32.const 0.5) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const 1.75) + (f32.const -0.5) + (f32.const 1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_maxf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1826) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -8.06684839057968) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const -8.88799136300345) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -8.38143342755525) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -6.531673581913484) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1841) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 4.811392084359796) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1842) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -6.450045556060236) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1843) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 0.05215452675006225) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1844) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1845) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1846) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.5587586823609152) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1847) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1850) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1851) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const 1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0.5) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0.5) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1862) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1863) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const 0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const 0) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const -0) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const 2) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const 2) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const -0.5) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1902) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1903) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1.75) + (f64.const 0.5) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1904) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1.75) + (f64.const 0.5) + (f64.const -1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1905) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const 1.75) + (f64.const -0.5) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1906) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_min + (f64.const -1.75) + (f64.const -0.5) + (f64.const -1.75) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1907) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -8.066848754882812) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1916) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const -8.887990951538086) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -8.381433486938477) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -6.531673431396484) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 4.811392307281494) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1920) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -6.450045585632324) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1921) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 0.052154526114463806) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.5587586760520935) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1928) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const 1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0.5) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0.5) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1944) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1945) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1946) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1947) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1948) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1949) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1950) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const 0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1951) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1952) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1953) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1954) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1955) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1956) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const 0) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1957) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1958) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1959) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1960) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const -0) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1961) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1962) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1963) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1964) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const 2) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1965) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1966) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1967) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const 2) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1968) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const -0.5) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1969) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1970) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1971) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1972) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1973) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1974) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1975) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1976) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1977) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1978) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1979) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1980) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1981) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1982) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1.75) + (f32.const 0.5) + (f32.const -1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1983) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const 1.75) + (f32.const -0.5) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1984) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_minf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -1.75) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 1985) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const -3.531185829902812) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2001) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2002) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -0.09061141541648476) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2003) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -1.9641383050707404) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2004) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 4.45566488261279) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2005) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const -0.4913994250211714) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2006) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 0.035711240532359426) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2007) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2008) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2009) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.0106815621160685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2010) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2013) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2014) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2015) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2016) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2017) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2018) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2019) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2020) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 2) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2021) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -2) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2022) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2023) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2024) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2025) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2026) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2027) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2028) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2029) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2030) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2031) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2032) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2033) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 2) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2034) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -2) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2035) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2036) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2037) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2038) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2039) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2040) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2041) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2042) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2043) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2044) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2045) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2046) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2047) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2048) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2049) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2050) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2051) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2052) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2053) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2054) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2055) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2056) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2057) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2058) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2059) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2060) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2061) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2062) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2063) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2064) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2065) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2066) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2067) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2068) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2069) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2070) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2071) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2072) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2073) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2074) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.75) + (f64.const 0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2075) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.75) + (f64.const 0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2076) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const 1.75) + (f64.const -0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2077) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_mod + (f64.const -1.75) + (f64.const -0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2078) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const -3.531186103820801) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2087) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2088) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -0.09061169624328613) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2089) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -1.9641380310058594) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2090) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 4.455665111541748) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2091) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const -0.49139970541000366) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2092) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 0.0357111394405365) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2093) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2094) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2095) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.010681532323360443) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2096) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2099) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2100) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2101) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2102) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2103) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2104) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2106) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2107) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -2) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 2) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -2) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2125) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2126) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2134) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2154) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2155) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.75) + (f32.const 0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.75) + (f32.const 0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const 1.75) + (f32.const -0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_modf + (f32.const -1.75) + (f32.const -0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2176) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 2.1347118825587285e-06) + (f64.const 0.3250160217285156) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2177) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2178) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2179) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const 44909.29941512966) + (f64.const -0.26659080386161804) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2180) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2181) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const 1.1135177413458652) + (f64.const -0.37168607115745544) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2182) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2183) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.37690773521380183) + (f64.const 0.32473301887512207) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2184) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2185) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2188) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2189) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 3) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2190) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2191) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2192) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2193) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2194) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2195) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2196) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -1) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2197) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -2) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2198) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -3) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2199) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.const -4) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2200) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2201) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2202) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2203) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 3) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2204) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2205) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2206) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2207) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2208) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2209) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2210) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2211) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -2) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2212) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -3) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2213) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.const -4) + (f64.const inf) + (f64.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2214) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2215) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2216) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2217) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2218) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2219) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2220) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2221) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2222) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2223) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2224) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2225) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2226) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const -0) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2227) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2228) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2229) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2230) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2231) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2232) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2233) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const -3) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2234) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -1) + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2235) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2236) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2237) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2238) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 3) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2239) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2240) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -0.5) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2241) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1) + (f64.const -3) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2242) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2243) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 1.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2244) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 2) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2245) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const 3) + (f64.const -0.125) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2246) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2247) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2248) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2249) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2250) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2251) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 0.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2252) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2253) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2254) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const 1.5) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2255) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2256) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2257) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2258) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 3) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2259) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2260) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 1) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2261) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2262) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2263) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2264) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const inf) + (f64.const -2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2265) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2266) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2267) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2268) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const 3) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2269) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const 2) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2270) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2271) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const 0.5) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2272) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const -0.5) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2273) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2274) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.neg + (f64.const inf) + ) + (f64.const -2) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2275) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2276) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2277) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -2) + (f64.const 1) + (f64.const -2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2278) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_pow + (f64.const -2) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2279) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2288) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 2.134714122803416e-06) + (f32.const 0.1436440795660019) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2289) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2290) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2291) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const 44909.33203125) + (f32.const -0.05356409028172493) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2292) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2293) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const 1.1135177612304688) + (f32.const 0.19122089445590973) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2294) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2295) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.3769077658653259) + (f32.const 0.337149053812027) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2296) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2297) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2300) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2301) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 3) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2302) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2303) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2304) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2305) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2306) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2307) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2308) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -1) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2309) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -2) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2310) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -3) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2311) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.const -4) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2312) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2313) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2314) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2315) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 3) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2316) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2317) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2318) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2319) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2320) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2321) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2322) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2323) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -2) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2324) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -3) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2325) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.const -4) + (f32.const inf) + (f32.const 0) + (i32.const 4) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2326) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2327) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2328) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2329) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2330) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2331) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2332) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2333) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2334) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2335) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2336) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2337) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2338) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const -0) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2339) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2340) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2341) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2342) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2343) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2344) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2345) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const -3) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2346) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -1) + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2347) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2348) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2349) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2350) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 3) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2351) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2352) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -0.5) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2353) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1) + (f32.const -3) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2354) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2355) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 1.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2356) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 2) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2357) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const 3) + (f32.const -0.125) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2358) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2359) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2360) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2361) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2362) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2363) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 0.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2364) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2365) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2366) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const 1.5) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2367) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2368) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2369) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2370) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 3) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2371) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2372) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 1) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2373) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2374) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2375) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2376) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const inf) + (f32.const -2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2377) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2378) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2379) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2380) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const 3) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2381) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const 2) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2382) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2383) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const 0.5) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2384) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const -0.5) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2385) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2386) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.neg + (f32.const inf) + ) + (f32.const -2) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2387) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2388) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2389) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -2) + (f32.const 1) + (f32.const -2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2390) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_powf + (f32.const -2) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2391) + (i32.const 0) + ) + (unreachable) + ) ) (call "$(lib)/math/NativeMath.seedRandom" (i64.reinterpret/f64 @@ -9376,7 +47899,7 @@ (f64.convert_s/i32 (get_local $0) ) - (f64.const 1e7) + (f64.const 1e6) ) (block (block @@ -9406,7 +47929,7 @@ (call $abort (i32.const 0) (i32.const 4) - (i32.const 601) + (i32.const 2400) (i32.const 2) ) (unreachable) @@ -9424,5 +47947,8906 @@ ) ) ) + (call "$(lib)/math/NativeMathf.seedRandom" + (i64.reinterpret/f64 + (call "$(lib)/math/JSMath.random") + ) + ) + (block $break|1 + (set_local $0 + (i32.const 0) + ) + (loop $continue|1 + (if + (f64.lt + (f64.convert_s/i32 + (get_local $0) + ) + (f64.const 1e6) + ) + (block + (block + (set_local $3 + (call "$(lib)/math/NativeMathf.random") + ) + (if + (i32.eqz + (i32.and + (if (result i32) + (tee_local $2 + (f32.ge + (get_local $3) + (f32.const 0) + ) + ) + (f32.lt + (get_local $3) + (f32.const 1) + ) + (get_local $2) + ) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2408) + (i32.const 2) + ) + (unreachable) + ) + ) + ) + (set_local $0 + (i32.add + (get_local $0) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2422) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2423) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2424) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -6.531673581913484) + (f64.const -7) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2425) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2426) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.6619858980995045) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2427) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2428) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.5617597462207241) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2429) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.7741522965913037) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2430) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.6787637026394024) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2431) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2434) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2435) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2436) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2437) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2438) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2439) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2440) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.5) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2441) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2442) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.5) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2443) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2444) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2445) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2446) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 0.9999923706054688) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2447) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -0.9999923706054688) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2448) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2449) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2450) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2459) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2460) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2461) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -6.531673431396484) + (f32.const -7) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2462) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2463) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.6619858741760254) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2464) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2465) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.5617597699165344) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2466) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.7741522789001465) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2467) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.6787636876106262) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2468) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2471) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2472) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2473) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2474) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2475) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2476) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2477) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.5) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2478) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2479) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const 1.5) + (f64.const 2) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2480) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_round + (f64.const -1.5) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2481) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2482) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2483) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 0.9999923706054688) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2484) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -0.9999923706054688) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2485) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2486) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_roundf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2487) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2498) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2499) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2500) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const 2) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2501) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2502) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const -2) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2503) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2504) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2505) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sign + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2506) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2514) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2515) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2516) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2517) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2518) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const -2) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2519) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2520) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2521) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_signf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2522) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -8.06684839057968) + (f64.const 4.535662560676869) + (f64.const 1.0044767307740567) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2533) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 4.345239849338305) + (f64.const -8.88799136300345) + (f64.const 4.345239849338305) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2534) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -8.38143342755525) + (f64.const -2.763607337379588) + (f64.const -0.09061141541648476) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2535) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -6.531673581913484) + (f64.const 4.567535276842744) + (f64.const -1.9641383050707404) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2536) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 9.267056966972586) + (f64.const 4.811392084359796) + (f64.const -0.35572720174700656) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2537) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -6.450045556060236) + (f64.const 0.6620717923376739) + (f64.const 0.17067236731650248) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2538) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 7.858890253041697) + (f64.const 0.05215452675006225) + (f64.const -0.016443286217702822) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2539) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.792054511984896) + (f64.const 7.67640268511754) + (f64.const -0.792054511984896) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2540) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.615702673197924) + (f64.const 2.0119025790324803) + (f64.const 0.615702673197924) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2541) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5587586823609152) + (f64.const 0.03223983060263804) + (f64.const -0.0106815621160685) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2542) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2545) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2546) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2547) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2548) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2549) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2550) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.5) + (f64.const 1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2551) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.5) + (f64.const 1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2552) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 2) + (f64.const 1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2553) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -2) + (f64.const 1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2554) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2555) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2556) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2557) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2558) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2559) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2560) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2561) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2562) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2563) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.5) + (f64.const -1) + (f64.const -0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2564) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.5) + (f64.const -1) + (f64.const 0.5) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2565) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 2) + (f64.const -1) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2566) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -2) + (f64.const -1) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2567) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2568) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2569) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2570) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2571) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2572) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const inf) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2573) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2574) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2575) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2576) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2577) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const inf) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2578) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2579) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2580) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2581) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2582) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2583) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2584) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2585) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2586) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2587) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2588) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2589) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2590) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2591) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2592) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const 2) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2593) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const -0.5) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2594) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2595) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2596) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2597) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2598) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2599) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.const inf) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2600) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2601) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2602) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2603) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2604) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2605) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2606) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.75) + (f64.const 0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2607) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.75) + (f64.const 0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2608) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 1.75) + (f64.const -0.5) + (f64.const -0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2609) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const -1.75) + (f64.const -0.5) + (f64.const 0.25) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2610) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_rem + (f64.const 8e-323) + (f64.const inf) + (f64.const 8e-323) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2611) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -8.066848754882812) + (f32.const 4.535662651062012) + (f32.const 1.004476547241211) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2620) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 4.345239639282227) + (f32.const -8.887990951538086) + (f32.const 4.345239639282227) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2621) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -8.381433486938477) + (f32.const -2.7636072635650635) + (f32.const -0.09061169624328613) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2622) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -6.531673431396484) + (f32.const 4.567535400390625) + (f32.const -1.9641380310058594) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2623) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 9.267057418823242) + (f32.const 4.811392307281494) + (f32.const -0.3557271957397461) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2624) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -6.450045585632324) + (f32.const 0.6620717644691467) + (f32.const 0.17067205905914307) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2625) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 7.858890056610107) + (f32.const 0.052154526114463806) + (f32.const -0.016443386673927307) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2626) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.7920545339584351) + (f32.const 7.676402568817139) + (f32.const -0.7920545339584351) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2627) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.6157026886940002) + (f32.const 2.0119025707244873) + (f32.const 0.6157026886940002) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2628) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5587586760520935) + (f32.const 0.03223983198404312) + (f32.const -0.010681532323360443) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2629) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2632) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2633) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2634) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2635) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2636) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2637) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.5) + (f32.const 1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2638) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.5) + (f32.const 1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2639) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 2) + (f32.const 1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2640) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -2) + (f32.const 1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2641) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2642) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2643) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2644) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2645) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2646) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2647) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2648) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2649) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2650) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.5) + (f32.const -1) + (f32.const -0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2651) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.5) + (f32.const -1) + (f32.const 0.5) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2652) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 2) + (f32.const -1) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2653) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -2) + (f32.const -1) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2654) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2655) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2656) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2657) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2658) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2659) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const inf) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2660) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2661) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2662) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2663) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2664) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const inf) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2665) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2666) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -0) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2667) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2668) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2669) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2670) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2671) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2672) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2673) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2674) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2675) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2676) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2677) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2678) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2679) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const 2) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2680) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const -0.5) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2681) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2682) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2683) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2684) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2685) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2686) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.const inf) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2687) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2688) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2689) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2690) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2691) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2692) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2693) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.75) + (f32.const 0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2694) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.75) + (f32.const 0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2695) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 1.75) + (f32.const -0.5) + (f32.const -0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2696) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const -1.75) + (f32.const -0.5) + (f32.const 0.25) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2697) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_remf + (f32.const 5.877471754111438e-39) + (f32.const inf) + (f32.const 5.877471754111438e-39) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2698) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -8.06684839057968) + (f64.const -1593.5206801156262) + (f64.const -0.2138727605342865) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2763) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 4.345239849338305) + (f64.const 38.54878088685412) + (f64.const 0.21537430584430695) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2764) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -8.38143342755525) + (f64.const -2182.6307505145546) + (f64.const 0.16213826835155487) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2765) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -6.531673581913484) + (f64.const -343.2723926847529) + (f64.const 0.20479513704776764) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2766) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 9.267056966972586) + (f64.const 5291.7790755194055) + (f64.const -0.48676517605781555) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2767) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.6619858980995045) + (f64.const 0.7114062568229157) + (f64.const -0.4584641456604004) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2768) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0.4066039223853553) + (f64.const -0.41790065258739445) + (f64.const 0.37220045924186707) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2769) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.5617597462207241) + (f64.const 0.5917755935451237) + (f64.const 0.46178996562957764) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2770) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0.7741522965913037) + (f64.const 0.8538292008852542) + (f64.const -0.07019051909446716) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2771) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0.6787637026394024) + (f64.const -0.732097615653169) + (f64.const 0.26858529448509216) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2772) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2775) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2776) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2777) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2778) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2779) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -8.066848754882812) + (f32.const -1593.521240234375) + (f32.const 0.1671663224697113) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2788) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 4.345239639282227) + (f32.const 38.548770904541016) + (f32.const -0.49340328574180603) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2789) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -8.381433486938477) + (f32.const -2182.630859375) + (f32.const 0.0849970355629921) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2790) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -6.531673431396484) + (f32.const -343.2723388671875) + (f32.const 0.0704190656542778) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2791) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 9.267057418823242) + (f32.const 5291.78125) + (f32.const -0.44362515211105347) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2792) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.6619858741760254) + (f32.const 0.7114062309265137) + (f32.const 0.058103885501623154) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2793) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0.40660393238067627) + (f32.const -0.4179006516933441) + (f32.const 0.39349499344825745) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2794) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.5617597699165344) + (f32.const 0.5917755961418152) + (f32.const -0.4183797240257263) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2795) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0.7741522789001465) + (f32.const 0.8538292050361633) + (f32.const 0.45992106199264526) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2796) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0.6787636876106262) + (f32.const -0.7320976257324219) + (f32.const -0.48159059882164) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2797) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2800) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2801) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2802) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2803) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sinhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2804) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -8.06684839057968) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2816) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4.345239849338305) + (f64.const 2.0845238903256313) + (f64.const -0.07180261611938477) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2817) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -8.38143342755525) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2818) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -6.531673581913484) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2819) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 9.267056966972586) + (f64.const 3.0441841217266385) + (f64.const -0.01546262577176094) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2820) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.6619858980995045) + (f64.const 0.8136251582267503) + (f64.const -0.08618157356977463) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2821) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0.4066039223853553) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2822) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.5617597462207241) + (f64.const 0.7495063350104014) + (f64.const -0.0981396734714508) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2823) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.7741522965913037) + (f64.const 0.879859248170583) + (f64.const -0.37124353647232056) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2824) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0.6787637026394024) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2825) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2828) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2829) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2830) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2831) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2832) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2833) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -1) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2834) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4) + (f64.const 2) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2835) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1e-323) + (f64.const 3.1434555694052576e-162) + (f64.const 0.43537619709968567) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2836) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.5e-323) + (f64.const 3.849931087076416e-162) + (f64.const -0.45194002985954285) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2837) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5e-324) + (f64.const 2.2227587494850775e-162) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2838) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -5e-324) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2839) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.9999999999999999) + (f64.const 0.9999999999999999) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2840) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.9999999999999998) + (f64.const 1.414213562373095) + (f64.const -0.21107041835784912) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2841) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.0000000000000002) + (f64.const 1) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2842) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.0000000000000004) + (f64.const 1.4142135623730951) + (f64.const -0.27173060178756714) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2843) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.0000000000000002) + (f64.const 1) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2844) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 0.9999999999999999) + (f64.const 0.9999999999999999) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2845) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const -1797693134862315708145274e284) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2846) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862315708145274e284) + (f64.const 1340780792994259561100831e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2847) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 179769313486231490980915e285) + (f64.const 134078079299425926338769e131) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2848) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862314111473026e284) + (f64.const 1340780792994258965674548e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2849) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862313313136902e284) + (f64.const 1340780792994258667961407e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2850) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862312514800778e284) + (f64.const 1340780792994258370248265e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2851) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862311716464655e284) + (f64.const 1340780792994258072535124e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2852) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862310918128531e284) + (f64.const 1340780792994257774821982e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2853) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862310119792407e284) + (f64.const 1340780792994257477108841e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2854) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862309321456283e284) + (f64.const 1340780792994257179395699e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2855) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862308523120159e284) + (f64.const 1340780792994256881682558e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2856) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1797693134862307724784036e284) + (f64.const 1340780792994256583969417e130) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2857) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507203e-308) + (f64.const 1.4916681462400417e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2858) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507205e-308) + (f64.const 1.4916681462400423e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2859) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507207e-308) + (f64.const 1.491668146240043e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2860) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507209e-308) + (f64.const 1.4916681462400437e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2861) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.225073858507211e-308) + (f64.const 1.4916681462400443e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2862) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072127e-308) + (f64.const 1.491668146240045e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2863) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072147e-308) + (f64.const 1.4916681462400457e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2864) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072167e-308) + (f64.const 1.4916681462400463e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2865) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072187e-308) + (f64.const 1.491668146240047e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2866) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072207e-308) + (f64.const 1.4916681462400476e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2867) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072226e-308) + (f64.const 1.4916681462400483e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2868) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072246e-308) + (f64.const 1.491668146240049e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2869) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072266e-308) + (f64.const 1.4916681462400496e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2870) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.2250738585072286e-308) + (f64.const 1.4916681462400503e-154) + (f64.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2871) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 92.35130391890645) + (f64.const 9.609958580499006) + (f64.const 0.4998137056827545) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2872) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 93.3599596388916) + (f64.const 9.662295774757238) + (f64.const -0.49979978799819946) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2873) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 95.42049628886124) + (f64.const 9.76834153215689) + (f64.const -0.49997270107269287) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2874) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 95.87916941885449) + (f64.const 9.791790919890728) + (f64.const 0.4998766779899597) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2875) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 96.84804174884022) + (f64.const 9.841140266698785) + (f64.const 0.499801903963089) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2876) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.43639050883155) + (f64.const 9.87098731175517) + (f64.const 0.4997696280479431) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2877) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.50957979883047) + (f64.const 9.874693909120955) + (f64.const 0.49999818205833435) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2878) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 97.80496893882612) + (f64.const 9.88963947466368) + (f64.const -0.4999580681324005) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2879) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 98.2751822888192) + (f64.const 9.913383997849534) + (f64.const 0.49979931116104126) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2880) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 99.47293564880155) + (f64.const 9.973611966023219) + (f64.const -0.4999540448188782) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2881) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.57047130878539) + (f64.const 10.028483001370914) + (f64.const -0.49996453523635864) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2882) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.60954608878481) + (f64.const 10.030431002144665) + (f64.const 0.49975672364234924) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2883) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 100.67909109878379) + (f64.const 10.033897104255344) + (f64.const -0.4997771382331848) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2884) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 101.12268095877725) + (f64.const 10.055977374615422) + (f64.const 0.49988678097724915) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2885) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 101.3027691287746) + (f64.const 10.064927676281366) + (f64.const 0.4999105632305145) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2886) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.45932313565507e-307) + (f64.const 4.9591563149945874e-154) + (f64.const -0.4998999834060669) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2887) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5.610957305180409e-307) + (f64.const 7.490632353266584e-154) + (f64.const -0.4999343752861023) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2888) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 5.8073887977408524e-307) + (f64.const 7.62062254526548e-154) + (f64.const -0.49989569187164307) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2889) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 7.026137080471427e-307) + (f64.const 8.382205605013174e-154) + (f64.const 0.49980640411376953) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2890) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 8.438697769194972e-307) + (f64.const 9.186238495268328e-154) + (f64.const -0.4999065697193146) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2891) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.1607792515836795e-306) + (f64.const 1.0773946591586944e-153) + (f64.const -0.49997684359550476) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2892) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.2827413827423193e-306) + (f64.const 1.1325817333606962e-153) + (f64.const -0.4999513030052185) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2893) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 1.7116604596087457e-306) + (f64.const 1.3083044216117078e-153) + (f64.const -0.49986395239830017) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2894) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.038173251686994e-306) + (f64.const 1.4276460526639628e-153) + (f64.const 0.4998403787612915) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2895) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.171572060856931e-306) + (f64.const 1.4736254818836879e-153) + (f64.const 0.4999290406703949) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2896) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.4681399631804094e-306) + (f64.const 1.5710314965589996e-153) + (f64.const 0.49989044666290283) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2897) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.5175533964200588e-306) + (f64.const 1.5866799918131124e-153) + (f64.const -0.4997701048851013) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2898) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 2.6461505468829625e-306) + (f64.const 1.6266992797941982e-153) + (f64.const 0.4998672902584076) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2899) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 3.8167076367720413e-306) + (f64.const 1.9536395872248397e-153) + (f64.const 0.49983471632003784) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2900) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrt + (f64.const 4.5743220778562766e-306) + (f64.const 2.1387664851161936e-153) + (f64.const 0.49985939264297485) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2901) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -8.066848754882812) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2910) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4.345239639282227) + (f32.const 2.084523916244507) + (f32.const 0.3200402557849884) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2911) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -8.381433486938477) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2912) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -6.531673431396484) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2913) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 9.267057418823242) + (f32.const 3.0441842079162598) + (f32.const 0.05022354796528816) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2914) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.6619858741760254) + (f32.const 0.813625156879425) + (f32.const 0.2240506112575531) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2915) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0.40660393238067627) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2916) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.5617597699165344) + (f32.const 0.7495063543319702) + (f32.const 0.05895441770553589) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2917) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.7741522789001465) + (f32.const 0.879859209060669) + (f32.const -0.4874873757362366) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2918) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0.6787636876106262) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2919) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2922) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2923) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2924) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2925) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2926) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2927) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -1) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2928) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4) + (f32.const 2) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2929) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.802596928649634e-45) + (f32.const 5.293955920339377e-23) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2930) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 4.203895392974451e-45) + (f32.const 6.483745598763743e-23) + (f32.const 0.37388554215431213) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2931) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.401298464324817e-45) + (f32.const 3.743392066509216e-23) + (f32.const -0.20303145051002502) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2932) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -1.401298464324817e-45) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2933) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 3402823466385288598117041e14) + (f32.const 18446742974197923840) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2934) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const -3402823466385288598117041e14) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 2) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2935) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.9999998807907104) + (f32.const 0.9999999403953552) + (f32.const 2.980232594040899e-08) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2936) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 0.9999999403953552) + (f32.const 0.9999999403953552) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2937) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.999999761581421) + (f32.const 1.4142134189605713) + (f32.const -0.4959246516227722) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2938) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.9999998807907104) + (f32.const 1.4142135381698608) + (f32.const 0.15052194893360138) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2939) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.0000001192092896) + (f32.const 1) + (f32.const -0.5) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2940) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 1.000000238418579) + (f32.const 1.0000001192092896) + (f32.const 5.960463766996327e-08) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2941) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.000000238418579) + (f32.const 1.4142136573791504) + (f32.const 0.08986179530620575) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2942) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_sqrtf + (f32.const 2.000000476837158) + (f32.const 1.41421377658844) + (f32.const 0.3827550709247589) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 2943) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -8.06684839057968) + (f64.const -0.999999803096032) + (f64.const 0.012793331407010555) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3008) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 4.345239849338305) + (f64.const 0.9996636978961307) + (f64.const 0.1573508232831955) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3009) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -8.38143342755525) + (f64.const -0.9999998950434862) + (f64.const 0.27985066175460815) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3010) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -6.531673581913484) + (f64.const -0.9999957568392429) + (f64.const -0.44285574555397034) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3011) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 9.267056966972586) + (f64.const 0.9999999821447234) + (f64.const 0.4462755024433136) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3012) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.6619858980995045) + (f64.const 0.5796835018635275) + (f64.const 0.4892043173313141) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3013) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0.4066039223853553) + (f64.const -0.3855853099901652) + (f64.const 0.35993871092796326) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3014) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.5617597462207241) + (f64.const 0.5092819248700439) + (f64.const -0.39436522126197815) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3015) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0.7741522965913037) + (f64.const 0.6493374550318555) + (f64.const -0.4899396002292633) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3016) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0.6787637026394024) + (f64.const -0.590715084799841) + (f64.const -0.0145387789234519) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3017) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3020) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3021) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const inf) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3022) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3023) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanh + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3024) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -8.066848754882812) + (f32.const -0.9999998211860657) + (f32.const -0.3034979999065399) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3033) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 4.345239639282227) + (f32.const 0.9996637105941772) + (f32.const 0.2154078334569931) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3034) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -8.381433486938477) + (f32.const -0.9999998807907104) + (f32.const 0.23912210762500763) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3035) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -6.531673431396484) + (f32.const -0.999995768070221) + (f32.const -0.18844597041606903) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3036) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 9.267057418823242) + (f32.const 1) + (f32.const 0.1497807800769806) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3037) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.6619858741760254) + (f32.const 0.5796834826469421) + (f32.const -0.05590476095676422) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3038) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0.40660393238067627) + (f32.const -0.38558530807495117) + (f32.const 0.349787175655365) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3039) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.5617597699165344) + (f32.const 0.5092819333076477) + (f32.const -0.1528785079717636) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3040) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0.7741522789001465) + (f32.const 0.6493374705314636) + (f32.const 0.4317026138305664) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3041) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0.6787636876106262) + (f32.const -0.5907150506973267) + (f32.const 0.4079873859882355) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3042) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3045) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3046) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const inf) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3047) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3048) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_tanhf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3049) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -8.06684839057968) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3061) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 4.345239849338305) + (f64.const 4) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3062) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -8.38143342755525) + (f64.const -8) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3063) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -6.531673581913484) + (f64.const -6) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3064) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 9.267056966972586) + (f64.const 9) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3065) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.6619858980995045) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3066) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.4066039223853553) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3067) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.5617597462207241) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3068) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.7741522965913037) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3069) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.6787637026394024) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3070) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3073) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const inf) + (f64.const inf) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3074) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3075) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0) + (f64.const 0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3076) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0) + (f64.const -0) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3077) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 1) + (f64.const 1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3078) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -1) + (f64.const -1) + (f64.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3079) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.5) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3080) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.5) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3081) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 1.0000152587890625) + (f64.const 1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3082) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -1.0000152587890625) + (f64.const -1) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3083) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 0.9999923706054688) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3084) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -0.9999923706054688) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3085) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const 7.888609052210118e-31) + (f64.const 0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3086) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_trunc + (f64.const -7.888609052210118e-31) + (f64.const -0) + (f64.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3087) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -8.066848754882812) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3096) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 4.345239639282227) + (f32.const 4) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3097) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -8.381433486938477) + (f32.const -8) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3098) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -6.531673431396484) + (f32.const -6) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3099) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 9.267057418823242) + (f32.const 9) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3100) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.6619858741760254) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3101) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.40660393238067627) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3102) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.5617597699165344) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3103) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.7741522789001465) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3104) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.6787636876106262) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const inf) + (f32.const inf) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0) + (f32.const 0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0) + (f32.const -0) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 1) + (f32.const 1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -1) + (f32.const -1) + (f32.const 0) + (i32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.5) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.5) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 1.0000152587890625) + (f32.const 1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -1.0000152587890625) + (f32.const -1) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 0.9999923706054688) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -0.9999923706054688) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const 7.888609052210118e-31) + (f32.const 0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/math/test_truncf + (f32.const -7.888609052210118e-31) + (f32.const -0) + (f32.const 0) + (i32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 3122) + (i32.const 0) + ) + (unreachable) + ) + ) ) ) diff --git a/tests/compiler/std/mod.optimized.wat b/tests/compiler/std/mod.optimized.wat new file mode 100644 index 00000000..05781836 --- /dev/null +++ b/tests/compiler/std/mod.optimized.wat @@ -0,0 +1,3294 @@ +(module + (type $FFFi (func (param f64 f64 f64) (result i32))) + (type $FFF (func (param f64 f64) (result f64))) + (type $FFi (func (param f64 f64) (result i32))) + (type $iiiiv (func (param i32 i32 i32 i32))) + (type $fffi (func (param f32 f32 f32) (result i32))) + (type $fff (func (param f32 f32) (result f32))) + (type $ffi (func (param f32 f32) (result i32))) + (type $v (func)) + (import "JSOp" "mod" (func $std/mod/JSOp.mod (param f64 f64) (result f64))) + (import "env" "abort" (func $abort (param i32 i32 i32 i32))) + (memory $0 1) + (data (i32.const 4) "\n\00\00\00s\00t\00d\00/\00m\00o\00d\00.\00t\00s") + (export "memory" (memory $0)) + (start $start) + (func "$(lib)/math/NativeMath.mod" (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 f64) + (block $folding-inner0 + (set_local $3 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (tee_local $5 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $7 + (i32.and + (if (result i32) + (tee_local $7 + (i64.eq + (i64.shl + (get_local $5) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $7) + (f64.ne + (tee_local $8 + (get_local $1) + ) + (get_local $8) + ) + ) + (i32.const 1) + ) + ) + (get_local $7) + (i32.eq + (get_local $3) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.le_u + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + (block + (br_if $folding-inner0 + (i64.eq + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $5) + (i64.const 1) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $7 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + ) + (set_local $2 + (if (result i64) + (get_local $3) + (i64.or + (i64.and + (get_local $2) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $4 + (i64.shl + (get_local $2) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eqz + (i64.shr_u + (get_local $4) + (i64.const 63) + ) + ) + (block + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (set_local $4 + (i64.shl + (get_local $4) + (i64.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i64.shl + (get_local $2) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + ) + ) + ) + ) + (set_local $5 + (if (result i64) + (get_local $6) + (i64.or + (i64.and + (get_local $5) + (i64.const 4503599627370495) + ) + (i64.const 4503599627370496) + ) + (block (result i64) + (set_local $4 + (i64.shl + (get_local $5) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eqz + (i64.shr_u + (get_local $4) + (i64.const 63) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $4 + (i64.shl + (get_local $4) + (i64.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i64.shl + (get_local $5) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + ) + (loop $continue|2 + (if + (i32.gt_s + (get_local $3) + (get_local $6) + ) + (block + (if + (i64.eqz + (i64.shr_u + (tee_local $4 + (i64.sub + (get_local $2) + (get_local $5) + ) + ) + (i64.const 63) + ) + ) + (block + (br_if $folding-inner0 + (i64.eqz + (get_local $4) + ) + ) + (set_local $2 + (get_local $4) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + (if + (i64.eqz + (i64.shr_u + (tee_local $4 + (i64.sub + (get_local $2) + (get_local $5) + ) + ) + (i64.const 63) + ) + ) + (block + (br_if $folding-inner0 + (i64.eqz + (get_local $4) + ) + ) + (set_local $2 + (get_local $4) + ) + ) + ) + (loop $continue|3 + (if + (i64.eqz + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + (block + (set_local $3 + (i32.sub + (get_local $3) + (i32.const 1) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (return + (f64.reinterpret/i64 + (i64.or + (tee_local $2 + (select + (i64.or + (i64.sub + (get_local $2) + (i64.const 4503599627370496) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $3) + ) + (i64.const 52) + ) + ) + (i64.shr_u + (get_local $2) + (i64.extend_u/i32 + (i32.sub + (i32.const 1) + (get_local $3) + ) + ) + ) + (i32.gt_s + (get_local $3) + (i32.const 0) + ) + ) + ) + (i64.shl + (i64.extend_u/i32 + (get_local $7) + ) + (i64.const 63) + ) + ) + ) + ) + ) + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + (func $std/mod/check (; 3 ;) (type $FFi) (param $0 f64) (param $1 f64) (result i32) + (local $2 f64) + (if + (f64.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + (return + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + ) + (if + (f64.eq + (get_local $1) + (f64.const 0) + ) + (return + (f64.eq + (f64.div + (f64.const 1) + (get_local $1) + ) + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (f64.eq + (get_local $0) + (get_local $1) + ) + ) + (func $std/mod/test_fmod (; 4 ;) (type $FFFi) (param $0 f64) (param $1 f64) (param $2 f64) (result i32) + (local $3 i32) + (i32.and + (if (result i32) + (tee_local $3 + (call $std/mod/check + (call "$(lib)/math/NativeMath.mod" + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + (if (result i32) + (tee_local $3 + (i32.const 0) + ) + (get_local $3) + (call $std/mod/check + (call $std/mod/JSOp.mod + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + (get_local $3) + ) + (i32.const 1) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (block $folding-inner0 + (set_local $4 + (i32.and + (i32.shr_u + (tee_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (i32.shr_u + (tee_local $5 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $3 + (i32.and + (if (result i32) + (tee_local $3 + (i32.eqz + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (get_local $3) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $3) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + (block + (br_if $folding-inner0 + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $5) + (i32.const 1) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (set_local $8 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (set_local $2 + (if (result i32) + (get_local $4) + (i32.or + (i32.and + (get_local $2) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + (i32.shl + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + ) + ) + ) + (set_local $5 + (if (result i32) + (get_local $6) + (i32.or + (i32.and + (get_local $5) + (i32.const 8388607) + ) + (i32.const 8388608) + ) + (block (result i32) + (set_local $3 + (i32.shl + (get_local $5) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $3) + (i32.const 31) + ) + ) + (block + (set_local $6 + (i32.sub + (get_local $6) + (i32.const 1) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + (i32.shl + (get_local $5) + (i32.sub + (i32.const 1) + (get_local $6) + ) + ) + ) + ) + ) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $6) + ) + (block + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + (if + (i32.eqz + (i32.shr_u + (tee_local $3 + (i32.sub + (get_local $2) + (get_local $5) + ) + ) + (i32.const 31) + ) + ) + (block + (br_if $folding-inner0 + (i32.eqz + (get_local $3) + ) + ) + (set_local $2 + (get_local $3) + ) + ) + ) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + (return + (f32.reinterpret/i32 + (i32.or + (tee_local $2 + (select + (i32.or + (i32.sub + (get_local $2) + (i32.const 8388608) + ) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + (i32.shr_u + (get_local $2) + (i32.sub + (i32.const 1) + (get_local $4) + ) + ) + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + ) + ) + (get_local $8) + ) + ) + ) + ) + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + (func $std/mod/check (; 6 ;) (type $ffi) (param $0 f32) (param $1 f32) (result i32) + (local $2 f32) + (if + (f32.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + (return + (f32.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + ) + (if + (f32.eq + (get_local $1) + (f32.const 0) + ) + (return + (f32.eq + (f32.div + (f32.const 1) + (get_local $1) + ) + (f32.div + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (f32.eq + (get_local $0) + (get_local $1) + ) + ) + (func $std/mod/test_fmodf (; 7 ;) (type $fffi) (param $0 f32) (param $1 f32) (param $2 f32) (result i32) + (call $std/mod/check + (call "$(lib)/math/NativeMathf.mod" + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + (func $start (; 8 ;) (type $v) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const 2) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 21) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const -2) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 22) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const 2) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 23) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const -2) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 24) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3.5) + (f64.const 2) + (f64.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 25) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3.5) + (f64.const -2) + (f64.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 26) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3.5) + (f64.const 2) + (f64.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 27) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3.5) + (f64.const -2) + (f64.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 28) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const 2.5) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 29) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const -2.5) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 30) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const 2.5) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 31) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const -2.5) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 32) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 33) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 34) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 35) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 36) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.5) + (f64.const 1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 37) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.5) + (f64.const -1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 38) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.5) + (f64.const 1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 39) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.5) + (f64.const -1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 40) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.25) + (f64.const 1) + (f64.const 0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 41) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.25) + (f64.const -1) + (f64.const 0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 42) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.25) + (f64.const 1) + (f64.const -0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 43) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.25) + (f64.const -1) + (f64.const -0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 44) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const 1.25) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 45) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const -1.25) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 46) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const 1.25) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 47) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const -1.25) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 48) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -13) + (f64.const 64) + (f64.const -13) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 49) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 52) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 53) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 54) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 55) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const 1) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 56) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const 1) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 57) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const -1) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 58) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const -1) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 59) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 60) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 61) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 62) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 63) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 64) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 65) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 66) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 67) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 68) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 69) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 70) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 71) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 72) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const inf) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 73) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const inf) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 74) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const -inf) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 75) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const -inf) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 76) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const inf) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 77) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const inf) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 78) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const -inf) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 79) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const -inf) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 80) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 81) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 82) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 83) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 84) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 85) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 86) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 87) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 88) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 89) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 90) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 91) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const -inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 92) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 93) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 94) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 95) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 96) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const 2) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const -2) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 106) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const 2) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 107) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const -2) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3.5) + (f32.const 2) + (f32.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3.5) + (f32.const -2) + (f32.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3.5) + (f32.const 2) + (f32.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3.5) + (f32.const -2) + (f32.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const 2.5) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const -2.5) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const 2.5) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const -2.5) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1.5) + (f32.const 1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1.5) + (f32.const -1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1.5) + (f32.const 1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1.5) + (f32.const -1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 134) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const inf) + (f32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const inf) + (f32.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const -inf) + (f32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const -inf) + (f32.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const inf) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const inf) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const -inf) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const -inf) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 154) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 155) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const -inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const -inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 167) + (i32.const 0) + ) + (unreachable) + ) + ) + ) +) diff --git a/tests/compiler/std/mod.ts b/tests/compiler/std/mod.ts new file mode 100644 index 00000000..9328f616 --- /dev/null +++ b/tests/compiler/std/mod.ts @@ -0,0 +1,167 @@ +const js = true; + +declare namespace JSOp { + export function mod(x: f64, y: f64): f64; +} + +function check(actual: T, expected: T): bool { + if (isNaN(expected)) return isNaN(actual); + if (expected == 0) return 1 / expected == 1 / actual; + return actual == expected; +} + +// === f64 % f64 ================================ + +function test_fmod(left: f64, right: f64, expected: f64): bool { + return check( left % right , expected) && + (!js || check(JSOp.mod(left , right), expected)); +} + +// sanity +assert(test_fmod(3.0, 2.0, 1.0)); +assert(test_fmod(3.0, -2.0, 1.0)); +assert(test_fmod(-3.0, 2.0, -1.0)); +assert(test_fmod(-3.0, -2.0, -1.0)); +assert(test_fmod(3.5, 2.0, 1.5)); +assert(test_fmod(3.5, -2.0, 1.5)); +assert(test_fmod(-3.5, 2.0, -1.5)); +assert(test_fmod(-3.5, -2.0, -1.5)); +assert(test_fmod(3.0, 2.5, 0.5)); +assert(test_fmod(3.0, -2.5, 0.5)); +assert(test_fmod(-3.0, 2.5, -0.5)); +assert(test_fmod(-3.0, -2.5, -0.5)); +assert(test_fmod(0.5, 1.0, 0.5)); +assert(test_fmod(0.5, -1.0, 0.5)); +assert(test_fmod(-0.5, 1.0, -0.5)); +assert(test_fmod(-0.5, -1.0, -0.5)); +assert(test_fmod(1.5, 1.0, 0.5)); +assert(test_fmod(1.5, -1.0, 0.5)); +assert(test_fmod(-1.5, 1.0, -0.5)); +assert(test_fmod(-1.5, -1.0, -0.5)); +assert(test_fmod(1.25, 1.0, 0.25)); +assert(test_fmod(1.25, -1.0, 0.25)); +assert(test_fmod(-1.25, 1.0, -0.25)); +assert(test_fmod(-1.25, -1.0, -0.25)); +assert(test_fmod(1.0, 1.25, 1.0)); +assert(test_fmod(1.0, -1.25, 1.0)); +assert(test_fmod(-1.0, 1.25, -1.0)); +assert(test_fmod(-1.0, -1.25, -1.0)); +assert(test_fmod(-13, 64, -13)); + +// special +assert(test_fmod(0.0, 0.0, NaN)); +assert(test_fmod(-0.0, 0.0, NaN)); +assert(test_fmod(0.0, -0.0, NaN)); +assert(test_fmod(-0.0, -0.0, NaN)); +assert(test_fmod(0.0, 1.0, 0.0)); +assert(test_fmod(-0.0, 1.0, -0.0)); +assert(test_fmod(0.0, -1.0, 0.0)); +assert(test_fmod(-0.0, -1.0, -0.0)); +assert(test_fmod(1.0, 0.0, NaN)); +assert(test_fmod(-1.0, 0.0, NaN)); +assert(test_fmod(1.0, -0.0, NaN)); +assert(test_fmod(-1.0, -0.0, NaN)); +assert(test_fmod(NaN, 0.0, NaN)); +assert(test_fmod(NaN, -0.0, NaN)); +assert(test_fmod(NaN, 1.0, NaN)); +assert(test_fmod(NaN, -1.0, NaN)); +assert(test_fmod(NaN, 0.0, NaN)); +assert(test_fmod(NaN, -0.0, NaN)); +assert(test_fmod(NaN, 1.0, NaN)); +assert(test_fmod(NaN, -1.0, NaN)); +assert(test_fmod(NaN, NaN, NaN)); +assert(test_fmod(0.0, Infinity, 0.0)); +assert(test_fmod(-0.0, Infinity, -0.0)); +assert(test_fmod(0.0, -Infinity, 0.0)); +assert(test_fmod(-0.0, -Infinity, -0.0)); +assert(test_fmod(1.0, Infinity, 1.0)); +assert(test_fmod(-1.0, Infinity, -1.0)); +assert(test_fmod(1.0, -Infinity, 1.0)); +assert(test_fmod(-1.0, -Infinity, -1.0)); +assert(test_fmod(Infinity, 0.0, NaN)); +assert(test_fmod(Infinity, -0.0, NaN)); +assert(test_fmod(-Infinity, 0.0, NaN)); +assert(test_fmod(-Infinity, -0.0, NaN)); +assert(test_fmod(Infinity, 1.0, NaN)); +assert(test_fmod(Infinity, -1.0, NaN)); +assert(test_fmod(-Infinity, 1.0, NaN)); +assert(test_fmod(-Infinity, -1.0, NaN)); +assert(test_fmod(Infinity, Infinity, NaN)); +assert(test_fmod(-Infinity, Infinity, NaN)); +assert(test_fmod(Infinity, -Infinity, NaN)); +assert(test_fmod(-Infinity, -Infinity, NaN)); +assert(test_fmod(Infinity, NaN, NaN)); +assert(test_fmod(-Infinity, NaN, NaN)); +assert(test_fmod(NaN, Infinity, NaN)); +assert(test_fmod(NaN, -Infinity, NaN)); + +// === f32 % f32 ================================ + +function test_fmodf(left: f32, right: f32, expected: f32): bool { + return check(left % right, expected); +} + +// sanity +assert(test_fmodf(3.0, 2.0, 1.0)); +assert(test_fmodf(3.0, -2.0, 1.0)); +assert(test_fmodf(-3.0, 2.0, -1.0)); +assert(test_fmodf(-3.0, -2.0, -1.0)); +assert(test_fmodf(3.5, 2.0, 1.5)); +assert(test_fmodf(3.5, -2.0, 1.5)); +assert(test_fmodf(-3.5, 2.0, -1.5)); +assert(test_fmodf(-3.5, -2.0, -1.5)); +assert(test_fmodf(3.0, 2.5, 0.5)); +assert(test_fmodf(3.0, -2.5, 0.5)); +assert(test_fmodf(-3.0, 2.5, -0.5)); +assert(test_fmodf(-3.0, -2.5, -0.5)); +assert(test_fmodf(0.5, 1.0, 0.5)); +assert(test_fmodf(0.5, -1.0, 0.5)); +assert(test_fmodf(-0.5, 1.0, -0.5)); +assert(test_fmodf(-0.5, -1.0, -0.5)); +assert(test_fmodf(1.5, 1.0, 0.5)); +assert(test_fmodf(1.5, -1.0, 0.5)); +assert(test_fmodf(-1.5, 1.0, -0.5)); +assert(test_fmodf(-1.5, -1.0, -0.5)); + +// special +assert(test_fmodf(0.0, 0.0, NaN)); +assert(test_fmodf(-0.0, 0.0, NaN)); +assert(test_fmodf(0.0, -0.0, NaN)); +assert(test_fmodf(-0.0, -0.0, NaN)); +assert(test_fmodf(1.0, 0.0, NaN)); +assert(test_fmodf(-1.0, 0.0, NaN)); +assert(test_fmodf(1.0, -0.0, NaN)); +assert(test_fmodf(-1.0, -0.0, NaN)); +assert(test_fmodf(NaN, 0.0, NaN)); +assert(test_fmodf(NaN, -0.0, NaN)); +assert(test_fmodf(NaN, 1.0, NaN)); +assert(test_fmodf(NaN, -1.0, NaN)); +assert(test_fmodf(NaN, 0.0, NaN)); +assert(test_fmodf(NaN, -0.0, NaN)); +assert(test_fmodf(NaN, 1.0, NaN)); +assert(test_fmodf(NaN, -1.0, NaN)); +assert(test_fmodf(NaN, NaN, NaN)); +assert(test_fmodf(0.0, Infinity, 0.0)); +assert(test_fmodf(-0.0, Infinity, -0.0)); +assert(test_fmodf(0.0, -Infinity, 0.0)); +assert(test_fmodf(-0.0, -Infinity, -0.0)); +assert(test_fmodf(1.0, Infinity, 1.0)); +assert(test_fmodf(-1.0, Infinity, -1.0)); +assert(test_fmodf(1.0, -Infinity, 1.0)); +assert(test_fmodf(-1.0, -Infinity, -1.0)); +assert(test_fmodf(Infinity, 0.0, NaN)); +assert(test_fmodf(Infinity, -0.0, NaN)); +assert(test_fmodf(-Infinity, 0.0, NaN)); +assert(test_fmodf(-Infinity, -0.0, NaN)); +assert(test_fmodf(Infinity, 1.0, NaN)); +assert(test_fmodf(Infinity, -1.0, NaN)); +assert(test_fmodf(-Infinity, 1.0, NaN)); +assert(test_fmodf(-Infinity, -1.0, NaN)); +assert(test_fmodf(Infinity, Infinity, NaN)); +assert(test_fmodf(-Infinity, Infinity, NaN)); +assert(test_fmodf(Infinity, -Infinity, NaN)); +assert(test_fmodf(-Infinity, -Infinity, NaN)); +assert(test_fmodf(Infinity, NaN, NaN)); +assert(test_fmodf(-Infinity, NaN, NaN)); +assert(test_fmodf(NaN, Infinity, NaN)); +assert(test_fmodf(NaN, -Infinity, NaN)); diff --git a/tests/compiler/std/mod.untouched.wat b/tests/compiler/std/mod.untouched.wat new file mode 100644 index 00000000..66ee81f5 --- /dev/null +++ b/tests/compiler/std/mod.untouched.wat @@ -0,0 +1,3534 @@ +(module + (type $FFFi (func (param f64 f64 f64) (result i32))) + (type $FFF (func (param f64 f64) (result f64))) + (type $FFi (func (param f64 f64) (result i32))) + (type $i (func (result i32))) + (type $iiiiv (func (param i32 i32 i32 i32))) + (type $fffi (func (param f32 f32 f32) (result i32))) + (type $fff (func (param f32 f32) (result f32))) + (type $ffi (func (param f32 f32) (result i32))) + (type $v (func)) + (import "JSOp" "mod" (func $std/mod/JSOp.mod (param f64 f64) (result f64))) + (import "env" "abort" (func $abort (param i32 i32 i32 i32))) + (global $std/mod/js i32 (i32.const 1)) + (global $HEAP_BASE i32 (i32.const 28)) + (memory $0 1) + (data (i32.const 4) "\n\00\00\00s\00t\00d\00/\00m\00o\00d\00.\00t\00s\00") + (export "memory" (memory $0)) + (start $start) + (func "$(lib)/math/NativeMath.mod" (; 2 ;) (type $FFF) (param $0 f64) (param $1 f64) (result f64) + (local $2 i64) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f64) + (local $8 i32) + (local $9 i64) + (set_local $2 + (i64.reinterpret/f64 + (get_local $0) + ) + ) + (set_local $3 + (i64.reinterpret/f64 + (get_local $1) + ) + ) + (set_local $4 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $5 + (i32.wrap/i64 + (i64.and + (i64.shr_u + (get_local $3) + (i64.const 52) + ) + (i64.const 2047) + ) + ) + ) + (set_local $6 + (i32.wrap/i64 + (i64.shr_u + (get_local $2) + (i64.const 63) + ) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.and + (if (result i32) + (tee_local $8 + (i64.eq + (i64.shl + (get_local $3) + (i64.const 1) + ) + (i64.const 0) + ) + ) + (get_local $8) + (f64.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $8) + (i32.eq + (get_local $4) + (i32.const 2047) + ) + ) + (i32.const 1) + ) + (return + (f64.div + (f64.mul + (get_local $0) + (get_local $1) + ) + (f64.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i64.le_u + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (block + (if + (i64.eq + (i64.shl + (get_local $2) + (i64.const 1) + ) + (i64.shl + (get_local $3) + (i64.const 1) + ) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $9 + (i64.shl + (get_local $2) + (i64.const 12) + ) + ) + (loop $continue|0 + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i64.shl + (get_local $9) + (i64.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $2 + (i64.and + (get_local $2) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $9 + (i64.shl + (get_local $3) + (i64.const 12) + ) + ) + (loop $continue|1 + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $9 + (i64.shl + (get_local $9) + (i64.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i64.shl + (get_local $3) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (block + (set_local $3 + (i64.and + (get_local $3) + (i64.shr_u + (i64.const -1) + (i64.const 12) + ) + ) + ) + (set_local $3 + (i64.or + (get_local $3) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + ) + ) + (block $break|2 + (nop) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $9 + (i64.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (if + (i64.eqz + (get_local $9) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + ) + (set_local $9 + (i64.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i64.eqz + (i64.shr_u + (get_local $9) + (i64.const 63) + ) + ) + (block + (if + (i64.eqz + (get_local $9) + ) + (return + (f64.mul + (f64.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i64.eqz + (i64.shr_u + (get_local $2) + (i64.const 52) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i64.shl + (get_local $2) + (i64.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $2 + (i64.sub + (get_local $2) + (i64.shl + (i64.const 1) + (i64.const 52) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.extend_u/i32 + (get_local $4) + ) + (i64.const 52) + ) + ) + ) + ) + (set_local $2 + (i64.shr_u + (get_local $2) + (i64.extend_u/i32 + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + ) + (set_local $2 + (i64.or + (get_local $2) + (i64.shl + (i64.extend_u/i32 + (get_local $6) + ) + (i64.const 63) + ) + ) + ) + (return + (f64.reinterpret/i64 + (get_local $2) + ) + ) + ) + (func $std/mod/check (; 3 ;) (type $FFi) (param $0 f64) (param $1 f64) (result i32) + (local $2 f64) + (if + (f64.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + (return + (f64.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + ) + (if + (f64.eq + (get_local $1) + (f64.const 0) + ) + (return + (f64.eq + (f64.div + (f64.convert_u/i32 + (i32.const 1) + ) + (get_local $1) + ) + (f64.div + (f64.const 1) + (get_local $0) + ) + ) + ) + ) + (return + (f64.eq + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/mod/test_fmod (; 4 ;) (type $FFFi) (param $0 f64) (param $1 f64) (param $2 f64) (result i32) + (local $3 i32) + (return + (i32.and + (if (result i32) + (tee_local $3 + (call $std/mod/check + (call "$(lib)/math/NativeMath.mod" + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + (if (result i32) + (tee_local $3 + (i32.eqz + (i32.const 1) + ) + ) + (get_local $3) + (call $std/mod/check + (call $std/mod/JSOp.mod + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + (get_local $3) + ) + (i32.const 1) + ) + ) + ) + (func "$(lib)/math/NativeMathf.mod" (; 5 ;) (type $fff) (param $0 f32) (param $1 f32) (result f32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 f32) + (local $8 i32) + (local $9 i32) + (set_local $2 + (i32.reinterpret/f32 + (get_local $0) + ) + ) + (set_local $3 + (i32.reinterpret/f32 + (get_local $1) + ) + ) + (set_local $4 + (i32.and + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $5 + (i32.and + (i32.shr_u + (get_local $3) + (i32.const 23) + ) + (i32.const 255) + ) + ) + (set_local $6 + (i32.and + (get_local $2) + (i32.const -2147483648) + ) + ) + (if + (i32.and + (if (result i32) + (tee_local $8 + (i32.and + (if (result i32) + (tee_local $8 + (i32.eq + (i32.shl + (get_local $3) + (i32.const 1) + ) + (i32.const 0) + ) + ) + (get_local $8) + (f32.ne + (tee_local $7 + (get_local $1) + ) + (get_local $7) + ) + ) + (i32.const 1) + ) + ) + (get_local $8) + (i32.eq + (get_local $4) + (i32.const 255) + ) + ) + (i32.const 1) + ) + (return + (f32.div + (f32.mul + (get_local $0) + (get_local $1) + ) + (f32.mul + (get_local $0) + (get_local $1) + ) + ) + ) + ) + (if + (i32.le_u + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (block + (if + (i32.eq + (i32.shl + (get_local $2) + (i32.const 1) + ) + (i32.shl + (get_local $3) + (i32.const 1) + ) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (return + (get_local $0) + ) + ) + ) + (nop) + (if + (i32.eqz + (get_local $4) + ) + (block + (block $break|0 + (set_local $9 + (i32.shl + (get_local $2) + (i32.const 9) + ) + ) + (loop $continue|0 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|0) + ) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $2 + (i32.and + (get_local $2) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (if + (i32.eqz + (get_local $5) + ) + (block + (block $break|1 + (set_local $9 + (i32.shl + (get_local $3) + (i32.const 9) + ) + ) + (loop $continue|1 + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (set_local $5 + (i32.sub + (get_local $5) + (i32.const 1) + ) + ) + (set_local $9 + (i32.shl + (get_local $9) + (i32.const 1) + ) + ) + (br $continue|1) + ) + ) + ) + ) + (set_local $3 + (i32.shl + (get_local $3) + (i32.add + (i32.sub + (i32.const 0) + (get_local $5) + ) + (i32.const 1) + ) + ) + ) + ) + (block + (set_local $3 + (i32.and + (get_local $3) + (i32.shr_u + (i32.const -1) + (i32.const 9) + ) + ) + ) + (set_local $3 + (i32.or + (get_local $3) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + ) + ) + (block $break|2 + (nop) + (loop $continue|2 + (if + (i32.gt_s + (get_local $4) + (get_local $5) + ) + (block + (block + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + ) + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (br $continue|2) + ) + ) + ) + ) + (set_local $9 + (i32.sub + (get_local $2) + (get_local $3) + ) + ) + (if + (i32.eqz + (i32.shr_u + (get_local $9) + (i32.const 31) + ) + ) + (block + (if + (i32.eqz + (get_local $9) + ) + (return + (f32.mul + (f32.const 0) + (get_local $0) + ) + ) + ) + (set_local $2 + (get_local $9) + ) + ) + ) + (block $break|3 + (nop) + (loop $continue|3 + (if + (i32.eqz + (i32.shr_u + (get_local $2) + (i32.const 23) + ) + ) + (block + (set_local $4 + (i32.sub + (get_local $4) + (i32.const 1) + ) + ) + (set_local $2 + (i32.shl + (get_local $2) + (i32.const 1) + ) + ) + (br $continue|3) + ) + ) + ) + ) + (if + (i32.gt_s + (get_local $4) + (i32.const 0) + ) + (block + (set_local $2 + (i32.sub + (get_local $2) + (i32.shl + (i32.const 1) + (i32.const 23) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (i32.shl + (get_local $4) + (i32.const 23) + ) + ) + ) + ) + (set_local $2 + (i32.shr_u + (get_local $2) + (i32.add + (i32.sub + (i32.const 0) + (get_local $4) + ) + (i32.const 1) + ) + ) + ) + ) + (set_local $2 + (i32.or + (get_local $2) + (get_local $6) + ) + ) + (return + (f32.reinterpret/i32 + (get_local $2) + ) + ) + ) + (func $std/mod/check (; 6 ;) (type $ffi) (param $0 f32) (param $1 f32) (result i32) + (local $2 f32) + (if + (f32.ne + (tee_local $2 + (get_local $1) + ) + (get_local $2) + ) + (return + (f32.ne + (tee_local $2 + (get_local $0) + ) + (get_local $2) + ) + ) + ) + (if + (f32.eq + (get_local $1) + (f32.const 0) + ) + (return + (f32.eq + (f32.div + (f32.convert_u/i32 + (i32.const 1) + ) + (get_local $1) + ) + (f32.div + (f32.const 1) + (get_local $0) + ) + ) + ) + ) + (return + (f32.eq + (get_local $0) + (get_local $1) + ) + ) + ) + (func $std/mod/test_fmodf (; 7 ;) (type $fffi) (param $0 f32) (param $1 f32) (param $2 f32) (result i32) + (return + (call $std/mod/check + (call "$(lib)/math/NativeMathf.mod" + (get_local $0) + (get_local $1) + ) + (get_local $2) + ) + ) + ) + (func $start (; 8 ;) (type $v) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const 2) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 21) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const -2) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 22) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const 2) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 23) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const -2) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 24) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3.5) + (f64.const 2) + (f64.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 25) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3.5) + (f64.const -2) + (f64.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 26) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3.5) + (f64.const 2) + (f64.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 27) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3.5) + (f64.const -2) + (f64.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 28) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const 2.5) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 29) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 3) + (f64.const -2.5) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 30) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const 2.5) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 31) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -3) + (f64.const -2.5) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 32) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0.5) + (f64.const 1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 33) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0.5) + (f64.const -1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 34) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0.5) + (f64.const 1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 35) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0.5) + (f64.const -1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 36) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.5) + (f64.const 1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 37) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.5) + (f64.const -1) + (f64.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 38) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.5) + (f64.const 1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 39) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.5) + (f64.const -1) + (f64.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 40) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.25) + (f64.const 1) + (f64.const 0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 41) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1.25) + (f64.const -1) + (f64.const 0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 42) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.25) + (f64.const 1) + (f64.const -0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 43) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1.25) + (f64.const -1) + (f64.const -0.25) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 44) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const 1.25) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 45) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const -1.25) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 46) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const 1.25) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 47) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const -1.25) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 48) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -13) + (f64.const 64) + (f64.const -13) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 49) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 52) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 53) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 54) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 55) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const 1) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 56) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const 1) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 57) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const -1) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 58) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const -1) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 59) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 60) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 61) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 62) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 63) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 64) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 65) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 66) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 67) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 68) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 69) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 70) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 71) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 72) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.const inf) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 73) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.const inf) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 74) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 0) + (f64.neg + (f64.const inf) + ) + (f64.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 75) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -0) + (f64.neg + (f64.const inf) + ) + (f64.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 76) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.const inf) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 77) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.const inf) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 78) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const 1) + (f64.neg + (f64.const inf) + ) + (f64.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 79) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const -1) + (f64.neg + (f64.const inf) + ) + (f64.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 80) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 81) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 82) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const 0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 83) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const -0) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 84) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 85) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 86) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const 1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 87) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const -1) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 88) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 89) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 90) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 91) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 92) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const inf) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 93) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 94) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.const inf) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 95) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmod + (f64.const nan:0x8000000000000) + (f64.neg + (f64.const inf) + ) + (f64.const nan:0x8000000000000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 96) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const 2) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 105) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const -2) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 106) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const 2) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 107) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const -2) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 108) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3.5) + (f32.const 2) + (f32.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 109) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3.5) + (f32.const -2) + (f32.const 1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 110) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3.5) + (f32.const 2) + (f32.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 111) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3.5) + (f32.const -2) + (f32.const -1.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 112) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const 2.5) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 113) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 3) + (f32.const -2.5) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 114) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const 2.5) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 115) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -3) + (f32.const -2.5) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 116) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0.5) + (f32.const 1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 117) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0.5) + (f32.const -1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 118) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0.5) + (f32.const 1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 119) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0.5) + (f32.const -1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 120) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1.5) + (f32.const 1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 121) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1.5) + (f32.const -1) + (f32.const 0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 122) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1.5) + (f32.const 1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 123) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1.5) + (f32.const -1) + (f32.const -0.5) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 124) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 127) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 128) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 129) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 130) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 131) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 132) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 133) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 134) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 135) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 136) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 137) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 138) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 139) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 140) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 141) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 142) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 143) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.const inf) + (f32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 144) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.const inf) + (f32.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 145) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 0) + (f32.neg + (f32.const inf) + ) + (f32.const 0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 146) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -0) + (f32.neg + (f32.const inf) + ) + (f32.const -0) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 147) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.const inf) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 148) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.const inf) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 149) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const 1) + (f32.neg + (f32.const inf) + ) + (f32.const 1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 150) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const -1) + (f32.neg + (f32.const inf) + ) + (f32.const -1) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 151) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 152) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 153) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const 0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 154) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const -0) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 155) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 156) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 157) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const 1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 158) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const -1) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 159) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 160) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 161) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 162) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 163) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const inf) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 164) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 165) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.const inf) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 166) + (i32.const 0) + ) + (unreachable) + ) + ) + (if + (i32.eqz + (call $std/mod/test_fmodf + (f32.const nan:0x400000) + (f32.neg + (f32.const inf) + ) + (f32.const nan:0x400000) + ) + ) + (block + (call $abort + (i32.const 0) + (i32.const 4) + (i32.const 167) + (i32.const 0) + ) + (unreachable) + ) + ) + ) +) diff --git a/tests/compiler/std/string.optimized.wat b/tests/compiler/std/string.optimized.wat index 1f5a8d45..6cda8328 100644 --- a/tests/compiler/std/string.optimized.wat +++ b/tests/compiler/std/string.optimized.wat @@ -1134,7 +1134,7 @@ (call $abort (i32.const 0) (i32.const 72) - (i32.const 483) + (i32.const 484) (i32.const 10) ) (unreachable) diff --git a/tests/compiler/std/string.untouched.wat b/tests/compiler/std/string.untouched.wat index 3ae80a52..cff58ce9 100644 --- a/tests/compiler/std/string.untouched.wat +++ b/tests/compiler/std/string.untouched.wat @@ -1313,7 +1313,7 @@ (call $abort (i32.const 0) (i32.const 72) - (i32.const 483) + (i32.const 484) (i32.const 10) ) (unreachable) diff --git a/webpack.config.js b/webpack.config.js index 96b9d9d6..759d67b5 100644 --- a/webpack.config.js +++ b/webpack.config.js @@ -52,6 +52,9 @@ const bin = { globalObject: "typeof self !== 'undefined' ? self : this" }, devtool: "source-map", + performance: { + hints : false + }, plugins: [ new webpack.DefinePlugin({ BUNDLE_VERSION: JSON.stringify(require("./package.json").version),