(module

  ;; Import our myprint function
  (import "myenv" "print" (func $print (param i64 i32)))

  ;; Define a single page memory of 64KB.
  (memory $0 1)

  ;; Store the Hello World (null terminated) string at byte offset 0
  (data (i32.const 0) "Test Passed\n")
  (data (i32.const 16) "#Test Failed\n")

  ;; Debug function
  (func $printd (param $len i32)
    i64.const 0
    (local.get $len)
    (call $print)
  )

  (func $printSuccess
    i64.const 0
    i32.const 12
    (call $print)
  )

  (func $printFail
    i64.const 16
    i32.const 13
    (call $print)
  )

  (func $assert_test_f32 (param $expected f32) (param $result f32)
    local.get $expected
    local.get $result
    f32.eq
    (if
      (then
        (call $printSuccess)
      )
      (else
        (call $printFail)
      )
    )
  )

  (func $assert_test_f64 (param $expected f64) (param $result f64)
    local.get $expected
    local.get $result
    f64.eq
    (if
      (then
        (call $printSuccess)
      )
      (else
        (call $printFail)
      )
    )
  )
  (func $add (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
  (func $sub (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
  (func $mul (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
  (func $div (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
  ;;(func $sqrt (param $x f64) (result f64) (f64.sqrt (local.get $x)))
  ;;(func $min (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
  ;;(func $max (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
  ;;(func $ceil (param $x f64) (result f64) (f64.ceil (local.get $x)))
  ;;(func $floor (param $x f64) (result f64) (f64.floor (local.get $x)))
  ;;(func $trunc (param $x f64) (result f64) (f64.trunc (local.get $x)))
  ;;(func $nearest (param $x f64) (result f64) (f64.nearest (local.get $x)))

  (func (export "_start")
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1021))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1021))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1.8p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1.8p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1.8p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1.8p+0))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+1))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+1))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $add (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
(call $assert_test_f64 (call $add (f64.const inf) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $add (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1021))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1021))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1.8p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1.8p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1.8p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1.8p+0))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+1))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+1))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $sub (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const inf)) (f64.const -inf))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -inf)) (f64.const inf))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $sub (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x0.8p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-2))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-2))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-2))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-2))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;;;(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;;;(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;;;(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;;;(call $assert_test_f64 (call $mul (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -inf)) (f64.const inf))
(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -inf)) (f64.const -inf))
(call $assert_test_f64 (call $mul (f64.const inf) (f64.const inf)) (f64.const inf))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $mul (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-52))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-52))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-52))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-52))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000002p-1022))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000002p-1022))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000002p-1022))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000002p-1022))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+52))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+52))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1021))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1021))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1021))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1021))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p+1021))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+1022))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+1))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+1))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+1))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+1))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x0p+0))
(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0))
(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x0p+0))
;;(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
(call $assert_test_f64 (call $div (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
(call $assert_test_f64 (call $div (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
;;(call $assert_test_f64 (call $div (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
  )
)