Quelle  f32_cmp.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/f32_cmp.wast

// ./test/core/f32_cmp.wast:4
let $0 = instantiate(`(module
  (func (export "eq") (param $$x f32) (param $$y f32) (result i32) (f32.eq (local.get $$x) (local.get $$y)))
  (func (export "ne") (param $$x f32) (param $$y f32) (result i32) (f32.ne (local.get $$x) (local.get $$y)))
  (func (export "lt") (param $$x f32) (param $$y f32) (result i32) (f32.lt (local.get $$x) (local.get $$y)))
  (func (export "le") (param $$x f32) (param $$y f32) (result i32) (f32.le (local.get $$x) (local.get $$y)))
  (func (export "gt") (param $$x f32) (param $$y f32) (result i32) (f32.gt (local.get $$x) (local.get $$y)))
  (func (export "ge") (param $$x f32) (param $$y f32) (result i32) (f32.ge (local.get $$x) (local.get $$y)))
)`);

// ./test/core/f32_cmp.wast:13
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -0)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:14
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 0)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:15
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -0)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:16
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 0)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:17
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:18
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:19
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:20
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:21
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:22
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:23
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:24
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:25
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:26
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:27
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:28
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:29
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:30
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:31
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:32
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:33
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:34
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:35
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:36
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:37
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:38
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:39
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:40
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:41
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:42
assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:43
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:44
assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:45
assert_return(
  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:46
assert_return(
  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:47
assert_return(
  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:48
assert_return(
  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:49
assert_return(
  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:50
assert_return(
  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:51
assert_return(
  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:52
assert_return(
  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:53
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:54
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:55
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:56
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:57
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:58
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:59
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:60
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:61
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:62
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:63
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:64
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:65
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:66
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:67
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:68
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:69
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:70
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:71
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:72
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:73
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:74
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:75
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:76
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:77
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:78
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:79
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:80
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:81
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:82
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:83
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:84
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:85
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:86
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:87
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:88
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:89
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:90
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:91
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:92
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000000000001),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:93
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:94
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:95
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:96
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:97
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:98
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:99
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:100
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:101
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:102
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:103
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:104
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:105
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:106
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:107
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:108
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:109
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:110
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:111
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:112
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:113
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:114
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:115
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:116
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:117
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:118
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:119
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:120
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:121
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:122
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:123
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:124
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:125
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:126
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:127
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:128
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:129
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:130
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:131
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:132
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.000000000000000000000000000000000000011754944),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:133
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:134
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:135
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:136
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:137
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:138
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:139
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:140
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:141
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:142
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:143
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:144
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:145
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:146
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:147
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:148
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:149
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:150
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:151
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:152
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:153
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:154
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:155
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:156
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:157
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:158
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -0.5),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:159
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:160
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 0.5),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:161
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:162
assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:163
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:164
assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:165
assert_return(
  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:166
assert_return(
  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:167
assert_return(
  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:168
assert_return(
  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:169
assert_return(
  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:170
assert_return(
  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:171
assert_return(
  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:172
assert_return(
  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:173
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:174
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:175
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:176
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:177
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:178
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:179
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:180
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:181
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:182
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:183
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:184
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:185
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:186
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:187
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:188
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:189
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -1)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:190
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:191
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:192
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 1)]), [value("i32", 1)]);

// ./test/core/f32_cmp.wast:193
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:194
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:195
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:196
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:197
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:198
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -1),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:199
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:200
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 1),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:201
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:202
assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:203
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:204
assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:205
assert_return(
  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:206
assert_return(
  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:207
assert_return(
  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:208
assert_return(
  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:209
assert_return(
  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:210
assert_return(
  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:211
assert_return(
  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:212
assert_return(
  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:213
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:214
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:215
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:216
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:217
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:218
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:219
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:220
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:221
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:222
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:223
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:224
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:225
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:226
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:227
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:228
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:229
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:230
assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:231
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:232
assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:233
assert_return(
  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:234
assert_return(
  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:235
assert_return(
  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:236
assert_return(
  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:237
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:238
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:239
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:240
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:241
assert_return(
  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:242
assert_return(
  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:243
assert_return(
  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:244
assert_return(
  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:245
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:246
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:247
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:248
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -6.2831855),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:249
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:250
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:251
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:252
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 6.2831855),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:253
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:254
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:255
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:256
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 0),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:257
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:258
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:259
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:260
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:261
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:262
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:263
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:264
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:265
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:266
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:267
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:268
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 0.5),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:269
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:270
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:271
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:272
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 1),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:273
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:274
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:275
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:276
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 6.2831855),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:277
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:278
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:279
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:280
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:281
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:282
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:283
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", -Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:284
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    value("f32", Infinity),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:285
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:286
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:287
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:288
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:289
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:290
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:291
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:292
assert_return(
  () => invoke($0, `eq`, [
    value("f32", 340282350000000000000000000000000000000),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:293
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:294
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:295
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:296
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:297
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:298
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:299
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:300
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:301
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:302
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:303
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:304
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:305
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:306
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:307
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:308
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:309
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:310
assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:311
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:312
assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 0)]);

// ./test/core/f32_cmp.wast:313
assert_return(
  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:314
assert_return(
  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:315
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", -6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:316
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", 6.2831855)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:317
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:318
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:319
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", -340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:320
assert_return(
  () => invoke($0, `eq`, [
    value("f32", Infinity),
    value("f32", 340282350000000000000000000000000000000),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:321
assert_return(
  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -Infinity)]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:322
assert_return(
  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:323
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", -Infinity)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:324
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", Infinity)]),
  [value("i32", 1)],
);

// ./test/core/f32_cmp.wast:325
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:326
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:327
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:328
assert_return(
  () => invoke($0, `eq`, [
    value("f32", -Infinity),
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:329
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:330
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:331
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:332
assert_return(
  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:333
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:334
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:335
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:336
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:337
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:338
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:339
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:340
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:341
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:342
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:343
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:344
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:345
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:346
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
    value("f32", -0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:347
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:348
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
    value("f32", 0.000000000000000000000000000000000000000000001),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:349
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:350
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:351
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:352
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:353
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:354
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
    value("f32", -0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:355
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:356
assert_return(
  () => invoke($0, `eq`, [
    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
    value("f32", 0.000000000000000000000000000000000000011754944),
  ]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:357
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:358
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:359
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:360
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:361
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:362
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:363
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:364
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:365
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:366
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:367
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:368
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:369
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:370
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:371
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:372
assert_return(
  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
  [value("i32", 0)],
);

// ./test/core/f32_cmp.wast:373
assert_return(
  () => invoke($0, `eq`, [
--> --------------------

--> maximum size reached

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