From 6689add40704eb7bc8172ce60562cf0e182375b0 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Mon, 4 Nov 2019 10:39:33 +0800
Subject: [PATCH 1/2] [test] Integrate tests for f64x2 min/max/abs ops from
 WAVM

---
 test/core/simd/meta/README.md     |    1 +
 test/core/simd/meta/gen_tests.py  |    1 +
 test/core/simd/meta/simd_f64x2.py |  443 ++++++
 test/core/simd/simd_f64x2.wast    | 2425 +++++++++++++++++++++++++++++
 4 files changed, 2870 insertions(+)
 create mode 100644 test/core/simd/meta/simd_f64x2.py
 create mode 100644 test/core/simd/simd_f64x2.wast

diff --git a/test/core/simd/meta/README.md b/test/core/simd/meta/README.md
index d4c202994a..74567cca50 100644
--- a/test/core/simd/meta/README.md
+++ b/test/core/simd/meta/README.md
@@ -16,6 +16,7 @@ Currently it only support following simd test files generation.
 - 'simd_i8x16_sat_arith.wast'
 - 'simd_i16x8_sat_arith.wast'
 - 'simd_f32x4.wast'
+- 'simd_f64x2.wast'
 
 
 Usage:
diff --git a/test/core/simd/meta/gen_tests.py b/test/core/simd/meta/gen_tests.py
index b9f17a7409..7d37dce982 100644
--- a/test/core/simd/meta/gen_tests.py
+++ b/test/core/simd/meta/gen_tests.py
@@ -21,6 +21,7 @@
     'simd_sat_arith',
     'simd_bitwise',
     'simd_f32x4',
+    'simd_f64x2',
 )
 
 
diff --git a/test/core/simd/meta/simd_f64x2.py b/test/core/simd/meta/simd_f64x2.py
new file mode 100644
index 0000000000..1d7c53bc7b
--- /dev/null
+++ b/test/core/simd/meta/simd_f64x2.py
@@ -0,0 +1,443 @@
+#!/usr/bin/env python3
+
+"""
+Generate f64x2 [abs, min, max] cases.
+"""
+
+from simd_f32x4 import Simdf32x4Case
+from simd_f32x4_arith import Simdf32x4ArithmeticCase
+from test_assert import AssertReturn
+
+
+class Simdf64x2Case(Simdf32x4Case):
+
+    LANE_TYPE = 'f64x2'
+
+    FLOAT_NUMBERS = (
+        '0x0p+0', '-0x0p+0', '0x1p-1074', '-0x1p-1074', '0x1p-1022', '-0x1p-1022', '0x1p-1', '-0x1p-1', '0x1p+0', '-0x1p+0',
+        '0x1.921fb54442d18p+2', '-0x1.921fb54442d18p+2', '0x1.fffffffffffffp+1023', '-0x1.fffffffffffffp+1023', 'inf', '-inf'
+    )
+
+    NAN_NUMBERS = ('nan', '-nan', 'nan:0x4000000000000', '-nan:0x4000000000000')
+
+    def gen_test_fn_template(self):
+
+        # Get function code
+        template = Simdf32x4ArithmeticCase.gen_test_fn_template(self)
+
+        # Function template
+        tpl_func = '  (func (export "{}"){} (result v128) ({} {}{}))'
+
+        # Const data for min and max
+        lst_instr_with_const = [
+            [
+                [['0', '1'], ['0', '2']],
+                [['0', '1'], ['0', '2']]
+            ],
+            [
+                [['2', '-3'], ['1', '3']],
+                [['1', '-3'], ['2', '3']]
+            ],
+            [
+                [['0', '1'], ['0', '1']],
+                [['0', '1'], ['0', '1']]
+            ],
+            [
+                [['2', '3'], ['2', '3']],
+                [['2', '3'], ['2', '3']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x02']],
+                [['0x00', '0x01'], ['0x00', '0x02']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x01', '2147483648']],
+                [['0x01', '0x80000000'], ['0x02', '2147483648']]
+            ],
+            [
+                [['0x00', '0x01'], ['0x00', '0x01']],
+                [['0x00', '0x01'], ['0x00', '0x01']]
+            ],
+            [
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']],
+                [['0x02', '0x80000000'], ['0x02', '0x80000000']]
+            ]
+        ]
+
+        # Assert data
+        lst_oprt_with_const_assert = {}
+
+        # Generate func and assert
+        for op in self.BINARY_OPS:
+
+            op_name = self.full_op_name(op)
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] const vs const"
+            template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
+
+            # Add const vs const cases
+            for case_data in lst_instr_with_const:
+
+                func_name = "{}_with_const_{}".format(op_name, len(template)-7)
+                template.insert(len(template)-1,
+                                tpl_func.format(func_name, '', op_name,
+                                                self.v128_const('f64x2', case_data[0][0]),
+                                                ' ' + self.v128_const('f64x2', case_data[0][1])))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func_name, case_data[1][ret_idx]])
+
+            # Add comment for the case script "  ;; [f64x2.min, f64x2.max] param vs const"
+            template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
+
+            case_cnt = 0
+
+            # Add param vs const cases
+            for case_data in lst_instr_with_const:
+
+                func_name = "{}_with_const_{}".format(op_name, len(template)-7)
+
+                # Cross parameters and constants
+                if case_cnt in (0, 3):
+                    func_param_0 = '(local.get 0)'
+                    func_param_1 = self.v128_const('f64x2', case_data[0][0])
+                else:
+                    func_param_0 = self.v128_const('f64x2', case_data[0][0])
+                    func_param_1 = '(local.get 0)'
+
+                template.insert(len(template)-1,
+                                tpl_func.format(func_name, '(param v128)', op_name, func_param_0, ' ' + func_param_1))
+
+                ret_idx = 0 if op == 'min' else 1
+
+                if op not in lst_oprt_with_const_assert:
+                    lst_oprt_with_const_assert[op] = []
+
+                lst_oprt_with_const_assert[op].append([func_name, case_data[0][1], case_data[1][ret_idx]])
+
+                case_cnt += 1
+
+        # print(lst_oprt_with_const_assert)
+
+        # Generate func for abs
+        op_name = self.full_op_name('abs')
+        template.insert(len(template)-1, '')
+        func_name = "{}_with_const_{}".format(op_name, 35)
+        template.insert(len(template)-1,
+                        tpl_func.format(func_name, '', op_name,
+                                        self.v128_const('f64x2', ['-0', '-1']), ''))
+        func_name = "{}_with_const_{}".format(op_name, 36)
+        template.insert(len(template)-1,
+                        tpl_func.format(func_name, '', op_name,
+                                        self.v128_const('f64x2', ['-2', '-3']), ''))
+
+        # Test different lanes go through different if-then clauses
+        lst_diff_lane_vs_clause = [
+            [
+                'f64x2.min',
+                [['nan', '0'], ['0', '1']],
+                [['nan', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '0']],
+                [['-nan', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['0', '1'], ['-nan', '1']],
+                [['-nan', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['nan', '0'], ['0', '1']],
+                [['nan', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '0']],
+                [['-nan', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '1'], ['-nan', '1']],
+                [['-nan', '1']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ]
+        ]
+
+        # Case number
+        case_cnt = 0
+
+        # Template for func name to extract a lane
+        tpl_func_name_by_lane = 'call_indirect_vv_v_f64x2_extract_lane_{}'
+
+        # Template for assert
+        tpl_assert = '({}\n' \
+                     '  (invoke "{}"\n' \
+                     '    {}\n' \
+                     '    {}\n' \
+                     '    {}\n' \
+                     '  )\n' \
+                     '{}' \
+                     ')'
+
+        lst_diff_lane_vs_clause_assert = []
+
+        # Add comment in wast script
+        lst_diff_lane_vs_clause_assert.append('')
+        lst_diff_lane_vs_clause_assert.append(';; Test different lanes go through different if-then clauses')
+
+        template.insert(len(template)-1, '')
+        template.insert(len(template)-1, '  ;;  Test different lanes go through different if-then clauses')
+
+        # Add test case for test different lanes go through different if-then clauses
+        template.insert(len(template)-1, '  (type $vv_v (func (param v128 v128) (result v128)))\n'
+                                         '  (table funcref (elem $f64x2_min $f64x2_max))\n'
+                                         '\n'
+                                         '  (func $f64x2_min (type $vv_v)\n'
+                                         '    (f64x2.min (local.get 0) (local.get 1))\n'
+                                         '  )\n'
+                                         '\n'
+                                         '  (func $f64x2_max (type $vv_v)\n'
+                                         '    (f64x2.max (local.get 0) (local.get 1))\n'
+                                         '  )\n'
+                                         '\n'
+                                         '  (func (export "call_indirect_vv_v_f64x2_extract_lane_0")\n'
+                                         '    (param v128 v128 i32) (result f64)\n'
+                                         '    (f64x2.extract_lane 0\n'
+                                         '      (call_indirect (type $vv_v) (local.get 0) (local.get 1) (local.get 2))\n'
+                                         '    )\n'
+                                         '  )\n'
+                                         '  (func (export "call_indirect_vv_v_f64x2_extract_lane_1")\n'
+                                         '    (param v128 v128 i32) (result f64)\n'
+                                         '    (f64x2.extract_lane 1\n'
+                                         '      (call_indirect (type $vv_v) (local.get 0) (local.get 1) (local.get 2))\n'
+                                         '    )\n'
+                                         '  )')
+
+        for case_data in lst_diff_lane_vs_clause:
+
+            lst_diff_lane_vs_clause_assert.append(';; {} {}'.format(case_data[0], case_cnt))
+
+            # generate assert for every data lane
+            for lane_idx in range(0, len(case_data[2][0])):
+
+                # get the result by lane
+                ret = case_data[2][0][lane_idx]
+
+                idx_func = '0' if 'min' in case_data[0] else '1'
+
+                # append assert
+                if 'nan' in ret:
+
+                    lst_diff_lane_vs_clause_assert.append(tpl_assert.format('assert_return_canonical_nan',
+                                                                            tpl_func_name_by_lane.format(lane_idx),
+                                                                            self.v128_const('f64x2', case_data[1][0]),
+                                                                            self.v128_const('f64x2', case_data[1][1]),
+                                                                            self.v128_const('i32', idx_func),
+                                                                            ''))
+                else:
+
+                    lst_diff_lane_vs_clause_assert.append(tpl_assert.format('assert_return',
+                                                                            tpl_func_name_by_lane.format(lane_idx),
+                                                                            self.v128_const('f64x2', case_data[1][0]),
+                                                                            self.v128_const('f64x2', case_data[1][1]),
+                                                                            self.v128_const('i32', idx_func),
+                                                                            '  '+self.v128_const('f64', ret)+'\n'))
+
+            case_cnt += 1
+            if case_cnt == 2:
+                case_cnt = 0
+
+        lst_diff_lane_vs_clause_assert.append('')
+
+        # Add test for operations with constant operands
+        for key in lst_oprt_with_const_assert:
+
+            case_cnt = 0
+            for case_data in lst_oprt_with_const_assert[key]:
+
+                # Add comment for the param combination
+                if case_cnt == 0:
+                    template.append(';; {} const vs const'.format(op_name))
+                if case_cnt == 4:
+                    template.append(';; {} param vs const'.format(op_name))
+
+                # Cross parameters and constants
+                if case_cnt < 8:
+                    template.append(str(AssertReturn(case_data[0], [], self.v128_const('f64x2', case_data[1]))))
+                else:
+                    template.append(str(AssertReturn(case_data[0], [self.v128_const('f64x2', case_data[1])], self.v128_const('f64x2', case_data[2]))))
+                case_cnt += 1
+
+        # Generate and append f64x2.abs assert
+        op_name = self.full_op_name('abs')
+        template.append('')
+        func_name = "{}_with_const_{}".format(op_name, 35)
+        template.append(str(AssertReturn(func_name, [], self.v128_const('f64x2', ['0', '1']))))
+        func_name = "{}_with_const_{}".format(op_name, 36)
+        template.append(str(AssertReturn(func_name, [], self.v128_const('f64x2', ['2', '3']))))
+
+        template.extend(lst_diff_lane_vs_clause_assert)
+
+        return template
+
+    @property
+    def combine_ternary_arith_test_data(self):
+        return {
+            'min-max': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-min': [
+                ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.25'] * 2
+            ]
+        }
+
+    @property
+    def combine_binary_arith_test_data(self):
+        return {
+            'min-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['0.125'] * 2
+            ],
+            'max-abs': [
+                ['-1.125'] * 2, ['0.125'] * 2, ['1.125'] * 2
+            ]
+        }
+
+    def get_normal_case(self):
+        """Normal test cases from WebAssembly core tests, 4 assert statements:
+            assert_return
+            assert_return_canonical_nan
+            assert_return_arithmetic_nan
+            assert_malformed
+        """
+        cases = []
+        binary_test_data = []
+        unary_test_data = []
+
+        for op in self.BINARY_OPS:
+            op_name = self.full_op_name(op)
+            for p1 in self.FLOAT_NUMBERS:
+                for p2 in self.FLOAT_NUMBERS:
+                    result = self.floatOp.binary_op(op, p1, p2)
+                    if 'nan' not in result:
+                        # Normal floating point numbers as the results
+                        binary_test_data.append(['assert_return', op_name, p1, p2, result])
+                    else:
+                        # Since the results contain the 'nan' string, it should be in the
+                        # assert_return_canonical_nan statements
+                        binary_test_data.append(['assert_return_canonical_nan_f64x2', op_name, p1, p2])
+
+            # assert_return_canonical_nan and assert_return_arithmetic_nan cases
+            for p1 in self.NAN_NUMBERS:
+                for p2 in self.FLOAT_NUMBERS:
+                    if 'nan:' in p1 or 'nan:' in p2:
+                        # When the arguments contain 'nan:', always use assert_return_arithmetic_nan
+                        # statements for the cases. Since there 2 parameters for binary operation and
+                        # the order of the parameters matter. Different order makes different cases.
+                        binary_test_data.append(['assert_return_arithmetic_nan_f64x2', op_name, p1, p2])
+                        binary_test_data.append(['assert_return_arithmetic_nan_f64x2', op_name, p2, p1])
+                    else:
+                        # No 'nan' string found, then it should be assert_return_canonical_nan.
+                        binary_test_data.append(['assert_return_canonical_nan_f64x2', op_name, p1, p2])
+                        binary_test_data.append(['assert_return_canonical_nan_f64x2', op_name, p2, p1])
+                for p2 in self.NAN_NUMBERS:
+                    # Both parameters contain 'nan', then there must be no assert_return.
+                    if 'nan:' in p1 or 'nan:' in p2:
+                        binary_test_data.append(['assert_return_arithmetic_nan_f64x2', op_name, p1, p2])
+                    else:
+                        binary_test_data.append(['assert_return_canonical_nan_f64x2', op_name, p1, p2])
+
+        for case in binary_test_data:
+            cases.append(self.single_binary_test(case))
+
+        # Test opposite signs of zero
+        lst_oppo_signs_0 = [
+            '\n;; Test opposite signs of zero',
+            [
+                'f64x2.min',
+                [['0', '0' ], ['+0', '-0']],
+                [['0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '+0'], ['+0', '-0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.min',
+                [['-0', '-0'], ['+0', '+0']],
+                [['-0', '-0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['0', '0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '+0'], ['+0', '-0']],
+                [['0', '0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            [
+                'f64x2.max',
+                [['-0', '-0'], ['+0', '+0']],
+                [['+0', '+0']],
+                ['f64x2', 'f64x2', 'f64x2']
+            ],
+            '\n'
+        ]
+
+        # Generate test case for opposite signs of zero
+        for case_data in lst_oppo_signs_0:
+
+            if isinstance(case_data, str):
+                cases.append(case_data)
+                continue
+
+            cases.append(str(AssertReturn(case_data[0],
+                                          [self.v128_const(case_data[3][0], case_data[1][0]),
+                                           self.v128_const(case_data[3][1], case_data[1][1])],
+                                          self.v128_const(case_data[3][2], case_data[2][0]))))
+
+        for p in self.FLOAT_NUMBERS:
+            op_name = self.full_op_name('abs')
+            result = self.floatOp.unary_op('abs', p)
+            # Abs operation is valid for all the floating point numbers
+            unary_test_data.append(['assert_return', op_name, p, result])
+
+        for case in unary_test_data:
+            cases.append(self.single_unary_test(case))
+
+        return '\n'.join(cases)
+
+    def gen_test_cases(self):
+        wast_filename = '../simd_{lane_type}.wast'.format(lane_type=self.LANE_TYPE)
+        with open(wast_filename, 'w') as fp:
+            txt_test_case = self.get_all_cases()
+            txt_test_case = txt_test_case.replace('f64x2 arithmetic', 'f64x2 [abs, min, max]')
+            fp.write(txt_test_case)
+
+
+def gen_test_cases():
+    simd_f64x2_case = Simdf64x2Case()
+    simd_f64x2_case.gen_test_cases()
+
+
+if __name__ == '__main__':
+    gen_test_cases()
\ No newline at end of file
diff --git a/test/core/simd/simd_f64x2.wast b/test/core/simd/simd_f64x2.wast
new file mode 100644
index 0000000000..d08e93f6ae
--- /dev/null
+++ b/test/core/simd/simd_f64x2.wast
@@ -0,0 +1,2425 @@
+;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1)))
+  (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1)))
+  (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0)))
+  ;; f64x2.min const vs const
+  (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.min param vs const
+  (func (export "f64x2.min_with_const_9")(param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10")(param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11")(param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12")(param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  ;; f64x2.max const vs const
+  (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.max param vs const
+  (func (export "f64x2.max_with_const_27")(param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28")(param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29")(param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30")(param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+
+  (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
+  (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))
+
+  ;;  Test different lanes go through different if-then clauses
+  (type $vv_v (func (param v128 v128) (result v128)))
+  (table funcref (elem $f64x2_min $f64x2_max))
+
+  (func $f64x2_min (type $vv_v)
+    (f64x2.min (local.get 0) (local.get 1))
+  )
+
+  (func $f64x2_max (type $vv_v)
+    (f64x2.max (local.get 0) (local.get 1))
+  )
+
+  (func (export "call_indirect_vv_v_f64x2_extract_lane_0")
+    (param v128 v128 i32) (result f64)
+    (f64x2.extract_lane 0
+      (call_indirect (type $vv_v) (local.get 0) (local.get 1) (local.get 2))
+    )
+  )
+  (func (export "call_indirect_vv_v_f64x2_extract_lane_1")
+    (param v128 v128 i32) (result f64)
+    (f64x2.extract_lane 1
+      (call_indirect (type $vv_v) (local.get 0) (local.get 1) (local.get 2))
+    )
+  )
+)
+
+;; f64x2.abs const vs const
+(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3))
+;; f64x2.abs param vs const
+(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2))
+                                                (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+;; f64x2.abs const vs const
+(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3))
+;; f64x2.abs param vs const
+(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2))
+                                                 (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+
+(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f64x2.min 0
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+    (i32.const 0)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+    (i32.const 0)
+  )
+  (f64.const 0)
+)
+;; f64x2.min 1
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+    (i32.const 0)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+    (i32.const 0)
+  )
+  (f64.const 0)
+)
+;; f64x2.min 0
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+    (i32.const 0)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+    (i32.const 0)
+  )
+  (f64.const 1)
+)
+;; f64x2.max 1
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+    (i32.const 1)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+    (i32.const 1)
+  )
+  (f64.const 1)
+)
+;; f64x2.max 0
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+    (i32.const 1)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+    (i32.const 1)
+  )
+  (f64.const 1)
+)
+;; f64x2.max 1
+(assert_return_canonical_nan
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_0"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+    (i32.const 1)
+  )
+)
+(assert_return
+  (invoke "call_indirect_vv_v_f64x2_extract_lane_1"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+    (i32.const 1)
+  )
+  (f64.const 1)
+)
+
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 inf inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -inf -inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 inf inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -inf -inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 inf inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -inf -inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 nan nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 inf inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -inf -inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 nan nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 inf inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -inf -inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 inf inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -inf -inf)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 nan nan)))
+(assert_return_canonical_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                       (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 inf inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -inf -inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 nan nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x0p+0 0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x0p+0 -0x0p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1074 0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1074 -0x1p-1074)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1022 0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1022 -0x1p-1022)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p-1 0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p-1 -0x1p-1)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1p+0 0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1p+0 -0x1p+0)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 inf inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -inf -inf)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 nan nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan -nan)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)))
+(assert_return_arithmetic_nan_f64x2 (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                                        (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 +0 +0))
+
+
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f64x2.max (f64x2.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f64x2.min (f64x2.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
\ No newline at end of file

From 8f33792b7537026896f197c240e5270704e84a5d Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 5 Nov 2019 17:48:43 +0800
Subject: [PATCH 2/2] Addressed comments

---
 test/core/simd/meta/simd_f64x2.py | 39 +++++++++++++++++--------------
 test/core/simd/simd_f64x2.wast    | 32 ++++++++++++-------------
 2 files changed, 37 insertions(+), 34 deletions(-)

diff --git a/test/core/simd/meta/simd_f64x2.py b/test/core/simd/meta/simd_f64x2.py
index 1d7c53bc7b..5b39b8e42e 100644
--- a/test/core/simd/meta/simd_f64x2.py
+++ b/test/core/simd/meta/simd_f64x2.py
@@ -28,8 +28,8 @@ def gen_test_fn_template(self):
         # Function template
         tpl_func = '  (func (export "{}"){} (result v128) ({} {}{}))'
 
-        # Const data for min and max
-        lst_instr_with_const = [
+        # Raw data list specific for "const vs const" and "param vs const" tests
+        const_test_raw_data = [
             [
                 [['0', '1'], ['0', '2']],
                 [['0', '1'], ['0', '2']]
@@ -64,8 +64,9 @@ def gen_test_fn_template(self):
             ]
         ]
 
-        # Assert data
-        lst_oprt_with_const_assert = {}
+        # Test data list combined with `const_test_raw_data` and corresponding ops and function names
+        # specific for "const vs const" and "param vs const" tests
+        const_test_data = {}
 
         # Generate func and assert
         for op in self.BINARY_OPS:
@@ -76,7 +77,7 @@ def gen_test_fn_template(self):
             template.insert(len(template)-1, '  ;; {} const vs const'.format(op_name))
 
             # Add const vs const cases
-            for case_data in lst_instr_with_const:
+            for case_data in const_test_raw_data:
 
                 func_name = "{}_with_const_{}".format(op_name, len(template)-7)
                 template.insert(len(template)-1,
@@ -86,10 +87,10 @@ def gen_test_fn_template(self):
 
                 ret_idx = 0 if op == 'min' else 1
 
-                if op not in lst_oprt_with_const_assert:
-                    lst_oprt_with_const_assert[op] = []
+                if op not in const_test_data:
+                    const_test_data[op] = []
 
-                lst_oprt_with_const_assert[op].append([func_name, case_data[1][ret_idx]])
+                const_test_data[op].append([func_name, case_data[1][ret_idx]])
 
             # Add comment for the case script "  ;; [f64x2.min, f64x2.max] param vs const"
             template.insert(len(template)-1, '  ;; {} param vs const'.format(op_name))
@@ -97,7 +98,7 @@ def gen_test_fn_template(self):
             case_cnt = 0
 
             # Add param vs const cases
-            for case_data in lst_instr_with_const:
+            for case_data in const_test_raw_data:
 
                 func_name = "{}_with_const_{}".format(op_name, len(template)-7)
 
@@ -110,19 +111,17 @@ def gen_test_fn_template(self):
                     func_param_1 = '(local.get 0)'
 
                 template.insert(len(template)-1,
-                                tpl_func.format(func_name, '(param v128)', op_name, func_param_0, ' ' + func_param_1))
+                                tpl_func.format(func_name, ' (param v128)', op_name, func_param_0, ' ' + func_param_1))
 
                 ret_idx = 0 if op == 'min' else 1
 
-                if op not in lst_oprt_with_const_assert:
-                    lst_oprt_with_const_assert[op] = []
+                if op not in const_test_data:
+                    const_test_data[op] = []
 
-                lst_oprt_with_const_assert[op].append([func_name, case_data[0][1], case_data[1][ret_idx]])
+                const_test_data[op].append([func_name, case_data[0][1], case_data[1][ret_idx]])
 
                 case_cnt += 1
 
-        # print(lst_oprt_with_const_assert)
-
         # Generate func for abs
         op_name = self.full_op_name('abs')
         template.insert(len(template)-1, '')
@@ -262,10 +261,10 @@ def gen_test_fn_template(self):
         lst_diff_lane_vs_clause_assert.append('')
 
         # Add test for operations with constant operands
-        for key in lst_oprt_with_const_assert:
+        for key in const_test_data:
 
             case_cnt = 0
-            for case_data in lst_oprt_with_const_assert[key]:
+            for case_data in const_test_data[key]:
 
                 # Add comment for the param combination
                 if case_cnt == 0:
@@ -294,6 +293,8 @@ def gen_test_fn_template(self):
 
     @property
     def combine_ternary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min and max combination tests.
         return {
             'min-max': [
                 ['1.125'] * 2, ['0.25'] * 2, ['0.125'] * 2, ['0.125'] * 2
@@ -305,6 +306,8 @@ def combine_ternary_arith_test_data(self):
 
     @property
     def combine_binary_arith_test_data(self):
+        # This method overrides the base class method from SimdArithmeticCase
+        # used for generating test data for min, max and abs combination tests.
         return {
             'min-abs': [
                 ['-1.125'] * 2, ['0.125'] * 2, ['0.125'] * 2
@@ -440,4 +443,4 @@ def gen_test_cases():
 
 
 if __name__ == '__main__':
-    gen_test_cases()
\ No newline at end of file
+    gen_test_cases()
diff --git a/test/core/simd/simd_f64x2.wast b/test/core/simd/simd_f64x2.wast
index d08e93f6ae..22ffa5b86e 100644
--- a/test/core/simd/simd_f64x2.wast
+++ b/test/core/simd/simd_f64x2.wast
@@ -15,14 +15,14 @@
   (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
   (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
   ;; f64x2.min param vs const
-  (func (export "f64x2.min_with_const_9")(param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
-  (func (export "f64x2.min_with_const_10")(param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
-  (func (export "f64x2.min_with_const_11")(param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
-  (func (export "f64x2.min_with_const_12")(param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
-  (func (export "f64x2.min_with_const_13")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
-  (func (export "f64x2.min_with_const_14")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
-  (func (export "f64x2.min_with_const_15")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
-  (func (export "f64x2.min_with_const_16")(param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
   ;; f64x2.max const vs const
   (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
   (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
@@ -33,14 +33,14 @@
   (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
   (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
   ;; f64x2.max param vs const
-  (func (export "f64x2.max_with_const_27")(param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
-  (func (export "f64x2.max_with_const_28")(param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
-  (func (export "f64x2.max_with_const_29")(param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
-  (func (export "f64x2.max_with_const_30")(param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
-  (func (export "f64x2.max_with_const_31")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
-  (func (export "f64x2.max_with_const_32")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
-  (func (export "f64x2.max_with_const_33")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
-  (func (export "f64x2.max_with_const_34")(param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
 
   (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
   (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))