Linear.V3:$cdot from linear-1.19.1.3, B

Time bar (total: 6.0s)

start0.0ms (0%)

Memory
0.1MiB live, 0.1MiB allocated; 0ms collecting garbage

analyze0.0ms (0%)

Memory
0.3MiB live, 0.3MiB allocated; 0ms collecting garbage
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.7%0.3%0%0%0%0
100%99.7%0%0.3%0%0%0%1
Compiler

Compiled 13 to 13 computations (0% saved)

sample1.2s (19.3%)

Memory
8.9MiB live, 1 376.4MiB allocated; 377ms collecting garbage
Samples
594.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 207.0ms
ival-mult!: 173.0ms (83.7% of total)
ival-add!: 32.0ms (15.5% of total)
adjust: 2.0ms (1% of total)
Bogosity

preprocess54.0ms (0.9%)

Memory
-50.6MiB live, 25.6MiB allocated; 34ms collecting garbage
Iterations

Useful iterations: 3 (0.0ms)

IterNodesCost
089318
1255312
2647310
31163308
41366308
51462308
61505308
Stop Event
1×saturated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶98.8%
(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
Symmetry

(sort x y)

(sort z t)

(sort a b)

Compiler

Compiled 22 to 22 computations (0% saved)

series15.0ms (0.2%)

Memory
40.8MiB live, 40.8MiB allocated; 0ms collecting garbage
Counts
11 → 33
Calls
Call 1
Inputs
(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
(+.f64 (*.f64 x y) (*.f64 z t))
(*.f64 x y)
x
y
(*.f64 z t)
z
t
(*.f64 a b)
a
b
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* t z)))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (* x y) #s(hole binary64 (* x y)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx (* a b) #s(hole binary64 (* a b)))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
Calls

18 calls:

TimeVariablePointExpression
1.0ms
x
@inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* x y) (* z t)) (* x y) x y (* z t) z t (* a b) a b)
1.0ms
x
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* x y) (* z t)) (* x y) x y (* z t) z t (* a b) a b)
1.0ms
z
@inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* x y) (* z t)) (* x y) x y (* z t) z t (* a b) a b)
1.0ms
z
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* x y) (* z t)) (* x y) x y (* z t) z t (* a b) a b)
1.0ms
x
@0
((+ (+ (* x y) (* z t)) (* a b)) (+ (* x y) (* z t)) (* x y) x y (* z t) z t (* a b) a b)

rewrite179.0ms (3%)

Memory
16.1MiB live, 338.3MiB allocated; 42ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0145660
0150618
1912608
08433540
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
44 → 101
Calls
Call 1
Inputs
(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
(+.f64 (*.f64 x y) (*.f64 z t))
(*.f64 x y)
x
y
(*.f64 z t)
z
t
(*.f64 a b)
a
b
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* t z)))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (* x y) #s(hole binary64 (* x y)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* x y) (* z t)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx (* a b) #s(hole binary64 (* a b)))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
Outputs
(/.f64 (-.f64 (*.f64 (fma.f64 b a (*.f64 t z)) (fma.f64 b a (*.f64 t z))) (*.f64 (*.f64 (*.f64 y x) y) x)) (-.f64 (fma.f64 b a (*.f64 t z)) (*.f64 y x)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y x) y) x) (*.f64 (fma.f64 b a (*.f64 t z)) (fma.f64 b a (*.f64 t z)))) (-.f64 (*.f64 y x) (fma.f64 b a (*.f64 t z))))
(/.f64 (+.f64 (pow.f64 (fma.f64 b a (*.f64 t z)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (fma.f64 b a (*.f64 t z)) (fma.f64 b a (*.f64 t z)) (-.f64 (*.f64 (*.f64 (*.f64 y x) y) x) (*.f64 (fma.f64 b a (*.f64 t z)) (*.f64 y x)))))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (pow.f64 (fma.f64 b a (*.f64 t z)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 y x) y) x (-.f64 (*.f64 (fma.f64 b a (*.f64 t z)) (fma.f64 b a (*.f64 t z))) (*.f64 (*.f64 y x) (fma.f64 b a (*.f64 t z))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 a) b) #s(literal 3 binary64))) (fma.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x)) (fma.f64 (*.f64 (*.f64 b a) b) a (*.f64 (fma.f64 t z (*.f64 y x)) (*.f64 (neg.f64 a) b)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a)))) (neg.f64 (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))))
(/.f64 (neg.f64 (*.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x))))) (neg.f64 (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a)))) (neg.f64 (fma.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x)) (*.f64 (*.f64 b a) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a) (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 (*.f64 b a) b) a (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))))))
(/.f64 (*.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a)))
(/.f64 (*.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x))))
(/.f64 (+.f64 (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a))) (fma.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x)) (*.f64 (*.f64 b a) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x))))))
(/.f64 (fma.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a) (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 b a) b) a (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a)))))
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
(fma.f64 a b (fma.f64 t z (*.f64 y x)))
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
(fma.f64 x y (fma.f64 b a (*.f64 t z)))
(-.f64 (/.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x))) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))) (/.f64 (*.f64 (*.f64 (*.f64 b a) b) a) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 b a) b) a) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))) (/.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x))) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))))
(-.f64 (fma.f64 b a (*.f64 t z)) (*.f64 (neg.f64 x) y))
(-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 (neg.f64 a) b))
(+.f64 (/.f64 (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)) (fma.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x)) (*.f64 (*.f64 b a) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))))) (/.f64 (*.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a)) (fma.f64 (fma.f64 t z (*.f64 y x)) (fma.f64 t z (*.f64 y x)) (*.f64 (*.f64 b a) (-.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 b b) b) (*.f64 (*.f64 a a) a)) (fma.f64 (*.f64 (*.f64 b a) b) a (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))))) (/.f64 (pow.f64 (fma.f64 t z (*.f64 y x)) #s(literal 3 binary64)) (fma.f64 (*.f64 (*.f64 b a) b) a (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))))))
(+.f64 (fma.f64 b a (*.f64 t z)) (*.f64 y x))
(+.f64 (*.f64 b a) (fma.f64 t z (*.f64 y x)))
(+.f64 (fma.f64 t z (*.f64 y x)) (*.f64 (neg.f64 (neg.f64 a)) b))
(+.f64 (fma.f64 t z (*.f64 y x)) (*.f64 b a))
(+.f64 (*.f64 y x) (fma.f64 b a (*.f64 t z)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 x) y) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 t z) t) z (fma.f64 (*.f64 (*.f64 y x) y) x (*.f64 (*.f64 t z) (*.f64 (neg.f64 x) y)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (neg.f64 z) t) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 y x) y) x (fma.f64 (*.f64 (*.f64 t z) t) z (*.f64 (*.f64 y x) (*.f64 (neg.f64 z) t)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (*.f64 y x) (*.f64 t z)))) (neg.f64 (-.f64 (*.f64 y x) (*.f64 t z))))
(/.f64 (neg.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (*.f64 t z) (*.f64 y x)))) (neg.f64 (-.f64 (*.f64 t z) (*.f64 y x))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)))) (neg.f64 (fma.f64 (*.f64 (*.f64 y x) y) x (*.f64 (*.f64 t z) (-.f64 (*.f64 t z) (*.f64 y x))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)))) (neg.f64 (fma.f64 (*.f64 (*.f64 t z) t) z (*.f64 (*.f64 y x) (-.f64 (*.f64 y x) (*.f64 t z))))))
(/.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (*.f64 y x) (*.f64 t z))) (-.f64 (*.f64 y x) (*.f64 t z)))
(/.f64 (*.f64 (fma.f64 t z (*.f64 y x)) (-.f64 (*.f64 t z) (*.f64 y x))) (-.f64 (*.f64 t z) (*.f64 y x)))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z))) (fma.f64 (*.f64 (*.f64 y x) y) x (*.f64 (*.f64 t z) (-.f64 (*.f64 t z) (*.f64 y x)))))
(/.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (*.f64 (*.f64 t z) t) z (*.f64 (*.f64 y x) (-.f64 (*.f64 y x) (*.f64 t z)))))
(fma.f64 t z (*.f64 (neg.f64 (neg.f64 x)) y))
(fma.f64 t z (*.f64 y x))
(fma.f64 z t (*.f64 (neg.f64 (neg.f64 x)) y))
(fma.f64 z t (*.f64 y x))
(fma.f64 y x (*.f64 (neg.f64 (neg.f64 z)) t))
(fma.f64 y x (*.f64 t z))
(fma.f64 x y (*.f64 (neg.f64 (neg.f64 z)) t))
(fma.f64 x y (*.f64 t z))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 y x) y) x) (-.f64 (*.f64 y x) (*.f64 t z))) (/.f64 (*.f64 (*.f64 (*.f64 t z) t) z) (-.f64 (*.f64 y x) (*.f64 t z))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 t z) t) z) (-.f64 (*.f64 t z) (*.f64 y x))) (/.f64 (*.f64 (*.f64 (*.f64 y x) y) x) (-.f64 (*.f64 t z) (*.f64 y x))))
(-.f64 (*.f64 t z) (*.f64 (neg.f64 x) y))
(-.f64 (*.f64 y x) (*.f64 (neg.f64 z) t))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 (*.f64 y x) y) x (*.f64 (*.f64 t z) (-.f64 (*.f64 t z) (*.f64 y x))))) (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 (*.f64 y x) y) x (*.f64 (*.f64 t z) (-.f64 (*.f64 t z) (*.f64 y x))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 (*.f64 t z) t) z (*.f64 (*.f64 y x) (-.f64 (*.f64 y x) (*.f64 t z))))) (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 (*.f64 t z) t) z (*.f64 (*.f64 y x) (-.f64 (*.f64 y x) (*.f64 t z))))))
(+.f64 (*.f64 t z) (*.f64 (neg.f64 (neg.f64 x)) y))
(+.f64 (*.f64 t z) (*.f64 y x))
(+.f64 (*.f64 y x) (*.f64 (neg.f64 (neg.f64 z)) t))
(+.f64 (*.f64 y x) (*.f64 t z))
(*.f64 y x)
(*.f64 x y)
x
y
(*.f64 t z)
(*.f64 z t)
z
t
(*.f64 b a)
(*.f64 a b)
a
b
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (fma.f64 t z (*.f64 y x))))
#s(approx (+ (* x y) (* z t)) (*.f64 t z))
#s(approx (+ (* x y) (* z t)) (fma.f64 t z (*.f64 y x)))
#s(approx (* x y) (*.f64 y x))
#s(approx x x)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) x) y) x))
#s(approx (+ (* x y) (* z t)) (*.f64 (fma.f64 t (/.f64 z x) y) x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 y) (/.f64 (fma.f64 b a (*.f64 t z)) x))) x))
#s(approx (+ (* x y) (* z t)) (*.f64 (neg.f64 x) (neg.f64 (fma.f64 t (/.f64 z x) y))))
#s(approx y y)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) y) x) y))
#s(approx (+ (* x y) (* z t)) (*.f64 (fma.f64 t (/.f64 z y) x) y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 x) (/.f64 (fma.f64 b a (*.f64 t z)) y))) y))
#s(approx (+ (* x y) (* z t)) (*.f64 (neg.f64 (fma.f64 t (/.f64 z y) x)) (neg.f64 y)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx z z)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) z) t) z))
#s(approx (+ (* x y) (* z t)) (*.f64 (fma.f64 y (/.f64 x z) t) z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 t) (/.f64 (fma.f64 b a (*.f64 y x)) z))) z))
#s(approx (+ (* x y) (* z t)) (*.f64 (neg.f64 z) (neg.f64 (fma.f64 y (/.f64 x z) t))))
#s(approx t t)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
#s(approx (+ (* x y) (* z t)) (*.f64 (fma.f64 y (/.f64 x t) z) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 z) (/.f64 (fma.f64 b a (*.f64 y x)) t))) t))
#s(approx (+ (* x y) (* z t)) (*.f64 (neg.f64 (fma.f64 y (/.f64 x t) z)) (neg.f64 t)))
#s(approx (* a b) (*.f64 b a))
#s(approx a a)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) a) b) a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 b) (/.f64 (fma.f64 t z (*.f64 y x)) a))) a))
#s(approx b b)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) b) a) b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 (-.f64 (neg.f64 a) (/.f64 (fma.f64 t z (*.f64 y x)) b))) b))

eval11.0ms (0.2%)

Memory
-35.1MiB live, 24.4MiB allocated; 4ms collecting garbage
Compiler

Compiled 1 012 to 347 computations (65.7% saved)

prune4.0ms (0.1%)

Memory
10.1MiB live, 10.1MiB allocated; 0ms collecting garbage
Pruning

5 alts after pruning (5 fresh and 0 done)

PrunedKeptTotal
New87592
Fresh000
Picked101
Done000
Total88593
Accuracy
100.0%
Counts
93 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.6%
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
▶99.2%
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
▶63.4%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
▶67.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
▶89.2%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
Compiler

Compiled 126 to 126 computations (0% saved)

series35.0ms (0.6%)

Memory
-3.6MiB live, 88.9MiB allocated; 5ms collecting garbage
Counts
19 → 89
Calls
Call 1
Inputs
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
y
x
(fma.f64 b a (*.f64 t z))
b
a
(*.f64 t z)
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
(fma.f64 b a (*.f64 y x))
(*.f64 y x)
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
(fma.f64 t z (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
(*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t)
(+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z)
(/.f64 (fma.f64 b a (*.f64 y x)) t)
Outputs
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a b)))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* y x) #s(hole binary64 (* x y)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t z)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (/ (* a b) t)))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* x (+ y (/ (* a b) x)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* x (+ (/ y t) (/ (* a b) (* t x))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* a b) x)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (* a b) (* t x))))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* y (+ x (/ (* a b) y)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* y (+ (/ x t) (/ (* a b) (* t y))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* a b) y)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (* a b) (* t y))))))))
#s(approx z #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* z (+ t (/ (* a b) z)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* a b) z)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* a b) t)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx a #s(hole binary64 a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* a (+ b (/ (* t z) a)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a (+ b (/ (* x y) a)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* a (+ (/ b t) (/ (* x y) (* a t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t z) a)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* x y) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (* x y) (* a t))))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* b (+ a (/ (* t z) b)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* b (+ a (/ (* x y) b)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* b (+ (/ a t) (/ (* x y) (* b t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t z) b)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* x y) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (* x y) (* b t))))))))
Calls

18 calls:

TimeVariablePointExpression
4.0ms
t
@-inf
((+ (* y x) (+ (* b a) (* t z))) y x (+ (* b a) (* t z)) b a (* t z) t z (+ (+ (* x y) (* z t)) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* y x) (+ (* b a) (+ (* t z) (* y x))) (+ (* t z) (* y x)) (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (/ (+ (* b a) (* y x)) t))
3.0ms
x
@-inf
((+ (* y x) (+ (* b a) (* t z))) y x (+ (* b a) (* t z)) b a (* t z) t z (+ (+ (* x y) (* z t)) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* y x) (+ (* b a) (+ (* t z) (* y x))) (+ (* t z) (* y x)) (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (/ (+ (* b a) (* y x)) t))
3.0ms
a
@inf
((+ (* y x) (+ (* b a) (* t z))) y x (+ (* b a) (* t z)) b a (* t z) t z (+ (+ (* x y) (* z t)) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* y x) (+ (* b a) (+ (* t z) (* y x))) (+ (* t z) (* y x)) (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (/ (+ (* b a) (* y x)) t))
3.0ms
x
@0
((+ (* y x) (+ (* b a) (* t z))) y x (+ (* b a) (* t z)) b a (* t z) t z (+ (+ (* x y) (* z t)) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* y x) (+ (* b a) (+ (* t z) (* y x))) (+ (* t z) (* y x)) (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (/ (+ (* b a) (* y x)) t))
2.0ms
y
@-inf
((+ (* y x) (+ (* b a) (* t z))) y x (+ (* b a) (* t z)) b a (* t z) t z (+ (+ (* x y) (* z t)) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* y x) (+ (* b a) (+ (* t z) (* y x))) (+ (* t z) (* y x)) (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (/ (+ (* b a) (* y x)) t))

rewrite228.0ms (3.8%)

Memory
-9.1MiB live, 278.1MiB allocated; 37ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03932117
04101952
125091944
096101880
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
108 → 276
Calls
Call 1
Inputs
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
y
x
(fma.f64 b a (*.f64 t z))
b
a
(*.f64 t z)
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
(fma.f64 b a (*.f64 y x))
(*.f64 y x)
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
(fma.f64 t z (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
(*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t)
(+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z)
(/.f64 (fma.f64 b a (*.f64 y x)) t)
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a b)))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* y x) #s(hole binary64 (* x y)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t z)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (/ (* a b) t)))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* x (+ y (/ (* a b) x)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* x (+ (/ y t) (/ (* a b) (* t x))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* a b) x)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (* a b) (* t x))))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* y (+ x (/ (* a b) y)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* y (+ (/ x t) (/ (* a b) (* t y))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* a b) y)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (* a b) (* t y))))))))
#s(approx z #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* z (+ t (/ (* a b) z)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* a b) z)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* a b) t)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx a #s(hole binary64 a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* a (+ b (/ (* t z) a)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a (+ b (/ (* x y) a)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* a (+ (/ b t) (/ (* x y) (* a t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t z) a)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* x y) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (* x y) (* a t))))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* b (+ a (/ (* t z) b)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* b (+ a (/ (* x y) b)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* b (+ (/ a t) (/ (* x y) (* b t))))))
#s(approx (+ (* y x) (+ (* b a) (* t z))) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (+ (* b a) (* t z)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t z) b)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* x y) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
#s(approx (/ (+ (* b a) (* y x)) t) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (* x y) (* b t))))))))
Outputs
(/.f64 (-.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 a) b) #s(literal 3 binary64))) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (fma.f64 (*.f64 (neg.f64 a) b) (*.f64 (neg.f64 a) b) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 (neg.f64 a) b)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))))) (neg.f64 (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (*.f64 a b)))) (neg.f64 (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))))) (neg.f64 (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)))) (neg.f64 (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))))
(/.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b)))) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b))))
(/.f64 (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (*.f64 a b))) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b)))
(/.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)))) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y))))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64))) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b))) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b)))))
(/.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64))) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y))))))
(fma.f64 a b (fma.f64 z t (*.f64 x y)))
(fma.f64 b a (fma.f64 z t (*.f64 x y)))
(fma.f64 x y (fma.f64 z t (*.f64 a b)))
(fma.f64 y x (fma.f64 z t (*.f64 a b)))
(-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))) (/.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))
(-.f64 (/.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))) (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))
(-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))) (/.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))
(-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 (neg.f64 a) b))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))) (/.f64 (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))))
(+.f64 (/.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))) (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))) (/.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))))
(+.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))
(+.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t))
(+.f64 (fma.f64 z t (*.f64 a b)) (*.f64 x y))
(+.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))
(+.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))
y
x
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 t) z) #s(literal 3 binary64))) (fma.f64 (*.f64 a b) (*.f64 a b) (fma.f64 (*.f64 (neg.f64 t) z) (*.f64 (neg.f64 t) z) (*.f64 (*.f64 a b) (*.f64 (neg.f64 t) z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (*.f64 z t) (*.f64 z t)))) (neg.f64 (-.f64 (*.f64 a b) (*.f64 z t))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)))) (neg.f64 (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 a b) (*.f64 z t))))))
(/.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (*.f64 z t) (*.f64 z t))) (-.f64 (*.f64 a b) (*.f64 z t)))
(/.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z))) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 a b) (*.f64 z t)))))
(fma.f64 z t (*.f64 a b))
(fma.f64 t z (*.f64 a b))
(fma.f64 a b (*.f64 z t))
(fma.f64 b a (*.f64 z t))
(-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 a b) (*.f64 z t))) (/.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (-.f64 (*.f64 a b) (*.f64 z t))))
(-.f64 (*.f64 a b) (*.f64 (neg.f64 t) z))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 a b) (*.f64 z t))))) (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 a b) (*.f64 z t))))))
(+.f64 (*.f64 z t) (*.f64 a b))
(+.f64 (*.f64 a b) (*.f64 z t))
b
a
(*.f64 z t)
(*.f64 t z)
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 a b (*.f64 x y)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 x) y) #s(literal 3 binary64))) (fma.f64 (*.f64 a b) (*.f64 a b) (fma.f64 (*.f64 (neg.f64 x) y) (*.f64 (neg.f64 x) y) (*.f64 (*.f64 a b) (*.f64 (neg.f64 x) y)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 y) x) #s(literal 3 binary64))) (fma.f64 (*.f64 a b) (*.f64 a b) (fma.f64 (*.f64 (neg.f64 y) x) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 a b) (*.f64 (neg.f64 y) x)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (*.f64 x y) (*.f64 x y)))) (neg.f64 (-.f64 (*.f64 a b) (*.f64 x y))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)))) (neg.f64 (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 a b) (*.f64 x y))))))
(/.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (*.f64 x y) (*.f64 x y))) (-.f64 (*.f64 a b) (*.f64 x y)))
(/.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 a b) (*.f64 x y)))))
(fma.f64 a b (*.f64 x y))
(fma.f64 b a (*.f64 x y))
(fma.f64 x y (*.f64 a b))
(fma.f64 y x (*.f64 a b))
(-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 a b) (*.f64 x y))) (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (-.f64 (*.f64 a b) (*.f64 x y))))
(-.f64 (*.f64 a b) (*.f64 (neg.f64 x) y))
(-.f64 (*.f64 a b) (*.f64 (neg.f64 y) x))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 a b) (*.f64 x y))))) (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 a b) (*.f64 x y))))))
(+.f64 (*.f64 a b) (*.f64 x y))
(+.f64 (*.f64 x y) (*.f64 a b))
(*.f64 x y)
(*.f64 y x)
(/.f64 (-.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (pow.f64 (*.f64 (neg.f64 a) b) #s(literal 3 binary64))) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (fma.f64 (*.f64 (neg.f64 a) b) (*.f64 (neg.f64 a) b) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 (neg.f64 a) b)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))))) (neg.f64 (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (*.f64 a b)))) (neg.f64 (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))))) (neg.f64 (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)))) (neg.f64 (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))))
(/.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b)))) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b))))
(/.f64 (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (*.f64 a b))) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b)))
(/.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)))) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y))))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64))) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b))) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b)))))
(/.f64 (fma.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b) (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64))) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y))))))
(fma.f64 a b (fma.f64 z t (*.f64 x y)))
(fma.f64 b a (fma.f64 z t (*.f64 x y)))
(fma.f64 x y (fma.f64 z t (*.f64 a b)))
(fma.f64 y x (fma.f64 z t (*.f64 a b)))
(-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))) (/.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (-.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))
(-.f64 (/.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))) (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))
(-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))) (/.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (-.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))
(-.f64 (fma.f64 z t (*.f64 x y)) (*.f64 (neg.f64 a) b))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))) (/.f64 (pow.f64 (fma.f64 z t (*.f64 a b)) #s(literal 3 binary64)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (fma.f64 z t (*.f64 a b)) (fma.f64 z t (*.f64 a b))) (*.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))))))
(+.f64 (/.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))) (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y)) (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))) (/.f64 (pow.f64 (fma.f64 z t (*.f64 x y)) #s(literal 3 binary64)) (fma.f64 (*.f64 a b) (*.f64 a b) (-.f64 (*.f64 (fma.f64 z t (*.f64 x y)) (fma.f64 z t (*.f64 x y))) (*.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))))))
(+.f64 (fma.f64 z t (*.f64 x y)) (*.f64 a b))
(+.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t))
(+.f64 (fma.f64 z t (*.f64 a b)) (*.f64 x y))
(+.f64 (*.f64 a b) (fma.f64 z t (*.f64 x y)))
(+.f64 (*.f64 x y) (fma.f64 z t (*.f64 a b)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 x) y) #s(literal 3 binary64))) (fma.f64 (*.f64 z t) (*.f64 z t) (fma.f64 (*.f64 (neg.f64 x) y) (*.f64 (neg.f64 x) y) (*.f64 (*.f64 z t) (*.f64 (neg.f64 x) y)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 y) x) #s(literal 3 binary64))) (fma.f64 (*.f64 z t) (*.f64 z t) (fma.f64 (*.f64 (neg.f64 y) x) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 z t) (*.f64 (neg.f64 y) x)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (neg.f64 z) t) #s(literal 3 binary64))) (fma.f64 (*.f64 x y) (*.f64 x y) (fma.f64 (*.f64 (neg.f64 z) t) (*.f64 (neg.f64 z) t) (*.f64 (*.f64 x y) (*.f64 (neg.f64 z) t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 z t)))) (neg.f64 (-.f64 (*.f64 x y) (*.f64 z t))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 x y)))) (neg.f64 (-.f64 (*.f64 z t) (*.f64 x y))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)))) (neg.f64 (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 z t))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)))) (neg.f64 (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 x y))))))
(/.f64 (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 z t))) (-.f64 (*.f64 x y) (*.f64 z t)))
(/.f64 (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 x y))) (-.f64 (*.f64 z t) (*.f64 x y)))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z))) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 z t)))))
(/.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 x y)))))
(fma.f64 z t (*.f64 x y))
(fma.f64 t z (*.f64 x y))
(fma.f64 x y (*.f64 z t))
(fma.f64 y x (*.f64 z t))
(-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (-.f64 (*.f64 x y) (*.f64 z t))) (/.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (-.f64 (*.f64 x y) (*.f64 z t))))
(-.f64 (/.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (-.f64 (*.f64 z t) (*.f64 x y))) (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (-.f64 (*.f64 z t) (*.f64 x y))))
(-.f64 (*.f64 z t) (*.f64 (neg.f64 x) y))
(-.f64 (*.f64 z t) (*.f64 (neg.f64 y) x))
(-.f64 (*.f64 x y) (*.f64 (neg.f64 z) t))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 z t))))) (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 x y) (*.f64 x y) (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (*.f64 (*.f64 x y) (*.f64 z t))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 x y))))) (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 (*.f64 z t) (*.f64 x y))))))
(+.f64 (*.f64 z t) (*.f64 x y))
(+.f64 (*.f64 x y) (*.f64 z t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z) t))
(*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z) t)
(*.f64 t (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 t) (/.f64 (fma.f64 a b (*.f64 x y)) t)) #s(literal 3 binary64))) (fma.f64 (*.f64 z t) (*.f64 z t) (fma.f64 (*.f64 (neg.f64 t) (/.f64 (fma.f64 a b (*.f64 x y)) t)) (*.f64 (neg.f64 t) (/.f64 (fma.f64 a b (*.f64 x y)) t)) (*.f64 (*.f64 z t) (*.f64 (neg.f64 t) (/.f64 (fma.f64 a b (*.f64 x y)) t))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)) (*.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))))))
(/.f64 (-.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64))) (-.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t)))
(/.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 3 binary64))) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)) (*.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t)))))
(fma.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t (*.f64 z t))
(fma.f64 z t (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))
(fma.f64 t (/.f64 (fma.f64 a b (*.f64 x y)) t) (*.f64 z t))
(fma.f64 t z (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))
(-.f64 (/.f64 (*.f64 (*.f64 z t) (*.f64 z t)) (-.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))) (/.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)) (-.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))))
(-.f64 (*.f64 z t) (*.f64 (neg.f64 t) (/.f64 (fma.f64 a b (*.f64 x y)) t)))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)) (*.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))))) (/.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 3 binary64)) (fma.f64 (*.f64 z t) (*.f64 z t) (-.f64 (pow.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) #s(literal 2 binary64)) (*.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))))))
(+.f64 (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t) (*.f64 z t))
(+.f64 (*.f64 z t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))
(/.f64 (fma.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t))) (neg.f64 t) (*.f64 (-.f64 z (/.f64 (*.f64 a b) t)) (neg.f64 (*.f64 x y)))) (*.f64 (-.f64 z (/.f64 (*.f64 a b) t)) (neg.f64 t)))
(/.f64 (fma.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t))) t (*.f64 (-.f64 z (/.f64 (*.f64 a b) t)) (*.f64 x y))) (*.f64 (-.f64 z (/.f64 (*.f64 a b) t)) t))
(/.f64 (fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (*.f64 a b) t) #s(literal 3 binary64))) (neg.f64 t) (*.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 a b) t)))) (neg.f64 (*.f64 x y)))) (*.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 a b) t)))) (neg.f64 t)))
(/.f64 (fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (*.f64 a b) t) #s(literal 3 binary64))) t (*.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 a b) t)))) (*.f64 x y))) (*.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 a b) t)))) t))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z z))) (neg.f64 (-.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)))) (neg.f64 (-.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64)) (*.f64 (*.f64 z z) z))) (neg.f64 (fma.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) (/.f64 (fma.f64 a b (*.f64 x y)) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))))))
(/.f64 (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z z)) (-.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z))
(/.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t))) (-.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t)))
(/.f64 (+.f64 (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64)) (*.f64 (*.f64 z z) z)) (fma.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) (/.f64 (fma.f64 a b (*.f64 x y)) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z))))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t)))))
(-.f64 (/.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (-.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)) (/.f64 (*.f64 z z) (-.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))) (/.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (-.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))))
(+.f64 (/.f64 (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64)) (fma.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) (/.f64 (fma.f64 a b (*.f64 x y)) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)))) (/.f64 (*.f64 (*.f64 z z) z) (fma.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) (/.f64 (fma.f64 a b (*.f64 x y)) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)))))
(+.f64 (/.f64 (*.f64 (*.f64 z z) z) (fma.f64 z z (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))))) (/.f64 (pow.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) #s(literal 3 binary64)) (fma.f64 z z (-.f64 (/.f64 (*.f64 (fma.f64 a b (*.f64 x y)) (fma.f64 a b (*.f64 x y))) (*.f64 t t)) (*.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))))))
(+.f64 (fma.f64 a (/.f64 b t) z) (/.f64 (*.f64 x y) t))
(+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z)
(+.f64 z (/.f64 (fma.f64 a b (*.f64 x y)) t))
(/.f64 (+.f64 (neg.f64 (*.f64 x y)) (neg.f64 (*.f64 a b))) (neg.f64 t))
(/.f64 (+.f64 (neg.f64 (*.f64 a b)) (neg.f64 (*.f64 x y))) (neg.f64 t))
(/.f64 (fma.f64 (neg.f64 (*.f64 x y)) (neg.f64 t) (*.f64 (neg.f64 t) (neg.f64 (*.f64 a b)))) (*.f64 t t))
(/.f64 (fma.f64 (neg.f64 (*.f64 x y)) t (*.f64 (neg.f64 t) (*.f64 a b))) (*.f64 (neg.f64 t) t))
(/.f64 (fma.f64 (*.f64 x y) (neg.f64 t) (*.f64 t (neg.f64 (*.f64 a b)))) (*.f64 t (neg.f64 t)))
(/.f64 (fma.f64 (*.f64 x y) t (*.f64 t (*.f64 a b))) (*.f64 t t))
(/.f64 (fma.f64 (neg.f64 (*.f64 a b)) (neg.f64 t) (*.f64 (neg.f64 t) (neg.f64 (*.f64 x y)))) (*.f64 t t))
(/.f64 (fma.f64 (neg.f64 (*.f64 a b)) t (*.f64 (neg.f64 t) (*.f64 x y))) (*.f64 (neg.f64 t) t))
(/.f64 (fma.f64 (*.f64 a b) (neg.f64 t) (*.f64 t (neg.f64 (*.f64 x y)))) (*.f64 t (neg.f64 t)))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)))) (neg.f64 (/.f64 (-.f64 (*.f64 a b) (*.f64 x y)) t)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (/.f64 (*.f64 a b) t) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 x y) t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 a b) t) (-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 a b) (*.f64 x y)) (*.f64 t t))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 a b) t (*.f64 t (*.f64 x y)))) (neg.f64 (*.f64 t t)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 a b (*.f64 x y)))) (neg.f64 (neg.f64 t)))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t))) (/.f64 (-.f64 (*.f64 a b) (*.f64 x y)) t))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 a b) t) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 x y) t) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 a b) t) (-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 a b) (*.f64 x y)) (*.f64 t t)))))
(/.f64 (fma.f64 (*.f64 a b) t (*.f64 t (*.f64 x y))) (*.f64 t t))
(/.f64 (neg.f64 (fma.f64 a b (*.f64 x y))) (neg.f64 t))
(/.f64 (fma.f64 a b (*.f64 x y)) t)
(fma.f64 a (/.f64 b t) (/.f64 (*.f64 x y) t))
(fma.f64 x (/.f64 y t) (/.f64 (*.f64 a b) t))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 t t)) (/.f64 (-.f64 (*.f64 a b) (*.f64 x y)) t)) (/.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)) (/.f64 (-.f64 (*.f64 a b) (*.f64 x y)) t)))
(-.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 (neg.f64 x) y) t))
(-.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 (neg.f64 y) x) t))
(+.f64 (/.f64 (pow.f64 (/.f64 (*.f64 a b) t) #s(literal 3 binary64)) (fma.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 a b) t) (-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 a b) (*.f64 x y)) (*.f64 t t))))) (/.f64 (pow.f64 (/.f64 (*.f64 x y) t) #s(literal 3 binary64)) (fma.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 a b) t) (-.f64 (/.f64 (*.f64 (*.f64 x y) (*.f64 x y)) (*.f64 t t)) (/.f64 (*.f64 (*.f64 a b) (*.f64 x y)) (*.f64 t t))))))
(+.f64 (/.f64 (*.f64 (*.f64 a b) t) (*.f64 t t)) (/.f64 (*.f64 t (*.f64 x y)) (*.f64 t t)))
(+.f64 (/.f64 (*.f64 x y) t) (/.f64 (*.f64 a b) t))
(+.f64 (/.f64 (*.f64 a b) t) (/.f64 (*.f64 x y) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 x y (fma.f64 z t (*.f64 a b))))
#s(approx x x)
#s(approx (+ (* b a) (* y x)) (*.f64 a b))
#s(approx (+ (* b a) (* y x)) (fma.f64 a b (*.f64 x y)))
#s(approx (* y x) (*.f64 x y))
#s(approx (+ (* t z) (* y x)) (*.f64 z t))
#s(approx (+ (* t z) (* y x)) (fma.f64 z t (*.f64 x y)))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 a (/.f64 b t) z) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 a (/.f64 b t) z) t (*.f64 x y)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 a (/.f64 b t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z))
#s(approx (/ (+ (* b a) (* y x)) t) (/.f64 (*.f64 a b) t))
#s(approx (/ (+ (* b a) (* y x)) t) (/.f64 (fma.f64 a b (*.f64 x y)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 z t (*.f64 a b)) x) y) x))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 a (/.f64 b x) y) x))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 t (/.f64 z x) y) x))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) x) y) x))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (*.f64 x y) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x) (/.f64 y t)) x))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (fma.f64 a (/.f64 b (*.f64 t x)) (/.f64 y t)) x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 z t (*.f64 a b)) x)) (neg.f64 y))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 a b) x)) (neg.f64 y))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 z t) x)) (neg.f64 y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) x)) (neg.f64 y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x)) (/.f64 (neg.f64 y) t))))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (*.f64 a (/.f64 b (*.f64 t x)))) (/.f64 (neg.f64 y) t))))
#s(approx y y)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 z t (*.f64 a b)) y) x) y))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 a (/.f64 b y) x) y))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 t (/.f64 z y) x) y))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) y) x) y))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y) (/.f64 x t)) y))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (fma.f64 a (/.f64 b (*.f64 t y)) (/.f64 x t)) y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 z t (*.f64 a b)) y)) (neg.f64 x))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 a b) y)) (neg.f64 x))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 z t) y)) (neg.f64 x))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) y)) (neg.f64 x))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y)) (/.f64 (neg.f64 x) t))))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (*.f64 a (/.f64 b (*.f64 t y)))) (/.f64 (neg.f64 x) t))))
#s(approx z z)
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) z) t) z))
#s(approx (+ (* b a) (* t z)) (*.f64 (fma.f64 a (/.f64 b z) t) z))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 x (/.f64 y z) t) z))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t)) t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t)) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (fma.f64 a b (*.f64 x y)) z)) (neg.f64 t))))
#s(approx (+ (* b a) (* t z)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 a b) z)) (neg.f64 t))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 x y) z)) (neg.f64 t))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (*.f64 t (/.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t)))) (neg.f64 t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 a b (*.f64 x y)) (*.f64 z t))) #s(literal 1 binary64))))
#s(approx t t)
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 a b (*.f64 x y)) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 x y (fma.f64 z t (*.f64 a b))) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t) z) t))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 x (/.f64 y t) z) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (fma.f64 a b (*.f64 x y)) t)) (neg.f64 z))))
#s(approx (+ (* b a) (* t z)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (*.f64 a b) t)) (neg.f64 z))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (*.f64 x y) t)) (neg.f64 z))))
#s(approx a a)
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 x (/.f64 y t) z) t (*.f64 a b)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 z t (*.f64 x y)) a) b) a))
#s(approx (+ (* b a) (* t z)) (*.f64 (fma.f64 t (/.f64 z a) b) a))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 x (/.f64 y a) b) a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 y t) z) a) b) a))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 t a)) (/.f64 z a)) (/.f64 b t)) a))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (/.f64 (fma.f64 x (/.f64 y a) b) t) a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 z t (*.f64 x y)) a)) (neg.f64 b))))
#s(approx (+ (* b a) (* t z)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 z t) a)) (neg.f64 b))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 x y) a)) (neg.f64 b))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 x (/.f64 y t) z) t) a)) (neg.f64 b))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) z) a)) (/.f64 (neg.f64 b) t))))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (neg.f64 a) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 x (/.f64 y a) b) t))))
#s(approx b b)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 z t (*.f64 x y)) b) a) b))
#s(approx (+ (* b a) (* t z)) (*.f64 (fma.f64 t (/.f64 z b) a) b))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 x (/.f64 y b) a) b))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 y t) z) b) a) b))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 t b)) (/.f64 z b)) (/.f64 a t)) b))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (/.f64 (fma.f64 x (/.f64 y b) a) t) b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 z t (*.f64 x y)) b)) (neg.f64 a))))
#s(approx (+ (* b a) (* t z)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 z t) b)) (neg.f64 a))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 x y) b)) (neg.f64 a))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 x (/.f64 y t) z) t) b)) (neg.f64 a))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 y t) z) b)) (/.f64 (neg.f64 a) t))))
#s(approx (/ (+ (* b a) (* y x)) t) (*.f64 (neg.f64 b) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 x (/.f64 y b) a) t))))

eval43.0ms (0.7%)

Memory
22.8MiB live, 68.8MiB allocated; 4ms collecting garbage
Compiler

Compiled 3 985 to 1 241 computations (68.9% saved)

prune13.0ms (0.2%)

Memory
-23.5MiB live, 20.9MiB allocated; 4ms collecting garbage
Pruning

6 alts after pruning (4 fresh and 2 done)

PrunedKeptTotal
New3054309
Fresh000
Picked325
Done000
Total3086314
Accuracy
100.0%
Counts
314 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓99.2%
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
▶67.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
▶63.7%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
✓63.4%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
▶65.3%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
▶31.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
Compiler

Compiled 89 to 89 computations (0% saved)

series43.0ms (0.7%)

Memory
8.9MiB live, 54.6MiB allocated; 4ms collecting garbage
Counts
18 → 82
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (* b a) (* y x)) (*.f64 a b))
(*.f64 a b)
a
b
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t)
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z))
(fma.f64 x (/.f64 y t) z)
x
(/.f64 y t)
y
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
(fma.f64 y x (*.f64 a b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
(fma.f64 z t (*.f64 a b))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a b)))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 z))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x y)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* x (+ y (/ (* a b) x)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* x (+ (/ y t) (/ z x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* a b) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ z x)))))))
#s(approx (/ y t) #s(hole binary64 (/ y t)))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* y (+ x (/ (* a b) y)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* y (+ (/ x t) (/ z y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* a b) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ z y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* z (+ 1 (/ (* x y) (* t z))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* z (+ t (/ (* a b) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x y) (* t z))) 1)))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* a b) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (/ (+ (* t z) (* x y)) t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* a b) t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx a #s(hole binary64 a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a (+ b (/ (* x y) a)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* a b) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* a (+ b (/ (* t z) a)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* x y) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t z) a)))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* b (+ a (/ (* x y) b)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* b (+ a (/ (* t z) b)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* x y) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t z) b)))))))
Calls

18 calls:

TimeVariablePointExpression
22.0ms
a
@inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* a b) a b (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) x (/ y t) y t z (+ (+ (* x y) (* z t)) (* a b)) (+ (* y x) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* z t) (* a b)))
2.0ms
a
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* a b) a b (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) x (/ y t) y t z (+ (+ (* x y) (* z t)) (* a b)) (+ (* y x) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* z t) (* a b)))
2.0ms
t
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* a b) a b (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) x (/ y t) y t z (+ (+ (* x y) (* z t)) (* a b)) (+ (* y x) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* z t) (* a b)))
2.0ms
y
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* a b) a b (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) x (/ y t) y t z (+ (+ (* x y) (* z t)) (* a b)) (+ (* y x) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* z t) (* a b)))
1.0ms
y
@inf
((+ (+ (* x y) (* z t)) (* a b)) (+ (* b a) (* y x)) (* a b) a b (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) x (/ y t) y t z (+ (+ (* x y) (* z t)) (* a b)) (+ (* y x) (* a b)) (+ (+ (* x y) (* z t)) (* a b)) (+ (* z t) (* a b)))

rewrite202.0ms (3.4%)

Memory
14.8MiB live, 257.2MiB allocated; 22ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03582052
03651838
122321836
088681766
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
100 → 167
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (* b a) (* y x)) (*.f64 a b))
(*.f64 a b)
a
b
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t)
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z))
(fma.f64 x (/.f64 y t) z)
x
(/.f64 y t)
y
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
(fma.f64 y x (*.f64 a b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
(fma.f64 z t (*.f64 a b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a b)))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 z))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x y)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* x (+ y (/ (* a b) x)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* x (+ (/ y t) (/ z x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* a b) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ z x)))))))
#s(approx (/ y t) #s(hole binary64 (/ y t)))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* y (+ x (/ (* a b) y)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* y (+ (/ x t) (/ z y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* a b) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ z y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* z (+ 1 (/ (* x y) (* t z))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* z (+ t (/ (* a b) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x y) (* t z))) 1)))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* a b) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (/ (+ (* t z) (* x y)) t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* a b) t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx a #s(hole binary64 a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* a (+ b (/ (* x y) a)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* a b) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* a (+ b (/ (* t z) a)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* x y) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t z) a)))))))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* b (+ a (/ (* x y) b)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* b (+ a (/ (* t z) b)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (+ (* b a) (* y x)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* x y) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
#s(approx (+ (* z t) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t z) b)))))))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 b a)))
#s(approx (+ (* b a) (* y x)) (*.f64 b a))
(*.f64 b a)
(*.f64 a b)
a
b
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 (/.f64 y t) x z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 (/.f64 y t) x z)) t)
(*.f64 t #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 (/.f64 y t) x z)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 (/.f64 y t) x z))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)))) (neg.f64 (-.f64 z (/.f64 (*.f64 y x) t))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z z))) (neg.f64 (-.f64 (/.f64 (*.f64 y x) t) z)))
(/.f64 (neg.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 y x) t))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64)) (*.f64 (*.f64 z z) z))) (neg.f64 (fma.f64 (/.f64 (*.f64 y x) t) (/.f64 (*.f64 y x) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (*.f64 y x) t) z)))))
(/.f64 (-.f64 (*.f64 z z) (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t))) (-.f64 z (/.f64 (*.f64 y x) t)))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z z)) (-.f64 (/.f64 (*.f64 y x) t) z))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 y x) t)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64)) (*.f64 (*.f64 z z) z)) (fma.f64 (/.f64 (*.f64 y x) t) (/.f64 (*.f64 y x) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (*.f64 y x) t) z))))
(fma.f64 (/.f64 y t) x z)
(fma.f64 x (/.f64 y t) z)
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (/.f64 (*.f64 y x) t))) (/.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (-.f64 z (/.f64 (*.f64 y x) t))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (-.f64 (/.f64 (*.f64 y x) t) z)) (/.f64 (*.f64 z z) (-.f64 (/.f64 (*.f64 y x) t) z)))
(+.f64 (/.f64 (*.f64 (*.f64 z z) z) (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 y x) t))))) (/.f64 (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64)) (fma.f64 z z (-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 t t)) (*.f64 z (/.f64 (*.f64 y x) t))))))
(+.f64 (/.f64 (pow.f64 (/.f64 (*.f64 y x) t) #s(literal 3 binary64)) (fma.f64 (/.f64 (*.f64 y x) t) (/.f64 (*.f64 y x) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (*.f64 y x) t) z)))) (/.f64 (*.f64 (*.f64 z z) z) (fma.f64 (/.f64 (*.f64 y x) t) (/.f64 (*.f64 y x) t) (-.f64 (*.f64 z z) (*.f64 (/.f64 (*.f64 y x) t) z)))))
(+.f64 (/.f64 (*.f64 y x) t) z)
(+.f64 z (/.f64 (*.f64 y x) t))
x
(*.f64 (/.f64 y #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) t))
(*.f64 (/.f64 #s(literal -1 binary64) t) (/.f64 y #s(literal -1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 y t))
(*.f64 (/.f64 y t) #s(literal 1 binary64))
(/.f64 (neg.f64 (neg.f64 y)) (neg.f64 (neg.f64 t)))
(/.f64 (neg.f64 y) (neg.f64 t))
(/.f64 y t)
y
t
z
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 x) y) #s(literal 3 binary64))) (fma.f64 (*.f64 b a) (*.f64 b a) (fma.f64 (*.f64 (neg.f64 x) y) (*.f64 (neg.f64 x) y) (*.f64 (*.f64 b a) (*.f64 (neg.f64 x) y)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 y) x) #s(literal 3 binary64))) (fma.f64 (*.f64 b a) (*.f64 b a) (fma.f64 (*.f64 (neg.f64 y) x) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 b a) (*.f64 (neg.f64 y) x)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (neg.f64 a) b) #s(literal 3 binary64))) (fma.f64 (*.f64 y x) (*.f64 y x) (fma.f64 (*.f64 (neg.f64 a) b) (*.f64 (neg.f64 a) b) (*.f64 (*.f64 y x) (*.f64 (neg.f64 a) b)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 b a)))) (neg.f64 (-.f64 (*.f64 y x) (*.f64 b a))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 y x)))) (neg.f64 (-.f64 (*.f64 b a) (*.f64 y x))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)))) (neg.f64 (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 b a))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 b a) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)))) (neg.f64 (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 y x))))))
(/.f64 (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 b a))) (-.f64 (*.f64 y x) (*.f64 b a)))
(/.f64 (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 y x))) (-.f64 (*.f64 b a) (*.f64 y x)))
(/.f64 (fma.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b))) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 b a)))))
(/.f64 (fma.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 b a) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 y x)))))
(fma.f64 b a (*.f64 y x))
(fma.f64 a b (*.f64 y x))
(fma.f64 y x (*.f64 b a))
(fma.f64 x y (*.f64 b a))
(-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (-.f64 (*.f64 y x) (*.f64 b a))) (/.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 y x) (*.f64 b a))))
(-.f64 (/.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 b a) (*.f64 y x))) (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (-.f64 (*.f64 b a) (*.f64 y x))))
(-.f64 (*.f64 b a) (*.f64 (neg.f64 x) y))
(-.f64 (*.f64 b a) (*.f64 (neg.f64 y) x))
(-.f64 (*.f64 y x) (*.f64 (neg.f64 a) b))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 b a))))) (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 y x) (*.f64 b a))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 y x))))) (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 b a) (*.f64 y x))))))
(+.f64 (*.f64 b a) (*.f64 y x))
(+.f64 (*.f64 y x) (*.f64 b a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 a) b) #s(literal 3 binary64))) (fma.f64 (*.f64 t z) (*.f64 t z) (fma.f64 (*.f64 (neg.f64 a) b) (*.f64 (neg.f64 a) b) (*.f64 (*.f64 t z) (*.f64 (neg.f64 a) b)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (pow.f64 (*.f64 (neg.f64 t) z) #s(literal 3 binary64))) (fma.f64 (*.f64 b a) (*.f64 b a) (fma.f64 (*.f64 (neg.f64 t) z) (*.f64 (neg.f64 t) z) (*.f64 (*.f64 b a) (*.f64 (neg.f64 t) z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 t z)))) (neg.f64 (-.f64 (*.f64 b a) (*.f64 t z))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 b a)))) (neg.f64 (-.f64 (*.f64 t z) (*.f64 b a))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 b a) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)))) (neg.f64 (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 t z))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)))) (neg.f64 (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 b a))))))
(/.f64 (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 t z))) (-.f64 (*.f64 b a) (*.f64 t z)))
(/.f64 (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 b a))) (-.f64 (*.f64 t z) (*.f64 b a)))
(/.f64 (fma.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 b a) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z))) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 t z)))))
(/.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b))) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 b a)))))
(fma.f64 b a (*.f64 t z))
(fma.f64 a b (*.f64 t z))
(fma.f64 t z (*.f64 b a))
(fma.f64 z t (*.f64 b a))
(-.f64 (/.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 b a) (*.f64 t z))) (/.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (-.f64 (*.f64 b a) (*.f64 t z))))
(-.f64 (/.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (-.f64 (*.f64 t z) (*.f64 b a))) (/.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 t z) (*.f64 b a))))
(-.f64 (*.f64 t z) (*.f64 (neg.f64 a) b))
(-.f64 (*.f64 b a) (*.f64 (neg.f64 t) z))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 t z))))) (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 b a) (*.f64 b a) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 b a) (*.f64 t z))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 b a))))) (/.f64 (*.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 b b) b)) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 t z) (*.f64 b a))))))
(+.f64 (*.f64 t z) (*.f64 b a))
(+.f64 (*.f64 b a) (*.f64 t z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (fma.f64 t z (*.f64 y x))))
#s(approx (+ (* b a) (* y x)) (*.f64 b a))
#s(approx (+ (* b a) (* y x)) (fma.f64 b a (*.f64 y x)))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 a (/.f64 b t) z) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 a (/.f64 b t) z) t (*.f64 y x)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 a (/.f64 b t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z))
#s(approx (+ (* x (/ y t)) z) z)
#s(approx (+ (* x (/ y t)) z) (fma.f64 (/.f64 y t) x z))
#s(approx x x)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) x) y) x))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 a (/.f64 b x) y) x))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) x) y) x))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (*.f64 y x) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x) (/.f64 y t)) x))
#s(approx (+ (* x (/ y t)) z) (*.f64 (+.f64 (/.f64 z x) (/.f64 y t)) x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 t z)) x)) (neg.f64 y))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 b a) x)) (neg.f64 y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) x)) (neg.f64 y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x)) (/.f64 (neg.f64 y) t))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 y) t) (/.f64 z x))))
#s(approx (/ y t) (/.f64 y t))
#s(approx y y)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) y) x) y))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 a (/.f64 b y) x) y))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) y) x) y))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y) (/.f64 x t)) y))
#s(approx (+ (* x (/ y t)) z) (*.f64 (+.f64 (/.f64 z y) (/.f64 x t)) y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 t z)) y)) (neg.f64 x))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 b a) y)) (neg.f64 x))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) y)) (neg.f64 x))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y)) (/.f64 (neg.f64 x) t))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 x) t) (/.f64 z y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (*.f64 y x)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 t z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) z) t) z))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)) t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)) #s(literal 1 binary64)) z))
#s(approx (+ (* x (/ y t)) z) (*.f64 (fma.f64 x (/.f64 y (*.f64 t z)) #s(literal 1 binary64)) z))
#s(approx (+ (* z t) (* a b)) (*.f64 (fma.f64 a (/.f64 b z) t) z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) z)) (neg.f64 t))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (*.f64 t (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)))) (neg.f64 t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z))) #s(literal 1 binary64))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (*.f64 x (/.f64 y (*.f64 t z)))) #s(literal 1 binary64))))
#s(approx (+ (* z t) (* a b)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 b a) z)) (neg.f64 t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (*.f64 y x)) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) t))
#s(approx (+ (* x (/ y t)) z) (/.f64 (fma.f64 t z (*.f64 y x)) t))
#s(approx t t)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t)) (neg.f64 z))))
#s(approx (+ (* z t) (* a b)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (*.f64 b a) t)) (neg.f64 z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx a a)
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 (/.f64 y t) x z) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 (/.f64 y t) x z) t (*.f64 b a)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) a) b) a))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 x (/.f64 y a) b) a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 (/.f64 y t) x z) a) b) a))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (*.f64 b a) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 a t)) (/.f64 z a)) (/.f64 b t)) a))
#s(approx (+ (* z t) (* a b)) (*.f64 (fma.f64 t (/.f64 z a) b) a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 t z (*.f64 y x)) a)) (neg.f64 b))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 y x) a)) (neg.f64 b))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 (/.f64 y t) x z) t) a)) (neg.f64 b))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 y t) x z) a)) (/.f64 (neg.f64 b) t))))
#s(approx (+ (* z t) (* a b)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 t z) a)) (neg.f64 b))))
#s(approx b b)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) b) a) b))
#s(approx (+ (* b a) (* y x)) (*.f64 (fma.f64 x (/.f64 y b) a) b))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 (/.f64 y t) x z) b) a) b))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 b t)) (/.f64 z b)) (/.f64 a t)) b))
#s(approx (+ (* z t) (* a b)) (*.f64 (fma.f64 t (/.f64 z b) a) b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 t z (*.f64 y x)) b)) (neg.f64 a))))
#s(approx (+ (* b a) (* y x)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 y x) b)) (neg.f64 a))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 (/.f64 y t) x z) t) b)) (neg.f64 a))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 y t) x z) b)) (/.f64 (neg.f64 a) t))))
#s(approx (+ (* z t) (* a b)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 t z) b)) (neg.f64 a))))

eval18.0ms (0.3%)

Memory
-1.2MiB live, 44.3MiB allocated; 3ms collecting garbage
Compiler

Compiled 2 019 to 754 computations (62.7% saved)

prune5.0ms (0.1%)

Memory
16.1MiB live, 16.1MiB allocated; 0ms collecting garbage
Pruning

7 alts after pruning (3 fresh and 4 done)

PrunedKeptTotal
New1593162
Fresh000
Picked134
Done112
Total1617168
Accuracy
100.0%
Counts
168 → 7
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓67.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
✓63.7%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
▶71.3%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
✓63.4%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
▶39.2%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
▶35.6%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
✓31.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
Compiler

Compiled 109 to 109 computations (0% saved)

series22.0ms (0.4%)

Memory
-38.5MiB live, 54.7MiB allocated; 6ms collecting garbage
Counts
12 → 71
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
(*.f64 y x)
y
x
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t)
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z))
#s(approx (+ (* x (/ y t)) z) z)
z
t
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
(fma.f64 t z (*.f64 y x))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (* y x) #s(hole binary64 (* x y)))
#s(approx x #s(hole binary64 x))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 z))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t z)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* x (+ (/ y t) (/ z x)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ z x)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* y (+ (/ x t) (/ z y)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ z y)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* z (+ 1 (/ (* x y) (* t z))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x y) (* t z))) 1)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (/ (+ (* t z) (* x y)) t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* a b) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
Calls

18 calls:

TimeVariablePointExpression
3.0ms
x
@0
((+ (+ (* x y) (* z t)) (* a b)) (* y x) y x (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) z t (+ (+ (* x y) (* z t)) (* a b)) (+ (* t z) (* y x)))
3.0ms
b
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (* y x) y x (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) z t (+ (+ (* x y) (* z t)) (* a b)) (+ (* t z) (* y x)))
1.0ms
x
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (* y x) y x (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) z t (+ (+ (* x y) (* z t)) (* a b)) (+ (* t z) (* y x)))
1.0ms
y
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (* y x) y x (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) z t (+ (+ (* x y) (* z t)) (* a b)) (+ (* t z) (* y x)))
1.0ms
t
@-inf
((+ (+ (* x y) (* z t)) (* a b)) (* y x) y x (+ (+ (* x y) (* z t)) (* a b)) (* (+ (/ (+ (* b a) (* y x)) t) z) t) (+ (/ (+ (* b a) (* y x)) t) z) (+ (* x (/ y t)) z) z t (+ (+ (* x y) (* z t)) (* a b)) (+ (* t z) (* y x)))

rewrite164.0ms (2.7%)

Memory
23.7MiB live, 314.2MiB allocated; 32ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03181835
03221705
120201703
081871573
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
83 → 108
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
(*.f64 y x)
y
x
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t)
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z))
#s(approx (+ (* x (/ y t)) z) z)
z
t
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
(fma.f64 t z (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* t z))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (+ (* t z) (* x y)))))
#s(approx (* y x) #s(hole binary64 (* x y)))
#s(approx x #s(hole binary64 x))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ z (/ (* a b) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t (+ z (/ (* a b) t))) (* x y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (/ (* a b) t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ z (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 z))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (+ z (/ (* x y) t))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t z)))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (+ (* t z) (* x y))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* x (+ y (+ (/ (* a b) x) (/ (* t z) x))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* x (+ y (/ (* t (+ z (/ (* a b) t))) x)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* x y) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* x (+ (/ y t) (+ (/ z x) (/ (* a b) (* t x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* x (+ (/ y t) (/ z x)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* x (+ y (/ (* t z) x)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (+ (* a b) (* t z)) x)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t (+ z (/ (* a b) t))) x)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ (+ z (/ (* a b) t)) x)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (/ y t)) (* -1 (/ z x)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* x (+ (* -1 y) (* -1 (/ (* t z) x)))))))
#s(approx y #s(hole binary64 y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* y (+ x (+ (/ (* a b) y) (/ (* t z) y))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* y (+ x (/ (* t (+ z (/ (* a b) t))) y)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* y (+ (/ x t) (+ (/ z y) (/ (* a b) (* t y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* y (+ (/ x t) (/ z y)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* y (+ x (/ (* t z) y)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (+ (* a b) (* t z)) y)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t (+ z (/ (* a b) t))) y)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ (+ z (/ (* a b) t)) y)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* y (+ (* -1 (/ x t)) (* -1 (/ z y)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* y (+ (* -1 x) (* -1 (/ (* t z) y)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (+ (* a b) (* x y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* t (+ (/ (* a b) t) (/ (* x y) t)))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* t z) (* t (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (+ (/ (* a b) t) (/ (* x y) t))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* z (+ t (+ (/ (* a b) z) (/ (* x y) z))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* z (+ t (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* z (+ 1 (+ (/ (* a b) (* t z)) (/ (* x y) (* t z)))))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* z (+ 1 (/ (* x y) (* t z))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* z (+ t (/ (* x y) z)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (+ (* a b) (* x y)) z)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* t (+ (/ (* a b) t) (/ (* x y) t))) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ (* a b) t) (/ (* x y) t)) z)) 1)))))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x y) (* t z))) 1)))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* z (+ (* -1 t) (* -1 (/ (* x y) z)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (* x y)) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (+ (* a b) (+ (* t z) (* x y))) t)))
#s(approx (+ (* x (/ y t)) z) #s(hole binary64 (/ (+ (* t z) (* x y)) t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* t (+ z (+ (/ (* a b) t) (/ (* x y) t))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* t (+ z (/ (* x y) t)))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (+ (* a b) (* x y)) t)))))))
#s(approx (+ (* t z) (* y x)) #s(hole binary64 (* -1 (* t (+ (* -1 z) (* -1 (/ (* x y) t)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (+ (* a b) (* t (+ z (/ (* x y) t))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* a (+ b (+ (/ (* t z) a) (/ (* x y) a))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* a (+ b (/ (* t (+ z (/ (* x y) t))) a)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (/ (* a b) t)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* a (+ (/ b t) (+ (/ z a) (/ (* x y) (* a t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (+ (* t z) (* x y)) a)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* a (+ (* -1 b) (* -1 (/ (* t (+ z (/ (* x y) t))) a)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* a (+ (* -1 (/ b t)) (* -1 (/ (+ z (/ (* x y) t)) a)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* b (+ a (+ (/ (* t z) b) (/ (* x y) b))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* b (+ a (/ (* t (+ z (/ (* x y) t))) b)))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* b (+ (/ a t) (+ (/ z b) (/ (* x y) (* b t)))))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (+ (* t z) (* x y)) b)))))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) #s(hole binary64 (* -1 (* b (+ (* -1 a) (* -1 (/ (* t (+ z (/ (* x y) t))) b)))))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(hole binary64 (* -1 (* b (+ (* -1 (/ a t)) (* -1 (/ (+ z (/ (* x y) t)) b)))))))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
(*.f64 y x)
(*.f64 x y)
y
x
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
(*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t)
(*.f64 t #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z))
#s(approx (+ (* x (/ y t)) z) z)
z
t
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 x) y) #s(literal 3 binary64))) (fma.f64 (*.f64 t z) (*.f64 t z) (fma.f64 (*.f64 (neg.f64 x) y) (*.f64 (neg.f64 x) y) (*.f64 (*.f64 t z) (*.f64 (neg.f64 x) y)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (pow.f64 (*.f64 (neg.f64 y) x) #s(literal 3 binary64))) (fma.f64 (*.f64 t z) (*.f64 t z) (fma.f64 (*.f64 (neg.f64 y) x) (*.f64 (neg.f64 y) x) (*.f64 (*.f64 t z) (*.f64 (neg.f64 y) x)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (neg.f64 z) t) #s(literal 3 binary64))) (fma.f64 (*.f64 y x) (*.f64 y x) (fma.f64 (*.f64 (neg.f64 z) t) (*.f64 (neg.f64 z) t) (*.f64 (*.f64 y x) (*.f64 (neg.f64 z) t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 t z)))) (neg.f64 (-.f64 (*.f64 y x) (*.f64 t z))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 y x)))) (neg.f64 (-.f64 (*.f64 t z) (*.f64 y x))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 y x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)))) (neg.f64 (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 t z))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)))) (neg.f64 (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 y x))))))
(/.f64 (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 t z))) (-.f64 (*.f64 y x) (*.f64 t z)))
(/.f64 (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 y x))) (-.f64 (*.f64 t z) (*.f64 y x)))
(/.f64 (fma.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 y x) (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z))) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 t z)))))
(/.f64 (fma.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z) (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x))) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 y x)))))
(fma.f64 t z (*.f64 y x))
(fma.f64 z t (*.f64 y x))
(fma.f64 y x (*.f64 t z))
(fma.f64 x y (*.f64 t z))
(-.f64 (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (-.f64 (*.f64 y x) (*.f64 t z))) (/.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (-.f64 (*.f64 y x) (*.f64 t z))))
(-.f64 (/.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (-.f64 (*.f64 t z) (*.f64 y x))) (/.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (-.f64 (*.f64 t z) (*.f64 y x))))
(-.f64 (*.f64 t z) (*.f64 (neg.f64 x) y))
(-.f64 (*.f64 t z) (*.f64 (neg.f64 y) x))
(-.f64 (*.f64 y x) (*.f64 (neg.f64 z) t))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 t z))))) (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 y x) (*.f64 y x) (-.f64 (*.f64 (*.f64 t z) (*.f64 t z)) (*.f64 (*.f64 y x) (*.f64 t z))))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 z z) z)) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 y x))))) (/.f64 (*.f64 (*.f64 (*.f64 y y) y) (*.f64 (*.f64 x x) x)) (fma.f64 (*.f64 t z) (*.f64 t z) (-.f64 (*.f64 (*.f64 y x) (*.f64 y x)) (*.f64 (*.f64 t z) (*.f64 y x))))))
(+.f64 (*.f64 t z) (*.f64 y x))
(+.f64 (*.f64 y x) (*.f64 t z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (fma.f64 t z (*.f64 y x))))
#s(approx (* y x) (*.f64 y x))
#s(approx x x)
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 a (/.f64 b t) z) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 a (/.f64 b t) z) t (*.f64 y x)))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 a (/.f64 b t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z))
#s(approx (+ (* x (/ y t)) z) z)
#s(approx (+ (* x (/ y t)) z) (fma.f64 (/.f64 y t) x z))
#s(approx (+ (* t z) (* y x)) (*.f64 t z))
#s(approx (+ (* t z) (* y x)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) x) y) x))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) x) y) x))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (/.f64 y t) x))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x) (/.f64 y t)) x))
#s(approx (+ (* x (/ y t)) z) (*.f64 (+.f64 (/.f64 z x) (/.f64 y t)) x))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 t (/.f64 z x) y) x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 t z)) x)) (neg.f64 y))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) x)) (neg.f64 y))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) x)) (/.f64 (neg.f64 y) t))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 y) t) (/.f64 z x))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 x) (+.f64 (neg.f64 (/.f64 (*.f64 t z) x)) (neg.f64 y))))
#s(approx y y)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 t z)) y) x) y))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 a (/.f64 b t) z) y) x) y))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y) (/.f64 x t)) y))
#s(approx (+ (* x (/ y t)) z) (*.f64 (+.f64 (/.f64 z y) (/.f64 x t)) y))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 t (/.f64 z y) x) y))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 t z)) y)) (neg.f64 x))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 a (/.f64 b t) z) t) y)) (neg.f64 x))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (fma.f64 a (/.f64 b t) z) y)) (/.f64 (neg.f64 x) t))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 x) t) (/.f64 z y))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 y) (+.f64 (neg.f64 (/.f64 (*.f64 t z) y)) (neg.f64 x))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) t))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (*.f64 y x)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) z) t) z))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)) t) z))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)) #s(literal 1 binary64)) z))
#s(approx (+ (* x (/ y t)) z) (*.f64 (fma.f64 x (/.f64 y (*.f64 t z)) #s(literal 1 binary64)) z))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 x (/.f64 y z) t) z))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) z)) (neg.f64 t))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (*.f64 t (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z)))) (neg.f64 t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) (*.f64 t z))) #s(literal 1 binary64))))
#s(approx (+ (* x (/ y t)) z) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (*.f64 x (/.f64 y (*.f64 t z)))) #s(literal 1 binary64))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 z) (+.f64 (neg.f64 (/.f64 (*.f64 y x) z)) (neg.f64 t))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (*.f64 y x)) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (fma.f64 b a (fma.f64 t z (*.f64 y x))) t))
#s(approx (+ (* x (/ y t)) z) (/.f64 (fma.f64 t z (*.f64 y x)) t))
#s(approx t t)
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
#s(approx (+ (* t z) (* y x)) (*.f64 (fma.f64 (/.f64 y t) x z) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t)) (neg.f64 z))))
#s(approx (+ (* t z) (* y x)) (*.f64 (neg.f64 t) (+.f64 (neg.f64 (*.f64 (/.f64 y t) x)) (neg.f64 z))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (fma.f64 (fma.f64 (/.f64 y t) x z) t (*.f64 b a)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 b a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) a) b) a))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 (/.f64 y t) x z) a) b) a))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (/.f64 (*.f64 b a) t))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 a t)) (/.f64 z a)) (/.f64 b t)) a))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 t z (*.f64 y x)) a)) (neg.f64 b))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 (/.f64 y t) x z) t) a)) (neg.f64 b))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 a) (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 y t) x z) a)) (/.f64 (neg.f64 b) t))))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 t z (*.f64 y x)) b) a) b))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 (/.f64 y t) x z) b) a) b))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (+.f64 (fma.f64 x (/.f64 y (*.f64 b t)) (/.f64 z b)) (/.f64 a t)) b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 t z (*.f64 y x)) b)) (neg.f64 a))))
#s(approx (* (+ (/ (+ (* b a) (* y x)) t) z) t) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 (/.f64 y t) x z) t) b)) (neg.f64 a))))
#s(approx (+ (/ (+ (* b a) (* y x)) t) z) (*.f64 (neg.f64 b) (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 y t) x z) b)) (/.f64 (neg.f64 a) t))))

eval12.0ms (0.2%)

Memory
-16.7MiB live, 28.7MiB allocated; 4ms collecting garbage
Compiler

Compiled 1 217 to 475 computations (61% saved)

prune5.0ms (0.1%)

Memory
18.6MiB live, 18.7MiB allocated; 0ms collecting garbage
Pruning

7 alts after pruning (0 fresh and 7 done)

PrunedKeptTotal
New98098
Fresh000
Picked033
Done044
Total987105
Accuracy
100.0%
Counts
105 → 7
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓67.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
✓63.7%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
✓71.3%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
✓63.4%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
✓39.2%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
✓35.6%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
✓31.5%
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
Compiler

Compiled 197 to 163 computations (17.3% saved)

regimes57.0ms (1%)

Memory
-6.7MiB live, 137.4MiB allocated; 15ms collecting garbage
Counts
13 → 1
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 (+.f64 (/.f64 (fma.f64 b a (*.f64 y x)) t) z) t))
Outputs
(fma.f64 y x (fma.f64 b a (*.f64 t z)))
Calls

11 calls:

11.0ms
x
7.0ms
a
7.0ms
(*.f64 z t)
4.0ms
t
4.0ms
b
Results
AccuracySegmentsBranch
99.6%1(*.f64 a b)
99.6%1(*.f64 z t)
99.6%1(*.f64 x y)
99.6%1(+.f64 (*.f64 x y) (*.f64 z t))
99.6%1(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
99.6%1x
99.6%1y
99.6%1z
99.6%1t
99.6%1a
99.6%1b
Compiler

Compiled 33 to 77 computations (-133.3% saved)

regimes42.0ms (0.7%)

Memory
25.3MiB live, 117.4MiB allocated; 6ms collecting garbage
Counts
10 → 1
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
Outputs
(fma.f64 b a (fma.f64 t z (*.f64 y x)))
Calls

11 calls:

6.0ms
t
6.0ms
(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
3.0ms
z
3.0ms
b
3.0ms
a
Results
AccuracySegmentsBranch
99.2%1(*.f64 a b)
99.2%1(*.f64 z t)
99.2%1(*.f64 x y)
99.2%1(+.f64 (*.f64 x y) (*.f64 z t))
99.2%1(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
99.2%1x
99.2%1y
99.2%1z
99.2%1t
99.2%1a
99.2%1b
Compiler

Compiled 33 to 77 computations (-133.3% saved)

regimes46.0ms (0.8%)

Memory
-9.0MiB live, 125.1MiB allocated; 14ms collecting garbage
Counts
9 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 z t (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) (fma.f64 x (/.f64 y t) z)) t))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 y x (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
Calls

11 calls:

10.0ms
b
5.0ms
y
5.0ms
(*.f64 x y)
3.0ms
a
3.0ms
x
Results
AccuracySegmentsBranch
90.0%3(*.f64 a b)
91.2%3(*.f64 z t)
89.9%3(*.f64 x y)
89.2%4(+.f64 (*.f64 x y) (*.f64 z t))
78.5%2(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
84.2%3x
84.5%3y
87.3%3z
87.1%3t
84.8%4a
85.8%3b
Compiler

Compiled 33 to 77 computations (-133.3% saved)

regimes3.0ms (0%)

Memory
9.4MiB live, 9.4MiB allocated; 0ms collecting garbage
Counts
6 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 t z (*.f64 y x)))
Calls

1 calls:

2.0ms
(*.f64 z t)
Results
AccuracySegmentsBranch
90.8%3(*.f64 z t)
Compiler

Compiled 3 to 7 computations (-133.3% saved)

regimes15.0ms (0.2%)

Memory
-10.2MiB live, 28.0MiB allocated; 9ms collecting garbage
Counts
5 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 y x)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
Calls

3 calls:

10.0ms
(*.f64 a b)
2.0ms
(*.f64 x y)
2.0ms
(*.f64 z t)
Results
AccuracySegmentsBranch
87.9%3(*.f64 x y)
70.2%2(*.f64 a b)
89.2%3(*.f64 z t)
Compiler

Compiled 9 to 21 computations (-133.3% saved)

regimes41.0ms (0.7%)

Memory
4.7MiB live, 50.2MiB allocated; 28ms collecting garbage
Counts
4 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (fma.f64 b a (*.f64 t z)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
Calls

8 calls:

27.0ms
b
2.0ms
z
2.0ms
y
2.0ms
x
2.0ms
t
Results
AccuracySegmentsBranch
77.2%3x
74.9%3y
71.0%3b
71.3%3t
67.5%1z
67.5%1(+.f64 (*.f64 x y) (*.f64 z t))
84.0%3(*.f64 x y)
67.5%1(*.f64 z t)
Compiler

Compiled 18 to 53 computations (-194.4% saved)

regimes3.1s (51.1%)

Memory
-100.1MiB live, 558.9MiB allocated; 3.1s collecting garbage
Counts
3 → 5
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 #s(approx (+ (/ (+ (* b a) (* y x)) t) z) #s(approx (+ (* x (/ y t)) z) z)) t))
Calls

11 calls:

3.0s
y
48.0ms
(*.f64 a b)
2.0ms
t
2.0ms
b
2.0ms
a
Results
AccuracySegmentsBranch
65.1%5(*.f64 z t)
60.0%4z
58.5%4(+.f64 (*.f64 x y) (*.f64 z t))
56.9%5b
60.6%4t
58.0%4(*.f64 a b)
52.8%3y
57.6%4x
49.2%3(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
52.2%4a
60.2%3(*.f64 x y)
Compiler

Compiled 33 to 77 computations (-133.3% saved)

regimes16.0ms (0.3%)

Memory
-16.6MiB live, 32.0MiB allocated; 7ms collecting garbage
Counts
2 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
#s(approx (+ (+ (* x y) (* z t)) (* a b)) (*.f64 y x))
Calls

8 calls:

7.0ms
(+.f64 (*.f64 x y) (*.f64 z t))
1.0ms
(*.f64 a b)
1.0ms
t
1.0ms
b
1.0ms
z
Results
AccuracySegmentsBranch
50.3%3b
48.4%3x
52.9%3(*.f64 a b)
51.4%3(+.f64 (*.f64 x y) (*.f64 z t))
43.0%3z
37.8%2t
53.5%3(*.f64 x y)
38.9%3(*.f64 z t)
Compiler

Compiled 20 to 54 computations (-170% saved)

regimes12.0ms (0.2%)

Memory
-8.4MiB live, 39.8MiB allocated; 1ms collecting garbage
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
Outputs
#s(approx (+ (+ (* x y) (* z t)) (* a b)) #s(approx (+ (* b a) (* y x)) (*.f64 a b)))
Calls

11 calls:

2.0ms
t
1.0ms
y
1.0ms
a
1.0ms
x
1.0ms
z
Results
AccuracySegmentsBranch
31.5%1(*.f64 z t)
31.5%1t
31.5%1z
31.5%1x
31.5%1(+.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 a b))
31.5%1b
31.5%1a
31.5%1(+.f64 (*.f64 x y) (*.f64 z t))
31.5%1y
31.5%1(*.f64 a b)
31.5%1(*.f64 x y)
Compiler

Compiled 33 to 77 computations (-133.3% saved)

bsearch1.0ms (0%)

Memory
0.9MiB live, 0.9MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
7.272493629575374e-30
2.5799231779631434e-23
0.0ms
-3.024986334480896e-5
-2.739025152628348e-5
Compiler

Compiled 14 to 20 computations (-42.9% saved)

bsearch0.0ms (0%)

Memory
0.8MiB live, 0.8MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
7.272493629575374e-30
2.5799231779631434e-23
0.0ms
-3.024986334480896e-5
-2.739025152628348e-5
Compiler

Compiled 14 to 20 computations (-42.9% saved)

bsearch0.0ms (0%)

Memory
1.3MiB live, 1.3MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
1858811230869.9006
1.8222239627375486e+31
0.0ms
-3.56001034241427e+83
-6.063081243303971e+80
Compiler

Compiled 14 to 20 computations (-42.9% saved)

bsearch0.0ms (0%)

Memory
0.7MiB live, 0.7MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
3.258317137832811e+64
2.386350467485544e+68
0.0ms
-4.763574036778054e+47
-1.4041288787380917e+40
Compiler

Compiled 14 to 20 computations (-42.9% saved)

bsearch1.0ms (0%)

Memory
1.6MiB live, 1.6MiB allocated; 0ms collecting garbage
Algorithm
4×left-value
Steps
TimeLeftRight
0.0ms
2.117087134219675e+60
7.044817861281096e+63
0.0ms
1.520672111782765e-143
2.6636101546460775e-136
0.0ms
-2.770654872706262e-159
-8.376118560984709e-160
0.0ms
-3.56001034241427e+83
-6.063081243303971e+80
Compiler

Compiled 14 to 20 computations (-42.9% saved)

bsearch0.0ms (0%)

Memory
1.2MiB live, 1.1MiB allocated; 0ms collecting garbage
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
78.26638752712773
847477517880.2449
0.0ms
-4.763574036778054e+47
-1.4041288787380917e+40
Compiler

Compiled 14 to 20 computations (-42.9% saved)

derivations382.0ms (6.4%)

Memory
4.8MiB live, 375.5MiB allocated; 50ms collecting garbage
Stop Event
1×done
Compiler

Compiled 113 to 75 computations (33.6% saved)

preprocess113.0ms (1.9%)

Memory
48.1MiB live, 139.9MiB allocated; 9ms collecting garbage
Remove

(sort a b)

(sort z t)

(sort x y)

Compiler

Compiled 1 534 to 1 262 computations (17.7% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated; 0ms collecting garbage

Profiling

Loading profile data...