Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/C/Firefox/js/src/jit-test/tests/wasm/spec/spec/   (Browser von der Mozilla Stiftung Version 136.0.1©)  Datei vom 10.2.2025 mit Größe 124 kB image not shown  

SSL const.wast.js   Sprache: JAVA

 
/* Copyright 2021 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


// ./test/core/const.wast

// ./test/core/const.wast:5
let $0 = instantiate(`(module (func (i32.const 0_123_456_789) drop))`);

// ./test/core/const.wast:6
let $1 = instantiate(`(module (func (i32.const 0x0_9acf_fBDF) drop))`);

// ./test/core/const.wast:7
assert_malformed(() => instantiate(`(func (i32.const) drop) `), `unexpected token`);

// ./test/core/const.wast:11
assert_malformed(() => instantiate(`(func (i32.const 0x) drop) `), `unknown operator`);

// ./test/core/const.wast:15
assert_malformed(() => instantiate(`(func (i32.const 1x) drop) `), `unknown operator`);

// ./test/core/const.wast:19
assert_malformed(() => instantiate(`(func (i32.const 0xg) drop) `), `unknown operator`);

// ./test/core/const.wast:24
let $2 = instantiate(`(module (func (i64.const 0_123_456_789) drop))`);

// ./test/core/const.wast:25
let $3 = instantiate(`(module (func (i64.const 0x0125_6789_ADEF_bcef) drop))`);

// ./test/core/const.wast:26
assert_malformed(() => instantiate(`(func (i64.const) drop) `), `unexpected token`);

// ./test/core/const.wast:30
assert_malformed(() => instantiate(`(func (i64.const 0x) drop) `), `unknown operator`);

// ./test/core/const.wast:34
assert_malformed(() => instantiate(`(func (i64.const 1x) drop) `), `unknown operator`);

// ./test/core/const.wast:38
assert_malformed(() => instantiate(`(func (i64.const 0xg) drop) `), `unknown operator`);

// ./test/core/const.wast:43
let $4 = instantiate(`(module (func (f32.const 0123456789) drop))`);

// ./test/core/const.wast:44
let $5 = instantiate(`(module (func (f32.const 0123456789e019) drop))`);

// ./test/core/const.wast:45
let $6 = instantiate(`(module (func (f32.const 0123456789e+019) drop))`);

// ./test/core/const.wast:46
let $7 = instantiate(`(module (func (f32.const 0123456789e-019) drop))`);

// ./test/core/const.wast:47
let $8 = instantiate(`(module (func (f32.const 0123456789.) drop))`);

// ./test/core/const.wast:48
let $9 = instantiate(`(module (func (f32.const 0123456789.e019) drop))`);

// ./test/core/const.wast:49
let $10 = instantiate(`(module (func (f32.const 0123456789.e+019) drop))`);

// ./test/core/const.wast:50
let $11 = instantiate(`(module (func (f32.const 0123456789.e-019) drop))`);

// ./test/core/const.wast:51
let $12 = instantiate(`(module (func (f32.const 0123456789.0123456789) drop))`);

// ./test/core/const.wast:52
let $13 = instantiate(`(module (func (f32.const 0123456789.0123456789e019) drop))`);

// ./test/core/const.wast:53
let $14 = instantiate(`(module (func (f32.const 0123456789.0123456789e+019) drop))`);

// ./test/core/const.wast:54
let $15 = instantiate(`(module (func (f32.const 0123456789.0123456789e-019) drop))`);

// ./test/core/const.wast:55
let $16 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF) drop))`);

// ./test/core/const.wast:56
let $17 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp019) drop))`);

// ./test/core/const.wast:57
let $18 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp+019) drop))`);

// ./test/core/const.wast:58
let $19 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp-019) drop))`);

// ./test/core/const.wast:59
let $20 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.) drop))`);

// ./test/core/const.wast:60
let $21 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p019) drop))`);

// ./test/core/const.wast:61
let $22 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p+019) drop))`);

// ./test/core/const.wast:62
let $23 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p-019) drop))`);

// ./test/core/const.wast:63
let $24 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aF) drop))`);

// ./test/core/const.wast:64
let $25 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp019) drop))`);

// ./test/core/const.wast:65
let $26 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp+019) drop))`);

// ./test/core/const.wast:66
let $27 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp-019) drop))`);

// ./test/core/const.wast:67
assert_malformed(() => instantiate(`(func (f32.const) drop) `), `unexpected token`);

// ./test/core/const.wast:71
assert_malformed(() => instantiate(`(func (f32.const .0) drop) `), `unknown operator`);

// ./test/core/const.wast:75
assert_malformed(() => instantiate(`(func (f32.const .0e0) drop) `), `unknown operator`);

// ./test/core/const.wast:79
assert_malformed(() => instantiate(`(func (f32.const 0e) drop) `), `unknown operator`);

// ./test/core/const.wast:83
assert_malformed(() => instantiate(`(func (f32.const 0e+) drop) `), `unknown operator`);

// ./test/core/const.wast:87
assert_malformed(() => instantiate(`(func (f32.const 0.0e) drop) `), `unknown operator`);

// ./test/core/const.wast:91
assert_malformed(() => instantiate(`(func (f32.const 0.0e-) drop) `), `unknown operator`);

// ./test/core/const.wast:95
assert_malformed(() => instantiate(`(func (f32.const 0x) drop) `), `unknown operator`);

// ./test/core/const.wast:99
assert_malformed(() => instantiate(`(func (f32.const 1x) drop) `), `unknown operator`);

// ./test/core/const.wast:103
assert_malformed(() => instantiate(`(func (f32.const 0xg) drop) `), `unknown operator`);

// ./test/core/const.wast:107
assert_malformed(() => instantiate(`(func (f32.const 0x.) drop) `), `unknown operator`);

// ./test/core/const.wast:111
assert_malformed(() => instantiate(`(func (f32.const 0x0.g) drop) `), `unknown operator`);

// ./test/core/const.wast:115
assert_malformed(() => instantiate(`(func (f32.const 0x0p) drop) `), `unknown operator`);

// ./test/core/const.wast:119
assert_malformed(() => instantiate(`(func (f32.const 0x0p+) drop) `), `unknown operator`);

// ./test/core/const.wast:123
assert_malformed(() => instantiate(`(func (f32.const 0x0p-) drop) `), `unknown operator`);

// ./test/core/const.wast:127
assert_malformed(() => instantiate(`(func (f32.const 0x0.0p) drop) `), `unknown operator`);

// ./test/core/const.wast:131
assert_malformed(
  () => instantiate(`(func (f32.const 0x0.0p+) drop) `),
  `unknown operator`,
);

// ./test/core/const.wast:135
assert_malformed(
  () => instantiate(`(func (f32.const 0x0.0p-) drop) `),
  `unknown operator`,
);

// ./test/core/const.wast:139
assert_malformed(() => instantiate(`(func (f32.const 0x0pA) drop) `), `unknown operator`);

// ./test/core/const.wast:145
let $28 = instantiate(`(module (func (f64.const 0123456789) drop))`);

// ./test/core/const.wast:146
let $29 = instantiate(`(module (func (f64.const 0123456789e019) drop))`);

// ./test/core/const.wast:147
let $30 = instantiate(`(module (func (f64.const 0123456789e+019) drop))`);

// ./test/core/const.wast:148
let $31 = instantiate(`(module (func (f64.const 0123456789e-019) drop))`);

// ./test/core/const.wast:149
let $32 = instantiate(`(module (func (f64.const 0123456789.) drop))`);

// ./test/core/const.wast:150
let $33 = instantiate(`(module (func (f64.const 0123456789.e019) drop))`);

// ./test/core/const.wast:151
let $34 = instantiate(`(module (func (f64.const 0123456789.e+019) drop))`);

// ./test/core/const.wast:152
let $35 = instantiate(`(module (func (f64.const 0123456789.e-019) drop))`);

// ./test/core/const.wast:153
let $36 = instantiate(`(module (func (f64.const 0123456789.0123456789) drop))`);

// ./test/core/const.wast:154
let $37 = instantiate(`(module (func (f64.const 0123456789.0123456789e019) drop))`);

// ./test/core/const.wast:155
let $38 = instantiate(`(module (func (f64.const 0123456789.0123456789e+019) drop))`);

// ./test/core/const.wast:156
let $39 = instantiate(`(module (func (f64.const 0123456789.0123456789e-019) drop))`);

// ./test/core/const.wast:157
let $40 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9) drop))`);

// ./test/core/const.wast:158
let $41 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.) drop))`);

// ./test/core/const.wast:159
let $42 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9) drop))`);

// ./test/core/const.wast:160
let $43 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9e+0_1_9) drop))`);

// ./test/core/const.wast:161
let $44 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.e+0_1_9) drop))`);

// ./test/core/const.wast:162
let $45 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9e0_1_9) drop))`);

// ./test/core/const.wast:164
let $46 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef) drop))`);

// ./test/core/const.wast:165
let $47 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp019) drop))`);

// ./test/core/const.wast:166
let $48 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp+019) drop))`);

// ./test/core/const.wast:167
let $49 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp-019) drop))`);

// ./test/core/const.wast:168
let $50 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.) drop))`);

// ./test/core/const.wast:169
let $51 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p019) drop))`);

// ./test/core/const.wast:170
let $52 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p+019) drop))`);

// ./test/core/const.wast:171
let $53 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p-019) drop))`);

// ./test/core/const.wast:172
let $54 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))`);

// ./test/core/const.wast:173
let $55 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))`);

// ./test/core/const.wast:174
let $56 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))`);

// ./test/core/const.wast:175
let $57 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))`);

// ./test/core/const.wast:176
let $58 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))`);

// ./test/core/const.wast:177
let $59 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.) drop))`);

// ./test/core/const.wast:178
let $60 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))`);

// ./test/core/const.wast:179
let $61 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))`);

// ./test/core/const.wast:180
let $62 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.p0_1_9) drop))`);

// ./test/core/const.wast:181
let $63 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))`);

// ./test/core/const.wast:184
assert_malformed(() => instantiate(`(func (f64.const) drop) `), `unexpected token`);

// ./test/core/const.wast:188
assert_malformed(() => instantiate(`(func (f64.const .0) drop) `), `unknown operator`);

// ./test/core/const.wast:192
assert_malformed(() => instantiate(`(func (f64.const .0e0) drop) `), `unknown operator`);

// ./test/core/const.wast:196
assert_malformed(() => instantiate(`(func (f64.const 0e) drop) `), `unknown operator`);

// ./test/core/const.wast:200
assert_malformed(() => instantiate(`(func (f64.const 0e+) drop) `), `unknown operator`);

// ./test/core/const.wast:204
assert_malformed(() => instantiate(`(func (f64.const 0.0e) drop) `), `unknown operator`);

// ./test/core/const.wast:208
assert_malformed(() => instantiate(`(func (f64.const 0.0e-) drop) `), `unknown operator`);

// ./test/core/const.wast:212
assert_malformed(() => instantiate(`(func (f64.const 0x) drop) `), `unknown operator`);

// ./test/core/const.wast:216
assert_malformed(() => instantiate(`(func (f64.const 1x) drop) `), `unknown operator`);

// ./test/core/const.wast:220
assert_malformed(() => instantiate(`(func (f64.const 0xg) drop) `), `unknown operator`);

// ./test/core/const.wast:224
assert_malformed(() => instantiate(`(func (f64.const 0x.) drop) `), `unknown operator`);

// ./test/core/const.wast:228
assert_malformed(() => instantiate(`(func (f64.const 0x0.g) drop) `), `unknown operator`);

// ./test/core/const.wast:232
assert_malformed(() => instantiate(`(func (f64.const 0x0p) drop) `), `unknown operator`);

// ./test/core/const.wast:236
assert_malformed(() => instantiate(`(func (f64.const 0x0p+) drop) `), `unknown operator`);

// ./test/core/const.wast:240
assert_malformed(() => instantiate(`(func (f64.const 0x0p-) drop) `), `unknown operator`);

// ./test/core/const.wast:244
assert_malformed(() => instantiate(`(func (f64.const 0x0.0p) drop) `), `unknown operator`);

// ./test/core/const.wast:248
assert_malformed(
  () => instantiate(`(func (f64.const 0x0.0p+) drop) `),
  `unknown operator`,
);

// ./test/core/const.wast:252
assert_malformed(
  () => instantiate(`(func (f64.const 0x0.0p-) drop) `),
  `unknown operator`,
);

// ./test/core/const.wast:256
assert_malformed(() => instantiate(`(func (f64.const 0x0pA) drop) `), `unknown operator`);

// ./test/core/const.wast:264
let $64 = instantiate(`(module (func (i32.const 0xffffffff) drop))`);

// ./test/core/const.wast:265
let $65 = instantiate(`(module (func (i32.const -0x80000000) drop))`);

// ./test/core/const.wast:266
assert_malformed(
  () => instantiate(`(func (i32.const 0x100000000) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:270
assert_malformed(
  () => instantiate(`(func (i32.const -0x80000001) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:275
let $66 = instantiate(`(module (func (i32.const 4294967295) drop))`);

// ./test/core/const.wast:276
let $67 = instantiate(`(module (func (i32.const -2147483648) drop))`);

// ./test/core/const.wast:277
assert_malformed(
  () => instantiate(`(func (i32.const 4294967296) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:281
assert_malformed(
  () => instantiate(`(func (i32.const -2147483649) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:286
let $68 = instantiate(`(module (func (i64.const 0xffffffffffffffff) drop))`);

// ./test/core/const.wast:287
let $69 = instantiate(`(module (func (i64.const -0x8000000000000000) drop))`);

// ./test/core/const.wast:288
assert_malformed(
  () => instantiate(`(func (i64.const 0x10000000000000000) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:292
assert_malformed(
  () => instantiate(`(func (i64.const -0x8000000000000001) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:297
let $70 = instantiate(`(module (func (i64.const 18446744073709551615) drop))`);

// ./test/core/const.wast:298
let $71 = instantiate(`(module (func (i64.const -9223372036854775808) drop))`);

// ./test/core/const.wast:299
assert_malformed(
  () => instantiate(`(func (i64.const 18446744073709551616) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:303
assert_malformed(
  () => instantiate(`(func (i64.const -9223372036854775809) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:308
let $72 = instantiate(`(module (func (f32.const 0x1p127) drop))`);

// ./test/core/const.wast:309
let $73 = instantiate(`(module (func (f32.const -0x1p127) drop))`);

// ./test/core/const.wast:310
let $74 = instantiate(`(module (func (f32.const 0x1.fffffep127) drop))`);

// ./test/core/const.wast:311
let $75 = instantiate(`(module (func (f32.const -0x1.fffffep127) drop))`);

// ./test/core/const.wast:312
let $76 = instantiate(`(module (func (f32.const 0x1.fffffe7p127) drop))`);

// ./test/core/const.wast:313
let $77 = instantiate(`(module (func (f32.const -0x1.fffffe7p127) drop))`);

// ./test/core/const.wast:314
let $78 = instantiate(`(module (func (f32.const 0x1.fffffefffffff8000000p127) drop))`);

// ./test/core/const.wast:315
let $79 = instantiate(`(module (func (f32.const -0x1.fffffefffffff8000000p127) drop))`);

// ./test/core/const.wast:316
let $80 = instantiate(`(module (func (f32.const 0x1.fffffefffffffffffffp127) drop))`);

// ./test/core/const.wast:317
let $81 = instantiate(`(module (func (f32.const -0x1.fffffefffffffffffffp127) drop))`);

// ./test/core/const.wast:318
assert_malformed(
  () => instantiate(`(func (f32.const 0x1p128) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:322
assert_malformed(
  () => instantiate(`(func (f32.const -0x1p128) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:326
assert_malformed(
  () => instantiate(`(func (f32.const 0x1.ffffffp127) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:330
assert_malformed(
  () => instantiate(`(func (f32.const -0x1.ffffffp127) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:335
let $82 = instantiate(`(module (func (f32.const 1e38) drop))`);

// ./test/core/const.wast:336
let $83 = instantiate(`(module (func (f32.const -1e38) drop))`);

// ./test/core/const.wast:337
assert_malformed(
  () => instantiate(`(func (f32.const 1e39) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:341
assert_malformed(
  () => instantiate(`(func (f32.const -1e39) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:346
let $84 = instantiate(`(module (func (f32.const 340282356779733623858607532500980858880) drop))`);

// ./test/core/const.wast:347
let $85 = instantiate(`(module (func (f32.const -340282356779733623858607532500980858880) drop))`);

// ./test/core/const.wast:348
assert_malformed(
  () => instantiate(`(func (f32.const 340282356779733661637539395458142568448) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:352
assert_malformed(
  () => instantiate(`(func (f32.const -340282356779733661637539395458142568448) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:357
let $86 = instantiate(`(module (func (f64.const 0x1p1023) drop))`);

// ./test/core/const.wast:358
let $87 = instantiate(`(module (func (f64.const -0x1p1023) drop))`);

// ./test/core/const.wast:359
let $88 = instantiate(`(module (func (f64.const 0x1.fffffffffffffp1023) drop))`);

// ./test/core/const.wast:360
let $89 = instantiate(`(module (func (f64.const -0x1.fffffffffffffp1023) drop))`);

// ./test/core/const.wast:361
let $90 = instantiate(`(module (func (f64.const 0x1.fffffffffffff7p1023) drop))`);

// ./test/core/const.wast:362
let $91 = instantiate(`(module (func (f64.const -0x1.fffffffffffff7p1023) drop))`);

// ./test/core/const.wast:363
let $92 = instantiate(`(module (func (f64.const 0x1.fffffffffffff7ffffffp1023) drop))`);

// ./test/core/const.wast:364
let $93 = instantiate(`(module (func (f64.const -0x1.fffffffffffff7ffffffp1023) drop))`);

// ./test/core/const.wast:365
assert_malformed(
  () => instantiate(`(func (f64.const 0x1p1024) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:369
assert_malformed(
  () => instantiate(`(func (f64.const -0x1p1024) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:373
assert_malformed(
  () => instantiate(`(func (f64.const 0x1.fffffffffffff8p1023) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:377
assert_malformed(
  () => instantiate(`(func (f64.const -0x1.fffffffffffff8p1023) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:382
let $94 = instantiate(`(module (func (f64.const 1e308) drop))`);

// ./test/core/const.wast:383
let $95 = instantiate(`(module (func (f64.const -1e308) drop))`);

// ./test/core/const.wast:384
assert_malformed(
  () => instantiate(`(func (f64.const 1e309) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:388
assert_malformed(
  () => instantiate(`(func (f64.const -1e309) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:393
let $96 = instantiate(`(module (func (f64.const 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);

// ./test/core/const.wast:394
let $97 = instantiate(`(module (func (f64.const -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);

// ./test/core/const.wast:395
assert_malformed(
  () => instantiate(`(func (f64.const 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:399
assert_malformed(
  () => instantiate(`(func (f64.const -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:404
let $98 = instantiate(`(module (func (f32.const nan:0x1) drop))`);

// ./test/core/const.wast:405
let $99 = instantiate(`(module (func (f64.const nan:0x1) drop))`);

// ./test/core/const.wast:406
let $100 = instantiate(`(module (func (f32.const nan:0x7f_ffff) drop))`);

// ./test/core/const.wast:407
let $101 = instantiate(`(module (func (f64.const nan:0xf_ffff_ffff_ffff) drop))`);

// ./test/core/const.wast:409
assert_malformed(() => instantiate(`(func (f32.const nan:1) drop) `), `unknown operator`);

// ./test/core/const.wast:413
assert_malformed(() => instantiate(`(func (f64.const nan:1) drop) `), `unknown operator`);

// ./test/core/const.wast:418
assert_malformed(
  () => instantiate(`(func (f32.const nan:0x0) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:422
assert_malformed(
  () => instantiate(`(func (f64.const nan:0x0) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:427
assert_malformed(
  () => instantiate(`(func (f32.const nan:0x80_0000) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:431
assert_malformed(
  () => instantiate(`(func (f64.const nan:0x10_0000_0000_0000) drop) `),
  `constant out of range`,
);

// ./test/core/const.wast:440
let $102 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p-50)))`);

// ./test/core/const.wast:441
assert_return(() => invoke($102, `f`, []), [value("f32", 0.0000000000000008881784)]);

// ./test/core/const.wast:442
let $103 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p-50)))`);

// ./test/core/const.wast:443
assert_return(() => invoke($103, `f`, []), [value("f32", -0.0000000000000008881784)]);

// ./test/core/const.wast:444
let $104 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p-50)))`);

// ./test/core/const.wast:445
assert_return(() => invoke($104, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:446
let $105 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p-50)))`);

// ./test/core/const.wast:447
assert_return(() => invoke($105, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:448
let $106 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp-50)))`);

// ./test/core/const.wast:449
assert_return(() => invoke($106, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:450
let $107 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp-50)))`);

// ./test/core/const.wast:451
assert_return(() => invoke($107, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:452
let $108 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p-50)))`);

// ./test/core/const.wast:453
assert_return(() => invoke($108, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:454
let $109 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p-50)))`);

// ./test/core/const.wast:455
assert_return(() => invoke($109, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:456
let $110 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p-50)))`);

// ./test/core/const.wast:457
assert_return(() => invoke($110, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:458
let $111 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p-50)))`);

// ./test/core/const.wast:459
assert_return(() => invoke($111, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:460
let $112 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp-50)))`);

// ./test/core/const.wast:461
assert_return(() => invoke($112, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:462
let $113 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp-50)))`);

// ./test/core/const.wast:463
assert_return(() => invoke($113, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:464
let $114 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p-50)))`);

// ./test/core/const.wast:465
assert_return(() => invoke($114, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:466
let $115 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p-50)))`);

// ./test/core/const.wast:467
assert_return(() => invoke($115, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:468
let $116 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p-50)))`);

// ./test/core/const.wast:469
assert_return(() => invoke($116, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:470
let $117 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p-50)))`);

// ./test/core/const.wast:471
assert_return(() => invoke($117, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:472
let $118 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp-50)))`);

// ./test/core/const.wast:473
assert_return(() => invoke($118, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:474
let $119 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp-50)))`);

// ./test/core/const.wast:475
assert_return(() => invoke($119, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:476
let $120 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p-50)))`);

// ./test/core/const.wast:477
assert_return(() => invoke($120, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:478
let $121 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p-50)))`);

// ./test/core/const.wast:479
assert_return(() => invoke($121, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:480
let $122 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p-50)))`);

// ./test/core/const.wast:481
assert_return(() => invoke($122, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:482
let $123 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p-50)))`);

// ./test/core/const.wast:483
assert_return(() => invoke($123, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:484
let $124 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp-50)))`);

// ./test/core/const.wast:485
assert_return(() => invoke($124, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:486
let $125 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp-50)))`);

// ./test/core/const.wast:487
assert_return(() => invoke($125, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:488
let $126 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p-50)))`);

// ./test/core/const.wast:489
assert_return(() => invoke($126, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:490
let $127 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p-50)))`);

// ./test/core/const.wast:491
assert_return(() => invoke($127, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:492
let $128 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p-50)))`);

// ./test/core/const.wast:493
assert_return(() => invoke($128, `f`, []), [value("f32", 0.0000000000000008881787)]);

// ./test/core/const.wast:494
let $129 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p-50)))`);

// ./test/core/const.wast:495
assert_return(() => invoke($129, `f`, []), [value("f32", -0.0000000000000008881787)]);

// ./test/core/const.wast:497
let $130 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.004000000p-64)))`);

// ./test/core/const.wast:498
assert_return(() => invoke($130, `f`, []), [value("f32", 0.0000000000000008881784)]);

// ./test/core/const.wast:499
let $131 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.004000000p-64)))`);

// ./test/core/const.wast:500
assert_return(() => invoke($131, `f`, []), [value("f32", -0.0000000000000008881784)]);

// ./test/core/const.wast:501
let $132 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.004000001p-64)))`);

// ./test/core/const.wast:502
assert_return(() => invoke($132, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:503
let $133 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.004000001p-64)))`);

// ./test/core/const.wast:504
assert_return(() => invoke($133, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:505
let $134 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.007ffffffp-64)))`);

// ./test/core/const.wast:506
assert_return(() => invoke($134, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:507
let $135 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.007ffffffp-64)))`);

// ./test/core/const.wast:508
assert_return(() => invoke($135, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:509
let $136 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.008000000p-64)))`);

// ./test/core/const.wast:510
assert_return(() => invoke($136, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:511
let $137 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.008000000p-64)))`);

// ./test/core/const.wast:512
assert_return(() => invoke($137, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:513
let $138 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.008000001p-64)))`);

// ./test/core/const.wast:514
assert_return(() => invoke($138, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:515
let $139 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.008000001p-64)))`);

// ./test/core/const.wast:516
assert_return(() => invoke($139, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:517
let $140 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00bffffffp-64)))`);

// ./test/core/const.wast:518
assert_return(() => invoke($140, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:519
let $141 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00bffffffp-64)))`);

// ./test/core/const.wast:520
assert_return(() => invoke($141, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:521
let $142 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00c000000p-64)))`);

// ./test/core/const.wast:522
assert_return(() => invoke($142, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:523
let $143 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00c000000p-64)))`);

// ./test/core/const.wast:524
assert_return(() => invoke($143, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:525
let $144 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00c000001p-64)))`);

// ./test/core/const.wast:526
assert_return(() => invoke($144, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:527
let $145 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00c000001p-64)))`);

// ./test/core/const.wast:528
assert_return(() => invoke($145, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:529
let $146 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00fffffffp-64)))`);

// ./test/core/const.wast:530
assert_return(() => invoke($146, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:531
let $147 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00fffffffp-64)))`);

// ./test/core/const.wast:532
assert_return(() => invoke($147, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:533
let $148 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.010000001p-64)))`);

// ./test/core/const.wast:534
assert_return(() => invoke($148, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:535
let $149 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.010000001p-64)))`);

// ./test/core/const.wast:536
assert_return(() => invoke($149, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:537
let $150 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.013ffffffp-64)))`);

// ./test/core/const.wast:538
assert_return(() => invoke($150, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:539
let $151 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.013ffffffp-64)))`);

// ./test/core/const.wast:540
assert_return(() => invoke($151, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:541
let $152 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.014000001p-64)))`);

// ./test/core/const.wast:542
assert_return(() => invoke($152, `f`, []), [value("f32", 0.0000000000000008881787)]);

// ./test/core/const.wast:543
let $153 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.014000001p-64)))`);

// ./test/core/const.wast:544
assert_return(() => invoke($153, `f`, []), [value("f32", -0.0000000000000008881787)]);

// ./test/core/const.wast:546
let $154 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817847263968443573e-16)))`);

// ./test/core/const.wast:547
assert_return(() => invoke($154, `f`, []), [value("f32", 0.0000000000000008881784)]);

// ./test/core/const.wast:548
let $155 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817847263968443573e-16)))`);

// ./test/core/const.wast:549
assert_return(() => invoke($155, `f`, []), [value("f32", -0.0000000000000008881784)]);

// ./test/core/const.wast:550
let $156 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817847263968443574e-16)))`);

// ./test/core/const.wast:551
assert_return(() => invoke($156, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:552
let $157 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817847263968443574e-16)))`);

// ./test/core/const.wast:553
assert_return(() => invoke($157, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:554
let $158 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817857851880284252e-16)))`);

// ./test/core/const.wast:555
assert_return(() => invoke($158, `f`, []), [value("f32", 0.0000000000000008881785)]);

// ./test/core/const.wast:556
let $159 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817857851880284252e-16)))`);

// ./test/core/const.wast:557
assert_return(() => invoke($159, `f`, []), [value("f32", -0.0000000000000008881785)]);

// ./test/core/const.wast:558
let $160 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817857851880284253e-16)))`);

// ./test/core/const.wast:559
assert_return(() => invoke($160, `f`, []), [value("f32", 0.0000000000000008881786)]);

// ./test/core/const.wast:560
let $161 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817857851880284253e-16)))`);

// ./test/core/const.wast:561
assert_return(() => invoke($161, `f`, []), [value("f32", -0.0000000000000008881786)]);

// ./test/core/const.wast:564
let $162 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p+50)))`);

// ./test/core/const.wast:565
assert_return(() => invoke($162, `f`, []), [value("f32", 1125899900000000)]);

// ./test/core/const.wast:566
let $163 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p+50)))`);

// ./test/core/const.wast:567
assert_return(() => invoke($163, `f`, []), [value("f32", -1125899900000000)]);

// ./test/core/const.wast:568
let $164 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p+50)))`);

// ./test/core/const.wast:569
assert_return(() => invoke($164, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:570
let $165 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p+50)))`);

// ./test/core/const.wast:571
assert_return(() => invoke($165, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:572
let $166 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp+50)))`);

// ./test/core/const.wast:573
assert_return(() => invoke($166, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:574
let $167 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp+50)))`);

// ./test/core/const.wast:575
assert_return(() => invoke($167, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:576
let $168 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p+50)))`);

// ./test/core/const.wast:577
assert_return(() => invoke($168, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:578
let $169 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p+50)))`);

// ./test/core/const.wast:579
assert_return(() => invoke($169, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:580
let $170 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p+50)))`);

// ./test/core/const.wast:581
assert_return(() => invoke($170, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:582
let $171 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p+50)))`);

// ./test/core/const.wast:583
assert_return(() => invoke($171, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:584
let $172 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp+50)))`);

// ./test/core/const.wast:585
assert_return(() => invoke($172, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:586
let $173 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp+50)))`);

// ./test/core/const.wast:587
assert_return(() => invoke($173, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:588
let $174 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p+50)))`);

// ./test/core/const.wast:589
assert_return(() => invoke($174, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:590
let $175 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p+50)))`);

// ./test/core/const.wast:591
assert_return(() => invoke($175, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:592
let $176 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p+50)))`);

// ./test/core/const.wast:593
assert_return(() => invoke($176, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:594
let $177 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p+50)))`);

// ./test/core/const.wast:595
assert_return(() => invoke($177, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:596
let $178 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp+50)))`);

// ./test/core/const.wast:597
assert_return(() => invoke($178, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:598
let $179 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp+50)))`);

// ./test/core/const.wast:599
assert_return(() => invoke($179, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:600
let $180 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p+50)))`);

// ./test/core/const.wast:601
assert_return(() => invoke($180, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:602
let $181 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p+50)))`);

// ./test/core/const.wast:603
assert_return(() => invoke($181, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:604
let $182 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p+50)))`);

// ./test/core/const.wast:605
assert_return(() => invoke($182, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:606
let $183 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p+50)))`);

// ./test/core/const.wast:607
assert_return(() => invoke($183, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:608
let $184 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp+50)))`);

// ./test/core/const.wast:609
assert_return(() => invoke($184, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:610
let $185 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp+50)))`);

// ./test/core/const.wast:611
assert_return(() => invoke($185, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:612
let $186 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p+50)))`);

// ./test/core/const.wast:613
assert_return(() => invoke($186, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:614
let $187 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p+50)))`);

// ./test/core/const.wast:615
assert_return(() => invoke($187, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:616
let $188 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p+50)))`);

// ./test/core/const.wast:617
assert_return(() => invoke($188, `f`, []), [value("f32", 1125900300000000)]);

// ./test/core/const.wast:618
let $189 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p+50)))`);

// ./test/core/const.wast:619
assert_return(() => invoke($189, `f`, []), [value("f32", -1125900300000000)]);

// ./test/core/const.wast:621
let $190 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000004000000)))`);

// ./test/core/const.wast:622
assert_return(() => invoke($190, `f`, []), [value("f32", 1125899900000000)]);

// ./test/core/const.wast:623
let $191 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000004000000)))`);

// ./test/core/const.wast:624
assert_return(() => invoke($191, `f`, []), [value("f32", -1125899900000000)]);

// ./test/core/const.wast:625
let $192 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000004000001)))`);

// ./test/core/const.wast:626
assert_return(() => invoke($192, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:627
let $193 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000004000001)))`);

// ./test/core/const.wast:628
assert_return(() => invoke($193, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:629
let $194 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000007ffffff)))`);

// ./test/core/const.wast:630
assert_return(() => invoke($194, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:631
let $195 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000007ffffff)))`);

// ./test/core/const.wast:632
assert_return(() => invoke($195, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:633
let $196 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000008000000)))`);

// ./test/core/const.wast:634
assert_return(() => invoke($196, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:635
let $197 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000008000000)))`);

// ./test/core/const.wast:636
assert_return(() => invoke($197, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:637
let $198 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000008000001)))`);

// ./test/core/const.wast:638
assert_return(() => invoke($198, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:639
let $199 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000008000001)))`);

// ./test/core/const.wast:640
assert_return(() => invoke($199, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:641
let $200 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x400000bffffff)))`);

// ./test/core/const.wast:642
assert_return(() => invoke($200, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:643
let $201 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x400000bffffff)))`);

// ./test/core/const.wast:644
assert_return(() => invoke($201, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:645
let $202 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x400000c000000)))`);

// ./test/core/const.wast:646
assert_return(() => invoke($202, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:647
let $203 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x400000c000000)))`);

// ./test/core/const.wast:648
assert_return(() => invoke($203, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:650
let $204 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125899973951488)))`);

// ./test/core/const.wast:651
assert_return(() => invoke($204, `f`, []), [value("f32", 1125899900000000)]);

// ./test/core/const.wast:652
let $205 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125899973951488)))`);

// ./test/core/const.wast:653
assert_return(() => invoke($205, `f`, []), [value("f32", -1125899900000000)]);

// ./test/core/const.wast:654
let $206 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125899973951489)))`);

// ./test/core/const.wast:655
assert_return(() => invoke($206, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:656
let $207 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125899973951489)))`);

// ./test/core/const.wast:657
assert_return(() => invoke($207, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:658
let $208 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125900108169215)))`);

// ./test/core/const.wast:659
assert_return(() => invoke($208, `f`, []), [value("f32", 1125900000000000)]);

// ./test/core/const.wast:660
let $209 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125900108169215)))`);

// ./test/core/const.wast:661
assert_return(() => invoke($209, `f`, []), [value("f32", -1125900000000000)]);

// ./test/core/const.wast:662
let $210 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125900108169216)))`);

// ./test/core/const.wast:663
assert_return(() => invoke($210, `f`, []), [value("f32", 1125900200000000)]);

// ./test/core/const.wast:664
let $211 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125900108169216)))`);

// ./test/core/const.wast:665
assert_return(() => invoke($211, `f`, []), [value("f32", -1125900200000000)]);

// ./test/core/const.wast:668
let $212 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000100000000000p-126)))`);

// ./test/core/const.wast:669
assert_return(() => invoke($212, `f`, []), [value("f32", 0)]);

// ./test/core/const.wast:670
let $213 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000100000000000p-126)))`);

// ./test/core/const.wast:671
assert_return(() => invoke($213, `f`, []), [value("f32", -0)]);

// ./test/core/const.wast:672
let $214 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000100000000001p-126)))`);

// ./test/core/const.wast:673
assert_return(
  () => invoke($214, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:674
let $215 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000100000000001p-126)))`);

// ./test/core/const.wast:675
assert_return(
  () => invoke($215, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:676
let $216 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000001fffffffffffp-126)))`);

// ./test/core/const.wast:677
assert_return(
  () => invoke($216, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:678
let $217 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000001fffffffffffp-126)))`);

// ./test/core/const.wast:679
assert_return(
  () => invoke($217, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:680
let $218 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000200000000000p-126)))`);

// ./test/core/const.wast:681
assert_return(
  () => invoke($218, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:682
let $219 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000200000000000p-126)))`);

// ./test/core/const.wast:683
assert_return(
  () => invoke($219, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:684
let $220 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000200000000001p-126)))`);

// ./test/core/const.wast:685
assert_return(
  () => invoke($220, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:686
let $221 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000200000000001p-126)))`);

// ./test/core/const.wast:687
assert_return(
  () => invoke($221, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:688
let $222 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000002fffffffffffp-126)))`);

// ./test/core/const.wast:689
assert_return(
  () => invoke($222, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:690
let $223 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000002fffffffffffp-126)))`);

// ./test/core/const.wast:691
assert_return(
  () => invoke($223, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000001)],
);

// ./test/core/const.wast:692
let $224 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000300000000000p-126)))`);

// ./test/core/const.wast:693
assert_return(
  () => invoke($224, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:694
let $225 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000300000000000p-126)))`);

// ./test/core/const.wast:695
assert_return(
  () => invoke($225, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:696
let $226 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000300000000001p-126)))`);

// ./test/core/const.wast:697
assert_return(
  () => invoke($226, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:698
let $227 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000300000000001p-126)))`);

// ./test/core/const.wast:699
assert_return(
  () => invoke($227, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:700
let $228 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000003fffffffffffp-126)))`);

// ./test/core/const.wast:701
assert_return(
  () => invoke($228, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:702
let $229 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000003fffffffffffp-126)))`);

// ./test/core/const.wast:703
assert_return(
  () => invoke($229, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:704
let $230 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000400000000000p-126)))`);

// ./test/core/const.wast:705
assert_return(
  () => invoke($230, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:706
let $231 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000400000000000p-126)))`);

// ./test/core/const.wast:707
assert_return(
  () => invoke($231, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:708
let $232 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000400000000001p-126)))`);

// ./test/core/const.wast:709
assert_return(
  () => invoke($232, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:710
let $233 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000400000000001p-126)))`);

// ./test/core/const.wast:711
assert_return(
  () => invoke($233, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:712
let $234 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000004fffffffffffp-126)))`);

// ./test/core/const.wast:713
assert_return(
  () => invoke($234, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:714
let $235 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000004fffffffffffp-126)))`);

// ./test/core/const.wast:715
assert_return(
  () => invoke($235, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:716
let $236 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000500000000000p-126)))`);

// ./test/core/const.wast:717
assert_return(
  () => invoke($236, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:718
let $237 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000500000000000p-126)))`);

// ./test/core/const.wast:719
assert_return(
  () => invoke($237, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000003)],
);

// ./test/core/const.wast:720
let $238 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000500000000001p-126)))`);

// ./test/core/const.wast:721
assert_return(
  () => invoke($238, `f`, []),
  [value("f32", 0.000000000000000000000000000000000000000000004)],
);

// ./test/core/const.wast:722
let $239 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000500000000001p-126)))`);

// ./test/core/const.wast:723
assert_return(
  () => invoke($239, `f`, []),
  [value("f32", -0.000000000000000000000000000000000000000000004)],
);

// ./test/core/const.wast:726
let $240 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffe8p127)))`);

// ./test/core/const.wast:727
assert_return(() => invoke($240, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);

// ./test/core/const.wast:728
let $241 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffe8p127)))`);

// ./test/core/const.wast:729
assert_return(() => invoke($241, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);

// ./test/core/const.wast:730
let $242 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffff8p127)))`);

// ./test/core/const.wast:731
assert_return(() => invoke($242, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);

// ./test/core/const.wast:732
let $243 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffff8p127)))`);

// ./test/core/const.wast:733
assert_return(() => invoke($243, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);

// ./test/core/const.wast:734
let $244 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffffffffp127)))`);

// ./test/core/const.wast:735
assert_return(() => invoke($244, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);

// ./test/core/const.wast:736
let $245 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffffffffp127)))`);

// ./test/core/const.wast:737
assert_return(() => invoke($245, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);

// ./test/core/const.wast:740
let $246 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))`);

// ./test/core/const.wast:741
assert_return(
  () => invoke($246, `f`, []),
  [
    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
  ],
);

// ./test/core/const.wast:742
let $247 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))`);

// ./test/core/const.wast:743
assert_return(
  () => invoke($247, `f`, []),
  [
    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
  ],
);

// ./test/core/const.wast:744
let $248 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))`);

// ./test/core/const.wast:745
assert_return(
  () => invoke($248, `f`, []),
  [
    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:746
let $249 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))`);

// ./test/core/const.wast:747
assert_return(
  () => invoke($249, `f`, []),
  [
    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:748
let $250 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))`);

// ./test/core/const.wast:749
assert_return(
  () => invoke($250, `f`, []),
  [
    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:750
let $251 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))`);

// ./test/core/const.wast:751
assert_return(
  () => invoke($251, `f`, []),
  [
    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:752
let $252 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))`);

// ./test/core/const.wast:753
assert_return(
  () => invoke($252, `f`, []),
  [
    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:754
let $253 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))`);

// ./test/core/const.wast:755
assert_return(
  () => invoke($253, `f`, []),
  [
    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:756
let $254 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))`);

// ./test/core/const.wast:757
assert_return(
  () => invoke($254, `f`, []),
  [
    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:758
let $255 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))`);

// ./test/core/const.wast:759
assert_return(
  () => invoke($255, `f`, []),
  [
    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:760
let $256 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))`);

// ./test/core/const.wast:761
assert_return(
  () => invoke($256, `f`, []),
  [
    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
  ],
);

// ./test/core/const.wast:762
let $257 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))`);

// ./test/core/const.wast:763
assert_return(
  () => invoke($257, `f`, []),
  [
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=81 H=89 G=84

¤ Dauer der Verarbeitung: 0.29 Sekunden  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.