(*.f64 (-.f64 (*.f64 x y) (*.f64 z y)) t)

(-.f64 (*.f64 x y) (*.f64 z y))

(*.f64 x y)

x

y

(*.f64 z y)

z

t

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 (-.f64 x z) t) y)

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (-.f64 x z) (*.f64 t y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 t (*.f64 (-.f64 x z) y))

(*.f64 (*.f64 (-.f64 x z) y) t)

(*.f64 y (*.f64 (-.f64 x z) t))

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (*.f64 (neg.f64 t) y) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (*.f64 (neg.f64 t) y) z (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 t (*.f64 y x)))

(fma.f64 (neg.f64 x) (*.f64 (neg.f64 t) y) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 t (*.f64 y x)))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 t (*.f64 y x)))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 t (*.f64 y x)))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 t (*.f64 y x)))

(fma.f64 z (*.f64 (neg.f64 t) y) (*.f64 t (*.f64 y x)))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 t (*.f64 y x)))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 z) y) t))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 z) y) t))

(-.f64 (*.f64 (*.f64 (neg.f64 z) y) t) (*.f64 (*.f64 (neg.f64 t) x) y))

(-.f64 (*.f64 t (*.f64 y x)) (*.f64 (*.f64 t y) z))

(+.f64 (*.f64 (*.f64 (neg.f64 z) y) t) (*.f64 t (*.f64 y x)))

(+.f64 (*.f64 t (*.f64 y x)) (*.f64 (*.f64 (neg.f64 z) y) t))

(*.f64 (neg.f64 y) (-.f64 z x))

(*.f64 (-.f64 z x) (neg.f64 y))

(*.f64 (-.f64 x z) y)

(*.f64 y (-.f64 x z))

(neg.f64 (*.f64 (-.f64 z x) y))

(fma.f64 (neg.f64 y) (neg.f64 x) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 y) z (*.f64 y x))

(fma.f64 (neg.f64 x) (neg.f64 y) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 z) y (*.f64 y x))

(fma.f64 z (neg.f64 y) (*.f64 y x))

(fma.f64 y (neg.f64 z) (*.f64 y x))

(fma.f64 y x (*.f64 (neg.f64 z) y))

(fma.f64 x y (*.f64 (neg.f64 z) y))

(-.f64 (*.f64 (neg.f64 z) y) (*.f64 (neg.f64 y) x))

(-.f64 (*.f64 y x) (*.f64 z y))

(+.f64 (*.f64 (neg.f64 z) y) (*.f64 y x))

(+.f64 (*.f64 y x) (*.f64 (neg.f64 z) y))

(*.f64 (neg.f64 y) (neg.f64 x))

(*.f64 (neg.f64 x) (neg.f64 y))

(*.f64 y x)

(*.f64 x y)

(neg.f64 (*.f64 (neg.f64 y) x))

x

y

(*.f64 (neg.f64 y) (neg.f64 z))

(*.f64 (neg.f64 z) (neg.f64 y))

(*.f64 z y)

(*.f64 y z)

(neg.f64 (*.f64 (neg.f64 z) y))

z

t

(*.f64 (*.f64 (-.f64 x z) y) t)

(*.f64 (-.f64 x z) y)

(-.f64 x z)

x

z

y

t

#s(approx (* (- (* x y) (* z y)) t) (*.f64 t (*.f64 x y)))

(*.f64 t (*.f64 x y))

(*.f64 x y)

(*.f64 (*.f64 (-.f64 x z) t) y)

(*.f64 (-.f64 x z) t)

(*.f64 (-.f64 x z) (*.f64 t y))

(*.f64 t y)

(*.f64 (fma.f64 (neg.f64 z) y (*.f64 y x)) t)

(fma.f64 (neg.f64 z) y (*.f64 y x))

(neg.f64 z)

(*.f64 y x)

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 t (-.f64 x z)) y)

(*.f64 t (*.f64 y (-.f64 x z)))

(*.f64 (*.f64 y (-.f64 x z)) t)

(*.f64 y (*.f64 t (-.f64 x z)))

(*.f64 (-.f64 x z) (*.f64 t y))

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 t) y) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 t) y) z (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 y z) (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 z) t) y (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 x) (*.f64 (neg.f64 t) y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y z) (neg.f64 t) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 y x) t))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 y (*.f64 (neg.f64 z) t) (*.f64 (*.f64 y x) t))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 z (*.f64 (neg.f64 t) y) (*.f64 (*.f64 y x) t))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 z) t) y))

(-.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 (neg.f64 y) x) t))

(-.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 y z) t))

(+.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 y x) t))

(+.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 (neg.f64 z) t) y))

(*.f64 (neg.f64 y) (-.f64 z x))

(*.f64 (-.f64 z x) (neg.f64 y))

(*.f64 y (-.f64 x z))

(*.f64 (-.f64 x z) y)

(neg.f64 (*.f64 (-.f64 z x) y))

(fma.f64 (neg.f64 x) (neg.f64 y) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 y) (neg.f64 x) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 y) z (*.f64 y x))

(fma.f64 (neg.f64 z) y (*.f64 y x))

(fma.f64 y (neg.f64 z) (*.f64 y x))

(fma.f64 y x (*.f64 (neg.f64 z) y))

(fma.f64 z (neg.f64 y) (*.f64 y x))

(fma.f64 x y (*.f64 (neg.f64 z) y))

(-.f64 (*.f64 (neg.f64 z) y) (*.f64 (neg.f64 y) x))

(-.f64 (*.f64 y x) (*.f64 y z))

(+.f64 (*.f64 (neg.f64 z) y) (*.f64 y x))

(+.f64 (*.f64 y x) (*.f64 (neg.f64 z) y))

(neg.f64 (-.f64 z x))

(-.f64 (neg.f64 z) (neg.f64 x))

(-.f64 x z)

(+.f64 (neg.f64 z) x)

(+.f64 x (neg.f64 z))

x

z

y

t

#s(approx (* (- (* x y) (* z y)) t) (*.f64 (*.f64 y x) t))

(*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y))

(*.f64 (*.f64 (neg.f64 t) y) (neg.f64 x))

(*.f64 (neg.f64 t) (*.f64 (neg.f64 y) x))

(*.f64 (neg.f64 x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 t x) y)

(*.f64 (*.f64 (neg.f64 y) x) (neg.f64 t))

(*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x))

(*.f64 (*.f64 t y) x)

(*.f64 (*.f64 y x) t)

(*.f64 t (*.f64 y x))

(*.f64 y (*.f64 t x))

(*.f64 x (*.f64 t y))

(neg.f64 (*.f64 (*.f64 (neg.f64 y) x) t))

(*.f64 (neg.f64 x) (neg.f64 y))

(*.f64 (neg.f64 y) (neg.f64 x))

(*.f64 y x)

(*.f64 x y)

(neg.f64 (*.f64 (neg.f64 y) x))

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 t (-.f64 x z)) y)

(*.f64 t (*.f64 y (-.f64 x z)))

(*.f64 (*.f64 y (-.f64 x z)) t)

(*.f64 y (*.f64 t (-.f64 x z)))

(*.f64 (-.f64 x z) (*.f64 t y))

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 t) y) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 t) y) z (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 y z) (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 z) t) y (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 x) (*.f64 (neg.f64 t) y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y z) (neg.f64 t) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 y x) t))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 y (*.f64 (neg.f64 z) t) (*.f64 (*.f64 y x) t))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 z (*.f64 (neg.f64 t) y) (*.f64 (*.f64 y x) t))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 z) t) y))

(-.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 (neg.f64 y) x) t))

(-.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 y z) t))

(+.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 y x) t))

(+.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 (neg.f64 z) t) y))

(*.f64 (neg.f64 t) (-.f64 z x))

(*.f64 (-.f64 z x) (neg.f64 t))

(*.f64 t (-.f64 x z))

(*.f64 (-.f64 x z) t)

(neg.f64 (*.f64 (-.f64 z x) t))

(fma.f64 (neg.f64 t) (neg.f64 x) (*.f64 (neg.f64 z) t))

(fma.f64 (neg.f64 t) z (*.f64 t x))

(fma.f64 (neg.f64 x) (neg.f64 t) (*.f64 (neg.f64 z) t))

(fma.f64 (neg.f64 z) t (*.f64 t x))

(fma.f64 t (neg.f64 z) (*.f64 t x))

(fma.f64 t x (*.f64 (neg.f64 z) t))

(fma.f64 z (neg.f64 t) (*.f64 t x))

(fma.f64 x t (*.f64 (neg.f64 z) t))

(-.f64 (*.f64 (neg.f64 z) t) (*.f64 (neg.f64 t) x))

(-.f64 (*.f64 t x) (*.f64 t z))

(+.f64 (*.f64 (neg.f64 z) t) (*.f64 t x))

(+.f64 (*.f64 t x) (*.f64 (neg.f64 z) t))

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 t (-.f64 x z)) y)

(*.f64 t (*.f64 y (-.f64 x z)))

(*.f64 (*.f64 y (-.f64 x z)) t)

(*.f64 y (*.f64 t (-.f64 x z)))

(*.f64 (-.f64 x z) (*.f64 t y))

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 t) y) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 t) y) z (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 y z) (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 z) t) y (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 x) (*.f64 (neg.f64 t) y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y z) (neg.f64 t) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 y x) t))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 y (*.f64 (neg.f64 z) t) (*.f64 (*.f64 y x) t))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 z (*.f64 (neg.f64 t) y) (*.f64 (*.f64 y x) t))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 z) t) y))

(-.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 (neg.f64 y) x) t))

(-.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 y z) t))

(+.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 y x) t))

(+.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 (neg.f64 z) t) y))

(*.f64 (neg.f64 t) (neg.f64 y))

(*.f64 (neg.f64 y) (neg.f64 t))

(*.f64 t y)

(*.f64 y t)

(neg.f64 (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 t (-.f64 x z)) y)

(*.f64 t (*.f64 y (-.f64 x z)))

(*.f64 (*.f64 y (-.f64 x z)) t)

(*.f64 y (*.f64 t (-.f64 x z)))

(*.f64 (-.f64 x z) (*.f64 t y))

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 t) y) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 t) y) z (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 y z) (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 z) t) y (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 x) (*.f64 (neg.f64 t) y) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y z) (neg.f64 t) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 y x) t))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 y x) t))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 y x) t))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 y (*.f64 (neg.f64 z) t) (*.f64 (*.f64 y x) t))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 z) t) y))

(fma.f64 z (*.f64 (neg.f64 t) y) (*.f64 (*.f64 y x) t))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 z) t) y))

(-.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 (neg.f64 y) x) t))

(-.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 y z) t))

(+.f64 (*.f64 (*.f64 (neg.f64 z) t) y) (*.f64 (*.f64 y x) t))

(+.f64 (*.f64 (*.f64 y x) t) (*.f64 (*.f64 (neg.f64 z) t) y))

(*.f64 (neg.f64 y) (-.f64 z x))

(*.f64 (-.f64 z x) (neg.f64 y))

(*.f64 y (-.f64 x z))

(*.f64 (-.f64 x z) y)

(neg.f64 (*.f64 (-.f64 z x) y))

(fma.f64 (neg.f64 x) (neg.f64 y) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 y) (neg.f64 x) (*.f64 (neg.f64 z) y))

(fma.f64 (neg.f64 y) z (*.f64 y x))

(fma.f64 (neg.f64 z) y (*.f64 y x))

(fma.f64 y (neg.f64 z) (*.f64 y x))

(fma.f64 y x (*.f64 (neg.f64 z) y))

(fma.f64 z (neg.f64 y) (*.f64 y x))

(fma.f64 x y (*.f64 (neg.f64 z) y))

(-.f64 (*.f64 (neg.f64 z) y) (*.f64 (neg.f64 y) x))

(-.f64 (*.f64 y x) (*.f64 y z))

(+.f64 (*.f64 (neg.f64 z) y) (*.f64 y x))

(+.f64 (*.f64 y x) (*.f64 (neg.f64 z) y))

(neg.f64 z)

(*.f64 (neg.f64 x) (neg.f64 y))

(*.f64 (neg.f64 y) (neg.f64 x))

(*.f64 y x)

(*.f64 x y)

(neg.f64 (*.f64 (neg.f64 y) x))

#s(approx (* (- (* x y) (* z y)) t) (*.f64 (*.f64 t y) x))

(*.f64 (*.f64 t y) x)

(*.f64 t y)

t

y

x

(*.f64 #s(approx (* (- x z) t) (*.f64 t x)) y)

#s(approx (* (- x z) t) (*.f64 t x))

(*.f64 t x)

(*.f64 (*.f64 #s(approx (- x z) (*.f64 #s(literal -1 binary64) (*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64))))) t) y)

(*.f64 #s(approx (- x z) (*.f64 #s(literal -1 binary64) (*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64))))) t)

#s(approx (- x z) (*.f64 #s(literal -1 binary64) (*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64)))))

(*.f64 #s(literal -1 binary64) (*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64))))

#s(literal -1 binary64)

(*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(-.f64 (/.f64 z x) #s(literal 1 binary64))

(/.f64 z x)

z

#s(literal 1 binary64)

(*.f64 (-.f64 (*.f64 t x) (*.f64 t z)) y)

(-.f64 (*.f64 t x) (*.f64 t z))

(*.f64 t z)

#s(approx (* (- (* x y) (* z y)) t) (*.f64 (*.f64 t y) x))

(*.f64 (*.f64 (*.f64 t y) #s(literal 1 binary64)) x)

(*.f64 (*.f64 (*.f64 t y) #s(literal -1 binary64)) (neg.f64 x))

(*.f64 (*.f64 (*.f64 (neg.f64 x) y) t) #s(literal -1 binary64))

(*.f64 (neg.f64 x) (*.f64 #s(literal -1 binary64) (*.f64 t y)))

(*.f64 #s(literal 1 binary64) (*.f64 (*.f64 t y) x))

(*.f64 #s(literal -1 binary64) (*.f64 (*.f64 (neg.f64 x) y) t))

(*.f64 (*.f64 t x) y)

(*.f64 (*.f64 (*.f64 t y) x) #s(literal 1 binary64))

(*.f64 (*.f64 t y) x)

(*.f64 t (*.f64 y x))

(*.f64 (*.f64 y x) t)

(*.f64 y (*.f64 t x))

(*.f64 x (*.f64 #s(literal 1 binary64) (*.f64 t y)))

(*.f64 x (*.f64 t y))

(/.f64 (*.f64 (*.f64 t y) (+.f64 x x)) #s(literal 2 binary64))

(/.f64 (*.f64 (+.f64 x x) (*.f64 t y)) #s(literal 2 binary64))

(neg.f64 (*.f64 (*.f64 (neg.f64 x) y) t))

(*.f64 t y)

(*.f64 y t)

(neg.f64 (*.f64 (neg.f64 y) t))

t

y

x

(*.f64 #s(approx (* (- x z) t) (*.f64 t x)) y)

(*.f64 y #s(approx (* (- x z) t) (*.f64 t x)))

#s(approx (* (- x z) t) (*.f64 t x))

(*.f64 (*.f64 t #s(literal 1 binary64)) x)

(*.f64 (*.f64 (neg.f64 t) x) #s(literal -1 binary64))

(*.f64 (neg.f64 t) (neg.f64 x))

(*.f64 (neg.f64 x) (neg.f64 t))

(*.f64 #s(literal 1 binary64) (*.f64 t x))

(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) x))

(*.f64 (*.f64 t x) #s(literal 1 binary64))

(*.f64 t x)

(*.f64 x (*.f64 #s(literal 1 binary64) t))

(*.f64 x t)

(/.f64 (*.f64 t (+.f64 x x)) #s(literal 2 binary64))

(/.f64 (*.f64 (+.f64 x x) t) #s(literal 2 binary64))

(neg.f64 (*.f64 (neg.f64 t) x))

(*.f64 (*.f64 #s(approx (- x z) (-.f64 x z)) y) t)

(*.f64 (*.f64 #s(approx (- x z) (-.f64 x z)) t) y)

(*.f64 #s(approx (- x z) (-.f64 x z)) (*.f64 t y))

(*.f64 (*.f64 t y) #s(approx (- x z) (-.f64 x z)))

(*.f64 t (*.f64 #s(approx (- x z) (-.f64 x z)) y))

(*.f64 y (*.f64 #s(approx (- x z) (-.f64 x z)) t))

(neg.f64 (*.f64 (neg.f64 t) (*.f64 #s(approx (- x z) (-.f64 x z)) y)))

(neg.f64 (*.f64 (*.f64 #s(approx (- x z) (-.f64 x z)) y) (neg.f64 t)))

(*.f64 #s(approx (- x z) (-.f64 x z)) t)

(*.f64 t #s(approx (- x z) (-.f64 x z)))

(neg.f64 (*.f64 (neg.f64 t) #s(approx (- x z) (-.f64 x z))))

(neg.f64 (*.f64 #s(approx (- x z) (-.f64 x z)) (neg.f64 t)))

#s(approx (- x z) (-.f64 x z))

(*.f64 (/.f64 (*.f64 (-.f64 z x) x) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64))

(*.f64 (/.f64 (*.f64 (-.f64 x z) x) (+.f64 x x)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 z x) #s(literal 2 binary64)) #s(literal -2 binary64))

(*.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal 1/2 binary64))

(*.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x))

(*.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x))

(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 x z)))

(*.f64 (/.f64 (-.f64 x z) x) x)

(*.f64 (-.f64 z x) #s(literal -1 binary64))

(*.f64 (neg.f64 x) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x))

(*.f64 #s(literal 1 binary64) (-.f64 x z))

(*.f64 #s(literal -1 binary64) (-.f64 z x))

(*.f64 (-.f64 x z) #s(literal 1 binary64))

(*.f64 x (/.f64 (-.f64 x z) x))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) (+.f64 x x)) #s(literal 2 binary64))

(/.f64 (*.f64 (neg.f64 x) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 2 binary64))

(/.f64 (*.f64 x (*.f64 #s(literal 2 binary64) (-.f64 x z))) (+.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (+.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 x (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) x) (+.f64 x x))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) (neg.f64 x)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (neg.f64 x)) (+.f64 x x))

(/.f64 (*.f64 (+.f64 x x) (/.f64 (-.f64 x z) x)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (neg.f64 x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) x) (*.f64 #s(literal -2 binary64) x))

(/.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (neg.f64 x))

(/.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal -1 binary64)) x)

(/.f64 (/.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64)) x)

(/.f64 (/.f64 (*.f64 (-.f64 x z) x) #s(literal -1 binary64)) (neg.f64 x))

(/.f64 (fma.f64 (*.f64 z x) #s(literal 2 binary64) (*.f64 (+.f64 x x) (neg.f64 x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64) (*.f64 (+.f64 x x) x)) (+.f64 x x))

(/.f64 (fma.f64 (+.f64 x x) (neg.f64 x) (*.f64 (*.f64 z x) #s(literal 2 binary64))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (+.f64 x x) x (*.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64))) (+.f64 x x))

(/.f64 (fma.f64 (*.f64 z x) #s(literal 2 binary64) (*.f64 (neg.f64 x) (+.f64 x x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64) (*.f64 x (+.f64 x x))) (+.f64 x x))

(/.f64 (fma.f64 (+.f64 x x) (neg.f64 x) (*.f64 #s(literal 2 binary64) (*.f64 z x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (+.f64 x x) x (*.f64 #s(literal 2 binary64) (*.f64 (neg.f64 z) x))) (+.f64 x x))

(/.f64 (-.f64 (*.f64 (*.f64 z x) #s(literal 2 binary64)) (*.f64 (neg.f64 x) (*.f64 #s(literal -2 binary64) x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (-.f64 (*.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64)) (*.f64 x (*.f64 #s(literal -2 binary64) x))) (+.f64 x x))

(/.f64 (-.f64 (*.f64 (+.f64 x x) #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (+.f64 z z))) #s(literal 4 binary64))

(/.f64 (*.f64 (+.f64 x x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (+.f64 x x)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 4 binary64))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x)) #s(literal 4 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (+.f64 x x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (-.f64 z x) (*.f64 #s(literal -2 binary64) x)) (+.f64 x x))

(/.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64))

(/.f64 (*.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -2 binary64)) #s(literal 4 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 z x)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 (/.f64 z x) #s(literal 1 binary64))) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 z x) (+.f64 x x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 x z) (+.f64 x x)) (+.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 (-.f64 x z) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 (-.f64 z x) x)) (+.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal 4 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 x z) x)) (+.f64 x x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 z x) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal -4 binary64))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal 2 binary64))

(/.f64 (*.f64 (+.f64 x x) (-.f64 z x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (+.f64 x x) (-.f64 x z)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) #s(literal 2 binary64)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) #s(literal 2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64)) #s(literal -4 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -1 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) #s(literal -2 binary64)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 z x)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (+.f64 x x)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (-.f64 x z) x) x)

(/.f64 (*.f64 (-.f64 z x) x) (neg.f64 x))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -2 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64))

(/.f64 (-.f64 z x) #s(literal -1 binary64))

(/.f64 (-.f64 x z) #s(literal 1 binary64))

(neg.f64 (-.f64 z x))

(fma.f64 (/.f64 z #s(literal -2 binary64)) #s(literal 2 binary64) x)

(fma.f64 (/.f64 (*.f64 z x) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) x)

(fma.f64 (/.f64 (*.f64 (neg.f64 z) x) (+.f64 x x)) #s(literal 2 binary64) x)

(fma.f64 (/.f64 (*.f64 (-.f64 z x) x) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (+.f64 x x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 z x) #s(literal 2 binary64)) #s(literal -2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 z #s(literal 2 binary64)) #s(literal -2 binary64) x)

(fma.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 0 binary64))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x) #s(literal 0 binary64))

(fma.f64 (*.f64 (neg.f64 z) x) (/.f64 #s(literal 1 binary64) x) x)

(fma.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x) x)

(fma.f64 (neg.f64 z) #s(literal 1 binary64) x)

(fma.f64 #s(literal 1/2 binary64) (-.f64 x z) (*.f64 #s(literal 1/2 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 (+.f64 z z)) #s(literal 1/2 binary64) x)

(fma.f64 (/.f64 z (neg.f64 x)) x x)

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x) x)

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 x z)) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 x z) x) x #s(literal 0 binary64))

(fma.f64 (-.f64 z x) #s(literal -1 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x) x)

(fma.f64 (neg.f64 x) (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64))

(fma.f64 (neg.f64 x) (/.f64 z x) x)

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x) #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (neg.f64 z) x)

(fma.f64 #s(literal 1 binary64) (-.f64 x z) #s(literal 0 binary64))

(fma.f64 (/.f64 z x) (neg.f64 x) x)

(fma.f64 #s(literal -1 binary64) (-.f64 z x) #s(literal 0 binary64))

(fma.f64 #s(literal -1 binary64) z x)

(fma.f64 (-.f64 x z) #s(literal 1/2 binary64) (*.f64 (-.f64 x z) #s(literal 1/2 binary64)))

(fma.f64 (-.f64 x z) #s(literal 1 binary64) #s(literal 0 binary64))

(fma.f64 z #s(literal -1 binary64) x)

(fma.f64 x (/.f64 z (neg.f64 x)) x)

(fma.f64 x (/.f64 (-.f64 x z) x) #s(literal 0 binary64))

(-.f64 (neg.f64 z) (neg.f64 x))

(-.f64 (-.f64 x z) #s(literal 0 binary64))

(-.f64 x z)

(+.f64 (*.f64 (-.f64 x z) #s(literal 1/2 binary64)) (*.f64 (-.f64 x z) #s(literal 1/2 binary64)))

(+.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 x z)) (*.f64 #s(literal 1/2 binary64) (-.f64 x z)))

(+.f64 (neg.f64 z) x)

(+.f64 #s(literal 0 binary64) (-.f64 x z))

(+.f64 (-.f64 x z) #s(literal 0 binary64))

(+.f64 x (neg.f64 z))

#s(literal -1 binary64)

(*.f64 (/.f64 (*.f64 (-.f64 x z) x) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64))

(*.f64 (/.f64 (*.f64 (-.f64 z x) x) (+.f64 x x)) #s(literal 2 binary64))

(*.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 8 binary64)) #s(literal 4 binary64))

(*.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 4 binary64)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 z x) #s(literal 2 binary64)) #s(literal 2 binary64))

(*.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal -1 binary64) x))

(*.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal 1 binary64) x))

(*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 1/2 binary64))

(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 z x)))

(*.f64 #s(literal 2 binary64) (/.f64 (-.f64 z x) #s(literal 2 binary64)))

(*.f64 (/.f64 (-.f64 x z) x) (neg.f64 x))

(*.f64 (-.f64 z x) #s(literal 1 binary64))

(*.f64 (neg.f64 x) (/.f64 (-.f64 x z) x))

(*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x)

(*.f64 #s(literal 1 binary64) (-.f64 z x))

(*.f64 #s(literal -1 binary64) (-.f64 x z))

(*.f64 (-.f64 x z) #s(literal -1 binary64))

(*.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(/.f64 (*.f64 x (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (+.f64 x x))

(/.f64 (*.f64 x (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 2 binary64))

(/.f64 (*.f64 x (*.f64 #s(literal -2 binary64) (-.f64 x z))) (+.f64 x x))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) x) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (neg.f64 x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (neg.f64 x)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) x) (+.f64 x x))

(/.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 1 binary64)) #s(literal 2 binary64))

(/.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) x)

(/.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal -1 binary64)) (neg.f64 x))

(/.f64 (/.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64)) (neg.f64 x))

(/.f64 (/.f64 (*.f64 (-.f64 x z) x) #s(literal -1 binary64)) x)

(/.f64 (fma.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64) (*.f64 (*.f64 #s(literal -2 binary64) x) (neg.f64 x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 z x) #s(literal 2 binary64) (*.f64 (*.f64 #s(literal -2 binary64) x) x)) (+.f64 x x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) x (*.f64 (*.f64 z x) #s(literal 2 binary64))) (+.f64 x x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64) (*.f64 (+.f64 z z) #s(literal 2 binary64))) #s(literal 4 binary64))

(/.f64 (fma.f64 (+.f64 z z) #s(literal 2 binary64) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64))) #s(literal 4 binary64))

(/.f64 (fma.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64) (*.f64 (neg.f64 x) (*.f64 #s(literal -2 binary64) x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 z x) #s(literal 2 binary64) (*.f64 x (*.f64 #s(literal -2 binary64) x))) (+.f64 x x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) (neg.f64 x) (*.f64 #s(literal 2 binary64) (*.f64 (neg.f64 z) x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) x (*.f64 #s(literal 2 binary64) (*.f64 z x))) (+.f64 x x))

(/.f64 (fma.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (+.f64 z z))) #s(literal 4 binary64))

(/.f64 (fma.f64 (+.f64 z z) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x))) #s(literal 4 binary64))

(/.f64 (-.f64 (*.f64 (*.f64 (neg.f64 z) x) #s(literal 2 binary64)) (*.f64 (neg.f64 x) (+.f64 x x))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (-.f64 (*.f64 (*.f64 z x) #s(literal 2 binary64)) (*.f64 x (+.f64 x x))) (+.f64 x x))

(/.f64 (-.f64 (*.f64 (+.f64 z z) #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (+.f64 x x))) #s(literal 4 binary64))

(/.f64 (*.f64 (+.f64 x x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (+.f64 x x)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (+.f64 x x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (-.f64 z x) (*.f64 #s(literal -2 binary64) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal -2 binary64) x)) #s(literal -2 binary64))

(/.f64 (*.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -2 binary64)) #s(literal -4 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 z x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 (/.f64 z x) #s(literal 1 binary64))) #s(literal -2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) x) (-.f64 x z)) (+.f64 x x))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) (+.f64 x x)) #s(literal 4 binary64))

(/.f64 (*.f64 (-.f64 z x) (+.f64 x x)) (+.f64 x x))

(/.f64 (*.f64 (-.f64 x z) (+.f64 x x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 (-.f64 x z) x)) (+.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 (-.f64 z x) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal -4 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 x z) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 z x) x)) (+.f64 x x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal 4 binary64))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal -2 binary64))

(/.f64 (*.f64 (+.f64 x x) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 4 binary64))

(/.f64 (*.f64 (+.f64 x x) (-.f64 z x)) (+.f64 x x))

(/.f64 (*.f64 (+.f64 x x) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) #s(literal 2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) #s(literal 2 binary64)) (+.f64 x x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64)) #s(literal 4 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -1 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) #s(literal -2 binary64)) (+.f64 x x))

(/.f64 (*.f64 (-.f64 z x) #s(literal -2 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 z x)) #s(literal -2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (+.f64 x x)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (-.f64 x z) x) (neg.f64 x))

(/.f64 (*.f64 (-.f64 z x) x) x)

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal -2 binary64))

(/.f64 (-.f64 z x) #s(literal 1 binary64))

(/.f64 (-.f64 x z) #s(literal -1 binary64))

(neg.f64 (-.f64 x z))

(fma.f64 (/.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 8 binary64)) #s(literal 4 binary64) z)

(fma.f64 (/.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 4 binary64)) #s(literal 2 binary64) z)

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (*.f64 (-.f64 z x) x) (+.f64 x x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 8 binary64)) #s(literal 4 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 4 binary64)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 z x) #s(literal 2 binary64)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal -1 binary64) x) #s(literal 0 binary64))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 1/2 binary64) #s(literal 0 binary64))

(fma.f64 #s(literal 1/2 binary64) (-.f64 z x) (*.f64 #s(literal 1/2 binary64) (-.f64 z x)))

(fma.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 1/2 binary64) z)

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (neg.f64 x)) z)

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 z x)) #s(literal 0 binary64))

(fma.f64 #s(literal 2 binary64) (/.f64 (neg.f64 x) #s(literal 2 binary64)) z)

(fma.f64 #s(literal 2 binary64) (/.f64 (-.f64 z x) #s(literal 2 binary64)) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 x z) x) (neg.f64 x) #s(literal 0 binary64))

(fma.f64 (-.f64 z x) #s(literal 1/2 binary64) (*.f64 (-.f64 z x) #s(literal 1/2 binary64)))

(fma.f64 (-.f64 z x) #s(literal 1 binary64) #s(literal 0 binary64))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 x z) x) #s(literal 0 binary64))

(fma.f64 (neg.f64 x) #s(literal 1 binary64) z)

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (-.f64 z x) #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (neg.f64 x) z)

(fma.f64 #s(literal -1 binary64) (-.f64 x z) #s(literal 0 binary64))

(fma.f64 #s(literal -1 binary64) x z)

(fma.f64 (-.f64 x z) #s(literal -1 binary64) #s(literal 0 binary64))

(fma.f64 x (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64))

(fma.f64 x #s(literal -1 binary64) z)

(-.f64 (-.f64 z x) #s(literal 0 binary64))

(-.f64 (neg.f64 x) (-.f64 (neg.f64 z) #s(literal 0 binary64)))

(-.f64 (neg.f64 x) (neg.f64 z))

(-.f64 z (-.f64 x #s(literal 0 binary64)))

(-.f64 z x)

(+.f64 (*.f64 (-.f64 z x) #s(literal 1/2 binary64)) (*.f64 (-.f64 z x) #s(literal 1/2 binary64)))

(+.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 z x)) (*.f64 #s(literal 1/2 binary64) (-.f64 z x)))

(+.f64 (-.f64 z x) #s(literal 0 binary64))

(+.f64 (neg.f64 x) z)

(+.f64 #s(literal 0 binary64) (-.f64 z x))

(+.f64 z (+.f64 (neg.f64 x) #s(literal 0 binary64)))

(+.f64 z (+.f64 #s(literal 0 binary64) (neg.f64 x)))

(+.f64 z (-.f64 #s(literal 0 binary64) x))

(+.f64 z (neg.f64 x))

(*.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64))

(*.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64))

(*.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x))

(*.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x)

(*.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x)

(*.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x))

(*.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64))

(*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)))

(*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64))

(*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)))

(*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z))

(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(*.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64))

(*.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x))

(*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x))

(*.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)))

(*.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x))

(*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64))

(*.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(*.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x))

(*.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x))

(*.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x))

(*.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) #s(literal -2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) #s(literal 2 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (/.f64 (-.f64 x z) x)) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (/.f64 (-.f64 x z) x)) #s(literal -2 binary64))

(/.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1 binary64)) #s(literal 2 binary64))

(/.f64 (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (neg.f64 x)) #s(literal 2 binary64))

(/.f64 (/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) x) #s(literal 2 binary64))

(/.f64 (-.f64 #s(literal 2 binary64) (/.f64 (+.f64 z z) x)) #s(literal -2 binary64))

(/.f64 (-.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 2 binary64))

(/.f64 (-.f64 (*.f64 (/.f64 z x) #s(literal -2 binary64)) #s(literal -2 binary64)) #s(literal -2 binary64))

(/.f64 (fma.f64 (neg.f64 z) #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) x)) (+.f64 x x))

(/.f64 (fma.f64 #s(literal -2 binary64) x (*.f64 (neg.f64 z) #s(literal -2 binary64))) (+.f64 x x))

(/.f64 (fma.f64 z #s(literal -2 binary64) (+.f64 x x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (+.f64 #s(literal 2 binary64) (*.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64))) #s(literal -2 binary64))

(/.f64 (+.f64 #s(literal -2 binary64) (*.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64))) #s(literal 2 binary64))

(/.f64 (fma.f64 #s(literal 2 binary64) x (*.f64 z #s(literal -2 binary64))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (fma.f64 (/.f64 z x) #s(literal -2 binary64) #s(literal 2 binary64)) #s(literal -2 binary64))

(/.f64 (fma.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64) #s(literal 2 binary64)) #s(literal -2 binary64))

(/.f64 (fma.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64) #s(literal -2 binary64)) #s(literal 2 binary64))

(/.f64 (+.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (/.f64 z (neg.f64 x)))) #s(literal -2 binary64))

(/.f64 (+.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (/.f64 z (neg.f64 x)))) #s(literal 2 binary64))

(/.f64 (-.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 4 binary64))

(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 0 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (-.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (+.f64 x x) #s(literal 0 binary64))) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (*.f64 x #s(literal 0 binary64))) (+.f64 x x))

(/.f64 (-.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) (*.f64 (neg.f64 x) #s(literal 0 binary64))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (-.f64 (*.f64 (neg.f64 z) #s(literal -2 binary64)) (+.f64 x x)) (+.f64 x x))

(/.f64 (-.f64 (*.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (-.f64 (*.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64)) #s(literal -2 binary64))

(/.f64 (-.f64 (*.f64 z #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (-.f64 (+.f64 x x) (*.f64 #s(literal -2 binary64) (neg.f64 z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (-.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (/.f64 z x))) #s(literal 2 binary64))

(/.f64 (-.f64 (*.f64 #s(literal -2 binary64) x) (*.f64 #s(literal -2 binary64) z)) (+.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) #s(literal -2 binary64))

(/.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal -2 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -2 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -2 binary64)) (*.f64 (+.f64 x x) #s(literal -2 binary64)))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) (+.f64 x x)))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 #s(literal -2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal -2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) #s(literal -1 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal -2 binary64)) #s(literal -4 binary64))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal -1 binary64)) #s(literal -2 binary64))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal -2 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal -2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal -2 binary64)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64)) (*.f64 (+.f64 x x) #s(literal -2 binary64)))

(/.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 1 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 z x) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -2 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal -4 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 z x)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 4 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) (+.f64 x x)))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -1 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal -2 binary64))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 #s(literal 2 binary64) (-.f64 x z))) (+.f64 x x))

(/.f64 (neg.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64))) #s(literal -2 binary64))

(/.f64 (*.f64 (-.f64 x z) x) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (-.f64 x z) x) (*.f64 x (neg.f64 x)))

(/.f64 (*.f64 (-.f64 z x) x) (*.f64 (neg.f64 x) (neg.f64 x)))

(/.f64 (*.f64 (-.f64 z x) x) (*.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (+.f64 x x))

(/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64))

(/.f64 (-.f64 z x) x)

(/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64))

(/.f64 (-.f64 x z) (neg.f64 x))

(neg.f64 (/.f64 (-.f64 x z) x))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 8 binary64)) #s(literal 4 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 4 binary64)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (-.f64 z x) (+.f64 x x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (-.f64 x z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64) #s(literal -1 binary64))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64) #s(literal -1 binary64))

(fma.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) #s(literal -1 binary64))

(fma.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64) #s(literal -1 binary64))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (neg.f64 x) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) x #s(literal 0 binary64))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) x #s(literal 0 binary64))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (/.f64 (-.f64 x z) x) x) (neg.f64 x) #s(literal 0 binary64))

(fma.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 0 binary64))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (+.f64 x x)) #s(literal 0 binary64))

(fma.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x) #s(literal -1 binary64))

(fma.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (fma.f64 #s(literal 2 binary64) (/.f64 z x) #s(literal -2 binary64)) #s(literal 1/2 binary64) #s(literal 0 binary64))

(fma.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) x)) #s(literal 0 binary64))

(fma.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64) #s(literal -1 binary64))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z) #s(literal -1 binary64))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 x z) #s(literal 0 binary64))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)) #s(literal -1 binary64))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) #s(literal 0 binary64))

(fma.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 (-.f64 x z) x) #s(literal -1 binary64) #s(literal 0 binary64))

(fma.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (-.f64 z x) (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 z x) #s(literal 0 binary64))

(fma.f64 (/.f64 #s(literal 1 binary64) x) z #s(literal -1 binary64))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 x)) #s(literal 0 binary64))

(fma.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (neg.f64 x) (/.f64 (/.f64 (-.f64 x z) x) x) #s(literal 0 binary64))

(fma.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1/2 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1/2 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 #s(literal 1 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (/.f64 z x) #s(literal -1 binary64))

(fma.f64 (/.f64 z x) #s(literal 1 binary64) #s(literal -1 binary64))

(fma.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)) #s(literal -1 binary64))

(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 x z) x) #s(literal 0 binary64))

(fma.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 (-.f64 x z) (/.f64 #s(literal -1 binary64) x) #s(literal 0 binary64))

(fma.f64 z (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64))

(fma.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 x (/.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) x) #s(literal 0 binary64))

(fma.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(fma.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(fma.f64 x (/.f64 (/.f64 (-.f64 x z) x) (neg.f64 x)) #s(literal 0 binary64))

(-.f64 (-.f64 (/.f64 z x) #s(literal 1/2 binary64)) #s(literal 1/2 binary64))

(-.f64 (-.f64 (/.f64 z x) #s(literal 0 binary64)) #s(literal 1 binary64))

(-.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64))

(-.f64 (/.f64 z x) #s(literal 1 binary64))

(-.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)))

(+.f64 (-.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))

(+.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 1/2 binary64)))

(+.f64 (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(+.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(+.f64 (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(+.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(+.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64)))

(+.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (-.f64 x z) x)))

(+.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (-.f64 (/.f64 z x) #s(literal 1 binary64))))

(+.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) #s(literal 0 binary64))

(+.f64 (/.f64 z x) #s(literal -1 binary64))

(+.f64 #s(literal -1 binary64) (-.f64 (/.f64 z x) #s(literal 0 binary64)))

(+.f64 #s(literal -1 binary64) (+.f64 #s(literal 0 binary64) (/.f64 z x)))

(+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 z (neg.f64 x))))

(+.f64 #s(literal -1 binary64) (/.f64 z x))

(*.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64))

(*.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64))

(*.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64))

(*.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64))

(*.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x))

(*.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64))

(*.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z))

(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)))

(*.f64 (/.f64 #s(literal 1 binary64) x) z)

(*.f64 #s(literal 1 binary64) (/.f64 z x))

(*.f64 (/.f64 z x) #s(literal 1 binary64))

(*.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)))

(*.f64 z (/.f64 #s(literal 1 binary64) x))

(/.f64 (*.f64 (/.f64 #s(literal 2 binary64) x) z) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (neg.f64 z)) (+.f64 x x))

(/.f64 (*.f64 #s(literal -2 binary64) (/.f64 z x)) #s(literal -2 binary64))

(/.f64 (*.f64 (/.f64 #s(literal 2 binary64) x) (+.f64 z z)) #s(literal 4 binary64))

(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 z z)) #s(literal -2 binary64))

(/.f64 (*.f64 (+.f64 z z) (/.f64 #s(literal 2 binary64) x)) #s(literal 4 binary64))

(/.f64 (*.f64 (+.f64 z z) (/.f64 #s(literal -1 binary64) x)) #s(literal -2 binary64))

(/.f64 (*.f64 (+.f64 z z) #s(literal -2 binary64)) (*.f64 #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) x)))

(/.f64 (*.f64 #s(literal -1 binary64) (+.f64 z z)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 (+.f64 z z) #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (+.f64 x x)))

(/.f64 (*.f64 (+.f64 z z) (/.f64 #s(literal 1 binary64) x)) #s(literal 2 binary64))

(/.f64 (*.f64 (+.f64 z z) #s(literal -1 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 z #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal -2 binary64) (/.f64 z (neg.f64 x))) #s(literal 2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) z) (*.f64 #s(literal -2 binary64) x))

(/.f64 (*.f64 #s(literal 2 binary64) (/.f64 z (neg.f64 x))) #s(literal -2 binary64))

(/.f64 (*.f64 #s(literal -2 binary64) (+.f64 z z)) (*.f64 (*.f64 #s(literal -2 binary64) x) #s(literal 2 binary64)))

(/.f64 (*.f64 #s(literal 2 binary64) (+.f64 z z)) (*.f64 (+.f64 x x) #s(literal 2 binary64)))

(/.f64 (neg.f64 z) (neg.f64 x))

(/.f64 (/.f64 (+.f64 z z) x) #s(literal 2 binary64))

(/.f64 (neg.f64 (+.f64 z z)) (*.f64 #s(literal -2 binary64) x))

(/.f64 (+.f64 z z) (+.f64 x x))

(/.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64))

(/.f64 (/.f64 z x) #s(literal 1 binary64))

(/.f64 z x)

(neg.f64 (/.f64 z (neg.f64 x)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal -2 binary64)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (/.f64 z (neg.f64 x)) #s(literal 2 binary64)) #s(literal -2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (neg.f64 z) (*.f64 #s(literal -2 binary64) x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 z (+.f64 x x)) #s(literal 2 binary64) #s(literal 0 binary64))

(fma.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (neg.f64 z) (/.f64 #s(literal -1 binary64) x) #s(literal 0 binary64))

(fma.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 z (neg.f64 x)) #s(literal -1 binary64) #s(literal 0 binary64))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 z) #s(literal 0 binary64))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 z x)) #s(literal 0 binary64))

(fma.f64 (/.f64 #s(literal 1 binary64) x) z (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) z (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) z (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) z #s(literal 0 binary64))

(fma.f64 #s(literal 1 binary64) (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (/.f64 z x) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 #s(literal 1 binary64) (/.f64 z x) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (/.f64 z x) #s(literal 0 binary64))

(fma.f64 (/.f64 z x) #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 (/.f64 z x) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 (/.f64 z x) #s(literal 1 binary64) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 (/.f64 z x) #s(literal 1 binary64) #s(literal 0 binary64))

(fma.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (/.f64 z (neg.f64 x)) #s(literal 0 binary64))

(fma.f64 z (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(fma.f64 z (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(fma.f64 z (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(fma.f64 z (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64))

(+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 0 binary64)))

(+.f64 (/.f64 z x) (*.f64 #s(literal 0 binary64) (neg.f64 z)))

(+.f64 (/.f64 z x) (*.f64 (neg.f64 z) #s(literal 0 binary64)))

(+.f64 (/.f64 z x) #s(literal 0 binary64))

z

#s(literal 1 binary64)

(*.f64 (*.f64 (*.f64 t y) (/.f64 (-.f64 x z) x)) x)

(*.f64 (*.f64 (*.f64 t y) (-.f64 (/.f64 z x) #s(literal 1 binary64))) (neg.f64 x))

(*.f64 (*.f64 (*.f64 t y) #s(literal 1 binary64)) (-.f64 x z))

(*.f64 (*.f64 (*.f64 t y) #s(literal -1 binary64)) (-.f64 z x))

(*.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (-.f64 x z))

(*.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (-.f64 x z))

(*.f64 (*.f64 (neg.f64 y) t) (-.f64 z x))

(*.f64 (*.f64 (*.f64 (neg.f64 x) y) t) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(*.f64 (*.f64 (*.f64 (-.f64 z x) t) y) #s(literal -1 binary64))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (/.f64 (-.f64 x z) x) (*.f64 (*.f64 t y) x))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (-.f64 z x) (*.f64 #s(literal -1 binary64) (*.f64 t y)))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 y) t))

(*.f64 (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 t y)))

(*.f64 (*.f64 (-.f64 x z) t) y)

(*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (*.f64 (neg.f64 x) y) t))

(*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) t) y))

(*.f64 #s(literal -1 binary64) (*.f64 (*.f64 (-.f64 z x) t) y))

(*.f64 (-.f64 x z) (*.f64 #s(literal 1 binary64) (*.f64 t y)))

(*.f64 (-.f64 x z) (*.f64 (neg.f64 t) (neg.f64 y)))

(*.f64 (-.f64 x z) (*.f64 (neg.f64 y) (neg.f64 t)))

(*.f64 (-.f64 x z) (*.f64 t y))

(*.f64 (*.f64 (*.f64 t y) x) (/.f64 (-.f64 x z) x))

(*.f64 (*.f64 t y) (-.f64 x z))

(*.f64 (*.f64 (*.f64 (-.f64 x z) t) y) #s(literal 1 binary64))

(*.f64 t (*.f64 (-.f64 x z) y))

(*.f64 (*.f64 (-.f64 x z) y) t)

(*.f64 y (*.f64 (-.f64 x z) t))

(*.f64 x (*.f64 (/.f64 (-.f64 x z) x) (*.f64 t y)))

(/.f64 (*.f64 (*.f64 t y) (*.f64 (-.f64 z x) x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 t y) (*.f64 (-.f64 x z) x)) x)

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (*.f64 t y)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 t y)) x)

(neg.f64 (*.f64 (*.f64 (-.f64 z x) t) y))

(fma.f64 (*.f64 (*.f64 t y) #s(literal 1 binary64)) x (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (*.f64 t y) #s(literal -1 binary64)) (neg.f64 x) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (*.f64 (neg.f64 y) t) #s(literal 1 binary64)) z (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (*.f64 (neg.f64 y) t) #s(literal 1 binary64)) z (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (*.f64 (neg.f64 y) t) #s(literal 1 binary64)) z (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (*.f64 (neg.f64 y) t) #s(literal 1 binary64)) z (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (*.f64 (neg.f64 y) t) #s(literal 1 binary64)) z (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (neg.f64 z) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (neg.f64 z) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (neg.f64 z) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (neg.f64 z) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (neg.f64 t) (neg.f64 y)) (neg.f64 z) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (neg.f64 z) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (neg.f64 z) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (neg.f64 z) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (neg.f64 z) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (neg.f64 y) (neg.f64 t)) (neg.f64 z) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (neg.f64 y) t) z (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (neg.f64 y) t) z (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 y) t) z (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (neg.f64 y) t) z (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (neg.f64 y) t) z (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 t) (neg.f64 y)) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 t) (neg.f64 y)) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 t) (neg.f64 y)) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 t) (neg.f64 y)) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 t) (neg.f64 y)) (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 y) (neg.f64 t)) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 y) (neg.f64 t)) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 y) (neg.f64 t)) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 y) (neg.f64 t)) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (neg.f64 z) (*.f64 (neg.f64 y) (neg.f64 t)) (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (neg.f64 z) (*.f64 t y) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (*.f64 (neg.f64 x) y) t) #s(literal -1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) z) y) #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) z) y) #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) z) y) #s(literal 1 binary64) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) z) y) #s(literal 1 binary64) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) z) y) #s(literal 1 binary64) (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 y) (*.f64 (neg.f64 t) x) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (neg.f64 y) (*.f64 t z) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (neg.f64 x) y) (neg.f64 t) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (neg.f64 t) z) y (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 x) y) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (neg.f64 t) (*.f64 z y) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 (neg.f64 z) y) t (*.f64 (*.f64 t y) x))

(fma.f64 (neg.f64 x) (*.f64 #s(literal -1 binary64) (*.f64 t y)) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 t z) (neg.f64 y) (*.f64 (*.f64 t y) x))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 t y) x))

(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 t y) x) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 (neg.f64 x) y) t) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 t x) y (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 (*.f64 t y) x) #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 t y) (neg.f64 z) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 t y) x (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 t (*.f64 (neg.f64 z) y) (*.f64 (*.f64 t y) x))

(fma.f64 t (*.f64 y x) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 (*.f64 z y) (neg.f64 t) (*.f64 (*.f64 t y) x))

(fma.f64 z (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 y) t)) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 z (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 y) t)) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 z (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 y) t)) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 z (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 y) t)) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 z (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 y) t)) (*.f64 (*.f64 t y) x))

(fma.f64 z (*.f64 (neg.f64 y) t) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 z (*.f64 (neg.f64 y) t) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 z (*.f64 (neg.f64 y) t) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 z (*.f64 (neg.f64 y) t) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 z (*.f64 (neg.f64 y) t) (*.f64 (*.f64 t y) x))

(fma.f64 (*.f64 y x) t (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(fma.f64 y (*.f64 (neg.f64 t) z) (*.f64 (*.f64 t y) x))

(fma.f64 y (*.f64 t x) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 x (*.f64 #s(literal 1 binary64) (*.f64 t y)) (*.f64 (*.f64 (neg.f64 t) z) y))

(fma.f64 x (*.f64 t y) (*.f64 (*.f64 (neg.f64 t) z) y))

(-.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 (neg.f64 x) y) t))

(-.f64 (*.f64 (*.f64 t y) x) (*.f64 (*.f64 t z) y))

(+.f64 (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)) (*.f64 (*.f64 (neg.f64 t) z) y))

(+.f64 (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)) (*.f64 (*.f64 (neg.f64 t) z) y))

(+.f64 (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)) (*.f64 (*.f64 (neg.f64 t) z) y))

(+.f64 (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)) (*.f64 (*.f64 (neg.f64 t) z) y))

(+.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 (neg.f64 t) x) (neg.f64 y)))

(+.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 (neg.f64 x) y) (neg.f64 t)))

(+.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (neg.f64 t) (*.f64 (neg.f64 x) y)))

(+.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (neg.f64 y) (*.f64 (neg.f64 t) x)))

(+.f64 (*.f64 (*.f64 (neg.f64 t) z) y) (*.f64 (*.f64 t y) x))

(+.f64 (*.f64 (*.f64 t y) x) (*.f64 (*.f64 (neg.f64 t) z) y))

(*.f64 (*.f64 (neg.f64 t) (/.f64 (-.f64 x z) x)) (neg.f64 x))

(*.f64 (*.f64 (neg.f64 t) (-.f64 (/.f64 z x) #s(literal 1 binary64))) x)

(*.f64 (*.f64 (neg.f64 t) #s(literal 1 binary64)) (-.f64 z x))

(*.f64 (*.f64 (neg.f64 t) #s(literal -1 binary64)) (-.f64 x z))

(*.f64 (*.f64 t (/.f64 (-.f64 x z) x)) x)

(*.f64 (*.f64 t (-.f64 (/.f64 z x) #s(literal 1 binary64))) (neg.f64 x))

(*.f64 (*.f64 t #s(literal 1 binary64)) (-.f64 x z))

(*.f64 (*.f64 (neg.f64 t) x) (-.f64 (/.f64 z x) #s(literal 1 binary64)))

(*.f64 (neg.f64 t) (-.f64 z x))

(*.f64 (/.f64 (-.f64 x z) x) (*.f64 t x))

(*.f64 (*.f64 (-.f64 z x) t) #s(literal -1 binary64))

(*.f64 (-.f64 z x) (neg.f64 t))

(*.f64 (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) t))

(*.f64 (neg.f64 x) (*.f64 (/.f64 (-.f64 x z) x) (neg.f64 t)))

(*.f64 (*.f64 (-.f64 x z) t) #s(literal 1 binary64))

(*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (neg.f64 t) x))

(*.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) t))

(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 z x) t))

(*.f64 (*.f64 t x) (/.f64 (-.f64 x z) x))

(*.f64 (-.f64 x z) (*.f64 #s(literal 1 binary64) t))

(*.f64 (-.f64 x z) (*.f64 #s(literal -1 binary64) (neg.f64 t)))

(*.f64 (-.f64 x z) t)

(*.f64 t (-.f64 x z))

(*.f64 x (*.f64 (/.f64 (-.f64 x z) x) t))

(*.f64 x (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 t)))

(/.f64 (*.f64 (neg.f64 t) (*.f64 #s(literal -2 binary64) (-.f64 x z))) #s(literal 2 binary64))

(/.f64 (*.f64 (neg.f64 t) (*.f64 (-.f64 z x) x)) x)

(/.f64 (*.f64 (neg.f64 t) (*.f64 (-.f64 x z) x)) (neg.f64 x))

(/.f64 (*.f64 t (*.f64 (-.f64 x z) x)) x)

(/.f64 (*.f64 t (*.f64 (-.f64 z x) x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (-.f64 x z)) (neg.f64 t)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) t) x)

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) t) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (neg.f64 t)) x)

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 t)) (neg.f64 x))

(neg.f64 (*.f64 (-.f64 z x) t))

(fma.f64 (*.f64 (neg.f64 t) (/.f64 (-.f64 x z) x)) (neg.f64 x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (neg.f64 t) (/.f64 (-.f64 x z) x)) (neg.f64 x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) (-.f64 (/.f64 z x) #s(literal 1 binary64))) x (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (neg.f64 t) (-.f64 (/.f64 z x) #s(literal 1 binary64))) x (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) #s(literal 1 binary64)) (-.f64 z x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (neg.f64 t) #s(literal 1 binary64)) (-.f64 z x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) #s(literal 1 binary64)) z (*.f64 t x))

(fma.f64 (*.f64 (neg.f64 t) #s(literal -1 binary64)) (-.f64 x z) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (neg.f64 t) #s(literal -1 binary64)) (-.f64 x z) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t (/.f64 (-.f64 x z) x)) x (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 t (/.f64 (-.f64 x z) x)) x (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t (-.f64 (/.f64 z x) #s(literal 1 binary64))) (neg.f64 x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 t (-.f64 (/.f64 z x) #s(literal 1 binary64))) (neg.f64 x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t #s(literal 1 binary64)) (-.f64 x z) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 t #s(literal 1 binary64)) (-.f64 x z) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t #s(literal 1 binary64)) x (*.f64 (neg.f64 t) z))

(fma.f64 (neg.f64 z) t (*.f64 t x))

(fma.f64 (*.f64 (neg.f64 t) x) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 (neg.f64 t) x) #s(literal -1 binary64) (*.f64 (neg.f64 t) z))

(fma.f64 (*.f64 (neg.f64 t) z) #s(literal 1 binary64) (*.f64 t x))

(fma.f64 (neg.f64 t) (-.f64 z x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (neg.f64 t) (-.f64 z x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (neg.f64 t) (neg.f64 x) (*.f64 (neg.f64 t) z))

(fma.f64 (neg.f64 t) z (*.f64 t x))

(fma.f64 (/.f64 (-.f64 x z) x) (*.f64 t x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) x) (*.f64 t x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 (-.f64 z x) t) #s(literal -1 binary64) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) t) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (-.f64 z x) (neg.f64 t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) (neg.f64 t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (neg.f64 x) (*.f64 (/.f64 (-.f64 x z) x) (neg.f64 t)) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (*.f64 (/.f64 (-.f64 x z) x) (neg.f64 t)) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (neg.f64 x) (neg.f64 t) (*.f64 (neg.f64 t) z))

(fma.f64 (*.f64 (-.f64 x z) t) #s(literal 1 binary64) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 x z) t) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (neg.f64 t) x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (*.f64 (neg.f64 t) x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 #s(literal 1 binary64) (*.f64 (neg.f64 t) z) (*.f64 t x))

(fma.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 #s(literal 1 binary64) (*.f64 t x) (*.f64 (neg.f64 t) z))

(fma.f64 #s(literal -1 binary64) (*.f64 (neg.f64 t) x) (*.f64 (neg.f64 t) z))

(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 z x) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (*.f64 (-.f64 z x) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t x) (/.f64 (-.f64 x z) x) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (*.f64 t x) (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (*.f64 t x) #s(literal 1 binary64) (*.f64 (neg.f64 t) z))

(fma.f64 (-.f64 x z) (*.f64 #s(literal 1 binary64) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) (*.f64 #s(literal 1 binary64) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (-.f64 x z) (*.f64 #s(literal -1 binary64) (neg.f64 t)) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) (*.f64 #s(literal -1 binary64) (neg.f64 t)) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 (-.f64 x z) t (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) t (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 t (neg.f64 z) (*.f64 t x))

(fma.f64 t (-.f64 x z) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 t (-.f64 x z) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 t x (*.f64 (neg.f64 t) z))

(fma.f64 z (neg.f64 t) (*.f64 t x))

(fma.f64 x (*.f64 (/.f64 (-.f64 x z) x) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 x (*.f64 (/.f64 (-.f64 x z) x) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 x (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 t)) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(fma.f64 x (*.f64 (-.f64 (/.f64 z x) #s(literal 1 binary64)) (neg.f64 t)) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(fma.f64 x (*.f64 #s(literal 1 binary64) t) (*.f64 (neg.f64 t) z))

(fma.f64 x t (*.f64 (neg.f64 t) z))

(-.f64 (*.f64 (neg.f64 t) z) (*.f64 (neg.f64 t) x))

(-.f64 (*.f64 t x) (*.f64 t z))

(+.f64 (*.f64 (neg.f64 t) z) (*.f64 t x))

(+.f64 (*.f64 (-.f64 x z) t) (*.f64 (neg.f64 t) #s(literal 0 binary64)))

(+.f64 (*.f64 (-.f64 x z) t) (*.f64 #s(literal 0 binary64) (neg.f64 t)))

(+.f64 (*.f64 t x) (*.f64 (neg.f64 t) z))

(*.f64 (*.f64 t #s(literal 1 binary64)) z)

(*.f64 (neg.f64 z) (neg.f64 t))

(*.f64 (neg.f64 t) (neg.f64 z))

(*.f64 (*.f64 t z) #s(literal 1 binary64))

(*.f64 #s(literal 1 binary64) (*.f64 t z))

(*.f64 t z)

(*.f64 z (*.f64 #s(literal 1 binary64) t))

(*.f64 z t)

(/.f64 (*.f64 t (+.f64 z z)) #s(literal 2 binary64))

(/.f64 (*.f64 (+.f64 z z) t) #s(literal 2 binary64))

(neg.f64 (*.f64 (neg.f64 t) z))

(fma.f64 (*.f64 t #s(literal 1 binary64)) z (*.f64 t #s(literal 0 binary64)))

(fma.f64 (*.f64 t #s(literal 1 binary64)) z (*.f64 #s(literal 0 binary64) t))

(fma.f64 (neg.f64 z) (neg.f64 t) (*.f64 t #s(literal 0 binary64)))

(fma.f64 (neg.f64 z) (neg.f64 t) (*.f64 #s(literal 0 binary64) t))

(fma.f64 (neg.f64 t) (neg.f64 z) (*.f64 t #s(literal 0 binary64)))

(fma.f64 (neg.f64 t) (neg.f64 z) (*.f64 #s(literal 0 binary64) t))

(fma.f64 (*.f64 t z) #s(literal 1 binary64) (*.f64 t #s(literal 0 binary64)))

(fma.f64 (*.f64 t z) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) t))

(fma.f64 #s(literal 1 binary64) (*.f64 t z) (*.f64 t #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (*.f64 t z) (*.f64 #s(literal 0 binary64) t))

(fma.f64 t z (*.f64 t #s(literal 0 binary64)))

(fma.f64 t z (*.f64 #s(literal 0 binary64) t))

(fma.f64 z (*.f64 #s(literal 1 binary64) t) (*.f64 t #s(literal 0 binary64)))

(fma.f64 z (*.f64 #s(literal 1 binary64) t) (*.f64 #s(literal 0 binary64) t))

(fma.f64 z t (*.f64 t #s(literal 0 binary64)))

(fma.f64 z t (*.f64 #s(literal 0 binary64) t))

(+.f64 (*.f64 t z) (*.f64 t #s(literal 0 binary64)))

(+.f64 (*.f64 t z) (*.f64 #s(literal 0 binary64) t))

(*.f64 (*.f64 #s(approx (- x z) (/.f64 (*.f64 (-.f64 x z) x) x)) t) y)

(*.f64 #s(approx (- x z) (/.f64 (*.f64 (-.f64 x z) x) x)) t)

#s(approx (- x z) (/.f64 (*.f64 (-.f64 x z) x) x))

(/.f64 (*.f64 (-.f64 x z) x) x)

(*.f64 (-.f64 x z) x)

(-.f64 x z)

x

z

t

y

(*.f64 (/.f64 (-.f64 x z) x) (*.f64 (*.f64 t y) x))

(/.f64 (-.f64 x z) x)

(*.f64 (*.f64 t y) x)

(*.f64 t y)

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 t y)) x)

(*.f64 (*.f64 (-.f64 x z) x) (*.f64 t y))

(*.f64 (*.f64 y #s(approx (- x z) (-.f64 x z))) t)

(*.f64 (*.f64 y t) #s(approx (- x z) (-.f64 x z)))

(*.f64 y (*.f64 t #s(approx (- x z) (-.f64 x z))))

(*.f64 (*.f64 t #s(approx (- x z) (-.f64 x z))) y)

(*.f64 t (*.f64 y #s(approx (- x z) (-.f64 x z))))

(*.f64 #s(approx (- x z) (-.f64 x z)) (*.f64 y t))

(*.f64 t #s(approx (- x z) (-.f64 x z)))

(*.f64 #s(approx (- x z) (-.f64 x z)) t)

#s(approx (- x z) (-.f64 x z))

(*.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)))

(*.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)))

(*.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x))

(*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)))

(*.f64 (/.f64 (-.f64 z x) x) (neg.f64 x))

(*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x))

(*.f64 #s(literal -1 binary64) (-.f64 z x))

(*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x))

(*.f64 #s(literal 1 binary64) (-.f64 x z))

(*.f64 (-.f64 z x) #s(literal -1 binary64))

(*.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x))

(*.f64 (neg.f64 x) (/.f64 (-.f64 z x) x))

(*.f64 (/.f64 (-.f64 x z) x) x)

(*.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x))

(*.f64 (-.f64 x z) #s(literal 1 binary64))

(*.f64 x (/.f64 (-.f64 x z) x))

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x))) (neg.f64 x))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) (*.f64 (neg.f64 x) x)) (neg.f64 x))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) (*.f64 x x)) x)

(/.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) x)) x)

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) x)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 z x) x)) (*.f64 x x))

(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (neg.f64 x) x) (/.f64 (-.f64 x z) x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 x x) (/.f64 (-.f64 x z) x)) x)

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (/.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) x) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (neg.f64 x)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 x z) x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (-.f64 z x) x)) x)

(/.f64 (*.f64 x (*.f64 (-.f64 z x) x)) (*.f64 (neg.f64 x) x))

(/.f64 (fma.f64 (*.f64 (neg.f64 x) x) x (*.f64 (*.f64 (neg.f64 z) x) (neg.f64 x))) (*.f64 (neg.f64 x) x))

(/.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (fma.f64 (*.f64 (neg.f64 x) x) x (*.f64 (neg.f64 x) (*.f64 (neg.f64 z) x))) (*.f64 (neg.f64 x) x))

(/.f64 (fma.f64 (*.f64 x x) x (*.f64 x (*.f64 (neg.f64 z) x))) (*.f64 x x))

(/.f64 (neg.f64 (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (*.f64 x x))

(/.f64 (*.f64 (-.f64 z x) x) (neg.f64 x))

(/.f64 (*.f64 (-.f64 x z) x) x)

(/.f64 (-.f64 x z) #s(literal 1 binary64))

(neg.f64 (-.f64 z x))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x) x)

(fma.f64 (*.f64 (neg.f64 z) x) (/.f64 #s(literal 1 binary64) x) x)

(fma.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (-.f64 z x) x) (neg.f64 x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) x) (neg.f64 x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (neg.f64 z) x) x x)

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 #s(literal -1 binary64) (-.f64 z x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (-.f64 z x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 z) #s(literal 1 binary64) x)

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x) x)

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 #s(literal 1 binary64) (neg.f64 z) x)

(fma.f64 #s(literal 1 binary64) (-.f64 x z) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (-.f64 x z) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 z x) (neg.f64 x) x)

(fma.f64 (-.f64 z x) #s(literal -1 binary64) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 x) (/.f64 z x) x)

(fma.f64 (/.f64 (-.f64 x z) x) x (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) x) x (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (-.f64 x z) #s(literal 1 binary64) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 z #s(literal -1 binary64) x)

(fma.f64 x (/.f64 (neg.f64 z) x) x)

(fma.f64 x (/.f64 (-.f64 x z) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(-.f64 (neg.f64 z) (neg.f64 x))

(-.f64 x (*.f64 (*.f64 z x) (/.f64 #s(literal 1 binary64) x)))

(-.f64 x (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 z) x)))

(-.f64 x (*.f64 #s(literal -1 binary64) (neg.f64 z)))

(-.f64 x (*.f64 (neg.f64 x) (/.f64 (neg.f64 z) x)))

(-.f64 x (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(-.f64 x z)

(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)))

(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)))

(+.f64 (*.f64 (neg.f64 x) (/.f64 z x)) x)

(+.f64 (*.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x)) x)

(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x)

(+.f64 (neg.f64 z) x)

(+.f64 (-.f64 x z) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(+.f64 (-.f64 x z) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(+.f64 x (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(+.f64 x (*.f64 (neg.f64 x) (/.f64 z x)))

(+.f64 x (*.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x)))

(+.f64 x (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(+.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)))

(+.f64 x (neg.f64 z))

(*.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (/.f64 #s(literal -1 binary64) x))

(*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) x))

(*.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) x))

(*.f64 (-.f64 z x) (neg.f64 x))

(*.f64 (*.f64 (-.f64 z x) x) #s(literal -1 binary64))

(*.f64 (neg.f64 x) (-.f64 z x))

(*.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64))

(*.f64 (-.f64 x z) x)

(*.f64 x (-.f64 x z))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x))) (neg.f64 x))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) x)) x)

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (-.f64 x z) (*.f64 (neg.f64 x) x)) (neg.f64 x))

(/.f64 (*.f64 (-.f64 x z) (*.f64 x x)) x)

(/.f64 (*.f64 x (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 x (*.f64 (*.f64 (-.f64 x z) x) x)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 z x) x)) x)

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal -1 binary64)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (neg.f64 x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 x z) x)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) #s(literal 1 binary64)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) x)

(/.f64 (*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) x) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) x) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (neg.f64 x) x) (-.f64 x z)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 x x) (-.f64 x z)) x)

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) x) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (neg.f64 x)) x)

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 x z) x)) (neg.f64 x))

(/.f64 (*.f64 x (*.f64 (-.f64 z x) x)) (neg.f64 x))

(/.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) x)

(/.f64 (*.f64 x (*.f64 (-.f64 x z) x)) x)

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) x)

(/.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64))

(neg.f64 (*.f64 (-.f64 z x) x))

(fma.f64 (fabs.f64 (fabs.f64 x)) (fabs.f64 (fabs.f64 x)) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 (fabs.f64 (fabs.f64 x)) (fabs.f64 (fabs.f64 x)) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (fabs.f64 (fabs.f64 x)) (fabs.f64 (fabs.f64 x)) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 (fabs.f64 (fabs.f64 x)) (fabs.f64 (fabs.f64 x)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 (fabs.f64 (fabs.f64 x)) (fabs.f64 (fabs.f64 x)) (*.f64 (neg.f64 z) x))

(fma.f64 (neg.f64 (fabs.f64 x)) (neg.f64 (fabs.f64 x)) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 (neg.f64 (fabs.f64 x)) (neg.f64 (fabs.f64 x)) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (fabs.f64 x)) (neg.f64 (fabs.f64 x)) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (fabs.f64 x)) (neg.f64 (fabs.f64 x)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 (neg.f64 (fabs.f64 x)) (neg.f64 (fabs.f64 x)) (*.f64 (neg.f64 z) x))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (fabs.f64 x) (fabs.f64 x) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 (fabs.f64 x) (fabs.f64 x) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (fabs.f64 x) (fabs.f64 x) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 (fabs.f64 x) (fabs.f64 x) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 (fabs.f64 x) (fabs.f64 x) (*.f64 (neg.f64 z) x))

(fma.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64) (*.f64 x x))

(fma.f64 (*.f64 x x) #s(literal 1 binary64) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 (*.f64 x x) #s(literal 1 binary64) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 x x) #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 (*.f64 x x) #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 (*.f64 x x) #s(literal 1 binary64) (*.f64 (neg.f64 z) x))

(fma.f64 (neg.f64 z) x (*.f64 x x))

(fma.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x) (*.f64 x x))

(fma.f64 #s(literal 1 binary64) (*.f64 x x) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 #s(literal 1 binary64) (*.f64 x x) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 #s(literal 1 binary64) (*.f64 x x) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 #s(literal 1 binary64) (*.f64 x x) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 #s(literal 1 binary64) (*.f64 x x) (*.f64 (neg.f64 z) x))

(fma.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (*.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (-.f64 z x) (neg.f64 x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) (neg.f64 x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (*.f64 (-.f64 z x) x) #s(literal -1 binary64) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) x) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (neg.f64 x) (-.f64 z x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (-.f64 z x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (neg.f64 x) (neg.f64 x) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 (neg.f64 x) (neg.f64 x) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 x) (neg.f64 x) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 (neg.f64 x) (neg.f64 x) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 (neg.f64 x) (neg.f64 x) (*.f64 (neg.f64 z) x))

(fma.f64 (neg.f64 x) z (*.f64 x x))

(fma.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 x z) x) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 (-.f64 x z) x (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) x (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 z (neg.f64 x) (*.f64 x x))

(fma.f64 x (neg.f64 z) (*.f64 x x))

(fma.f64 x (-.f64 x z) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(fma.f64 x (-.f64 x z) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(fma.f64 x x (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(fma.f64 x x (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 x x (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(fma.f64 x x (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(fma.f64 x x (*.f64 (neg.f64 z) x))

(-.f64 (*.f64 (neg.f64 z) x) (*.f64 (neg.f64 x) x))

(-.f64 (*.f64 x x) (*.f64 z x))

(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)) (*.f64 x x))

(+.f64 (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)) (*.f64 x x))

(+.f64 (*.f64 (neg.f64 z) x) (*.f64 x x))

(+.f64 (*.f64 x x) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) x)))

(+.f64 (*.f64 x x) (*.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(+.f64 (*.f64 x x) (*.f64 (*.f64 (neg.f64 z) x) #s(literal 1 binary64)))

(+.f64 (*.f64 x x) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x))

(+.f64 (*.f64 x x) (*.f64 (neg.f64 z) x))

(+.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 (-.f64 x z) x) #s(literal 0 binary64)))

(+.f64 (*.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (*.f64 (-.f64 x z) x)))

(*.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)))

(*.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)))

(*.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x))

(*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)))

(*.f64 (/.f64 (-.f64 z x) x) (neg.f64 x))

(*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x))

(*.f64 #s(literal -1 binary64) (-.f64 z x))

(*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x))

(*.f64 #s(literal 1 binary64) (-.f64 x z))

(*.f64 (-.f64 z x) #s(literal -1 binary64))

(*.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x))

(*.f64 (neg.f64 x) (/.f64 (-.f64 z x) x))

(*.f64 (/.f64 (-.f64 x z) x) x)

(*.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x))

(*.f64 (-.f64 x z) #s(literal 1 binary64))

(*.f64 x (/.f64 (-.f64 x z) x))

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x))) (neg.f64 x))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) (*.f64 (neg.f64 x) x)) (neg.f64 x))

(/.f64 (*.f64 (/.f64 (-.f64 x z) x) (*.f64 x x)) x)

(/.f64 (*.f64 (-.f64 x z) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (-.f64 x z) x) x)) x)

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) x)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 z x) x)) (*.f64 x x))

(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 x z)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (neg.f64 x) x) (/.f64 (-.f64 x z) x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 x x) (/.f64 (-.f64 x z) x)) x)

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (/.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) x) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (neg.f64 x)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (-.f64 x z) x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (-.f64 z x) x)) x)

(/.f64 (*.f64 x (*.f64 (-.f64 z x) x)) (*.f64 (neg.f64 x) x))

(/.f64 (fma.f64 (*.f64 (neg.f64 x) x) x (*.f64 (*.f64 (neg.f64 z) x) (neg.f64 x))) (*.f64 (neg.f64 x) x))

(/.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (fma.f64 (*.f64 (neg.f64 x) x) x (*.f64 (neg.f64 x) (*.f64 (neg.f64 z) x))) (*.f64 (neg.f64 x) x))

(/.f64 (fma.f64 (*.f64 x x) x (*.f64 x (*.f64 (neg.f64 z) x))) (*.f64 x x))

(/.f64 (neg.f64 (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (*.f64 x x))

(/.f64 (*.f64 (-.f64 z x) x) (neg.f64 x))

(/.f64 (*.f64 (-.f64 x z) x) x)

(/.f64 (-.f64 x z) #s(literal 1 binary64))

(neg.f64 (-.f64 z x))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 x (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 x (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (neg.f64 x) #s(literal 1 binary64)) (/.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x) x)

(fma.f64 (*.f64 (neg.f64 z) x) (/.f64 #s(literal 1 binary64) x) x)

(fma.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) x) (/.f64 (neg.f64 x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (-.f64 z x) x) (neg.f64 x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 z x) x) (neg.f64 x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 (neg.f64 z) x) x x)

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 #s(literal -1 binary64) (-.f64 z x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 #s(literal -1 binary64) (-.f64 z x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 z) #s(literal 1 binary64) x)

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x) x)

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 #s(literal 1 binary64) (neg.f64 z) x)

(fma.f64 #s(literal 1 binary64) (-.f64 x z) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 #s(literal 1 binary64) (-.f64 x z) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (/.f64 z x) (neg.f64 x) x)

(fma.f64 (-.f64 z x) #s(literal -1 binary64) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (-.f64 z x) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) x) (/.f64 #s(literal -1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 z x) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (neg.f64 x) (/.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (neg.f64 x) (/.f64 z x) x)

(fma.f64 (/.f64 (-.f64 x z) x) x (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (/.f64 (-.f64 x z) x) x (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 x z) x) (/.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 (-.f64 x z) #s(literal 1 binary64) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 (-.f64 x z) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(fma.f64 z #s(literal -1 binary64) x)

(fma.f64 x (/.f64 (neg.f64 z) x) x)

(fma.f64 x (/.f64 (-.f64 x z) x) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(fma.f64 x (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(-.f64 (neg.f64 z) (neg.f64 x))

(-.f64 x (*.f64 (*.f64 z x) (/.f64 #s(literal 1 binary64) x)))

(-.f64 x (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 z) x)))

(-.f64 x (*.f64 #s(literal -1 binary64) (neg.f64 z)))

(-.f64 x (*.f64 (neg.f64 x) (/.f64 (neg.f64 z) x)))

(-.f64 x (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(-.f64 x z)

(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)))

(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 z x)) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 x) x)))

(+.f64 (*.f64 (neg.f64 x) (/.f64 z x)) x)

(+.f64 (*.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x)) x)

(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) x)

(+.f64 (neg.f64 z) x)

(+.f64 (-.f64 x z) (*.f64 (-.f64 x z) #s(literal 0 binary64)))

(+.f64 (-.f64 x z) (*.f64 #s(literal 0 binary64) (-.f64 x z)))

(+.f64 x (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(+.f64 x (*.f64 (neg.f64 x) (/.f64 z x)))

(+.f64 x (*.f64 (*.f64 z x) (/.f64 #s(literal -1 binary64) x)))

(+.f64 x (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(+.f64 x (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)))

(+.f64 x (neg.f64 z))

x

z

t

y

(*.f64 (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)))

(*.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)))

(*.f64 (/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (/.f64 (*.f64 t x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) y))

(*.f64 (/.f64 (*.f64 (*.f64 (-.f64 z x) t) x) #s(literal 1 binary64)) (/.f64 (neg.f64 y) x))

(*.f64 (/.f64 (*.f64 y x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) t))

(*.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (*.f64 (/.f64 (neg.f64 t) x) y))

(*.f64 (/.f64 (*.f64 t (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 y x))

(*.f64 (/.f64 (*.f64 y (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 t x))

(*.f64 (/.f64 (*.f64 (*.f64 t x) y) #s(literal 1 binary64)) (/.f64 (-.f64 x z) x))

(*.f64 (*.f64 y (-.f64 x z)) t)

(*.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) (*.f64 x x)))

(*.f64 (*.f64 (-.f64 z x) y) (/.f64 (*.f64 t x) (neg.f64 x)))

(*.f64 (*.f64 (-.f64 z x) y) (neg.f64 t))

(*.f64 (*.f64 (-.f64 z x) t) (/.f64 (neg.f64 y) #s(literal 1 binary64)))

(*.f64 (*.f64 (-.f64 z x) t) (neg.f64 y))

(*.f64 (*.f64 (*.f64 (-.f64 z x) y) x) (/.f64 (neg.f64 t) x))

(*.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)))

(*.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (*.f64 (-.f64 z x) x))

(*.f64 (*.f64 (*.f64 (/.f64 (-.f64 z x) x) t) y) (neg.f64 x))

(*.f64 (neg.f64 t) (*.f64 (-.f64 z x) y))

(*.f64 (*.f64 (/.f64 (-.f64 x z) x) y) (/.f64 (*.f64 t x) #s(literal 1 binary64)))

(*.f64 (*.f64 (/.f64 (-.f64 x z) x) y) (*.f64 t x))

(*.f64 (*.f64 (/.f64 (-.f64 x z) x) t) (/.f64 (*.f64 y x) #s(literal 1 binary64)))

(*.f64 (*.f64 (/.f64 (-.f64 x z) x) t) (*.f64 y x))

(*.f64 (*.f64 t (-.f64 x z)) y)

(*.f64 (*.f64 y (*.f64 (-.f64 x z) x)) (/.f64 t x))

(*.f64 (*.f64 t x) (*.f64 (/.f64 (-.f64 x z) x) y))

(*.f64 (*.f64 y t) (-.f64 x z))

(*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 1 binary64))

(*.f64 (/.f64 t x) (/.f64 (*.f64 y (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)))

(*.f64 (/.f64 t x) (*.f64 y (*.f64 (-.f64 x z) x)))

(*.f64 (/.f64 y x) (/.f64 (*.f64 t (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)))

(*.f64 (/.f64 y x) (*.f64 t (*.f64 (-.f64 x z) x)))

(*.f64 (*.f64 (*.f64 (-.f64 z x) t) x) (/.f64 (neg.f64 y) x))

(*.f64 (neg.f64 y) (*.f64 (-.f64 z x) t))

(*.f64 (*.f64 (*.f64 (neg.f64 t) x) y) (/.f64 (-.f64 z x) x))

(*.f64 (/.f64 (-.f64 z x) x) (/.f64 (*.f64 (*.f64 (neg.f64 t) x) y) #s(literal 1 binary64)))

(*.f64 (/.f64 (-.f64 z x) x) (*.f64 (*.f64 (neg.f64 t) x) y))

(*.f64 (*.f64 (*.f64 (-.f64 z x) y) t) #s(literal -1 binary64))

(*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x)))

(*.f64 (*.f64 (neg.f64 t) y) (-.f64 z x))

(*.f64 #s(literal -1 binary64) (*.f64 (*.f64 (-.f64 z x) y) t))

(*.f64 (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x)) x)

(*.f64 (*.f64 t (*.f64 (-.f64 x z) x)) (/.f64 y x))

(*.f64 (*.f64 y x) (*.f64 (/.f64 (-.f64 x z) x) t))

(*.f64 (*.f64 (/.f64 t x) y) (*.f64 (-.f64 x z) x))

(*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)))

(*.f64 #s(literal 1 binary64) (*.f64 (*.f64 y (-.f64 x z)) t))

(*.f64 (-.f64 z x) (*.f64 (neg.f64 t) y))

(*.f64 (*.f64 (-.f64 z x) x) (*.f64 (/.f64 (neg.f64 t) x) y))

(*.f64 (neg.f64 x) (*.f64 (*.f64 (/.f64 (-.f64 z x) x) t) y))

(*.f64 (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x)) (/.f64 #s(literal -1 binary64) x))

(*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) (/.f64 #s(literal 1 binary64) x))

(*.f64 (*.f64 (*.f64 t x) y) (/.f64 (-.f64 x z) x))

(*.f64 (/.f64 (-.f64 x z) x) (/.f64 (*.f64 (*.f64 t x) y) #s(literal 1 binary64)))

(*.f64 (/.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y))

(*.f64 y (*.f64 t (-.f64 x z)))

(*.f64 t (*.f64 y (-.f64 x z)))

(*.f64 (*.f64 (-.f64 x z) x) (*.f64 (/.f64 t x) y))

(*.f64 (-.f64 x z) (*.f64 y t))

(*.f64 x (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x)))

(/.f64 (*.f64 (*.f64 t x) (*.f64 y (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 2 binary64)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x)) (*.f64 (neg.f64 x) x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x)) (*.f64 x x)) x)

(/.f64 (*.f64 (*.f64 y x) (*.f64 t (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x))) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (*.f64 (-.f64 x z) x) x)) x)

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) (neg.f64 x))) (neg.f64 x))

(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x)) x)

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y))) (*.f64 x x))

(/.f64 (*.f64 (*.f64 y t) (*.f64 x (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (*.f64 y t) (*.f64 (*.f64 (-.f64 x z) x) x)) (*.f64 x x))

(/.f64 (*.f64 t (*.f64 (*.f64 y x) (*.f64 (-.f64 x z) x))) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 y x) (*.f64 (-.f64 x z) x)) t) (*.f64 x x))

(/.f64 (*.f64 (*.f64 y (*.f64 (-.f64 x z) x)) (*.f64 t x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 t (*.f64 (-.f64 x z) x)) (*.f64 y x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) #s(literal 1 binary64)) (*.f64 x x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x))) (*.f64 x x))

(/.f64 (*.f64 x (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x))) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (neg.f64 x) (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x))) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 x (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x))) (*.f64 x x))

(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)) #s(literal 2 binary64))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) (neg.f64 x)) (*.f64 (/.f64 t x) y)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (*.f64 (/.f64 t x) y)) x)

(/.f64 (*.f64 (*.f64 x (*.f64 (-.f64 x z) x)) (*.f64 y t)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 x z) x) x) (*.f64 y t)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (neg.f64 x) x) (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x))) (neg.f64 x))

(/.f64 (*.f64 (*.f64 x x) (*.f64 (*.f64 y (-.f64 x z)) (/.f64 t x))) x)

(/.f64 (/.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (/.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) (fabs.f64 x)) (fabs.f64 x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x)) x) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x)) (neg.f64 x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 z x) x) (*.f64 (*.f64 t x) y)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x))) x)

(/.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 z x) x)) (*.f64 (neg.f64 x) x))

(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x))) (*.f64 (neg.f64 x) x))

(/.f64 (neg.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y))) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) (neg.f64 x)) (*.f64 (neg.f64 x) x))

(/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) (*.f64 x x))

(/.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 1 binary64))

(/.f64 (*.f64 (*.f64 (-.f64 z x) y) (*.f64 t x)) (neg.f64 x))

(/.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x)

(neg.f64 (*.f64 (*.f64 (-.f64 z x) y) t))

(fma.f64 (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)) (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (-.f64 x z) x) (fabs.f64 x)) (/.f64 (*.f64 (*.f64 t x) y) (fabs.f64 x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 t x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) y) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 t x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) y) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 z x) t) x) #s(literal 1 binary64)) (/.f64 (neg.f64 y) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 (-.f64 z x) t) x) #s(literal 1 binary64)) (/.f64 (neg.f64 y) x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 y x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) t) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 y x) #s(literal 1 binary64)) (*.f64 (/.f64 (-.f64 x z) x) t) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (*.f64 (/.f64 (neg.f64 t) x) y) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (*.f64 (/.f64 (neg.f64 t) x) y) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 t (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 y x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 t (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 y x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 y (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 t x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 y (*.f64 (-.f64 x z) x)) #s(literal 1 binary64)) (/.f64 t x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (/.f64 (*.f64 (*.f64 t x) y) #s(literal 1 binary64)) (/.f64 (-.f64 x z) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (/.f64 (*.f64 (*.f64 t x) y) #s(literal 1 binary64)) (/.f64 (-.f64 x z) x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 y t) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (neg.f64 t) y) z))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 y t) (neg.f64 z))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) (*.f64 y t))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 t (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 t (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 x (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 x (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t))))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) (*.f64 y t)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 z (*.f64 (neg.f64 t) y)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 y t) (neg.f64 z)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) (*.f64 y t)) #s(literal 1 binary64)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x)) t))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x)) t))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x)) x))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t)) x))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 y t) (neg.f64 z)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (neg.f64 z) (*.f64 y t)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)))

(fma.f64 (neg.f64 (neg.f64 t)) (*.f64 y x) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)))

(fma.f64 (*.f64 y (-.f64 x z)) t (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 y (-.f64 x z)) t (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (*.f64 y (-.f64 x z)) (*.f64 t x)) x) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) (*.f64 (-.f64 x z) x)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 x z) x) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) (*.f64 x x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (-.f64 z x) y) (/.f64 (*.f64 t x) (neg.f64 x)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) y) (/.f64 (*.f64 t x) (neg.f64 x)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (-.f64 z x) y) (neg.f64 t) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) y) (neg.f64 t) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 y (*.f64 x x)) (/.f64 t x) (*.f64 (*.f64 y (*.f64 (neg.f64 z) x)) (/.f64 t x)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) (neg.f64 x)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) z) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) z) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (neg.f64 x)) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 (*.f64 y t) (neg.f64 z)) #s(literal 1 binary64) (*.f64 (*.f64 t x) y))

(fma.f64 (*.f64 t (*.f64 x x)) (/.f64 y x) (*.f64 (*.f64 t (*.f64 (neg.f64 z) x)) (/.f64 y x)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) x) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 (*.f64 (*.f64 t x) y) x) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 (*.f64 y t) (*.f64 x x)) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 y t) (*.f64 (neg.f64 z) x)) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 (*.f64 (neg.f64 t) y) (*.f64 x x)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (*.f64 (neg.f64 t) y) (*.f64 (neg.f64 z) x)) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 (*.f64 x x) y) (/.f64 t x) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) y) (/.f64 t x)))

(fma.f64 (*.f64 (neg.f64 x) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 z (*.f64 (*.f64 t x) y)) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 z (*.f64 (*.f64 t x) y)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (neg.f64 x) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 (neg.f64 z) (*.f64 y t)) #s(literal 1 binary64) (*.f64 (*.f64 t x) y))

(fma.f64 (*.f64 (*.f64 x x) t) (/.f64 y x) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) t) (/.f64 y x)))

(fma.f64 (*.f64 (neg.f64 z) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 x (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 x (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (neg.f64 z) (*.f64 (*.f64 t x) y)) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 (*.f64 x x) (*.f64 y t)) (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) (*.f64 y t)) (/.f64 #s(literal 1 binary64) x)))

(fma.f64 (*.f64 (*.f64 x x) (*.f64 (neg.f64 t) y)) (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (neg.f64 t) y)) (/.f64 #s(literal -1 binary64) x)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 y t) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 t) y) z))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 y t) (neg.f64 z))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) (*.f64 y t))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 t (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 t (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 x (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 x (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t))))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) (*.f64 y t)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 z (*.f64 (neg.f64 t) y)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 y t) (neg.f64 z)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) (*.f64 y t)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x)) t))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x)) t))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x)) x))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t)) x))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 y t) (neg.f64 z)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (neg.f64 z) (*.f64 y t)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)))

(fma.f64 (*.f64 (neg.f64 t) x) (neg.f64 y) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 y t) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 t) y) z))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 y t) (neg.f64 z))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 #s(literal 1 binary64) (*.f64 (neg.f64 z) (*.f64 y t))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 t (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 t (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 x (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 x (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t))))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x)) (*.f64 y t)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 z (*.f64 (neg.f64 t) y)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 y t) (neg.f64 z)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) (*.f64 y t)) #s(literal 1 binary64)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 y x) (/.f64 (neg.f64 z) x)) t))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y x)) t))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 y t) (/.f64 (neg.f64 z) x)) x))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (/.f64 (neg.f64 z) x) (*.f64 y t)) x))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 y t) (neg.f64 z)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (/.f64 t x) y) (*.f64 (neg.f64 z) x)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (*.f64 t x) y) (/.f64 (neg.f64 z) x)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (neg.f64 z) (*.f64 y t)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (*.f64 (neg.f64 z) x) (*.f64 (/.f64 t x) y)))

(fma.f64 (*.f64 (neg.f64 y) x) (neg.f64 t) (*.f64 (/.f64 (neg.f64 z) x) (*.f64 (*.f64 t x) y)))

(fma.f64 (*.f64 (-.f64 z x) t) (/.f64 (neg.f64 y) #s(literal 1 binary64)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) t) (/.f64 (neg.f64 y) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (-.f64 z x) t) (neg.f64 y) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (-.f64 z x) t) (neg.f64 y) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (*.f64 (-.f64 z x) y) x) (/.f64 (neg.f64 t) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (-.f64 z x) y) x) (/.f64 (neg.f64 t) x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (/.f64 (*.f64 (-.f64 z x) x) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (*.f64 (-.f64 z x) x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (/.f64 (neg.f64 t) x) y) (*.f64 (-.f64 z x) x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (*.f64 (*.f64 (/.f64 (-.f64 z x) x) t) y) (neg.f64 x) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (*.f64 (*.f64 (/.f64 (-.f64 z x) x) t) y) (neg.f64 x) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (neg.f64 t) (*.f64 (-.f64 z x) y) (*.f64 (*.f64 (*.f64 y (-.f64 x z)) t) #s(literal 0 binary64)))

(fma.f64 (neg.f64 t) (*.f64 (-.f64 z x) y) (*.f64 #s(literal 0 binary64) (*.f64 (*.f64 y (-.f64 x z)) t)))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 y t) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 z) x))))

(fma.f64 (neg.f64 t) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 (neg.f64 t) y) z))